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_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, 1); 470 } else { 471 /* Otherwise need to copy the buffer */ 472 skb_copy_bits(skb, 0, midev->tx_scratch, skb->len); 473 hdr = (void *)midev->tx_scratch; 474 } 475 476 pecp = (void *)&hdr->source_slave + hdr->byte_count; 477 *pecp = i2c_smbus_pec(0, (u8 *)hdr, 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(midev->client, midev); 488 rc = __i2c_transfer(midev->adapter, &msg, 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(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(midev->adapter, &msg, 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(&midev->lock, flags); 534 535 if (unlock) 536 i2c_unlock_bus(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, 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(&midev->tx_queue); 578 if (netif_queue_stopped(midev->ndev)) 579 netif_wake_queue(midev->ndev); 580 spin_unlock_irqrestore(&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(&midev->tx_queue) >= MCTP_I2C_TX_WORK_LEN) { 607 netif_stop_queue(dev); 608 spin_unlock_irqrestore(&midev->tx_queue.lock, flags); 609 netdev_err(dev, "BUG! Tx Ring full when queue awake!\n"); 610 return NETDEV_TX_BUSY; 611 } 612 613 __skb_queue_tail(&midev->tx_queue, skb); 614 if (skb_queue_len(&midev->tx_queue) == MCTP_I2C_TX_WORK_LEN) 615 netif_stop_queue(dev); 616 spin_unlock_irqrestore(&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(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(&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(&midev->tx_queue.lock); 646 if (!midev->unlock_marker.next) 647 __skb_queue_tail(&midev->tx_queue, 648 &midev->unlock_marker); 649 spin_unlock(&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(midev->tx_thread)) 697 return ERR_CAST(midev->tx_thread); 698 699 midev->ndev = dev; 700 get_device(&adap->dev); 701 midev->adapter = adap; 702 get_device(&mcli->client->dev); 703 midev->client = mcli; 704 INIT_LIST_HEAD(&midev->list); 705 spin_lock_init(&midev->lock); 706 midev->i2c_lock_count = 0; 707 midev->release_count = 0; 708 init_completion(&midev->rx_done); 709 complete(&midev->rx_done); 710 init_waitqueue_head(&midev->tx_wq); 711 skb_queue_head_init(&midev->tx_queue); 712 713 /* Add to the parent mcli */ 714 spin_lock_irqsave(&mcli->sel_lock, flags); 715 list_add(&midev->list, &mcli->devs); 716 /* Select a device by default */ 717 if (!mcli->sel) 718 __mctp_i2c_device_select(mcli, midev); 719 spin_unlock_irqrestore(&mcli->sel_lock, flags); 720 721 /* Start the worker thread */ 722 wake_up_process(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(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(&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, first); 749 } 750 spin_unlock_irqrestore(&mcli->sel_lock, flags); 751 752 skb_queue_purge(&midev->tx_queue); 753 put_device(&midev->adapter->dev); 754 put_device(&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(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(&midev->lock, flags); 770 wait_for_completion(&midev->rx_done); 771 772 mctp_unregister_netdev(midev->ndev); 773 /* midev has been freed now by mctp_i2c_ndo_uninit callback */ 774 775 free_netdev(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(&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(namebuf, sizeof(namebuf), "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(ndev, current->nsproxy->net_ns); 829 SET_NETDEV_DEV(ndev, &adap->dev); 830 dev_addr_set(ndev, &mcli->lladdr); 831 832 midev = mctp_i2c_midev_init(ndev, mcli, adap); 833 if (IS_ERR(midev)) { 834 rc = PTR_ERR(midev); 835 midev = NULL; 836 goto err; 837 } 838 839 rc = mctp_register_netdev(ndev, &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(&midev->lock, flags); 850 851 return 0; 852err: 853 if (midev) 854 mctp_i2c_midev_free(midev); 855 if (ndev) 856 free_netdev(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(&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(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, &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, 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, &root); 941 if (!adap) 942 return; 943 /* Check for mctp-controller property on the adapter */ 944 if (!mctp_i2c_adapter_match(adap, 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(&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, &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(&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(mcli)) { 991 rc = PTR_ERR(mcli); 992 mcli = NULL; 993 goto out; 994 } else { 995 list_add(&mcli->list, &driver_clients); 996 } 997 998 /* Add a netdev for adapters that have a 'mctp-controller' property */ 999 i2c_for_each_dev(mcli, mctp_i2c_client_try_attach); 1000 rc = 0; 1001out: 1002 mutex_unlock(&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(&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(&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(&i2c_bus_type, &mctp_i2c_notifier); 1075 if (rc < 0) { 1076 i2c_del_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(&i2c_bus_type, &mctp_i2c_notifier); 1087 if (rc < 0) 1088 pr_warn("MCTP I2C could not unregister notifier, %d\n", rc); 1089 i2c_del_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