1142 lines · c
1// SPDX-License-Identifier: GPL-2.02/*3 * Management Controller Transport Protocol (MCTP)4 * Implements DMTF specification5 * "DSP0237 Management Component Transport Protocol (MCTP) SMBus/I2C6 * Transport Binding"7 * https://www.dmtf.org/sites/default/files/standards/documents/DSP0237_1.2.0.pdf8 *9 * A netdev is created for each I2C bus that handles MCTP. In the case of an I2C10 * 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 client12 * is attached per netdev.13 *14 * mctp-i2c-controller.yml devicetree binding has further details.15 *16 * Copyright (c) 2022 Code Construct17 * Copyright (c) 2022 Google18 */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 25530/* 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 836#define MCTP_I2C_COMMANDCODE 0x0f37#define MCTP_I2C_TX_WORK_LEN 10038/* Sufficient for 64kB at min mtu */39#define MCTP_I2C_TX_QUEUE_LEN 110040 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_client50 * Lock protects driver_clients and also prevents adding/removing adapters51 * 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 the87 * mux tree, shared by multiple netdevs88 */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#else120 /* In non-mux config all i2c adapters are root adapters */121 return adap;122#endif123}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 else200 kfree(mcli);201}202 203/* Switch the mctp i2c device to receive responses.204 * Call with sel_lock held205 */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 netdev326 * unregister occurs327 */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_state357mctp_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 able374 * to handle the flow at all; just drop now375 */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 other398 * i2c clients from using the bus. refcounts are simply to prevent399 * 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-allocated464 * keys, so cannot assume we can invalidate all future flows465 * 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 on475 * 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_BUFSZ495 */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 happen530 * on flow release531 */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 the676 * original lock with a release677 */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 fake687 * marker skb688 */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 holding827 * 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 if (rc < 0) {885 dev_err(&mcli->client->dev,886 "register netdev \"%s\" failed %d\n",887 ndev->name, rc);888 goto err;889 }890 891 spin_lock_irqsave(&midev->lock, flags);892 midev->allow_rx = false;893 spin_unlock_irqrestore(&midev->lock, flags);894 895 return 0;896err:897 if (midev)898 mctp_i2c_midev_free(midev);899 if (ndev)900 free_netdev(ndev);901 return rc;902}903 904/* Removes any netdev for adap. mcli is the parent root i2c client */905static void mctp_i2c_remove_netdev(struct mctp_i2c_client *mcli,906 struct i2c_adapter *adap)907{908 struct mctp_i2c_dev *midev = NULL, *m = NULL;909 unsigned long flags;910 911 WARN_ON(!mutex_is_locked(&driver_clients_lock));912 spin_lock_irqsave(&mcli->sel_lock, flags);913 /* List size is limited by number of MCTP netdevs on a single hardware bus */914 list_for_each_entry(m, &mcli->devs, list)915 if (m->adapter == adap) {916 midev = m;917 break;918 }919 spin_unlock_irqrestore(&mcli->sel_lock, flags);920 921 if (midev)922 mctp_i2c_unregister(midev);923}924 925/* Determines whether a device is an i2c adapter.926 * Optionally returns the root i2c_adapter927 */928static struct i2c_adapter *mctp_i2c_get_adapter(struct device *dev,929 struct i2c_adapter **ret_root)930{931 struct i2c_adapter *root, *adap;932 933 if (dev->type != &i2c_adapter_type)934 return NULL;935 adap = to_i2c_adapter(dev);936 root = mux_root_adapter(adap);937 WARN_ONCE(!root, "MCTP I2C failed to find root adapter for %s\n",938 dev_name(dev));939 if (!root)940 return NULL;941 if (ret_root)942 *ret_root = root;943 return adap;944}945 946/* Determines whether a device is an i2c adapter with the "mctp-controller"947 * devicetree property set. If adap is not an OF node, returns match_no_of948 */949static bool mctp_i2c_adapter_match(struct i2c_adapter *adap, bool match_no_of)950{951 if (!adap->dev.of_node)952 return match_no_of;953 return of_property_read_bool(adap->dev.of_node, MCTP_I2C_OF_PROP);954}955 956/* Called for each existing i2c device (adapter or client) when a957 * new mctp-i2c client is probed.958 */959static int mctp_i2c_client_try_attach(struct device *dev, void *data)960{961 struct i2c_adapter *adap = NULL, *root = NULL;962 struct mctp_i2c_client *mcli = data;963 964 adap = mctp_i2c_get_adapter(dev, &root);965 if (!adap)966 return 0;967 if (mcli->client->adapter != root)968 return 0;969 /* Must either have mctp-controller property on the adapter, or970 * be a root adapter if it's non-devicetree971 */972 if (!mctp_i2c_adapter_match(adap, adap == root))973 return 0;974 975 return mctp_i2c_add_netdev(mcli, adap);976}977 978static void mctp_i2c_notify_add(struct device *dev)979{980 struct mctp_i2c_client *mcli = NULL, *m = NULL;981 struct i2c_adapter *root = NULL, *adap = NULL;982 int rc;983 984 adap = mctp_i2c_get_adapter(dev, &root);985 if (!adap)986 return;987 /* Check for mctp-controller property on the adapter */988 if (!mctp_i2c_adapter_match(adap, false))989 return;990 991 /* Find an existing mcli for adap's root */992 mutex_lock(&driver_clients_lock);993 list_for_each_entry(m, &driver_clients, list) {994 if (m->client->adapter == root) {995 mcli = m;996 break;997 }998 }999 1000 if (mcli) {1001 rc = mctp_i2c_add_netdev(mcli, adap);1002 if (rc < 0)1003 dev_warn(dev, "Failed adding mctp-i2c net device\n");1004 }1005 mutex_unlock(&driver_clients_lock);1006}1007 1008static void mctp_i2c_notify_del(struct device *dev)1009{1010 struct i2c_adapter *root = NULL, *adap = NULL;1011 struct mctp_i2c_client *mcli = NULL;1012 1013 adap = mctp_i2c_get_adapter(dev, &root);1014 if (!adap)1015 return;1016 1017 mutex_lock(&driver_clients_lock);1018 list_for_each_entry(mcli, &driver_clients, list) {1019 if (mcli->client->adapter == root) {1020 mctp_i2c_remove_netdev(mcli, adap);1021 break;1022 }1023 }1024 mutex_unlock(&driver_clients_lock);1025}1026 1027static int mctp_i2c_probe(struct i2c_client *client)1028{1029 struct mctp_i2c_client *mcli = NULL;1030 int rc;1031 1032 mutex_lock(&driver_clients_lock);1033 mcli = mctp_i2c_new_client(client);1034 if (IS_ERR(mcli)) {1035 rc = PTR_ERR(mcli);1036 mcli = NULL;1037 goto out;1038 } else {1039 list_add(&mcli->list, &driver_clients);1040 }1041 1042 /* Add a netdev for adapters that have a 'mctp-controller' property */1043 i2c_for_each_dev(mcli, mctp_i2c_client_try_attach);1044 rc = 0;1045out:1046 mutex_unlock(&driver_clients_lock);1047 return rc;1048}1049 1050static void mctp_i2c_remove(struct i2c_client *client)1051{1052 struct mctp_i2c_client *mcli = i2c_get_clientdata(client);1053 struct mctp_i2c_dev *midev = NULL, *tmp = NULL;1054 1055 mutex_lock(&driver_clients_lock);1056 list_del(&mcli->list);1057 /* Remove all child adapter netdevs */1058 list_for_each_entry_safe(midev, tmp, &mcli->devs, list)1059 mctp_i2c_unregister(midev);1060 1061 mctp_i2c_free_client(mcli);1062 mutex_unlock(&driver_clients_lock);1063}1064 1065/* We look for a 'mctp-controller' property on I2C busses as they are1066 * added/deleted, creating/removing netdevs as required.1067 */1068static int mctp_i2c_notifier_call(struct notifier_block *nb,1069 unsigned long action, void *data)1070{1071 struct device *dev = data;1072 1073 switch (action) {1074 case BUS_NOTIFY_ADD_DEVICE:1075 mctp_i2c_notify_add(dev);1076 break;1077 case BUS_NOTIFY_DEL_DEVICE:1078 mctp_i2c_notify_del(dev);1079 break;1080 }1081 return NOTIFY_DONE;1082}1083 1084static struct notifier_block mctp_i2c_notifier = {1085 .notifier_call = mctp_i2c_notifier_call,1086};1087 1088static const struct i2c_device_id mctp_i2c_id[] = {1089 { "mctp-i2c-interface" },1090 {}1091};1092MODULE_DEVICE_TABLE(i2c, mctp_i2c_id);1093 1094static const struct of_device_id mctp_i2c_of_match[] = {1095 { .compatible = "mctp-i2c-controller" },1096 {},1097};1098MODULE_DEVICE_TABLE(of, mctp_i2c_of_match);1099 1100static struct i2c_driver mctp_i2c_driver = {1101 .driver = {1102 .name = "mctp-i2c-interface",1103 .of_match_table = mctp_i2c_of_match,1104 },1105 .probe = mctp_i2c_probe,1106 .remove = mctp_i2c_remove,1107 .id_table = mctp_i2c_id,1108};1109 1110static __init int mctp_i2c_mod_init(void)1111{1112 int rc;1113 1114 pr_info("MCTP I2C interface driver\n");1115 rc = i2c_add_driver(&mctp_i2c_driver);1116 if (rc < 0)1117 return rc;1118 rc = bus_register_notifier(&i2c_bus_type, &mctp_i2c_notifier);1119 if (rc < 0) {1120 i2c_del_driver(&mctp_i2c_driver);1121 return rc;1122 }1123 return 0;1124}1125 1126static __exit void mctp_i2c_mod_exit(void)1127{1128 int rc;1129 1130 rc = bus_unregister_notifier(&i2c_bus_type, &mctp_i2c_notifier);1131 if (rc < 0)1132 pr_warn("MCTP I2C could not unregister notifier, %d\n", rc);1133 i2c_del_driver(&mctp_i2c_driver);1134}1135 1136module_init(mctp_i2c_mod_init);1137module_exit(mctp_i2c_mod_exit);1138 1139MODULE_DESCRIPTION("MCTP I2C device");1140MODULE_LICENSE("GPL v2");1141MODULE_AUTHOR("Matt Johnston <matt@codeconstruct.com.au>");1142