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(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 */
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(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;
178err:
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
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(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 */
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(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 */
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(lock: &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(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 */
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(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
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, 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 */
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(lock: &midev->lock, flags);
410
411 if (lock)
412 i2c_lock_bus(adapter: 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(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 */
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(lock: &midev->lock, flags);
440
441 if (unlock)
442 i2c_unlock_bus(adapter: midev->adapter, I2C_LOCK_SEGMENT);
443}
444
445static 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
519static 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
539static int mctp_i2c_header_create(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
566static 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
599static 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
622static 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
654static 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
660static const struct header_ops mctp_i2c_headops = {
661 .create = mctp_i2c_header_create,
662};
663
664static const struct mctp_netdev_ops mctp_i2c_mctp_ops = {
665 .release_flow = mctp_i2c_release_flow,
666};
667
668static 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 */
687static 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 */
728static 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 */
758static 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
778static 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
789static 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
802static 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;
852err:
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 */
861static 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 */
884static 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 */
905static 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 */
915static 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
934static 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
964static 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
983static 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;
1001out:
1002 mutex_unlock(lock: &driver_clients_lock);
1003 return rc;
1004}
1005
1006static 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 */
1024static 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
1040static struct notifier_block mctp_i2c_notifier = {
1041 .notifier_call = mctp_i2c_notifier_call,
1042};
1043
1044static const struct i2c_device_id mctp_i2c_id[] = {
1045 { "mctp-i2c-interface", 0 },
1046 {},
1047};
1048MODULE_DEVICE_TABLE(i2c, mctp_i2c_id);
1049
1050static const struct of_device_id mctp_i2c_of_match[] = {
1051 { .compatible = "mctp-i2c-controller" },
1052 {},
1053};
1054MODULE_DEVICE_TABLE(of, mctp_i2c_of_match);
1055
1056static 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
1066static __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
1082static __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
1092module_init(mctp_i2c_mod_init);
1093module_exit(mctp_i2c_mod_exit);
1094
1095MODULE_DESCRIPTION("MCTP I2C device");
1096MODULE_LICENSE("GPL v2");
1097MODULE_AUTHOR("Matt Johnston <matt@codeconstruct.com.au>");
1098

source code of linux/drivers/net/mctp/mctp-i2c.c