Loading...
Note: File does not exist in v4.6.
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
43enum {
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 */
53static DEFINE_MUTEX(driver_clients_lock);
54static LIST_HEAD(driver_clients);
55
56struct mctp_i2c_client;
57
58/* The netdev structure. One of these per I2C adapter. */
59struct 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 */
89struct 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. */
101struct 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
109static int mctp_i2c_recv(struct mctp_i2c_dev *midev);
110static int mctp_i2c_slave_cb(struct i2c_client *client,
111 enum i2c_slave_event event, u8 *val);
112static void mctp_i2c_ndo_uninit(struct net_device *dev);
113static int mctp_i2c_ndo_open(struct net_device *dev);
114
115static 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 */
129static 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;
178err:
179 if (mcli) {
180 if (mcli->client)
181 i2c_unregister_device(mcli->client);
182 kfree(mcli);
183 }
184 return ERR_PTR(rc);
185}
186
187static 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 */
206static 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 */
218static 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
228static 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 */
272static 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
349enum 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
356static enum mctp_i2c_flow_state
357mctp_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 */
401static 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
415static 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 */
431static 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
445static 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
481static 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
560static 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
580static 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 if (!daddr || !saddr)
592 return -EINVAL;
593
594 lldst = *((u8 *)daddr);
595 llsrc = *((u8 *)saddr);
596
597 skb_push(skb, sizeof(struct mctp_i2c_hdr));
598 skb_reset_mac_header(skb);
599 hdr = (void *)skb_mac_header(skb);
600 mhdr = mctp_hdr(skb);
601 hdr->dest_slave = (lldst << 1) & 0xff;
602 hdr->command = MCTP_I2C_COMMANDCODE;
603 hdr->byte_count = len + 1;
604 hdr->source_slave = ((llsrc << 1) & 0xff) | 0x01;
605 mhdr->ver = 0x01;
606
607 return sizeof(struct mctp_i2c_hdr);
608}
609
610static int mctp_i2c_tx_thread(void *data)
611{
612 struct mctp_i2c_dev *midev = data;
613 struct sk_buff *skb;
614 unsigned long flags;
615
616 for (;;) {
617 if (kthread_should_stop())
618 break;
619
620 spin_lock_irqsave(&midev->tx_queue.lock, flags);
621 skb = __skb_dequeue(&midev->tx_queue);
622 if (netif_queue_stopped(midev->ndev))
623 netif_wake_queue(midev->ndev);
624 spin_unlock_irqrestore(&midev->tx_queue.lock, flags);
625
626 if (skb == &midev->unlock_marker) {
627 mctp_i2c_flow_release(midev);
628
629 } else if (skb) {
630 mctp_i2c_xmit(midev, skb);
631 kfree_skb(skb);
632
633 } else {
634 wait_event_idle(midev->tx_wq,
635 !skb_queue_empty(&midev->tx_queue) ||
636 kthread_should_stop());
637 }
638 }
639
640 return 0;
641}
642
643static netdev_tx_t mctp_i2c_start_xmit(struct sk_buff *skb,
644 struct net_device *dev)
645{
646 struct mctp_i2c_dev *midev = netdev_priv(dev);
647 unsigned long flags;
648
649 spin_lock_irqsave(&midev->tx_queue.lock, flags);
650 if (skb_queue_len(&midev->tx_queue) >= MCTP_I2C_TX_WORK_LEN) {
651 netif_stop_queue(dev);
652 spin_unlock_irqrestore(&midev->tx_queue.lock, flags);
653 netdev_err(dev, "BUG! Tx Ring full when queue awake!\n");
654 return NETDEV_TX_BUSY;
655 }
656
657 __skb_queue_tail(&midev->tx_queue, skb);
658 if (skb_queue_len(&midev->tx_queue) == MCTP_I2C_TX_WORK_LEN)
659 netif_stop_queue(dev);
660 spin_unlock_irqrestore(&midev->tx_queue.lock, flags);
661
662 wake_up(&midev->tx_wq);
663 return NETDEV_TX_OK;
664}
665
666static void mctp_i2c_release_flow(struct mctp_dev *mdev,
667 struct mctp_sk_key *key)
668
669{
670 struct mctp_i2c_dev *midev = netdev_priv(mdev->dev);
671 bool queue_release = false;
672 unsigned long flags;
673
674 spin_lock_irqsave(&midev->lock, flags);
675 /* if we have seen the flow/key previously, we need to pair the
676 * original lock with a release
677 */
678 if (key->dev_flow_state == MCTP_I2C_FLOW_STATE_ACTIVE) {
679 midev->release_count++;
680 queue_release = true;
681 }
682 key->dev_flow_state = MCTP_I2C_FLOW_STATE_INVALID;
683 spin_unlock_irqrestore(&midev->lock, flags);
684
685 if (queue_release) {
686 /* Ensure we have a release operation queued, through the fake
687 * marker skb
688 */
689 spin_lock(&midev->tx_queue.lock);
690 if (!midev->unlock_marker.next)
691 __skb_queue_tail(&midev->tx_queue,
692 &midev->unlock_marker);
693 spin_unlock(&midev->tx_queue.lock);
694 wake_up(&midev->tx_wq);
695 }
696}
697
698static const struct net_device_ops mctp_i2c_ops = {
699 .ndo_start_xmit = mctp_i2c_start_xmit,
700 .ndo_uninit = mctp_i2c_ndo_uninit,
701 .ndo_open = mctp_i2c_ndo_open,
702};
703
704static const struct header_ops mctp_i2c_headops = {
705 .create = mctp_i2c_header_create,
706};
707
708static const struct mctp_netdev_ops mctp_i2c_mctp_ops = {
709 .release_flow = mctp_i2c_release_flow,
710};
711
712static void mctp_i2c_net_setup(struct net_device *dev)
713{
714 dev->type = ARPHRD_MCTP;
715
716 dev->mtu = MCTP_I2C_MAXMTU;
717 dev->min_mtu = MCTP_I2C_MINMTU;
718 dev->max_mtu = MCTP_I2C_MAXMTU;
719 dev->tx_queue_len = MCTP_I2C_TX_QUEUE_LEN;
720
721 dev->hard_header_len = sizeof(struct mctp_i2c_hdr);
722 dev->addr_len = 1;
723
724 dev->netdev_ops = &mctp_i2c_ops;
725 dev->header_ops = &mctp_i2c_headops;
726}
727
728/* Populates the mctp_i2c_dev priv struct for a netdev.
729 * Returns an error pointer on failure.
730 */
731static struct mctp_i2c_dev *mctp_i2c_midev_init(struct net_device *dev,
732 struct mctp_i2c_client *mcli,
733 struct i2c_adapter *adap)
734{
735 struct mctp_i2c_dev *midev = netdev_priv(dev);
736 unsigned long flags;
737
738 midev->tx_thread = kthread_create(mctp_i2c_tx_thread, midev,
739 "%s/tx", dev->name);
740 if (IS_ERR(midev->tx_thread))
741 return ERR_CAST(midev->tx_thread);
742
743 midev->ndev = dev;
744 get_device(&adap->dev);
745 midev->adapter = adap;
746 get_device(&mcli->client->dev);
747 midev->client = mcli;
748 INIT_LIST_HEAD(&midev->list);
749 spin_lock_init(&midev->lock);
750 midev->i2c_lock_count = 0;
751 midev->release_count = 0;
752 init_completion(&midev->rx_done);
753 complete(&midev->rx_done);
754 init_waitqueue_head(&midev->tx_wq);
755 skb_queue_head_init(&midev->tx_queue);
756
757 /* Add to the parent mcli */
758 spin_lock_irqsave(&mcli->sel_lock, flags);
759 list_add(&midev->list, &mcli->devs);
760 /* Select a device by default */
761 if (!mcli->sel)
762 __mctp_i2c_device_select(mcli, midev);
763 spin_unlock_irqrestore(&mcli->sel_lock, flags);
764
765 /* Start the worker thread */
766 wake_up_process(midev->tx_thread);
767
768 return midev;
769}
770
771/* Counterpart of mctp_i2c_midev_init */
772static void mctp_i2c_midev_free(struct mctp_i2c_dev *midev)
773{
774 struct mctp_i2c_client *mcli = midev->client;
775 unsigned long flags;
776
777 if (midev->tx_thread) {
778 kthread_stop(midev->tx_thread);
779 midev->tx_thread = NULL;
780 }
781
782 /* Unconditionally unlock on close */
783 mctp_i2c_unlock_reset(midev);
784
785 /* Remove the netdev from the parent i2c client. */
786 spin_lock_irqsave(&mcli->sel_lock, flags);
787 list_del(&midev->list);
788 if (mcli->sel == midev) {
789 struct mctp_i2c_dev *first;
790
791 first = list_first_entry_or_null(&mcli->devs, struct mctp_i2c_dev, list);
792 __mctp_i2c_device_select(mcli, first);
793 }
794 spin_unlock_irqrestore(&mcli->sel_lock, flags);
795
796 skb_queue_purge(&midev->tx_queue);
797 put_device(&midev->adapter->dev);
798 put_device(&mcli->client->dev);
799}
800
801/* Stops, unregisters, and frees midev */
802static void mctp_i2c_unregister(struct mctp_i2c_dev *midev)
803{
804 unsigned long flags;
805
806 /* Stop tx thread prior to unregister, it uses netif_() functions */
807 kthread_stop(midev->tx_thread);
808 midev->tx_thread = NULL;
809
810 /* Prevent any new rx in mctp_i2c_recv(), let any pending work finish */
811 spin_lock_irqsave(&midev->lock, flags);
812 midev->allow_rx = false;
813 spin_unlock_irqrestore(&midev->lock, flags);
814 wait_for_completion(&midev->rx_done);
815
816 mctp_unregister_netdev(midev->ndev);
817 /* midev has been freed now by mctp_i2c_ndo_uninit callback */
818
819 free_netdev(midev->ndev);
820}
821
822static void mctp_i2c_ndo_uninit(struct net_device *dev)
823{
824 struct mctp_i2c_dev *midev = netdev_priv(dev);
825
826 /* Perform cleanup here to ensure that mcli->sel isn't holding
827 * a reference that would prevent unregister_netdevice()
828 * from completing.
829 */
830 mctp_i2c_midev_free(midev);
831}
832
833static int mctp_i2c_ndo_open(struct net_device *dev)
834{
835 struct mctp_i2c_dev *midev = netdev_priv(dev);
836 unsigned long flags;
837
838 /* i2c rx handler can only pass packets once the netdev is registered */
839 spin_lock_irqsave(&midev->lock, flags);
840 midev->allow_rx = true;
841 spin_unlock_irqrestore(&midev->lock, flags);
842
843 return 0;
844}
845
846static int mctp_i2c_add_netdev(struct mctp_i2c_client *mcli,
847 struct i2c_adapter *adap)
848{
849 struct mctp_i2c_dev *midev = NULL;
850 struct net_device *ndev = NULL;
851 struct i2c_adapter *root;
852 unsigned long flags;
853 char namebuf[30];
854 int rc;
855
856 root = mux_root_adapter(adap);
857 if (root != mcli->client->adapter) {
858 dev_err(&mcli->client->dev,
859 "I2C adapter %s is not a child bus of %s\n",
860 mcli->client->adapter->name, root->name);
861 return -EINVAL;
862 }
863
864 WARN_ON(!mutex_is_locked(&driver_clients_lock));
865 snprintf(namebuf, sizeof(namebuf), "mctpi2c%d", adap->nr);
866 ndev = alloc_netdev(sizeof(*midev), namebuf, NET_NAME_ENUM, mctp_i2c_net_setup);
867 if (!ndev) {
868 dev_err(&mcli->client->dev, "alloc netdev failed\n");
869 rc = -ENOMEM;
870 goto err;
871 }
872 dev_net_set(ndev, current->nsproxy->net_ns);
873 SET_NETDEV_DEV(ndev, &adap->dev);
874 dev_addr_set(ndev, &mcli->lladdr);
875
876 midev = mctp_i2c_midev_init(ndev, mcli, adap);
877 if (IS_ERR(midev)) {
878 rc = PTR_ERR(midev);
879 midev = NULL;
880 goto err;
881 }
882
883 rc = mctp_register_netdev(ndev, &mctp_i2c_mctp_ops,
884 MCTP_PHYS_BINDING_SMBUS);
885 if (rc < 0) {
886 dev_err(&mcli->client->dev,
887 "register netdev \"%s\" failed %d\n",
888 ndev->name, rc);
889 goto err;
890 }
891
892 spin_lock_irqsave(&midev->lock, flags);
893 midev->allow_rx = false;
894 spin_unlock_irqrestore(&midev->lock, flags);
895
896 return 0;
897err:
898 if (midev)
899 mctp_i2c_midev_free(midev);
900 if (ndev)
901 free_netdev(ndev);
902 return rc;
903}
904
905/* Removes any netdev for adap. mcli is the parent root i2c client */
906static void mctp_i2c_remove_netdev(struct mctp_i2c_client *mcli,
907 struct i2c_adapter *adap)
908{
909 struct mctp_i2c_dev *midev = NULL, *m = NULL;
910 unsigned long flags;
911
912 WARN_ON(!mutex_is_locked(&driver_clients_lock));
913 spin_lock_irqsave(&mcli->sel_lock, flags);
914 /* List size is limited by number of MCTP netdevs on a single hardware bus */
915 list_for_each_entry(m, &mcli->devs, list)
916 if (m->adapter == adap) {
917 midev = m;
918 break;
919 }
920 spin_unlock_irqrestore(&mcli->sel_lock, flags);
921
922 if (midev)
923 mctp_i2c_unregister(midev);
924}
925
926/* Determines whether a device is an i2c adapter.
927 * Optionally returns the root i2c_adapter
928 */
929static struct i2c_adapter *mctp_i2c_get_adapter(struct device *dev,
930 struct i2c_adapter **ret_root)
931{
932 struct i2c_adapter *root, *adap;
933
934 if (dev->type != &i2c_adapter_type)
935 return NULL;
936 adap = to_i2c_adapter(dev);
937 root = mux_root_adapter(adap);
938 WARN_ONCE(!root, "MCTP I2C failed to find root adapter for %s\n",
939 dev_name(dev));
940 if (!root)
941 return NULL;
942 if (ret_root)
943 *ret_root = root;
944 return adap;
945}
946
947/* Determines whether a device is an i2c adapter with the "mctp-controller"
948 * devicetree property set. If adap is not an OF node, returns match_no_of
949 */
950static bool mctp_i2c_adapter_match(struct i2c_adapter *adap, bool match_no_of)
951{
952 if (!adap->dev.of_node)
953 return match_no_of;
954 return of_property_read_bool(adap->dev.of_node, MCTP_I2C_OF_PROP);
955}
956
957/* Called for each existing i2c device (adapter or client) when a
958 * new mctp-i2c client is probed.
959 */
960static int mctp_i2c_client_try_attach(struct device *dev, void *data)
961{
962 struct i2c_adapter *adap = NULL, *root = NULL;
963 struct mctp_i2c_client *mcli = data;
964
965 adap = mctp_i2c_get_adapter(dev, &root);
966 if (!adap)
967 return 0;
968 if (mcli->client->adapter != root)
969 return 0;
970 /* Must either have mctp-controller property on the adapter, or
971 * be a root adapter if it's non-devicetree
972 */
973 if (!mctp_i2c_adapter_match(adap, adap == root))
974 return 0;
975
976 return mctp_i2c_add_netdev(mcli, adap);
977}
978
979static void mctp_i2c_notify_add(struct device *dev)
980{
981 struct mctp_i2c_client *mcli = NULL, *m = NULL;
982 struct i2c_adapter *root = NULL, *adap = NULL;
983 int rc;
984
985 adap = mctp_i2c_get_adapter(dev, &root);
986 if (!adap)
987 return;
988 /* Check for mctp-controller property on the adapter */
989 if (!mctp_i2c_adapter_match(adap, false))
990 return;
991
992 /* Find an existing mcli for adap's root */
993 mutex_lock(&driver_clients_lock);
994 list_for_each_entry(m, &driver_clients, list) {
995 if (m->client->adapter == root) {
996 mcli = m;
997 break;
998 }
999 }
1000
1001 if (mcli) {
1002 rc = mctp_i2c_add_netdev(mcli, adap);
1003 if (rc < 0)
1004 dev_warn(dev, "Failed adding mctp-i2c net device\n");
1005 }
1006 mutex_unlock(&driver_clients_lock);
1007}
1008
1009static void mctp_i2c_notify_del(struct device *dev)
1010{
1011 struct i2c_adapter *root = NULL, *adap = NULL;
1012 struct mctp_i2c_client *mcli = NULL;
1013
1014 adap = mctp_i2c_get_adapter(dev, &root);
1015 if (!adap)
1016 return;
1017
1018 mutex_lock(&driver_clients_lock);
1019 list_for_each_entry(mcli, &driver_clients, list) {
1020 if (mcli->client->adapter == root) {
1021 mctp_i2c_remove_netdev(mcli, adap);
1022 break;
1023 }
1024 }
1025 mutex_unlock(&driver_clients_lock);
1026}
1027
1028static int mctp_i2c_probe(struct i2c_client *client)
1029{
1030 struct mctp_i2c_client *mcli = NULL;
1031 int rc;
1032
1033 mutex_lock(&driver_clients_lock);
1034 mcli = mctp_i2c_new_client(client);
1035 if (IS_ERR(mcli)) {
1036 rc = PTR_ERR(mcli);
1037 mcli = NULL;
1038 goto out;
1039 } else {
1040 list_add(&mcli->list, &driver_clients);
1041 }
1042
1043 /* Add a netdev for adapters that have a 'mctp-controller' property */
1044 i2c_for_each_dev(mcli, mctp_i2c_client_try_attach);
1045 rc = 0;
1046out:
1047 mutex_unlock(&driver_clients_lock);
1048 return rc;
1049}
1050
1051static void mctp_i2c_remove(struct i2c_client *client)
1052{
1053 struct mctp_i2c_client *mcli = i2c_get_clientdata(client);
1054 struct mctp_i2c_dev *midev = NULL, *tmp = NULL;
1055
1056 mutex_lock(&driver_clients_lock);
1057 list_del(&mcli->list);
1058 /* Remove all child adapter netdevs */
1059 list_for_each_entry_safe(midev, tmp, &mcli->devs, list)
1060 mctp_i2c_unregister(midev);
1061
1062 mctp_i2c_free_client(mcli);
1063 mutex_unlock(&driver_clients_lock);
1064}
1065
1066/* We look for a 'mctp-controller' property on I2C busses as they are
1067 * added/deleted, creating/removing netdevs as required.
1068 */
1069static int mctp_i2c_notifier_call(struct notifier_block *nb,
1070 unsigned long action, void *data)
1071{
1072 struct device *dev = data;
1073
1074 switch (action) {
1075 case BUS_NOTIFY_ADD_DEVICE:
1076 mctp_i2c_notify_add(dev);
1077 break;
1078 case BUS_NOTIFY_DEL_DEVICE:
1079 mctp_i2c_notify_del(dev);
1080 break;
1081 }
1082 return NOTIFY_DONE;
1083}
1084
1085static struct notifier_block mctp_i2c_notifier = {
1086 .notifier_call = mctp_i2c_notifier_call,
1087};
1088
1089static const struct i2c_device_id mctp_i2c_id[] = {
1090 { "mctp-i2c-interface" },
1091 {}
1092};
1093MODULE_DEVICE_TABLE(i2c, mctp_i2c_id);
1094
1095static const struct of_device_id mctp_i2c_of_match[] = {
1096 { .compatible = "mctp-i2c-controller" },
1097 {},
1098};
1099MODULE_DEVICE_TABLE(of, mctp_i2c_of_match);
1100
1101static struct i2c_driver mctp_i2c_driver = {
1102 .driver = {
1103 .name = "mctp-i2c-interface",
1104 .of_match_table = mctp_i2c_of_match,
1105 },
1106 .probe = mctp_i2c_probe,
1107 .remove = mctp_i2c_remove,
1108 .id_table = mctp_i2c_id,
1109};
1110
1111static __init int mctp_i2c_mod_init(void)
1112{
1113 int rc;
1114
1115 pr_info("MCTP I2C interface driver\n");
1116 rc = i2c_add_driver(&mctp_i2c_driver);
1117 if (rc < 0)
1118 return rc;
1119 rc = bus_register_notifier(&i2c_bus_type, &mctp_i2c_notifier);
1120 if (rc < 0) {
1121 i2c_del_driver(&mctp_i2c_driver);
1122 return rc;
1123 }
1124 return 0;
1125}
1126
1127static __exit void mctp_i2c_mod_exit(void)
1128{
1129 int rc;
1130
1131 rc = bus_unregister_notifier(&i2c_bus_type, &mctp_i2c_notifier);
1132 if (rc < 0)
1133 pr_warn("MCTP I2C could not unregister notifier, %d\n", rc);
1134 i2c_del_driver(&mctp_i2c_driver);
1135}
1136
1137module_init(mctp_i2c_mod_init);
1138module_exit(mctp_i2c_mod_exit);
1139
1140MODULE_DESCRIPTION("MCTP I2C device");
1141MODULE_LICENSE("GPL v2");
1142MODULE_AUTHOR("Matt Johnston <matt@codeconstruct.com.au>");