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
mux_root_adapter(struct i2c_adapter * adap)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(&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 */
mctp_i2c_new_client(struct i2c_client * client)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(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(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(&mcli->devs);
164 INIT_LIST_HEAD(&mcli->list);
165 mcli->lladdr = client->addr & 0xff;
166 mcli->client = client;
167 i2c_set_clientdata(client, mcli);
168
169 rc = i2c_slave_register(mcli->client, 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(mcli->client);
182 kfree(mcli);
183 }
184 return ERR_PTR(rc);
185 }
186
mctp_i2c_free_client(struct mctp_i2c_client * mcli)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(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(mcli);
201 }
202
203 /* Switch the mctp i2c device to receive responses.
204 * Call with sel_lock held
205 */
__mctp_i2c_device_select(struct mctp_i2c_client * mcli,struct mctp_i2c_dev * midev)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(midev->ndev);
212 if (mcli->sel)
213 dev_put(mcli->sel->ndev);
214 mcli->sel = midev;
215 }
216
217 /* Switch the mctp i2c device to receive responses */
mctp_i2c_device_select(struct mctp_i2c_client * mcli,struct mctp_i2c_dev * midev)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(&mcli->sel_lock, flags);
226 }
227
mctp_i2c_slave_cb(struct i2c_client * client,enum i2c_slave_event event,u8 * val)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(midev->ndev);
240 spin_unlock_irqrestore(&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(midev->ndev);
268 return rc;
269 }
270
271 /* Processes incoming data that has been accumulated by the slave cb */
mctp_i2c_recv(struct mctp_i2c_dev * midev)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(0, midev->rx_buffer, recvlen);
304 if (pec != calc_pec) {
305 ndev->stats.rx_crc_errors++;
306 return -EINVAL;
307 }
308
309 skb = netdev_alloc_skb(ndev, 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, midev->rx_buffer, recvlen);
317 skb_reset_mac_header(skb);
318 skb_pull(skb, 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(&midev->rx_done);
331 spin_unlock_irqrestore(&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(&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
mctp_i2c_get_tx_flow_state(struct mctp_i2c_dev * midev,struct sk_buff * skb)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, 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(&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 */
mctp_i2c_lock_nest(struct mctp_i2c_dev * midev)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(&midev->lock, flags);
410
411 if (lock)
412 i2c_lock_bus(midev->adapter, I2C_LOCK_SEGMENT);
413 }
414
mctp_i2c_unlock_nest(struct mctp_i2c_dev * midev)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(&midev->lock, flags);
425
426 if (unlock)
427 i2c_unlock_bus(midev->adapter, I2C_LOCK_SEGMENT);
428 }
429
430 /* Unlocks the bus if was previously locked, used for cleanup */
mctp_i2c_unlock_reset(struct mctp_i2c_dev * midev)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(&midev->lock, flags);
440
441 if (unlock)
442 i2c_unlock_bus(midev->adapter, I2C_LOCK_SEGMENT);
443 }
444
mctp_i2c_invalidate_tx_flow(struct mctp_i2c_dev * midev,struct sk_buff * skb)445 static void mctp_i2c_invalidate_tx_flow(struct mctp_i2c_dev *midev,
446 struct sk_buff *skb)
447 {
448 struct mctp_sk_key *key;
449 struct mctp_flow *flow;
450 unsigned long flags;
451 bool release;
452
453 flow = skb_ext_find(skb, SKB_EXT_MCTP);
454 if (!flow)
455 return;
456
457 key = flow->key;
458 if (!key)
459 return;
460
461 spin_lock_irqsave(&key->lock, flags);
462 if (key->manual_alloc) {
463 /* we don't have control over lifetimes for manually-allocated
464 * keys, so cannot assume we can invalidate all future flows
465 * that would use this key.
466 */
467 release = false;
468 } else {
469 release = key->dev_flow_state == MCTP_I2C_FLOW_STATE_ACTIVE;
470 key->dev_flow_state = MCTP_I2C_FLOW_STATE_INVALID;
471 }
472 spin_unlock_irqrestore(&key->lock, flags);
473
474 /* if we have changed state from active, the flow held a reference on
475 * the lock; release that now.
476 */
477 if (release)
478 mctp_i2c_unlock_nest(midev);
479 }
480
mctp_i2c_xmit(struct mctp_i2c_dev * midev,struct sk_buff * skb)481 static void mctp_i2c_xmit(struct mctp_i2c_dev *midev, struct sk_buff *skb)
482 {
483 struct net_device_stats *stats = &midev->ndev->stats;
484 enum mctp_i2c_flow_state fs;
485 struct mctp_i2c_hdr *hdr;
486 struct i2c_msg msg = {0};
487 u8 *pecp;
488 int rc;
489
490 fs = mctp_i2c_get_tx_flow_state(midev, skb);
491
492 hdr = (void *)skb_mac_header(skb);
493 /* Sanity check that packet contents matches skb length,
494 * and can't exceed MCTP_I2C_BUFSZ
495 */
496 if (skb->len != hdr->byte_count + 3) {
497 dev_warn_ratelimited(&midev->adapter->dev,
498 "Bad tx length %d vs skb %u\n",
499 hdr->byte_count + 3, skb->len);
500 return;
501 }
502
503 if (skb_tailroom(skb) >= 1) {
504 /* Linear case with space, we can just append the PEC */
505 skb_put(skb, 1);
506 } else {
507 /* Otherwise need to copy the buffer */
508 skb_copy_bits(skb, 0, midev->tx_scratch, skb->len);
509 hdr = (void *)midev->tx_scratch;
510 }
511
512 pecp = (void *)&hdr->source_slave + hdr->byte_count;
513 *pecp = i2c_smbus_pec(0, (u8 *)hdr, hdr->byte_count + 3);
514 msg.buf = (void *)&hdr->command;
515 /* command, bytecount, data, pec */
516 msg.len = 2 + hdr->byte_count + 1;
517 msg.addr = hdr->dest_slave >> 1;
518
519 switch (fs) {
520 case MCTP_I2C_TX_FLOW_NONE:
521 /* no flow: full lock & unlock */
522 mctp_i2c_lock_nest(midev);
523 mctp_i2c_device_select(midev->client, midev);
524 rc = __i2c_transfer(midev->adapter, &msg, 1);
525 mctp_i2c_unlock_nest(midev);
526 break;
527
528 case MCTP_I2C_TX_FLOW_NEW:
529 /* new flow: lock, tx, but don't unlock; that will happen
530 * on flow release
531 */
532 mctp_i2c_lock_nest(midev);
533 mctp_i2c_device_select(midev->client, midev);
534 fallthrough;
535
536 case MCTP_I2C_TX_FLOW_EXISTING:
537 /* existing flow: we already have the lock; just tx */
538 rc = __i2c_transfer(midev->adapter, &msg, 1);
539
540 /* on tx errors, the flow can no longer be considered valid */
541 if (rc)
542 mctp_i2c_invalidate_tx_flow(midev, skb);
543
544 break;
545
546 case MCTP_I2C_TX_FLOW_INVALID:
547 return;
548 }
549
550 if (rc < 0) {
551 dev_warn_ratelimited(&midev->adapter->dev,
552 "__i2c_transfer failed %d\n", rc);
553 stats->tx_errors++;
554 } else {
555 stats->tx_bytes += skb->len;
556 stats->tx_packets++;
557 }
558 }
559
mctp_i2c_flow_release(struct mctp_i2c_dev * midev)560 static void mctp_i2c_flow_release(struct mctp_i2c_dev *midev)
561 {
562 unsigned long flags;
563 bool unlock;
564
565 spin_lock_irqsave(&midev->lock, flags);
566 if (midev->release_count > midev->i2c_lock_count) {
567 WARN_ONCE(1, "release count overflow");
568 midev->release_count = midev->i2c_lock_count;
569 }
570
571 midev->i2c_lock_count -= midev->release_count;
572 unlock = midev->i2c_lock_count == 0 && midev->release_count > 0;
573 midev->release_count = 0;
574 spin_unlock_irqrestore(&midev->lock, flags);
575
576 if (unlock)
577 i2c_unlock_bus(midev->adapter, I2C_LOCK_SEGMENT);
578 }
579
mctp_i2c_header_create(struct sk_buff * skb,struct net_device * dev,unsigned short type,const void * daddr,const void * saddr,unsigned int len)580 static int mctp_i2c_header_create(struct sk_buff *skb, struct net_device *dev,
581 unsigned short type, const void *daddr,
582 const void *saddr, unsigned int len)
583 {
584 struct mctp_i2c_hdr *hdr;
585 struct mctp_hdr *mhdr;
586 u8 lldst, llsrc;
587
588 if (len > MCTP_I2C_MAXMTU)
589 return -EMSGSIZE;
590
591 lldst = *((u8 *)daddr);
592 llsrc = *((u8 *)saddr);
593
594 skb_push(skb, sizeof(struct mctp_i2c_hdr));
595 skb_reset_mac_header(skb);
596 hdr = (void *)skb_mac_header(skb);
597 mhdr = mctp_hdr(skb);
598 hdr->dest_slave = (lldst << 1) & 0xff;
599 hdr->command = MCTP_I2C_COMMANDCODE;
600 hdr->byte_count = len + 1;
601 hdr->source_slave = ((llsrc << 1) & 0xff) | 0x01;
602 mhdr->ver = 0x01;
603
604 return sizeof(struct mctp_i2c_hdr);
605 }
606
mctp_i2c_tx_thread(void * data)607 static int mctp_i2c_tx_thread(void *data)
608 {
609 struct mctp_i2c_dev *midev = data;
610 struct sk_buff *skb;
611 unsigned long flags;
612
613 for (;;) {
614 if (kthread_should_stop())
615 break;
616
617 spin_lock_irqsave(&midev->tx_queue.lock, flags);
618 skb = __skb_dequeue(&midev->tx_queue);
619 if (netif_queue_stopped(midev->ndev))
620 netif_wake_queue(midev->ndev);
621 spin_unlock_irqrestore(&midev->tx_queue.lock, flags);
622
623 if (skb == &midev->unlock_marker) {
624 mctp_i2c_flow_release(midev);
625
626 } else if (skb) {
627 mctp_i2c_xmit(midev, skb);
628 kfree_skb(skb);
629
630 } else {
631 wait_event_idle(midev->tx_wq,
632 !skb_queue_empty(&midev->tx_queue) ||
633 kthread_should_stop());
634 }
635 }
636
637 return 0;
638 }
639
mctp_i2c_start_xmit(struct sk_buff * skb,struct net_device * dev)640 static netdev_tx_t mctp_i2c_start_xmit(struct sk_buff *skb,
641 struct net_device *dev)
642 {
643 struct mctp_i2c_dev *midev = netdev_priv(dev);
644 unsigned long flags;
645
646 spin_lock_irqsave(&midev->tx_queue.lock, flags);
647 if (skb_queue_len(&midev->tx_queue) >= MCTP_I2C_TX_WORK_LEN) {
648 netif_stop_queue(dev);
649 spin_unlock_irqrestore(&midev->tx_queue.lock, flags);
650 netdev_err(dev, "BUG! Tx Ring full when queue awake!\n");
651 return NETDEV_TX_BUSY;
652 }
653
654 __skb_queue_tail(&midev->tx_queue, skb);
655 if (skb_queue_len(&midev->tx_queue) == MCTP_I2C_TX_WORK_LEN)
656 netif_stop_queue(dev);
657 spin_unlock_irqrestore(&midev->tx_queue.lock, flags);
658
659 wake_up(&midev->tx_wq);
660 return NETDEV_TX_OK;
661 }
662
mctp_i2c_release_flow(struct mctp_dev * mdev,struct mctp_sk_key * key)663 static void mctp_i2c_release_flow(struct mctp_dev *mdev,
664 struct mctp_sk_key *key)
665
666 {
667 struct mctp_i2c_dev *midev = netdev_priv(mdev->dev);
668 bool queue_release = false;
669 unsigned long flags;
670
671 spin_lock_irqsave(&midev->lock, flags);
672 /* if we have seen the flow/key previously, we need to pair the
673 * original lock with a release
674 */
675 if (key->dev_flow_state == MCTP_I2C_FLOW_STATE_ACTIVE) {
676 midev->release_count++;
677 queue_release = true;
678 }
679 key->dev_flow_state = MCTP_I2C_FLOW_STATE_INVALID;
680 spin_unlock_irqrestore(&midev->lock, flags);
681
682 if (queue_release) {
683 /* Ensure we have a release operation queued, through the fake
684 * marker skb
685 */
686 spin_lock(&midev->tx_queue.lock);
687 if (!midev->unlock_marker.next)
688 __skb_queue_tail(&midev->tx_queue,
689 &midev->unlock_marker);
690 spin_unlock(&midev->tx_queue.lock);
691 wake_up(&midev->tx_wq);
692 }
693 }
694
695 static const struct net_device_ops mctp_i2c_ops = {
696 .ndo_start_xmit = mctp_i2c_start_xmit,
697 .ndo_uninit = mctp_i2c_ndo_uninit,
698 .ndo_open = mctp_i2c_ndo_open,
699 };
700
701 static const struct header_ops mctp_i2c_headops = {
702 .create = mctp_i2c_header_create,
703 };
704
705 static const struct mctp_netdev_ops mctp_i2c_mctp_ops = {
706 .release_flow = mctp_i2c_release_flow,
707 };
708
mctp_i2c_net_setup(struct net_device * dev)709 static void mctp_i2c_net_setup(struct net_device *dev)
710 {
711 dev->type = ARPHRD_MCTP;
712
713 dev->mtu = MCTP_I2C_MAXMTU;
714 dev->min_mtu = MCTP_I2C_MINMTU;
715 dev->max_mtu = MCTP_I2C_MAXMTU;
716 dev->tx_queue_len = MCTP_I2C_TX_QUEUE_LEN;
717
718 dev->hard_header_len = sizeof(struct mctp_i2c_hdr);
719 dev->addr_len = 1;
720
721 dev->netdev_ops = &mctp_i2c_ops;
722 dev->header_ops = &mctp_i2c_headops;
723 }
724
725 /* Populates the mctp_i2c_dev priv struct for a netdev.
726 * Returns an error pointer on failure.
727 */
mctp_i2c_midev_init(struct net_device * dev,struct mctp_i2c_client * mcli,struct i2c_adapter * adap)728 static struct mctp_i2c_dev *mctp_i2c_midev_init(struct net_device *dev,
729 struct mctp_i2c_client *mcli,
730 struct i2c_adapter *adap)
731 {
732 struct mctp_i2c_dev *midev = netdev_priv(dev);
733 unsigned long flags;
734
735 midev->tx_thread = kthread_create(mctp_i2c_tx_thread, midev,
736 "%s/tx", dev->name);
737 if (IS_ERR(midev->tx_thread))
738 return ERR_CAST(midev->tx_thread);
739
740 midev->ndev = dev;
741 get_device(&adap->dev);
742 midev->adapter = adap;
743 get_device(&mcli->client->dev);
744 midev->client = mcli;
745 INIT_LIST_HEAD(&midev->list);
746 spin_lock_init(&midev->lock);
747 midev->i2c_lock_count = 0;
748 midev->release_count = 0;
749 init_completion(&midev->rx_done);
750 complete(&midev->rx_done);
751 init_waitqueue_head(&midev->tx_wq);
752 skb_queue_head_init(&midev->tx_queue);
753
754 /* Add to the parent mcli */
755 spin_lock_irqsave(&mcli->sel_lock, flags);
756 list_add(&midev->list, &mcli->devs);
757 /* Select a device by default */
758 if (!mcli->sel)
759 __mctp_i2c_device_select(mcli, midev);
760 spin_unlock_irqrestore(&mcli->sel_lock, flags);
761
762 /* Start the worker thread */
763 wake_up_process(midev->tx_thread);
764
765 return midev;
766 }
767
768 /* Counterpart of mctp_i2c_midev_init */
mctp_i2c_midev_free(struct mctp_i2c_dev * midev)769 static void mctp_i2c_midev_free(struct mctp_i2c_dev *midev)
770 {
771 struct mctp_i2c_client *mcli = midev->client;
772 unsigned long flags;
773
774 if (midev->tx_thread) {
775 kthread_stop(midev->tx_thread);
776 midev->tx_thread = NULL;
777 }
778
779 /* Unconditionally unlock on close */
780 mctp_i2c_unlock_reset(midev);
781
782 /* Remove the netdev from the parent i2c client. */
783 spin_lock_irqsave(&mcli->sel_lock, flags);
784 list_del(&midev->list);
785 if (mcli->sel == midev) {
786 struct mctp_i2c_dev *first;
787
788 first = list_first_entry_or_null(&mcli->devs, struct mctp_i2c_dev, list);
789 __mctp_i2c_device_select(mcli, first);
790 }
791 spin_unlock_irqrestore(&mcli->sel_lock, flags);
792
793 skb_queue_purge(&midev->tx_queue);
794 put_device(&midev->adapter->dev);
795 put_device(&mcli->client->dev);
796 }
797
798 /* Stops, unregisters, and frees midev */
mctp_i2c_unregister(struct mctp_i2c_dev * midev)799 static void mctp_i2c_unregister(struct mctp_i2c_dev *midev)
800 {
801 unsigned long flags;
802
803 /* Stop tx thread prior to unregister, it uses netif_() functions */
804 kthread_stop(midev->tx_thread);
805 midev->tx_thread = NULL;
806
807 /* Prevent any new rx in mctp_i2c_recv(), let any pending work finish */
808 spin_lock_irqsave(&midev->lock, flags);
809 midev->allow_rx = false;
810 spin_unlock_irqrestore(&midev->lock, flags);
811 wait_for_completion(&midev->rx_done);
812
813 mctp_unregister_netdev(midev->ndev);
814 /* midev has been freed now by mctp_i2c_ndo_uninit callback */
815
816 free_netdev(midev->ndev);
817 }
818
mctp_i2c_ndo_uninit(struct net_device * dev)819 static void mctp_i2c_ndo_uninit(struct net_device *dev)
820 {
821 struct mctp_i2c_dev *midev = netdev_priv(dev);
822
823 /* Perform cleanup here to ensure that mcli->sel isn't holding
824 * a reference that would prevent unregister_netdevice()
825 * from completing.
826 */
827 mctp_i2c_midev_free(midev);
828 }
829
mctp_i2c_ndo_open(struct net_device * dev)830 static int mctp_i2c_ndo_open(struct net_device *dev)
831 {
832 struct mctp_i2c_dev *midev = netdev_priv(dev);
833 unsigned long flags;
834
835 /* i2c rx handler can only pass packets once the netdev is registered */
836 spin_lock_irqsave(&midev->lock, flags);
837 midev->allow_rx = true;
838 spin_unlock_irqrestore(&midev->lock, flags);
839
840 return 0;
841 }
842
mctp_i2c_add_netdev(struct mctp_i2c_client * mcli,struct i2c_adapter * adap)843 static int mctp_i2c_add_netdev(struct mctp_i2c_client *mcli,
844 struct i2c_adapter *adap)
845 {
846 struct mctp_i2c_dev *midev = NULL;
847 struct net_device *ndev = NULL;
848 struct i2c_adapter *root;
849 unsigned long flags;
850 char namebuf[30];
851 int rc;
852
853 root = mux_root_adapter(adap);
854 if (root != mcli->client->adapter) {
855 dev_err(&mcli->client->dev,
856 "I2C adapter %s is not a child bus of %s\n",
857 mcli->client->adapter->name, root->name);
858 return -EINVAL;
859 }
860
861 WARN_ON(!mutex_is_locked(&driver_clients_lock));
862 snprintf(namebuf, sizeof(namebuf), "mctpi2c%d", adap->nr);
863 ndev = alloc_netdev(sizeof(*midev), namebuf, NET_NAME_ENUM, mctp_i2c_net_setup);
864 if (!ndev) {
865 dev_err(&mcli->client->dev, "alloc netdev failed\n");
866 rc = -ENOMEM;
867 goto err;
868 }
869 dev_net_set(ndev, current->nsproxy->net_ns);
870 SET_NETDEV_DEV(ndev, &adap->dev);
871 dev_addr_set(ndev, &mcli->lladdr);
872
873 midev = mctp_i2c_midev_init(ndev, mcli, adap);
874 if (IS_ERR(midev)) {
875 rc = PTR_ERR(midev);
876 midev = NULL;
877 goto err;
878 }
879
880 rc = mctp_register_netdev(ndev, &mctp_i2c_mctp_ops);
881 if (rc < 0) {
882 dev_err(&mcli->client->dev,
883 "register netdev \"%s\" failed %d\n",
884 ndev->name, rc);
885 goto err;
886 }
887
888 spin_lock_irqsave(&midev->lock, flags);
889 midev->allow_rx = false;
890 spin_unlock_irqrestore(&midev->lock, flags);
891
892 return 0;
893 err:
894 if (midev)
895 mctp_i2c_midev_free(midev);
896 if (ndev)
897 free_netdev(ndev);
898 return rc;
899 }
900
901 /* Removes any netdev for adap. mcli is the parent root i2c client */
mctp_i2c_remove_netdev(struct mctp_i2c_client * mcli,struct i2c_adapter * adap)902 static void mctp_i2c_remove_netdev(struct mctp_i2c_client *mcli,
903 struct i2c_adapter *adap)
904 {
905 struct mctp_i2c_dev *midev = NULL, *m = NULL;
906 unsigned long flags;
907
908 WARN_ON(!mutex_is_locked(&driver_clients_lock));
909 spin_lock_irqsave(&mcli->sel_lock, flags);
910 /* List size is limited by number of MCTP netdevs on a single hardware bus */
911 list_for_each_entry(m, &mcli->devs, list)
912 if (m->adapter == adap) {
913 midev = m;
914 break;
915 }
916 spin_unlock_irqrestore(&mcli->sel_lock, flags);
917
918 if (midev)
919 mctp_i2c_unregister(midev);
920 }
921
922 /* Determines whether a device is an i2c adapter.
923 * Optionally returns the root i2c_adapter
924 */
mctp_i2c_get_adapter(struct device * dev,struct i2c_adapter ** ret_root)925 static struct i2c_adapter *mctp_i2c_get_adapter(struct device *dev,
926 struct i2c_adapter **ret_root)
927 {
928 struct i2c_adapter *root, *adap;
929
930 if (dev->type != &i2c_adapter_type)
931 return NULL;
932 adap = to_i2c_adapter(dev);
933 root = mux_root_adapter(adap);
934 WARN_ONCE(!root, "MCTP I2C failed to find root adapter for %s\n",
935 dev_name(dev));
936 if (!root)
937 return NULL;
938 if (ret_root)
939 *ret_root = root;
940 return adap;
941 }
942
943 /* Determines whether a device is an i2c adapter with the "mctp-controller"
944 * devicetree property set. If adap is not an OF node, returns match_no_of
945 */
mctp_i2c_adapter_match(struct i2c_adapter * adap,bool match_no_of)946 static bool mctp_i2c_adapter_match(struct i2c_adapter *adap, bool match_no_of)
947 {
948 if (!adap->dev.of_node)
949 return match_no_of;
950 return of_property_read_bool(adap->dev.of_node, MCTP_I2C_OF_PROP);
951 }
952
953 /* Called for each existing i2c device (adapter or client) when a
954 * new mctp-i2c client is probed.
955 */
mctp_i2c_client_try_attach(struct device * dev,void * data)956 static int mctp_i2c_client_try_attach(struct device *dev, void *data)
957 {
958 struct i2c_adapter *adap = NULL, *root = NULL;
959 struct mctp_i2c_client *mcli = data;
960
961 adap = mctp_i2c_get_adapter(dev, &root);
962 if (!adap)
963 return 0;
964 if (mcli->client->adapter != root)
965 return 0;
966 /* Must either have mctp-controller property on the adapter, or
967 * be a root adapter if it's non-devicetree
968 */
969 if (!mctp_i2c_adapter_match(adap, adap == root))
970 return 0;
971
972 return mctp_i2c_add_netdev(mcli, adap);
973 }
974
mctp_i2c_notify_add(struct device * dev)975 static void mctp_i2c_notify_add(struct device *dev)
976 {
977 struct mctp_i2c_client *mcli = NULL, *m = NULL;
978 struct i2c_adapter *root = NULL, *adap = NULL;
979 int rc;
980
981 adap = mctp_i2c_get_adapter(dev, &root);
982 if (!adap)
983 return;
984 /* Check for mctp-controller property on the adapter */
985 if (!mctp_i2c_adapter_match(adap, false))
986 return;
987
988 /* Find an existing mcli for adap's root */
989 mutex_lock(&driver_clients_lock);
990 list_for_each_entry(m, &driver_clients, list) {
991 if (m->client->adapter == root) {
992 mcli = m;
993 break;
994 }
995 }
996
997 if (mcli) {
998 rc = mctp_i2c_add_netdev(mcli, adap);
999 if (rc < 0)
1000 dev_warn(dev, "Failed adding mctp-i2c net device\n");
1001 }
1002 mutex_unlock(&driver_clients_lock);
1003 }
1004
mctp_i2c_notify_del(struct device * dev)1005 static void mctp_i2c_notify_del(struct device *dev)
1006 {
1007 struct i2c_adapter *root = NULL, *adap = NULL;
1008 struct mctp_i2c_client *mcli = NULL;
1009
1010 adap = mctp_i2c_get_adapter(dev, &root);
1011 if (!adap)
1012 return;
1013
1014 mutex_lock(&driver_clients_lock);
1015 list_for_each_entry(mcli, &driver_clients, list) {
1016 if (mcli->client->adapter == root) {
1017 mctp_i2c_remove_netdev(mcli, adap);
1018 break;
1019 }
1020 }
1021 mutex_unlock(&driver_clients_lock);
1022 }
1023
mctp_i2c_probe(struct i2c_client * client)1024 static int mctp_i2c_probe(struct i2c_client *client)
1025 {
1026 struct mctp_i2c_client *mcli = NULL;
1027 int rc;
1028
1029 mutex_lock(&driver_clients_lock);
1030 mcli = mctp_i2c_new_client(client);
1031 if (IS_ERR(mcli)) {
1032 rc = PTR_ERR(mcli);
1033 mcli = NULL;
1034 goto out;
1035 } else {
1036 list_add(&mcli->list, &driver_clients);
1037 }
1038
1039 /* Add a netdev for adapters that have a 'mctp-controller' property */
1040 i2c_for_each_dev(mcli, mctp_i2c_client_try_attach);
1041 rc = 0;
1042 out:
1043 mutex_unlock(&driver_clients_lock);
1044 return rc;
1045 }
1046
mctp_i2c_remove(struct i2c_client * client)1047 static void mctp_i2c_remove(struct i2c_client *client)
1048 {
1049 struct mctp_i2c_client *mcli = i2c_get_clientdata(client);
1050 struct mctp_i2c_dev *midev = NULL, *tmp = NULL;
1051
1052 mutex_lock(&driver_clients_lock);
1053 list_del(&mcli->list);
1054 /* Remove all child adapter netdevs */
1055 list_for_each_entry_safe(midev, tmp, &mcli->devs, list)
1056 mctp_i2c_unregister(midev);
1057
1058 mctp_i2c_free_client(mcli);
1059 mutex_unlock(&driver_clients_lock);
1060 }
1061
1062 /* We look for a 'mctp-controller' property on I2C busses as they are
1063 * added/deleted, creating/removing netdevs as required.
1064 */
mctp_i2c_notifier_call(struct notifier_block * nb,unsigned long action,void * data)1065 static int mctp_i2c_notifier_call(struct notifier_block *nb,
1066 unsigned long action, void *data)
1067 {
1068 struct device *dev = data;
1069
1070 switch (action) {
1071 case BUS_NOTIFY_ADD_DEVICE:
1072 mctp_i2c_notify_add(dev);
1073 break;
1074 case BUS_NOTIFY_DEL_DEVICE:
1075 mctp_i2c_notify_del(dev);
1076 break;
1077 }
1078 return NOTIFY_DONE;
1079 }
1080
1081 static struct notifier_block mctp_i2c_notifier = {
1082 .notifier_call = mctp_i2c_notifier_call,
1083 };
1084
1085 static const struct i2c_device_id mctp_i2c_id[] = {
1086 { "mctp-i2c-interface" },
1087 {}
1088 };
1089 MODULE_DEVICE_TABLE(i2c, mctp_i2c_id);
1090
1091 static const struct of_device_id mctp_i2c_of_match[] = {
1092 { .compatible = "mctp-i2c-controller" },
1093 {},
1094 };
1095 MODULE_DEVICE_TABLE(of, mctp_i2c_of_match);
1096
1097 static struct i2c_driver mctp_i2c_driver = {
1098 .driver = {
1099 .name = "mctp-i2c-interface",
1100 .of_match_table = mctp_i2c_of_match,
1101 },
1102 .probe = mctp_i2c_probe,
1103 .remove = mctp_i2c_remove,
1104 .id_table = mctp_i2c_id,
1105 };
1106
mctp_i2c_mod_init(void)1107 static __init int mctp_i2c_mod_init(void)
1108 {
1109 int rc;
1110
1111 pr_info("MCTP I2C interface driver\n");
1112 rc = i2c_add_driver(&mctp_i2c_driver);
1113 if (rc < 0)
1114 return rc;
1115 rc = bus_register_notifier(&i2c_bus_type, &mctp_i2c_notifier);
1116 if (rc < 0) {
1117 i2c_del_driver(&mctp_i2c_driver);
1118 return rc;
1119 }
1120 return 0;
1121 }
1122
mctp_i2c_mod_exit(void)1123 static __exit void mctp_i2c_mod_exit(void)
1124 {
1125 int rc;
1126
1127 rc = bus_unregister_notifier(&i2c_bus_type, &mctp_i2c_notifier);
1128 if (rc < 0)
1129 pr_warn("MCTP I2C could not unregister notifier, %d\n", rc);
1130 i2c_del_driver(&mctp_i2c_driver);
1131 }
1132
1133 module_init(mctp_i2c_mod_init);
1134 module_exit(mctp_i2c_mod_exit);
1135
1136 MODULE_DESCRIPTION("MCTP I2C device");
1137 MODULE_LICENSE("GPL v2");
1138 MODULE_AUTHOR("Matt Johnston <matt@codeconstruct.com.au>");
1139