1 | // SPDX-License-Identifier: GPL-2.0 |
2 | /* |
3 | * Management Controller Transport Protocol (MCTP) |
4 | * Implements DMTF specification |
5 | * "DSP0237 Management Component Transport Protocol (MCTP) SMBus/I2C |
6 | * Transport Binding" |
7 | * https://www.dmtf.org/sites/default/files/standards/documents/DSP0237_1.2.0.pdf |
8 | * |
9 | * A netdev is created for each I2C bus that handles MCTP. In the case of an I2C |
10 | * mux topology a single I2C client is attached to the root of the mux topology, |
11 | * shared between all mux I2C busses underneath. For non-mux cases an I2C client |
12 | * is attached per netdev. |
13 | * |
14 | * mctp-i2c-controller.yml devicetree binding has further details. |
15 | * |
16 | * Copyright (c) 2022 Code Construct |
17 | * Copyright (c) 2022 Google |
18 | */ |
19 | |
20 | #include <linux/module.h> |
21 | #include <linux/netdevice.h> |
22 | #include <linux/i2c.h> |
23 | #include <linux/i2c-mux.h> |
24 | #include <linux/if_arp.h> |
25 | #include <net/mctp.h> |
26 | #include <net/mctpdevice.h> |
27 | |
28 | /* byte_count is limited to u8 */ |
29 | #define MCTP_I2C_MAXBLOCK 255 |
30 | /* One byte is taken by source_slave */ |
31 | #define MCTP_I2C_MAXMTU (MCTP_I2C_MAXBLOCK - 1) |
32 | #define MCTP_I2C_MINMTU (64 + 4) |
33 | /* Allow space for dest_address, command, byte_count, data, PEC */ |
34 | #define MCTP_I2C_BUFSZ (3 + MCTP_I2C_MAXBLOCK + 1) |
35 | #define MCTP_I2C_MINLEN 8 |
36 | #define MCTP_I2C_COMMANDCODE 0x0f |
37 | #define MCTP_I2C_TX_WORK_LEN 100 |
38 | /* Sufficient for 64kB at min mtu */ |
39 | #define MCTP_I2C_TX_QUEUE_LEN 1100 |
40 | |
41 | #define MCTP_I2C_OF_PROP "mctp-controller" |
42 | |
43 | enum { |
44 | MCTP_I2C_FLOW_STATE_NEW = 0, |
45 | MCTP_I2C_FLOW_STATE_ACTIVE, |
46 | MCTP_I2C_FLOW_STATE_INVALID, |
47 | }; |
48 | |
49 | /* List of all struct mctp_i2c_client |
50 | * Lock protects driver_clients and also prevents adding/removing adapters |
51 | * during mctp_i2c_client probe/remove. |
52 | */ |
53 | static DEFINE_MUTEX(driver_clients_lock); |
54 | static LIST_HEAD(driver_clients); |
55 | |
56 | struct mctp_i2c_client; |
57 | |
58 | /* The netdev structure. One of these per I2C adapter. */ |
59 | struct mctp_i2c_dev { |
60 | struct net_device *ndev; |
61 | struct i2c_adapter *adapter; |
62 | struct mctp_i2c_client *client; |
63 | struct list_head list; /* For mctp_i2c_client.devs */ |
64 | |
65 | size_t rx_pos; |
66 | u8 rx_buffer[MCTP_I2C_BUFSZ]; |
67 | struct completion rx_done; |
68 | |
69 | struct task_struct *tx_thread; |
70 | wait_queue_head_t tx_wq; |
71 | struct sk_buff_head tx_queue; |
72 | u8 tx_scratch[MCTP_I2C_BUFSZ]; |
73 | |
74 | /* A fake entry in our tx queue to perform an unlock operation */ |
75 | struct sk_buff unlock_marker; |
76 | |
77 | /* Spinlock protects i2c_lock_count, release_count, allow_rx */ |
78 | spinlock_t lock; |
79 | int i2c_lock_count; |
80 | int release_count; |
81 | /* Indicates that the netif is ready to receive incoming packets */ |
82 | bool allow_rx; |
83 | |
84 | }; |
85 | |
86 | /* The i2c client structure. One per hardware i2c bus at the top of the |
87 | * mux tree, shared by multiple netdevs |
88 | */ |
89 | struct mctp_i2c_client { |
90 | struct i2c_client *client; |
91 | u8 lladdr; |
92 | |
93 | struct mctp_i2c_dev *sel; |
94 | struct list_head devs; |
95 | spinlock_t sel_lock; /* Protects sel and devs */ |
96 | |
97 | struct list_head list; /* For driver_clients */ |
98 | }; |
99 | |
100 | /* Header on the wire. */ |
101 | struct mctp_i2c_hdr { |
102 | u8 dest_slave; |
103 | u8 command; |
104 | /* Count of bytes following byte_count, excluding PEC */ |
105 | u8 byte_count; |
106 | u8 source_slave; |
107 | }; |
108 | |
109 | static int mctp_i2c_recv(struct mctp_i2c_dev *midev); |
110 | static int mctp_i2c_slave_cb(struct i2c_client *client, |
111 | enum i2c_slave_event event, u8 *val); |
112 | static void mctp_i2c_ndo_uninit(struct net_device *dev); |
113 | static int mctp_i2c_ndo_open(struct net_device *dev); |
114 | |
115 | static struct i2c_adapter *mux_root_adapter(struct i2c_adapter *adap) |
116 | { |
117 | #if IS_ENABLED(CONFIG_I2C_MUX) |
118 | return i2c_root_adapter(dev: &adap->dev); |
119 | #else |
120 | /* In non-mux config all i2c adapters are root adapters */ |
121 | return adap; |
122 | #endif |
123 | } |
124 | |
125 | /* Creates a new i2c slave device attached to the root adapter. |
126 | * Sets up the slave callback. |
127 | * Must be called with a client on a root adapter. |
128 | */ |
129 | static struct mctp_i2c_client *mctp_i2c_new_client(struct i2c_client *client) |
130 | { |
131 | struct mctp_i2c_client *mcli = NULL; |
132 | struct i2c_adapter *root = NULL; |
133 | int rc; |
134 | |
135 | if (client->flags & I2C_CLIENT_TEN) { |
136 | dev_err(&client->dev, "failed, MCTP requires a 7-bit I2C address, addr=0x%x\n" , |
137 | client->addr); |
138 | rc = -EINVAL; |
139 | goto err; |
140 | } |
141 | |
142 | root = mux_root_adapter(adap: client->adapter); |
143 | if (!root) { |
144 | dev_err(&client->dev, "failed to find root adapter\n" ); |
145 | rc = -ENOENT; |
146 | goto err; |
147 | } |
148 | if (root != client->adapter) { |
149 | dev_err(&client->dev, |
150 | "A mctp-i2c-controller client cannot be placed on an I2C mux adapter.\n" |
151 | " It should be placed on the mux tree root adapter\n" |
152 | " then set mctp-controller property on adapters to attach\n" ); |
153 | rc = -EINVAL; |
154 | goto err; |
155 | } |
156 | |
157 | mcli = kzalloc(size: sizeof(*mcli), GFP_KERNEL); |
158 | if (!mcli) { |
159 | rc = -ENOMEM; |
160 | goto err; |
161 | } |
162 | spin_lock_init(&mcli->sel_lock); |
163 | INIT_LIST_HEAD(list: &mcli->devs); |
164 | INIT_LIST_HEAD(list: &mcli->list); |
165 | mcli->lladdr = client->addr & 0xff; |
166 | mcli->client = client; |
167 | i2c_set_clientdata(client, data: mcli); |
168 | |
169 | rc = i2c_slave_register(client: mcli->client, slave_cb: mctp_i2c_slave_cb); |
170 | if (rc < 0) { |
171 | dev_err(&client->dev, "i2c register failed %d\n" , rc); |
172 | mcli->client = NULL; |
173 | i2c_set_clientdata(client, NULL); |
174 | goto err; |
175 | } |
176 | |
177 | return mcli; |
178 | err: |
179 | if (mcli) { |
180 | if (mcli->client) |
181 | i2c_unregister_device(client: mcli->client); |
182 | kfree(objp: mcli); |
183 | } |
184 | return ERR_PTR(error: rc); |
185 | } |
186 | |
187 | static void mctp_i2c_free_client(struct mctp_i2c_client *mcli) |
188 | { |
189 | int rc; |
190 | |
191 | WARN_ON(!mutex_is_locked(&driver_clients_lock)); |
192 | WARN_ON(!list_empty(&mcli->devs)); |
193 | WARN_ON(mcli->sel); /* sanity check, no locking */ |
194 | |
195 | rc = i2c_slave_unregister(client: mcli->client); |
196 | /* Leak if it fails, we can't propagate errors upwards */ |
197 | if (rc < 0) |
198 | dev_err(&mcli->client->dev, "i2c unregister failed %d\n" , rc); |
199 | else |
200 | kfree(objp: mcli); |
201 | } |
202 | |
203 | /* Switch the mctp i2c device to receive responses. |
204 | * Call with sel_lock held |
205 | */ |
206 | static void __mctp_i2c_device_select(struct mctp_i2c_client *mcli, |
207 | struct mctp_i2c_dev *midev) |
208 | { |
209 | assert_spin_locked(&mcli->sel_lock); |
210 | if (midev) |
211 | dev_hold(dev: midev->ndev); |
212 | if (mcli->sel) |
213 | dev_put(dev: mcli->sel->ndev); |
214 | mcli->sel = midev; |
215 | } |
216 | |
217 | /* Switch the mctp i2c device to receive responses */ |
218 | static void mctp_i2c_device_select(struct mctp_i2c_client *mcli, |
219 | struct mctp_i2c_dev *midev) |
220 | { |
221 | unsigned long flags; |
222 | |
223 | spin_lock_irqsave(&mcli->sel_lock, flags); |
224 | __mctp_i2c_device_select(mcli, midev); |
225 | spin_unlock_irqrestore(lock: &mcli->sel_lock, flags); |
226 | } |
227 | |
228 | static int mctp_i2c_slave_cb(struct i2c_client *client, |
229 | enum i2c_slave_event event, u8 *val) |
230 | { |
231 | struct mctp_i2c_client *mcli = i2c_get_clientdata(client); |
232 | struct mctp_i2c_dev *midev = NULL; |
233 | unsigned long flags; |
234 | int rc = 0; |
235 | |
236 | spin_lock_irqsave(&mcli->sel_lock, flags); |
237 | midev = mcli->sel; |
238 | if (midev) |
239 | dev_hold(dev: midev->ndev); |
240 | spin_unlock_irqrestore(lock: &mcli->sel_lock, flags); |
241 | |
242 | if (!midev) |
243 | return 0; |
244 | |
245 | switch (event) { |
246 | case I2C_SLAVE_WRITE_RECEIVED: |
247 | if (midev->rx_pos < MCTP_I2C_BUFSZ) { |
248 | midev->rx_buffer[midev->rx_pos] = *val; |
249 | midev->rx_pos++; |
250 | } else { |
251 | midev->ndev->stats.rx_over_errors++; |
252 | } |
253 | |
254 | break; |
255 | case I2C_SLAVE_WRITE_REQUESTED: |
256 | /* dest_slave as first byte */ |
257 | midev->rx_buffer[0] = mcli->lladdr << 1; |
258 | midev->rx_pos = 1; |
259 | break; |
260 | case I2C_SLAVE_STOP: |
261 | rc = mctp_i2c_recv(midev); |
262 | break; |
263 | default: |
264 | break; |
265 | } |
266 | |
267 | dev_put(dev: midev->ndev); |
268 | return rc; |
269 | } |
270 | |
271 | /* Processes incoming data that has been accumulated by the slave cb */ |
272 | static int mctp_i2c_recv(struct mctp_i2c_dev *midev) |
273 | { |
274 | struct net_device *ndev = midev->ndev; |
275 | struct mctp_i2c_hdr *hdr; |
276 | struct mctp_skb_cb *cb; |
277 | struct sk_buff *skb; |
278 | unsigned long flags; |
279 | u8 pec, calc_pec; |
280 | size_t recvlen; |
281 | int status; |
282 | |
283 | /* + 1 for the PEC */ |
284 | if (midev->rx_pos < MCTP_I2C_MINLEN + 1) { |
285 | ndev->stats.rx_length_errors++; |
286 | return -EINVAL; |
287 | } |
288 | /* recvlen excludes PEC */ |
289 | recvlen = midev->rx_pos - 1; |
290 | |
291 | hdr = (void *)midev->rx_buffer; |
292 | if (hdr->command != MCTP_I2C_COMMANDCODE) { |
293 | ndev->stats.rx_dropped++; |
294 | return -EINVAL; |
295 | } |
296 | |
297 | if (hdr->byte_count + offsetof(struct mctp_i2c_hdr, source_slave) != recvlen) { |
298 | ndev->stats.rx_length_errors++; |
299 | return -EINVAL; |
300 | } |
301 | |
302 | pec = midev->rx_buffer[midev->rx_pos - 1]; |
303 | calc_pec = i2c_smbus_pec(crc: 0, p: midev->rx_buffer, count: recvlen); |
304 | if (pec != calc_pec) { |
305 | ndev->stats.rx_crc_errors++; |
306 | return -EINVAL; |
307 | } |
308 | |
309 | skb = netdev_alloc_skb(dev: ndev, length: recvlen); |
310 | if (!skb) { |
311 | ndev->stats.rx_dropped++; |
312 | return -ENOMEM; |
313 | } |
314 | |
315 | skb->protocol = htons(ETH_P_MCTP); |
316 | skb_put_data(skb, data: midev->rx_buffer, len: recvlen); |
317 | skb_reset_mac_header(skb); |
318 | skb_pull(skb, len: sizeof(struct mctp_i2c_hdr)); |
319 | skb_reset_network_header(skb); |
320 | |
321 | cb = __mctp_cb(skb); |
322 | cb->halen = 1; |
323 | cb->haddr[0] = hdr->source_slave >> 1; |
324 | |
325 | /* We need to ensure that the netif is not used once netdev |
326 | * unregister occurs |
327 | */ |
328 | spin_lock_irqsave(&midev->lock, flags); |
329 | if (midev->allow_rx) { |
330 | reinit_completion(x: &midev->rx_done); |
331 | spin_unlock_irqrestore(lock: &midev->lock, flags); |
332 | |
333 | status = netif_rx(skb); |
334 | complete(&midev->rx_done); |
335 | } else { |
336 | status = NET_RX_DROP; |
337 | spin_unlock_irqrestore(lock: &midev->lock, flags); |
338 | } |
339 | |
340 | if (status == NET_RX_SUCCESS) { |
341 | ndev->stats.rx_packets++; |
342 | ndev->stats.rx_bytes += recvlen; |
343 | } else { |
344 | ndev->stats.rx_dropped++; |
345 | } |
346 | return 0; |
347 | } |
348 | |
349 | enum mctp_i2c_flow_state { |
350 | MCTP_I2C_TX_FLOW_INVALID, |
351 | MCTP_I2C_TX_FLOW_NONE, |
352 | MCTP_I2C_TX_FLOW_NEW, |
353 | MCTP_I2C_TX_FLOW_EXISTING, |
354 | }; |
355 | |
356 | static enum mctp_i2c_flow_state |
357 | mctp_i2c_get_tx_flow_state(struct mctp_i2c_dev *midev, struct sk_buff *skb) |
358 | { |
359 | enum mctp_i2c_flow_state state; |
360 | struct mctp_sk_key *key; |
361 | struct mctp_flow *flow; |
362 | unsigned long flags; |
363 | |
364 | flow = skb_ext_find(skb, id: SKB_EXT_MCTP); |
365 | if (!flow) |
366 | return MCTP_I2C_TX_FLOW_NONE; |
367 | |
368 | key = flow->key; |
369 | if (!key) |
370 | return MCTP_I2C_TX_FLOW_NONE; |
371 | |
372 | spin_lock_irqsave(&key->lock, flags); |
373 | /* If the key is present but invalid, we're unlikely to be able |
374 | * to handle the flow at all; just drop now |
375 | */ |
376 | if (!key->valid) { |
377 | state = MCTP_I2C_TX_FLOW_INVALID; |
378 | } else { |
379 | switch (key->dev_flow_state) { |
380 | case MCTP_I2C_FLOW_STATE_NEW: |
381 | key->dev_flow_state = MCTP_I2C_FLOW_STATE_ACTIVE; |
382 | state = MCTP_I2C_TX_FLOW_NEW; |
383 | break; |
384 | case MCTP_I2C_FLOW_STATE_ACTIVE: |
385 | state = MCTP_I2C_TX_FLOW_EXISTING; |
386 | break; |
387 | default: |
388 | state = MCTP_I2C_TX_FLOW_INVALID; |
389 | } |
390 | } |
391 | |
392 | spin_unlock_irqrestore(lock: &key->lock, flags); |
393 | |
394 | return state; |
395 | } |
396 | |
397 | /* We're not contending with ourselves here; we only need to exclude other |
398 | * i2c clients from using the bus. refcounts are simply to prevent |
399 | * recursive locking. |
400 | */ |
401 | static void mctp_i2c_lock_nest(struct mctp_i2c_dev *midev) |
402 | { |
403 | unsigned long flags; |
404 | bool lock; |
405 | |
406 | spin_lock_irqsave(&midev->lock, flags); |
407 | lock = midev->i2c_lock_count == 0; |
408 | midev->i2c_lock_count++; |
409 | spin_unlock_irqrestore(lock: &midev->lock, flags); |
410 | |
411 | if (lock) |
412 | i2c_lock_bus(adapter: midev->adapter, I2C_LOCK_SEGMENT); |
413 | } |
414 | |
415 | static void mctp_i2c_unlock_nest(struct mctp_i2c_dev *midev) |
416 | { |
417 | unsigned long flags; |
418 | bool unlock; |
419 | |
420 | spin_lock_irqsave(&midev->lock, flags); |
421 | if (!WARN_ONCE(midev->i2c_lock_count == 0, "lock count underflow!" )) |
422 | midev->i2c_lock_count--; |
423 | unlock = midev->i2c_lock_count == 0; |
424 | spin_unlock_irqrestore(lock: &midev->lock, flags); |
425 | |
426 | if (unlock) |
427 | i2c_unlock_bus(adapter: midev->adapter, I2C_LOCK_SEGMENT); |
428 | } |
429 | |
430 | /* Unlocks the bus if was previously locked, used for cleanup */ |
431 | static void mctp_i2c_unlock_reset(struct mctp_i2c_dev *midev) |
432 | { |
433 | unsigned long flags; |
434 | bool unlock; |
435 | |
436 | spin_lock_irqsave(&midev->lock, flags); |
437 | unlock = midev->i2c_lock_count > 0; |
438 | midev->i2c_lock_count = 0; |
439 | spin_unlock_irqrestore(lock: &midev->lock, flags); |
440 | |
441 | if (unlock) |
442 | i2c_unlock_bus(adapter: midev->adapter, I2C_LOCK_SEGMENT); |
443 | } |
444 | |
445 | static void mctp_i2c_xmit(struct mctp_i2c_dev *midev, struct sk_buff *skb) |
446 | { |
447 | struct net_device_stats *stats = &midev->ndev->stats; |
448 | enum mctp_i2c_flow_state fs; |
449 | struct mctp_i2c_hdr *hdr; |
450 | struct i2c_msg msg = {0}; |
451 | u8 *pecp; |
452 | int rc; |
453 | |
454 | fs = mctp_i2c_get_tx_flow_state(midev, skb); |
455 | |
456 | hdr = (void *)skb_mac_header(skb); |
457 | /* Sanity check that packet contents matches skb length, |
458 | * and can't exceed MCTP_I2C_BUFSZ |
459 | */ |
460 | if (skb->len != hdr->byte_count + 3) { |
461 | dev_warn_ratelimited(&midev->adapter->dev, |
462 | "Bad tx length %d vs skb %u\n" , |
463 | hdr->byte_count + 3, skb->len); |
464 | return; |
465 | } |
466 | |
467 | if (skb_tailroom(skb) >= 1) { |
468 | /* Linear case with space, we can just append the PEC */ |
469 | skb_put(skb, len: 1); |
470 | } else { |
471 | /* Otherwise need to copy the buffer */ |
472 | skb_copy_bits(skb, offset: 0, to: midev->tx_scratch, len: skb->len); |
473 | hdr = (void *)midev->tx_scratch; |
474 | } |
475 | |
476 | pecp = (void *)&hdr->source_slave + hdr->byte_count; |
477 | *pecp = i2c_smbus_pec(crc: 0, p: (u8 *)hdr, count: hdr->byte_count + 3); |
478 | msg.buf = (void *)&hdr->command; |
479 | /* command, bytecount, data, pec */ |
480 | msg.len = 2 + hdr->byte_count + 1; |
481 | msg.addr = hdr->dest_slave >> 1; |
482 | |
483 | switch (fs) { |
484 | case MCTP_I2C_TX_FLOW_NONE: |
485 | /* no flow: full lock & unlock */ |
486 | mctp_i2c_lock_nest(midev); |
487 | mctp_i2c_device_select(mcli: midev->client, midev); |
488 | rc = __i2c_transfer(adap: midev->adapter, msgs: &msg, num: 1); |
489 | mctp_i2c_unlock_nest(midev); |
490 | break; |
491 | |
492 | case MCTP_I2C_TX_FLOW_NEW: |
493 | /* new flow: lock, tx, but don't unlock; that will happen |
494 | * on flow release |
495 | */ |
496 | mctp_i2c_lock_nest(midev); |
497 | mctp_i2c_device_select(mcli: midev->client, midev); |
498 | fallthrough; |
499 | |
500 | case MCTP_I2C_TX_FLOW_EXISTING: |
501 | /* existing flow: we already have the lock; just tx */ |
502 | rc = __i2c_transfer(adap: midev->adapter, msgs: &msg, num: 1); |
503 | break; |
504 | |
505 | case MCTP_I2C_TX_FLOW_INVALID: |
506 | return; |
507 | } |
508 | |
509 | if (rc < 0) { |
510 | dev_warn_ratelimited(&midev->adapter->dev, |
511 | "__i2c_transfer failed %d\n" , rc); |
512 | stats->tx_errors++; |
513 | } else { |
514 | stats->tx_bytes += skb->len; |
515 | stats->tx_packets++; |
516 | } |
517 | } |
518 | |
519 | static void mctp_i2c_flow_release(struct mctp_i2c_dev *midev) |
520 | { |
521 | unsigned long flags; |
522 | bool unlock; |
523 | |
524 | spin_lock_irqsave(&midev->lock, flags); |
525 | if (midev->release_count > midev->i2c_lock_count) { |
526 | WARN_ONCE(1, "release count overflow" ); |
527 | midev->release_count = midev->i2c_lock_count; |
528 | } |
529 | |
530 | midev->i2c_lock_count -= midev->release_count; |
531 | unlock = midev->i2c_lock_count == 0 && midev->release_count > 0; |
532 | midev->release_count = 0; |
533 | spin_unlock_irqrestore(lock: &midev->lock, flags); |
534 | |
535 | if (unlock) |
536 | i2c_unlock_bus(adapter: midev->adapter, I2C_LOCK_SEGMENT); |
537 | } |
538 | |
539 | static int (struct sk_buff *skb, struct net_device *dev, |
540 | unsigned short type, const void *daddr, |
541 | const void *saddr, unsigned int len) |
542 | { |
543 | struct mctp_i2c_hdr *hdr; |
544 | struct mctp_hdr *mhdr; |
545 | u8 lldst, llsrc; |
546 | |
547 | if (len > MCTP_I2C_MAXMTU) |
548 | return -EMSGSIZE; |
549 | |
550 | lldst = *((u8 *)daddr); |
551 | llsrc = *((u8 *)saddr); |
552 | |
553 | skb_push(skb, len: sizeof(struct mctp_i2c_hdr)); |
554 | skb_reset_mac_header(skb); |
555 | hdr = (void *)skb_mac_header(skb); |
556 | mhdr = mctp_hdr(skb); |
557 | hdr->dest_slave = (lldst << 1) & 0xff; |
558 | hdr->command = MCTP_I2C_COMMANDCODE; |
559 | hdr->byte_count = len + 1; |
560 | hdr->source_slave = ((llsrc << 1) & 0xff) | 0x01; |
561 | mhdr->ver = 0x01; |
562 | |
563 | return sizeof(struct mctp_i2c_hdr); |
564 | } |
565 | |
566 | static int mctp_i2c_tx_thread(void *data) |
567 | { |
568 | struct mctp_i2c_dev *midev = data; |
569 | struct sk_buff *skb; |
570 | unsigned long flags; |
571 | |
572 | for (;;) { |
573 | if (kthread_should_stop()) |
574 | break; |
575 | |
576 | spin_lock_irqsave(&midev->tx_queue.lock, flags); |
577 | skb = __skb_dequeue(list: &midev->tx_queue); |
578 | if (netif_queue_stopped(dev: midev->ndev)) |
579 | netif_wake_queue(dev: midev->ndev); |
580 | spin_unlock_irqrestore(lock: &midev->tx_queue.lock, flags); |
581 | |
582 | if (skb == &midev->unlock_marker) { |
583 | mctp_i2c_flow_release(midev); |
584 | |
585 | } else if (skb) { |
586 | mctp_i2c_xmit(midev, skb); |
587 | kfree_skb(skb); |
588 | |
589 | } else { |
590 | wait_event_idle(midev->tx_wq, |
591 | !skb_queue_empty(&midev->tx_queue) || |
592 | kthread_should_stop()); |
593 | } |
594 | } |
595 | |
596 | return 0; |
597 | } |
598 | |
599 | static netdev_tx_t mctp_i2c_start_xmit(struct sk_buff *skb, |
600 | struct net_device *dev) |
601 | { |
602 | struct mctp_i2c_dev *midev = netdev_priv(dev); |
603 | unsigned long flags; |
604 | |
605 | spin_lock_irqsave(&midev->tx_queue.lock, flags); |
606 | if (skb_queue_len(list_: &midev->tx_queue) >= MCTP_I2C_TX_WORK_LEN) { |
607 | netif_stop_queue(dev); |
608 | spin_unlock_irqrestore(lock: &midev->tx_queue.lock, flags); |
609 | netdev_err(dev, format: "BUG! Tx Ring full when queue awake!\n" ); |
610 | return NETDEV_TX_BUSY; |
611 | } |
612 | |
613 | __skb_queue_tail(list: &midev->tx_queue, newsk: skb); |
614 | if (skb_queue_len(list_: &midev->tx_queue) == MCTP_I2C_TX_WORK_LEN) |
615 | netif_stop_queue(dev); |
616 | spin_unlock_irqrestore(lock: &midev->tx_queue.lock, flags); |
617 | |
618 | wake_up(&midev->tx_wq); |
619 | return NETDEV_TX_OK; |
620 | } |
621 | |
622 | static void mctp_i2c_release_flow(struct mctp_dev *mdev, |
623 | struct mctp_sk_key *key) |
624 | |
625 | { |
626 | struct mctp_i2c_dev *midev = netdev_priv(dev: mdev->dev); |
627 | bool queue_release = false; |
628 | unsigned long flags; |
629 | |
630 | spin_lock_irqsave(&midev->lock, flags); |
631 | /* if we have seen the flow/key previously, we need to pair the |
632 | * original lock with a release |
633 | */ |
634 | if (key->dev_flow_state == MCTP_I2C_FLOW_STATE_ACTIVE) { |
635 | midev->release_count++; |
636 | queue_release = true; |
637 | } |
638 | key->dev_flow_state = MCTP_I2C_FLOW_STATE_INVALID; |
639 | spin_unlock_irqrestore(lock: &midev->lock, flags); |
640 | |
641 | if (queue_release) { |
642 | /* Ensure we have a release operation queued, through the fake |
643 | * marker skb |
644 | */ |
645 | spin_lock(lock: &midev->tx_queue.lock); |
646 | if (!midev->unlock_marker.next) |
647 | __skb_queue_tail(list: &midev->tx_queue, |
648 | newsk: &midev->unlock_marker); |
649 | spin_unlock(lock: &midev->tx_queue.lock); |
650 | wake_up(&midev->tx_wq); |
651 | } |
652 | } |
653 | |
654 | static const struct net_device_ops mctp_i2c_ops = { |
655 | .ndo_start_xmit = mctp_i2c_start_xmit, |
656 | .ndo_uninit = mctp_i2c_ndo_uninit, |
657 | .ndo_open = mctp_i2c_ndo_open, |
658 | }; |
659 | |
660 | static const struct header_ops mctp_i2c_headops = { |
661 | .create = mctp_i2c_header_create, |
662 | }; |
663 | |
664 | static const struct mctp_netdev_ops mctp_i2c_mctp_ops = { |
665 | .release_flow = mctp_i2c_release_flow, |
666 | }; |
667 | |
668 | static void mctp_i2c_net_setup(struct net_device *dev) |
669 | { |
670 | dev->type = ARPHRD_MCTP; |
671 | |
672 | dev->mtu = MCTP_I2C_MAXMTU; |
673 | dev->min_mtu = MCTP_I2C_MINMTU; |
674 | dev->max_mtu = MCTP_I2C_MAXMTU; |
675 | dev->tx_queue_len = MCTP_I2C_TX_QUEUE_LEN; |
676 | |
677 | dev->hard_header_len = sizeof(struct mctp_i2c_hdr); |
678 | dev->addr_len = 1; |
679 | |
680 | dev->netdev_ops = &mctp_i2c_ops; |
681 | dev->header_ops = &mctp_i2c_headops; |
682 | } |
683 | |
684 | /* Populates the mctp_i2c_dev priv struct for a netdev. |
685 | * Returns an error pointer on failure. |
686 | */ |
687 | static struct mctp_i2c_dev *mctp_i2c_midev_init(struct net_device *dev, |
688 | struct mctp_i2c_client *mcli, |
689 | struct i2c_adapter *adap) |
690 | { |
691 | struct mctp_i2c_dev *midev = netdev_priv(dev); |
692 | unsigned long flags; |
693 | |
694 | midev->tx_thread = kthread_create(mctp_i2c_tx_thread, midev, |
695 | "%s/tx" , dev->name); |
696 | if (IS_ERR(ptr: midev->tx_thread)) |
697 | return ERR_CAST(ptr: midev->tx_thread); |
698 | |
699 | midev->ndev = dev; |
700 | get_device(dev: &adap->dev); |
701 | midev->adapter = adap; |
702 | get_device(dev: &mcli->client->dev); |
703 | midev->client = mcli; |
704 | INIT_LIST_HEAD(list: &midev->list); |
705 | spin_lock_init(&midev->lock); |
706 | midev->i2c_lock_count = 0; |
707 | midev->release_count = 0; |
708 | init_completion(x: &midev->rx_done); |
709 | complete(&midev->rx_done); |
710 | init_waitqueue_head(&midev->tx_wq); |
711 | skb_queue_head_init(list: &midev->tx_queue); |
712 | |
713 | /* Add to the parent mcli */ |
714 | spin_lock_irqsave(&mcli->sel_lock, flags); |
715 | list_add(new: &midev->list, head: &mcli->devs); |
716 | /* Select a device by default */ |
717 | if (!mcli->sel) |
718 | __mctp_i2c_device_select(mcli, midev); |
719 | spin_unlock_irqrestore(lock: &mcli->sel_lock, flags); |
720 | |
721 | /* Start the worker thread */ |
722 | wake_up_process(tsk: midev->tx_thread); |
723 | |
724 | return midev; |
725 | } |
726 | |
727 | /* Counterpart of mctp_i2c_midev_init */ |
728 | static void mctp_i2c_midev_free(struct mctp_i2c_dev *midev) |
729 | { |
730 | struct mctp_i2c_client *mcli = midev->client; |
731 | unsigned long flags; |
732 | |
733 | if (midev->tx_thread) { |
734 | kthread_stop(k: midev->tx_thread); |
735 | midev->tx_thread = NULL; |
736 | } |
737 | |
738 | /* Unconditionally unlock on close */ |
739 | mctp_i2c_unlock_reset(midev); |
740 | |
741 | /* Remove the netdev from the parent i2c client. */ |
742 | spin_lock_irqsave(&mcli->sel_lock, flags); |
743 | list_del(entry: &midev->list); |
744 | if (mcli->sel == midev) { |
745 | struct mctp_i2c_dev *first; |
746 | |
747 | first = list_first_entry_or_null(&mcli->devs, struct mctp_i2c_dev, list); |
748 | __mctp_i2c_device_select(mcli, midev: first); |
749 | } |
750 | spin_unlock_irqrestore(lock: &mcli->sel_lock, flags); |
751 | |
752 | skb_queue_purge(list: &midev->tx_queue); |
753 | put_device(dev: &midev->adapter->dev); |
754 | put_device(dev: &mcli->client->dev); |
755 | } |
756 | |
757 | /* Stops, unregisters, and frees midev */ |
758 | static void mctp_i2c_unregister(struct mctp_i2c_dev *midev) |
759 | { |
760 | unsigned long flags; |
761 | |
762 | /* Stop tx thread prior to unregister, it uses netif_() functions */ |
763 | kthread_stop(k: midev->tx_thread); |
764 | midev->tx_thread = NULL; |
765 | |
766 | /* Prevent any new rx in mctp_i2c_recv(), let any pending work finish */ |
767 | spin_lock_irqsave(&midev->lock, flags); |
768 | midev->allow_rx = false; |
769 | spin_unlock_irqrestore(lock: &midev->lock, flags); |
770 | wait_for_completion(&midev->rx_done); |
771 | |
772 | mctp_unregister_netdev(dev: midev->ndev); |
773 | /* midev has been freed now by mctp_i2c_ndo_uninit callback */ |
774 | |
775 | free_netdev(dev: midev->ndev); |
776 | } |
777 | |
778 | static void mctp_i2c_ndo_uninit(struct net_device *dev) |
779 | { |
780 | struct mctp_i2c_dev *midev = netdev_priv(dev); |
781 | |
782 | /* Perform cleanup here to ensure that mcli->sel isn't holding |
783 | * a reference that would prevent unregister_netdevice() |
784 | * from completing. |
785 | */ |
786 | mctp_i2c_midev_free(midev); |
787 | } |
788 | |
789 | static int mctp_i2c_ndo_open(struct net_device *dev) |
790 | { |
791 | struct mctp_i2c_dev *midev = netdev_priv(dev); |
792 | unsigned long flags; |
793 | |
794 | /* i2c rx handler can only pass packets once the netdev is registered */ |
795 | spin_lock_irqsave(&midev->lock, flags); |
796 | midev->allow_rx = true; |
797 | spin_unlock_irqrestore(lock: &midev->lock, flags); |
798 | |
799 | return 0; |
800 | } |
801 | |
802 | static int mctp_i2c_add_netdev(struct mctp_i2c_client *mcli, |
803 | struct i2c_adapter *adap) |
804 | { |
805 | struct mctp_i2c_dev *midev = NULL; |
806 | struct net_device *ndev = NULL; |
807 | struct i2c_adapter *root; |
808 | unsigned long flags; |
809 | char namebuf[30]; |
810 | int rc; |
811 | |
812 | root = mux_root_adapter(adap); |
813 | if (root != mcli->client->adapter) { |
814 | dev_err(&mcli->client->dev, |
815 | "I2C adapter %s is not a child bus of %s\n" , |
816 | mcli->client->adapter->name, root->name); |
817 | return -EINVAL; |
818 | } |
819 | |
820 | WARN_ON(!mutex_is_locked(&driver_clients_lock)); |
821 | snprintf(buf: namebuf, size: sizeof(namebuf), fmt: "mctpi2c%d" , adap->nr); |
822 | ndev = alloc_netdev(sizeof(*midev), namebuf, NET_NAME_ENUM, mctp_i2c_net_setup); |
823 | if (!ndev) { |
824 | dev_err(&mcli->client->dev, "alloc netdev failed\n" ); |
825 | rc = -ENOMEM; |
826 | goto err; |
827 | } |
828 | dev_net_set(dev: ndev, current->nsproxy->net_ns); |
829 | SET_NETDEV_DEV(ndev, &adap->dev); |
830 | dev_addr_set(dev: ndev, addr: &mcli->lladdr); |
831 | |
832 | midev = mctp_i2c_midev_init(dev: ndev, mcli, adap); |
833 | if (IS_ERR(ptr: midev)) { |
834 | rc = PTR_ERR(ptr: midev); |
835 | midev = NULL; |
836 | goto err; |
837 | } |
838 | |
839 | rc = mctp_register_netdev(dev: ndev, ops: &mctp_i2c_mctp_ops); |
840 | if (rc < 0) { |
841 | dev_err(&mcli->client->dev, |
842 | "register netdev \"%s\" failed %d\n" , |
843 | ndev->name, rc); |
844 | goto err; |
845 | } |
846 | |
847 | spin_lock_irqsave(&midev->lock, flags); |
848 | midev->allow_rx = false; |
849 | spin_unlock_irqrestore(lock: &midev->lock, flags); |
850 | |
851 | return 0; |
852 | err: |
853 | if (midev) |
854 | mctp_i2c_midev_free(midev); |
855 | if (ndev) |
856 | free_netdev(dev: ndev); |
857 | return rc; |
858 | } |
859 | |
860 | /* Removes any netdev for adap. mcli is the parent root i2c client */ |
861 | static void mctp_i2c_remove_netdev(struct mctp_i2c_client *mcli, |
862 | struct i2c_adapter *adap) |
863 | { |
864 | struct mctp_i2c_dev *midev = NULL, *m = NULL; |
865 | unsigned long flags; |
866 | |
867 | WARN_ON(!mutex_is_locked(&driver_clients_lock)); |
868 | spin_lock_irqsave(&mcli->sel_lock, flags); |
869 | /* List size is limited by number of MCTP netdevs on a single hardware bus */ |
870 | list_for_each_entry(m, &mcli->devs, list) |
871 | if (m->adapter == adap) { |
872 | midev = m; |
873 | break; |
874 | } |
875 | spin_unlock_irqrestore(lock: &mcli->sel_lock, flags); |
876 | |
877 | if (midev) |
878 | mctp_i2c_unregister(midev); |
879 | } |
880 | |
881 | /* Determines whether a device is an i2c adapter. |
882 | * Optionally returns the root i2c_adapter |
883 | */ |
884 | static struct i2c_adapter *mctp_i2c_get_adapter(struct device *dev, |
885 | struct i2c_adapter **ret_root) |
886 | { |
887 | struct i2c_adapter *root, *adap; |
888 | |
889 | if (dev->type != &i2c_adapter_type) |
890 | return NULL; |
891 | adap = to_i2c_adapter(dev); |
892 | root = mux_root_adapter(adap); |
893 | WARN_ONCE(!root, "MCTP I2C failed to find root adapter for %s\n" , |
894 | dev_name(dev)); |
895 | if (!root) |
896 | return NULL; |
897 | if (ret_root) |
898 | *ret_root = root; |
899 | return adap; |
900 | } |
901 | |
902 | /* Determines whether a device is an i2c adapter with the "mctp-controller" |
903 | * devicetree property set. If adap is not an OF node, returns match_no_of |
904 | */ |
905 | static bool mctp_i2c_adapter_match(struct i2c_adapter *adap, bool match_no_of) |
906 | { |
907 | if (!adap->dev.of_node) |
908 | return match_no_of; |
909 | return of_property_read_bool(np: adap->dev.of_node, MCTP_I2C_OF_PROP); |
910 | } |
911 | |
912 | /* Called for each existing i2c device (adapter or client) when a |
913 | * new mctp-i2c client is probed. |
914 | */ |
915 | static int mctp_i2c_client_try_attach(struct device *dev, void *data) |
916 | { |
917 | struct i2c_adapter *adap = NULL, *root = NULL; |
918 | struct mctp_i2c_client *mcli = data; |
919 | |
920 | adap = mctp_i2c_get_adapter(dev, ret_root: &root); |
921 | if (!adap) |
922 | return 0; |
923 | if (mcli->client->adapter != root) |
924 | return 0; |
925 | /* Must either have mctp-controller property on the adapter, or |
926 | * be a root adapter if it's non-devicetree |
927 | */ |
928 | if (!mctp_i2c_adapter_match(adap, match_no_of: adap == root)) |
929 | return 0; |
930 | |
931 | return mctp_i2c_add_netdev(mcli, adap); |
932 | } |
933 | |
934 | static void mctp_i2c_notify_add(struct device *dev) |
935 | { |
936 | struct mctp_i2c_client *mcli = NULL, *m = NULL; |
937 | struct i2c_adapter *root = NULL, *adap = NULL; |
938 | int rc; |
939 | |
940 | adap = mctp_i2c_get_adapter(dev, ret_root: &root); |
941 | if (!adap) |
942 | return; |
943 | /* Check for mctp-controller property on the adapter */ |
944 | if (!mctp_i2c_adapter_match(adap, match_no_of: false)) |
945 | return; |
946 | |
947 | /* Find an existing mcli for adap's root */ |
948 | mutex_lock(&driver_clients_lock); |
949 | list_for_each_entry(m, &driver_clients, list) { |
950 | if (m->client->adapter == root) { |
951 | mcli = m; |
952 | break; |
953 | } |
954 | } |
955 | |
956 | if (mcli) { |
957 | rc = mctp_i2c_add_netdev(mcli, adap); |
958 | if (rc < 0) |
959 | dev_warn(dev, "Failed adding mctp-i2c net device\n" ); |
960 | } |
961 | mutex_unlock(lock: &driver_clients_lock); |
962 | } |
963 | |
964 | static void mctp_i2c_notify_del(struct device *dev) |
965 | { |
966 | struct i2c_adapter *root = NULL, *adap = NULL; |
967 | struct mctp_i2c_client *mcli = NULL; |
968 | |
969 | adap = mctp_i2c_get_adapter(dev, ret_root: &root); |
970 | if (!adap) |
971 | return; |
972 | |
973 | mutex_lock(&driver_clients_lock); |
974 | list_for_each_entry(mcli, &driver_clients, list) { |
975 | if (mcli->client->adapter == root) { |
976 | mctp_i2c_remove_netdev(mcli, adap); |
977 | break; |
978 | } |
979 | } |
980 | mutex_unlock(lock: &driver_clients_lock); |
981 | } |
982 | |
983 | static int mctp_i2c_probe(struct i2c_client *client) |
984 | { |
985 | struct mctp_i2c_client *mcli = NULL; |
986 | int rc; |
987 | |
988 | mutex_lock(&driver_clients_lock); |
989 | mcli = mctp_i2c_new_client(client); |
990 | if (IS_ERR(ptr: mcli)) { |
991 | rc = PTR_ERR(ptr: mcli); |
992 | mcli = NULL; |
993 | goto out; |
994 | } else { |
995 | list_add(new: &mcli->list, head: &driver_clients); |
996 | } |
997 | |
998 | /* Add a netdev for adapters that have a 'mctp-controller' property */ |
999 | i2c_for_each_dev(data: mcli, fn: mctp_i2c_client_try_attach); |
1000 | rc = 0; |
1001 | out: |
1002 | mutex_unlock(lock: &driver_clients_lock); |
1003 | return rc; |
1004 | } |
1005 | |
1006 | static void mctp_i2c_remove(struct i2c_client *client) |
1007 | { |
1008 | struct mctp_i2c_client *mcli = i2c_get_clientdata(client); |
1009 | struct mctp_i2c_dev *midev = NULL, *tmp = NULL; |
1010 | |
1011 | mutex_lock(&driver_clients_lock); |
1012 | list_del(entry: &mcli->list); |
1013 | /* Remove all child adapter netdevs */ |
1014 | list_for_each_entry_safe(midev, tmp, &mcli->devs, list) |
1015 | mctp_i2c_unregister(midev); |
1016 | |
1017 | mctp_i2c_free_client(mcli); |
1018 | mutex_unlock(lock: &driver_clients_lock); |
1019 | } |
1020 | |
1021 | /* We look for a 'mctp-controller' property on I2C busses as they are |
1022 | * added/deleted, creating/removing netdevs as required. |
1023 | */ |
1024 | static int mctp_i2c_notifier_call(struct notifier_block *nb, |
1025 | unsigned long action, void *data) |
1026 | { |
1027 | struct device *dev = data; |
1028 | |
1029 | switch (action) { |
1030 | case BUS_NOTIFY_ADD_DEVICE: |
1031 | mctp_i2c_notify_add(dev); |
1032 | break; |
1033 | case BUS_NOTIFY_DEL_DEVICE: |
1034 | mctp_i2c_notify_del(dev); |
1035 | break; |
1036 | } |
1037 | return NOTIFY_DONE; |
1038 | } |
1039 | |
1040 | static struct notifier_block mctp_i2c_notifier = { |
1041 | .notifier_call = mctp_i2c_notifier_call, |
1042 | }; |
1043 | |
1044 | static const struct i2c_device_id mctp_i2c_id[] = { |
1045 | { "mctp-i2c-interface" , 0 }, |
1046 | {}, |
1047 | }; |
1048 | MODULE_DEVICE_TABLE(i2c, mctp_i2c_id); |
1049 | |
1050 | static const struct of_device_id mctp_i2c_of_match[] = { |
1051 | { .compatible = "mctp-i2c-controller" }, |
1052 | {}, |
1053 | }; |
1054 | MODULE_DEVICE_TABLE(of, mctp_i2c_of_match); |
1055 | |
1056 | static struct i2c_driver mctp_i2c_driver = { |
1057 | .driver = { |
1058 | .name = "mctp-i2c-interface" , |
1059 | .of_match_table = mctp_i2c_of_match, |
1060 | }, |
1061 | .probe = mctp_i2c_probe, |
1062 | .remove = mctp_i2c_remove, |
1063 | .id_table = mctp_i2c_id, |
1064 | }; |
1065 | |
1066 | static __init int mctp_i2c_mod_init(void) |
1067 | { |
1068 | int rc; |
1069 | |
1070 | pr_info("MCTP I2C interface driver\n" ); |
1071 | rc = i2c_add_driver(&mctp_i2c_driver); |
1072 | if (rc < 0) |
1073 | return rc; |
1074 | rc = bus_register_notifier(bus: &i2c_bus_type, nb: &mctp_i2c_notifier); |
1075 | if (rc < 0) { |
1076 | i2c_del_driver(driver: &mctp_i2c_driver); |
1077 | return rc; |
1078 | } |
1079 | return 0; |
1080 | } |
1081 | |
1082 | static __exit void mctp_i2c_mod_exit(void) |
1083 | { |
1084 | int rc; |
1085 | |
1086 | rc = bus_unregister_notifier(bus: &i2c_bus_type, nb: &mctp_i2c_notifier); |
1087 | if (rc < 0) |
1088 | pr_warn("MCTP I2C could not unregister notifier, %d\n" , rc); |
1089 | i2c_del_driver(driver: &mctp_i2c_driver); |
1090 | } |
1091 | |
1092 | module_init(mctp_i2c_mod_init); |
1093 | module_exit(mctp_i2c_mod_exit); |
1094 | |
1095 | MODULE_DESCRIPTION("MCTP I2C device" ); |
1096 | MODULE_LICENSE("GPL v2" ); |
1097 | MODULE_AUTHOR("Matt Johnston <matt@codeconstruct.com.au>" ); |
1098 | |