drivers/net/mctp/mctp-i2c.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * Management Controller Transport Protocol (MCTP)
   4  * Implements DMTF specification
   5  * "DSP0237 Management Component Transport Protocol (MCTP) SMBus/I2C
   6  * Transport Binding"
   7  * https://www.dmtf.org/sites/default/files/standards/documents/DSP0237_1.2.0.pdf
   8  *
   9  * A netdev is created for each I2C bus that handles MCTP. In the case of an I2C
  10  * mux topology a single I2C client is attached to the root of the mux topology,
  11  * shared between all mux I2C busses underneath. For non-mux cases an I2C client
  12  * is attached per netdev.
  13  *
  14  * mctp-i2c-controller.yml devicetree binding has further details.
  15  *
  16  * Copyright (c) 2022 Code Construct
  17  * Copyright (c) 2022 Google
  18  */
  19
  20 #include <linux/module.h>
  21 #include <linux/netdevice.h>
  22 #include <linux/i2c.h>
  23 #include <linux/i2c-mux.h>
  24 #include <linux/if_arp.h>
  25 #include <net/mctp.h>
  26 #include <net/mctpdevice.h>
  27
  28 /* byte_count is limited to u8 */
  29 #define MCTP_I2C_MAXBLOCK 255
  30 /* One byte is taken by source_slave */
  31 #define MCTP_I2C_MAXMTU (MCTP_I2C_MAXBLOCK - 1)
  32 #define MCTP_I2C_MINMTU (64 + 4)
  33 /* Allow space for dest_address, command, byte_count, data, PEC */
  34 #define MCTP_I2C_BUFSZ (3 + MCTP_I2C_MAXBLOCK + 1)
  35 #define MCTP_I2C_MINLEN 8
  36 #define MCTP_I2C_COMMANDCODE 0x0f
  37 #define MCTP_I2C_TX_WORK_LEN 100
  38 /* Sufficient for 64kB at min mtu */
  39 #define MCTP_I2C_TX_QUEUE_LEN 1100
  40
  41 #define MCTP_I2C_OF_PROP "mctp-controller"
  42
  43 enum {
  44         MCTP_I2C_FLOW_STATE_NEW = 0,
  45         MCTP_I2C_FLOW_STATE_ACTIVE,
  46         MCTP_I2C_FLOW_STATE_INVALID,
  47 };
  48
  49 /* List of all struct mctp_i2c_client
  50  * Lock protects driver_clients and also prevents adding/removing adapters
  51  * during mctp_i2c_client probe/remove.
  52  */
  53 static DEFINE_MUTEX(driver_clients_lock);
  54 static LIST_HEAD(driver_clients);
  55
  56 struct mctp_i2c_client;
  57
  58 /* The netdev structure. One of these per I2C adapter. */
  59 struct mctp_i2c_dev {
  60         struct net_device *ndev;
  61         struct i2c_adapter *adapter;
  62         struct mctp_i2c_client *client;
  63         struct list_head list; /* For mctp_i2c_client.devs */
  64
  65         size_t rx_pos;
  66         u8 rx_buffer[MCTP_I2C_BUFSZ];
  67         struct completion rx_done;
  68
  69         struct task_struct *tx_thread;
  70         wait_queue_head_t tx_wq;
  71         struct sk_buff_head tx_queue;
  72         u8 tx_scratch[MCTP_I2C_BUFSZ];
  73
  74         /* A fake entry in our tx queue to perform an unlock operation */
  75         struct sk_buff unlock_marker;
  76
  77         /* Spinlock protects i2c_lock_count, release_count, allow_rx */
  78         spinlock_t lock;
  79         int i2c_lock_count;
  80         int release_count;
  81         /* Indicates that the netif is ready to receive incoming packets */
  82         bool allow_rx;
  83
  84 };
  85
  86 /* The i2c client structure. One per hardware i2c bus at the top of the
  87  * mux tree, shared by multiple netdevs
  88  */
  89 struct mctp_i2c_client {
  90         struct i2c_client *client;
  91         u8 lladdr;
  92
  93         struct mctp_i2c_dev *sel;
  94         struct list_head devs;
  95         spinlock_t sel_lock; /* Protects sel and devs */
  96
  97         struct list_head list; /* For driver_clients */
  98 };
  99
 100 /* Header on the wire. */
 101 struct mctp_i2c_hdr {
 102         u8 dest_slave;
 103         u8 command;
 104         /* Count of bytes following byte_count, excluding PEC */
 105         u8 byte_count;
 106         u8 source_slave;
 107 };
 108
 109 static int mctp_i2c_recv(struct mctp_i2c_dev *midev);
 110 static int mctp_i2c_slave_cb(struct i2c_client *client,
 111                              enum i2c_slave_event event, u8 *val);
 112 static void mctp_i2c_ndo_uninit(struct net_device *dev);
 113 static int mctp_i2c_ndo_open(struct net_device *dev);
 114
 115 static struct i2c_adapter *mux_root_adapter(struct i2c_adapter *adap)
 116 {
 117 #if IS_ENABLED(CONFIG_I2C_MUX)
 118         return i2c_root_adapter(&adap->dev);
 119 #else
 120         /* In non-mux config all i2c adapters are root adapters */
 121         return adap;
 122 #endif
 123 }
 124
 125 /* Creates a new i2c slave device attached to the root adapter.
 126  * Sets up the slave callback.
 127  * Must be called with a client on a root adapter.
 128  */
 129 static struct mctp_i2c_client *mctp_i2c_new_client(struct i2c_client *client)
 130 {
 131         struct mctp_i2c_client *mcli = NULL;
 132         struct i2c_adapter *root = NULL;
 133         int rc;
 134
 135         if (client->flags & I2C_CLIENT_TEN) {
 136                 dev_err(&client->dev, "failed, MCTP requires a 7-bit I2C address, addr=0x%x\n",
 137                         client->addr);
 138                 rc = -EINVAL;
 139                 goto err;
 140         }
 141
 142         root = mux_root_adapter(client->adapter);
 143         if (!root) {
 144                 dev_err(&client->dev, "failed to find root adapter\n");
 145                 rc = -ENOENT;
 146                 goto err;
 147         }
 148         if (root != client->adapter) {
 149                 dev_err(&client->dev,
 150                         "A mctp-i2c-controller client cannot be placed on an I2C mux adapter.\n"
 151                         " It should be placed on the mux tree root adapter\n"
 152                         " then set mctp-controller property on adapters to attach\n");
 153                 rc = -EINVAL;
 154                 goto err;
 155         }
 156
 157         mcli = kzalloc(sizeof(*mcli), GFP_KERNEL);
 158         if (!mcli) {
 159                 rc = -ENOMEM;
 160                 goto err;
 161         }
 162         spin_lock_init(&mcli->sel_lock);
 163         INIT_LIST_HEAD(&mcli->devs);
 164         INIT_LIST_HEAD(&mcli->list);
 165         mcli->lladdr = client->addr & 0xff;
 166         mcli->client = client;
 167         i2c_set_clientdata(client, mcli);
 168
 169         rc = i2c_slave_register(mcli->client, mctp_i2c_slave_cb);
 170         if (rc < 0) {
 171                 dev_err(&client->dev, "i2c register failed %d\n", rc);
 172                 mcli->client = NULL;
 173                 i2c_set_clientdata(client, NULL);
 174                 goto err;
 175         }
 176
 177         return mcli;
 178 err:
 179         if (mcli) {
 180                 if (mcli->client)
 181                         i2c_unregister_device(mcli->client);
 182                 kfree(mcli);
 183         }
 184         return ERR_PTR(rc);
 185 }
 186
 187 static void mctp_i2c_free_client(struct mctp_i2c_client *mcli)
 188 {
 189         int rc;
 190
 191         WARN_ON(!mutex_is_locked(&driver_clients_lock));
 192         WARN_ON(!list_empty(&mcli->devs));
 193         WARN_ON(mcli->sel); /* sanity check, no locking */
 194
 195         rc = i2c_slave_unregister(mcli->client);
 196         /* Leak if it fails, we can't propagate errors upwards */
 197         if (rc < 0)
 198                 dev_err(&mcli->client->dev, "i2c unregister failed %d\n", rc);
 199         else
 200                 kfree(mcli);
 201 }
 202
 203 /* Switch the mctp i2c device to receive responses.
 204  * Call with sel_lock held
 205  */
 206 static void __mctp_i2c_device_select(struct mctp_i2c_client *mcli,
 207                                      struct mctp_i2c_dev *midev)
 208 {
 209         assert_spin_locked(&mcli->sel_lock);
 210         if (midev)
 211                 dev_hold(midev->ndev);
 212         if (mcli->sel)
 213                 dev_put(mcli->sel->ndev);
 214         mcli->sel = midev;
 215 }
 216
 217 /* Switch the mctp i2c device to receive responses */
 218 static void mctp_i2c_device_select(struct mctp_i2c_client *mcli,
 219                                    struct mctp_i2c_dev *midev)
 220 {
 221         unsigned long flags;
 222
 223         spin_lock_irqsave(&mcli->sel_lock, flags);
 224         __mctp_i2c_device_select(mcli, midev);
 225         spin_unlock_irqrestore(&mcli->sel_lock, flags);
 226 }
 227
 228 static int mctp_i2c_slave_cb(struct i2c_client *client,
 229                              enum i2c_slave_event event, u8 *val)
 230 {
 231         struct mctp_i2c_client *mcli = i2c_get_clientdata(client);
 232         struct mctp_i2c_dev *midev = NULL;
 233         unsigned long flags;
 234         int rc = 0;
 235
 236         spin_lock_irqsave(&mcli->sel_lock, flags);
 237         midev = mcli->sel;
 238         if (midev)
 239                 dev_hold(midev->ndev);
 240         spin_unlock_irqrestore(&mcli->sel_lock, flags);
 241
 242         if (!midev)
 243                 return 0;
 244
 245         switch (event) {
 246         case I2C_SLAVE_WRITE_RECEIVED:
 247                 if (midev->rx_pos < MCTP_I2C_BUFSZ) {
 248                         midev->rx_buffer[midev->rx_pos] = *val;
 249                         midev->rx_pos++;
 250                 } else {
 251                         midev->ndev->stats.rx_over_errors++;
 252                 }
 253
 254                 break;
 255         case I2C_SLAVE_WRITE_REQUESTED:
 256                 /* dest_slave as first byte */
 257                 midev->rx_buffer[0] = mcli->lladdr << 1;
 258                 midev->rx_pos = 1;
 259                 break;
 260         case I2C_SLAVE_STOP:
 261                 rc = mctp_i2c_recv(midev);
 262                 break;
 263         default:
 264                 break;
 265         }
 266
 267         dev_put(midev->ndev);
 268         return rc;
 269 }
 270
 271 /* Processes incoming data that has been accumulated by the slave cb */
 272 static int mctp_i2c_recv(struct mctp_i2c_dev *midev)
 273 {
 274         struct net_device *ndev = midev->ndev;
 275         struct mctp_i2c_hdr *hdr;
 276         struct mctp_skb_cb *cb;
 277         struct sk_buff *skb;
 278         unsigned long flags;
 279         u8 pec, calc_pec;
 280         size_t recvlen;
 281         int status;
 282
 283         /* + 1 for the PEC */
 284         if (midev->rx_pos < MCTP_I2C_MINLEN + 1) {
 285                 ndev->stats.rx_length_errors++;
 286                 return -EINVAL;
 287         }
 288         /* recvlen excludes PEC */
 289         recvlen = midev->rx_pos - 1;
 290
 291         hdr = (void *)midev->rx_buffer;
 292         if (hdr->command != MCTP_I2C_COMMANDCODE) {
 293                 ndev->stats.rx_dropped++;
 294                 return -EINVAL;
 295         }
 296
 297         if (hdr->byte_count + offsetof(struct mctp_i2c_hdr, source_slave) != recvlen) {
 298                 ndev->stats.rx_length_errors++;
 299                 return -EINVAL;
 300         }
 301
 302         pec = midev->rx_buffer[midev->rx_pos - 1];
 303         calc_pec = i2c_smbus_pec(0, midev->rx_buffer, recvlen);
 304         if (pec != calc_pec) {
 305                 ndev->stats.rx_crc_errors++;
 306                 return -EINVAL;
 307         }
 308
 309         skb = netdev_alloc_skb(ndev, recvlen);
 310         if (!skb) {
 311                 ndev->stats.rx_dropped++;
 312                 return -ENOMEM;
 313         }
 314
 315         skb->protocol = htons(ETH_P_MCTP);
 316         skb_put_data(skb, midev->rx_buffer, recvlen);
 317         skb_reset_mac_header(skb);
 318         skb_pull(skb, sizeof(struct mctp_i2c_hdr));
 319         skb_reset_network_header(skb);
 320
 321         cb = __mctp_cb(skb);
 322         cb->halen = 1;
 323         cb->haddr[0] = hdr->source_slave >> 1;
 324
 325         /* We need to ensure that the netif is not used once netdev
 326          * unregister occurs
 327          */
 328         spin_lock_irqsave(&midev->lock, flags);
 329         if (midev->allow_rx) {
 330                 reinit_completion(&midev->rx_done);
 331                 spin_unlock_irqrestore(&midev->lock, flags);
 332
 333                 status = netif_rx(skb);
 334                 complete(&midev->rx_done);
 335         } else {
 336                 status = NET_RX_DROP;
 337                 spin_unlock_irqrestore(&midev->lock, flags);
 338         }
 339
 340         if (status == NET_RX_SUCCESS) {
 341                 ndev->stats.rx_packets++;
 342                 ndev->stats.rx_bytes += recvlen;
 343         } else {
 344                 ndev->stats.rx_dropped++;
 345         }
 346         return 0;
 347 }
 348
 349 enum mctp_i2c_flow_state {
 350         MCTP_I2C_TX_FLOW_INVALID,
 351         MCTP_I2C_TX_FLOW_NONE,
 352         MCTP_I2C_TX_FLOW_NEW,
 353         MCTP_I2C_TX_FLOW_EXISTING,
 354 };
 355
 356 static enum mctp_i2c_flow_state
 357 mctp_i2c_get_tx_flow_state(struct mctp_i2c_dev *midev, struct sk_buff *skb)
 358 {
 359         enum mctp_i2c_flow_state state;
 360         struct mctp_sk_key *key;
 361         struct mctp_flow *flow;
 362         unsigned long flags;
 363
 364         flow = skb_ext_find(skb, SKB_EXT_MCTP);
 365         if (!flow)
 366                 return MCTP_I2C_TX_FLOW_NONE;
 367
 368         key = flow->key;
 369         if (!key)
 370                 return MCTP_I2C_TX_FLOW_NONE;
 371
 372         spin_lock_irqsave(&key->lock, flags);
 373         /* If the key is present but invalid, we're unlikely to be able
 374          * to handle the flow at all; just drop now
 375          */
 376         if (!key->valid) {
 377                 state = MCTP_I2C_TX_FLOW_INVALID;
 378         } else {
 379                 switch (key->dev_flow_state) {
 380                 case MCTP_I2C_FLOW_STATE_NEW:
 381                         key->dev_flow_state = MCTP_I2C_FLOW_STATE_ACTIVE;
 382                         state = MCTP_I2C_TX_FLOW_NEW;
 383                         break;
 384                 case MCTP_I2C_FLOW_STATE_ACTIVE:
 385                         state = MCTP_I2C_TX_FLOW_EXISTING;
 386                         break;
 387                 default:
 388                         state = MCTP_I2C_TX_FLOW_INVALID;
 389                 }
 390         }
 391
 392         spin_unlock_irqrestore(&key->lock, flags);
 393
 394         return state;
 395 }
 396
 397 /* We're not contending with ourselves here; we only need to exclude other
 398  * i2c clients from using the bus. refcounts are simply to prevent
 399  * recursive locking.
 400  */
 401 static void mctp_i2c_lock_nest(struct mctp_i2c_dev *midev)
 402 {
 403         unsigned long flags;
 404         bool lock;
 405
 406         spin_lock_irqsave(&midev->lock, flags);
 407         lock = midev->i2c_lock_count == 0;
 408         midev->i2c_lock_count++;
 409         spin_unlock_irqrestore(&midev->lock, flags);
 410
 411         if (lock)
 412                 i2c_lock_bus(midev->adapter, I2C_LOCK_SEGMENT);
 413 }
 414
 415 static void mctp_i2c_unlock_nest(struct mctp_i2c_dev *midev)
 416 {
 417         unsigned long flags;
 418         bool unlock;
 419
 420         spin_lock_irqsave(&midev->lock, flags);
 421         if (!WARN_ONCE(midev->i2c_lock_count == 0, "lock count underflow!"))
 422                 midev->i2c_lock_count--;
 423         unlock = midev->i2c_lock_count == 0;
 424         spin_unlock_irqrestore(&midev->lock, flags);
 425
 426         if (unlock)
 427                 i2c_unlock_bus(midev->adapter, I2C_LOCK_SEGMENT);
 428 }
 429
 430 /* Unlocks the bus if was previously locked, used for cleanup */
 431 static void mctp_i2c_unlock_reset(struct mctp_i2c_dev *midev)
 432 {
 433         unsigned long flags;
 434         bool unlock;
 435
 436         spin_lock_irqsave(&midev->lock, flags);
 437         unlock = midev->i2c_lock_count > 0;
 438         midev->i2c_lock_count = 0;
 439         spin_unlock_irqrestore(&midev->lock, flags);
 440
 441         if (unlock)
 442                 i2c_unlock_bus(midev->adapter, I2C_LOCK_SEGMENT);
 443 }
 444
 445 static void mctp_i2c_invalidate_tx_flow(struct mctp_i2c_dev *midev,
 446                                         struct sk_buff *skb)
 447 {
 448         struct mctp_sk_key *key;
 449         struct mctp_flow *flow;
 450         unsigned long flags;
 451         bool release;
 452
 453         flow = skb_ext_find(skb, SKB_EXT_MCTP);
 454         if (!flow)
 455                 return;
 456
 457         key = flow->key;
 458         if (!key)
 459                 return;
 460
 461         spin_lock_irqsave(&key->lock, flags);
 462         if (key->manual_alloc) {
 463                 /* we don't have control over lifetimes for manually-allocated
 464                  * keys, so cannot assume we can invalidate all future flows
 465                  * that would use this key.
 466                  */
 467                 release = false;
 468         } else {
 469                 release = key->dev_flow_state == MCTP_I2C_FLOW_STATE_ACTIVE;
 470                 key->dev_flow_state = MCTP_I2C_FLOW_STATE_INVALID;
 471         }
 472         spin_unlock_irqrestore(&key->lock, flags);
 473
 474         /* if we have changed state from active, the flow held a reference on
 475          * the lock; release that now.
 476          */
 477         if (release)
 478                 mctp_i2c_unlock_nest(midev);
 479 }
 480
 481 static void mctp_i2c_xmit(struct mctp_i2c_dev *midev, struct sk_buff *skb)
 482 {
 483         struct net_device_stats *stats = &midev->ndev->stats;
 484         enum mctp_i2c_flow_state fs;
 485         struct mctp_i2c_hdr *hdr;
 486         struct i2c_msg msg = {0};
 487         u8 *pecp;
 488         int rc;
 489
 490         fs = mctp_i2c_get_tx_flow_state(midev, skb);
 491
 492         hdr = (void *)skb_mac_header(skb);
 493         /* Sanity check that packet contents matches skb length,
 494          * and can't exceed MCTP_I2C_BUFSZ
 495          */
 496         if (skb->len != hdr->byte_count + 3) {
 497                 dev_warn_ratelimited(&midev->adapter->dev,
 498                                      "Bad tx length %d vs skb %u\n",
 499                                      hdr->byte_count + 3, skb->len);
 500                 return;
 501         }
 502
 503         if (skb_tailroom(skb) >= 1) {
 504                 /* Linear case with space, we can just append the PEC */
 505                 skb_put(skb, 1);
 506         } else {
 507                 /* Otherwise need to copy the buffer */
 508                 skb_copy_bits(skb, 0, midev->tx_scratch, skb->len);
 509                 hdr = (void *)midev->tx_scratch;
 510         }
 511
 512         pecp = (void *)&hdr->source_slave + hdr->byte_count;
 513         *pecp = i2c_smbus_pec(0, (u8 *)hdr, hdr->byte_count + 3);
 514         msg.buf = (void *)&hdr->command;
 515         /* command, bytecount, data, pec */
 516         msg.len = 2 + hdr->byte_count + 1;
 517         msg.addr = hdr->dest_slave >> 1;
 518
 519         switch (fs) {
 520         case MCTP_I2C_TX_FLOW_NONE:
 521                 /* no flow: full lock & unlock */
 522                 mctp_i2c_lock_nest(midev);
 523                 mctp_i2c_device_select(midev->client, midev);
 524                 rc = __i2c_transfer(midev->adapter, &msg, 1);
 525                 mctp_i2c_unlock_nest(midev);
 526                 break;
 527
 528         case MCTP_I2C_TX_FLOW_NEW:
 529                 /* new flow: lock, tx, but don't unlock; that will happen
 530                  * on flow release
 531                  */
 532                 mctp_i2c_lock_nest(midev);
 533                 mctp_i2c_device_select(midev->client, midev);
 534                 fallthrough;
 535
 536         case MCTP_I2C_TX_FLOW_EXISTING:
 537                 /* existing flow: we already have the lock; just tx */
 538                 rc = __i2c_transfer(midev->adapter, &msg, 1);
 539
 540                 /* on tx errors, the flow can no longer be considered valid */
 541                 if (rc)
 542                         mctp_i2c_invalidate_tx_flow(midev, skb);
 543
 544                 break;
 545
 546         case MCTP_I2C_TX_FLOW_INVALID:
 547                 return;
 548         }
 549
 550         if (rc < 0) {
 551                 dev_warn_ratelimited(&midev->adapter->dev,
 552                                      "__i2c_transfer failed %d\n", rc);
 553                 stats->tx_errors++;
 554         } else {
 555                 stats->tx_bytes += skb->len;
 556                 stats->tx_packets++;
 557         }
 558 }
 559
 560 static void mctp_i2c_flow_release(struct mctp_i2c_dev *midev)
 561 {
 562         unsigned long flags;
 563         bool unlock;
 564
 565         spin_lock_irqsave(&midev->lock, flags);
 566         if (midev->release_count > midev->i2c_lock_count) {
 567                 WARN_ONCE(1, "release count overflow");
 568                 midev->release_count = midev->i2c_lock_count;
 569         }
 570
 571         midev->i2c_lock_count -= midev->release_count;
 572         unlock = midev->i2c_lock_count == 0 && midev->release_count > 0;
 573         midev->release_count = 0;
 574         spin_unlock_irqrestore(&midev->lock, flags);
 575
 576         if (unlock)
 577                 i2c_unlock_bus(midev->adapter, I2C_LOCK_SEGMENT);
 578 }
 579
 580 static int mctp_i2c_header_create(struct sk_buff *skb, struct net_device *dev,
 581                                   unsigned short type, const void *daddr,
 582            const void *saddr, unsigned int len)
 583 {
 584         struct mctp_i2c_hdr *hdr;
 585         struct mctp_hdr *mhdr;
 586         u8 lldst, llsrc;
 587
 588         if (len > MCTP_I2C_MAXMTU)
 589                 return -EMSGSIZE;
 590
 591         lldst = *((u8 *)daddr);
 592         llsrc = *((u8 *)saddr);
 593
 594         skb_push(skb, sizeof(struct mctp_i2c_hdr));
 595         skb_reset_mac_header(skb);
 596         hdr = (void *)skb_mac_header(skb);
 597         mhdr = mctp_hdr(skb);
 598         hdr->dest_slave = (lldst << 1) & 0xff;
 599         hdr->command = MCTP_I2C_COMMANDCODE;
 600         hdr->byte_count = len + 1;
 601         hdr->source_slave = ((llsrc << 1) & 0xff) | 0x01;
 602         mhdr->ver = 0x01;
 603
 604         return sizeof(struct mctp_i2c_hdr);
 605 }
 606
 607 static int mctp_i2c_tx_thread(void *data)
 608 {
 609         struct mctp_i2c_dev *midev = data;
 610         struct sk_buff *skb;
 611         unsigned long flags;
 612
 613         for (;;) {
 614                 if (kthread_should_stop())
 615                         break;
 616
 617                 spin_lock_irqsave(&midev->tx_queue.lock, flags);
 618                 skb = __skb_dequeue(&midev->tx_queue);
 619                 if (netif_queue_stopped(midev->ndev))
 620                         netif_wake_queue(midev->ndev);
 621                 spin_unlock_irqrestore(&midev->tx_queue.lock, flags);
 622
 623                 if (skb == &midev->unlock_marker) {
 624                         mctp_i2c_flow_release(midev);
 625
 626                 } else if (skb) {
 627                         mctp_i2c_xmit(midev, skb);
 628                         kfree_skb(skb);
 629
 630                 } else {
 631                         wait_event_idle(midev->tx_wq,
 632                                         !skb_queue_empty(&midev->tx_queue) ||
 633                                    kthread_should_stop());
 634                 }
 635         }
 636
 637         return 0;
 638 }
 639
 640 static netdev_tx_t mctp_i2c_start_xmit(struct sk_buff *skb,
 641                                        struct net_device *dev)
 642 {
 643         struct mctp_i2c_dev *midev = netdev_priv(dev);
 644         unsigned long flags;
 645
 646         spin_lock_irqsave(&midev->tx_queue.lock, flags);
 647         if (skb_queue_len(&midev->tx_queue) >= MCTP_I2C_TX_WORK_LEN) {
 648                 netif_stop_queue(dev);
 649                 spin_unlock_irqrestore(&midev->tx_queue.lock, flags);
 650                 netdev_err(dev, "BUG! Tx Ring full when queue awake!\n");
 651                 return NETDEV_TX_BUSY;
 652         }
 653
 654         __skb_queue_tail(&midev->tx_queue, skb);
 655         if (skb_queue_len(&midev->tx_queue) == MCTP_I2C_TX_WORK_LEN)
 656                 netif_stop_queue(dev);
 657         spin_unlock_irqrestore(&midev->tx_queue.lock, flags);
 658
 659         wake_up(&midev->tx_wq);
 660         return NETDEV_TX_OK;
 661 }
 662
 663 static void mctp_i2c_release_flow(struct mctp_dev *mdev,
 664                                   struct mctp_sk_key *key)
 665
 666 {
 667         struct mctp_i2c_dev *midev = netdev_priv(mdev->dev);
 668         bool queue_release = false;
 669         unsigned long flags;
 670
 671         spin_lock_irqsave(&midev->lock, flags);
 672         /* if we have seen the flow/key previously, we need to pair the
 673          * original lock with a release
 674          */
 675         if (key->dev_flow_state == MCTP_I2C_FLOW_STATE_ACTIVE) {
 676                 midev->release_count++;
 677                 queue_release = true;
 678         }
 679         key->dev_flow_state = MCTP_I2C_FLOW_STATE_INVALID;
 680         spin_unlock_irqrestore(&midev->lock, flags);
 681
 682         if (queue_release) {
 683                 /* Ensure we have a release operation queued, through the fake
 684                  * marker skb
 685                  */
 686                 spin_lock(&midev->tx_queue.lock);
 687                 if (!midev->unlock_marker.next)
 688                         __skb_queue_tail(&midev->tx_queue,
 689                                          &midev->unlock_marker);
 690                 spin_unlock(&midev->tx_queue.lock);
 691                 wake_up(&midev->tx_wq);
 692         }
 693 }
 694
 695 static const struct net_device_ops mctp_i2c_ops = {
 696         .ndo_start_xmit = mctp_i2c_start_xmit,
 697         .ndo_uninit = mctp_i2c_ndo_uninit,
 698         .ndo_open = mctp_i2c_ndo_open,
 699 };
 700
 701 static const struct header_ops mctp_i2c_headops = {
 702         .create = mctp_i2c_header_create,
 703 };
 704
 705 static const struct mctp_netdev_ops mctp_i2c_mctp_ops = {
 706         .release_flow = mctp_i2c_release_flow,
 707 };
 708
 709 static void mctp_i2c_net_setup(struct net_device *dev)
 710 {
 711         dev->type = ARPHRD_MCTP;
 712
 713         dev->mtu = MCTP_I2C_MAXMTU;
 714         dev->min_mtu = MCTP_I2C_MINMTU;
 715         dev->max_mtu = MCTP_I2C_MAXMTU;
 716         dev->tx_queue_len = MCTP_I2C_TX_QUEUE_LEN;
 717
 718         dev->hard_header_len = sizeof(struct mctp_i2c_hdr);
 719         dev->addr_len = 1;
 720
 721         dev->netdev_ops         = &mctp_i2c_ops;
 722         dev->header_ops         = &mctp_i2c_headops;
 723 }
 724
 725 /* Populates the mctp_i2c_dev priv struct for a netdev.
 726  * Returns an error pointer on failure.
 727  */
 728 static struct mctp_i2c_dev *mctp_i2c_midev_init(struct net_device *dev,
 729                                                 struct mctp_i2c_client *mcli,
 730                                                 struct i2c_adapter *adap)
 731 {
 732         struct mctp_i2c_dev *midev = netdev_priv(dev);
 733         unsigned long flags;
 734
 735         midev->tx_thread = kthread_create(mctp_i2c_tx_thread, midev,
 736                                           "%s/tx", dev->name);
 737         if (IS_ERR(midev->tx_thread))
 738                 return ERR_CAST(midev->tx_thread);
 739
 740         midev->ndev = dev;
 741         get_device(&adap->dev);
 742         midev->adapter = adap;
 743         get_device(&mcli->client->dev);
 744         midev->client = mcli;
 745         INIT_LIST_HEAD(&midev->list);
 746         spin_lock_init(&midev->lock);
 747         midev->i2c_lock_count = 0;
 748         midev->release_count = 0;
 749         init_completion(&midev->rx_done);
 750         complete(&midev->rx_done);
 751         init_waitqueue_head(&midev->tx_wq);
 752         skb_queue_head_init(&midev->tx_queue);
 753
 754         /* Add to the parent mcli */
 755         spin_lock_irqsave(&mcli->sel_lock, flags);
 756         list_add(&midev->list, &mcli->devs);
 757         /* Select a device by default */
 758         if (!mcli->sel)
 759                 __mctp_i2c_device_select(mcli, midev);
 760         spin_unlock_irqrestore(&mcli->sel_lock, flags);
 761
 762         /* Start the worker thread */
 763         wake_up_process(midev->tx_thread);
 764
 765         return midev;
 766 }
 767
 768 /* Counterpart of mctp_i2c_midev_init */
 769 static void mctp_i2c_midev_free(struct mctp_i2c_dev *midev)
 770 {
 771         struct mctp_i2c_client *mcli = midev->client;
 772         unsigned long flags;
 773
 774         if (midev->tx_thread) {
 775                 kthread_stop(midev->tx_thread);
 776                 midev->tx_thread = NULL;
 777         }
 778
 779         /* Unconditionally unlock on close */
 780         mctp_i2c_unlock_reset(midev);
 781
 782         /* Remove the netdev from the parent i2c client. */
 783         spin_lock_irqsave(&mcli->sel_lock, flags);
 784         list_del(&midev->list);
 785         if (mcli->sel == midev) {
 786                 struct mctp_i2c_dev *first;
 787
 788                 first = list_first_entry_or_null(&mcli->devs, struct mctp_i2c_dev, list);
 789                 __mctp_i2c_device_select(mcli, first);
 790         }
 791         spin_unlock_irqrestore(&mcli->sel_lock, flags);
 792
 793         skb_queue_purge(&midev->tx_queue);
 794         put_device(&midev->adapter->dev);
 795         put_device(&mcli->client->dev);
 796 }
 797
 798 /* Stops, unregisters, and frees midev */
 799 static void mctp_i2c_unregister(struct mctp_i2c_dev *midev)
 800 {
 801         unsigned long flags;
 802
 803         /* Stop tx thread prior to unregister, it uses netif_() functions */
 804         kthread_stop(midev->tx_thread);
 805         midev->tx_thread = NULL;
 806
 807         /* Prevent any new rx in mctp_i2c_recv(), let any pending work finish */
 808         spin_lock_irqsave(&midev->lock, flags);
 809         midev->allow_rx = false;
 810         spin_unlock_irqrestore(&midev->lock, flags);
 811         wait_for_completion(&midev->rx_done);
 812
 813         mctp_unregister_netdev(midev->ndev);
 814         /* midev has been freed now by mctp_i2c_ndo_uninit callback */
 815
 816         free_netdev(midev->ndev);
 817 }
 818
 819 static void mctp_i2c_ndo_uninit(struct net_device *dev)
 820 {
 821         struct mctp_i2c_dev *midev = netdev_priv(dev);
 822
 823         /* Perform cleanup here to ensure that mcli->sel isn't holding
 824          * a reference that would prevent unregister_netdevice()
 825          * from completing.
 826          */
 827         mctp_i2c_midev_free(midev);
 828 }
 829
 830 static int mctp_i2c_ndo_open(struct net_device *dev)
 831 {
 832         struct mctp_i2c_dev *midev = netdev_priv(dev);
 833         unsigned long flags;
 834
 835         /* i2c rx handler can only pass packets once the netdev is registered */
 836         spin_lock_irqsave(&midev->lock, flags);
 837         midev->allow_rx = true;
 838         spin_unlock_irqrestore(&midev->lock, flags);
 839
 840         return 0;
 841 }
 842
 843 static int mctp_i2c_add_netdev(struct mctp_i2c_client *mcli,
 844                                struct i2c_adapter *adap)
 845 {
 846         struct mctp_i2c_dev *midev = NULL;
 847         struct net_device *ndev = NULL;
 848         struct i2c_adapter *root;
 849         unsigned long flags;
 850         char namebuf[30];
 851         int rc;
 852
 853         root = mux_root_adapter(adap);
 854         if (root != mcli->client->adapter) {
 855                 dev_err(&mcli->client->dev,
 856                         "I2C adapter %s is not a child bus of %s\n",
 857                         mcli->client->adapter->name, root->name);
 858                 return -EINVAL;
 859         }
 860
 861         WARN_ON(!mutex_is_locked(&driver_clients_lock));
 862         snprintf(namebuf, sizeof(namebuf), "mctpi2c%d", adap->nr);
 863         ndev = alloc_netdev(sizeof(*midev), namebuf, NET_NAME_ENUM, mctp_i2c_net_setup);
 864         if (!ndev) {
 865                 dev_err(&mcli->client->dev, "alloc netdev failed\n");
 866                 rc = -ENOMEM;
 867                 goto err;
 868         }
 869         dev_net_set(ndev, current->nsproxy->net_ns);
 870         SET_NETDEV_DEV(ndev, &adap->dev);
 871         dev_addr_set(ndev, &mcli->lladdr);
 872
 873         midev = mctp_i2c_midev_init(ndev, mcli, adap);
 874         if (IS_ERR(midev)) {
 875                 rc = PTR_ERR(midev);
 876                 midev = NULL;
 877                 goto err;
 878         }
 879
 880         rc = mctp_register_netdev(ndev, &mctp_i2c_mctp_ops);
 881         if (rc < 0) {
 882                 dev_err(&mcli->client->dev,
 883                         "register netdev \"%s\" failed %d\n",
 884                         ndev->name, rc);
 885                 goto err;
 886         }
 887
 888         spin_lock_irqsave(&midev->lock, flags);
 889         midev->allow_rx = false;
 890         spin_unlock_irqrestore(&midev->lock, flags);
 891
 892         return 0;
 893 err:
 894         if (midev)
 895                 mctp_i2c_midev_free(midev);
 896         if (ndev)
 897                 free_netdev(ndev);
 898         return rc;
 899 }
 900
 901 /* Removes any netdev for adap. mcli is the parent root i2c client */
 902 static void mctp_i2c_remove_netdev(struct mctp_i2c_client *mcli,
 903                                    struct i2c_adapter *adap)
 904 {
 905         struct mctp_i2c_dev *midev = NULL, *m = NULL;
 906         unsigned long flags;
 907
 908         WARN_ON(!mutex_is_locked(&driver_clients_lock));
 909         spin_lock_irqsave(&mcli->sel_lock, flags);
 910         /* List size is limited by number of MCTP netdevs on a single hardware bus */
 911         list_for_each_entry(m, &mcli->devs, list)
 912                 if (m->adapter == adap) {
 913                         midev = m;
 914                         break;
 915                 }
 916         spin_unlock_irqrestore(&mcli->sel_lock, flags);
 917
 918         if (midev)
 919                 mctp_i2c_unregister(midev);
 920 }
 921
 922 /* Determines whether a device is an i2c adapter.
 923  * Optionally returns the root i2c_adapter
 924  */
 925 static struct i2c_adapter *mctp_i2c_get_adapter(struct device *dev,
 926                                                 struct i2c_adapter **ret_root)
 927 {
 928         struct i2c_adapter *root, *adap;
 929
 930         if (dev->type != &i2c_adapter_type)
 931                 return NULL;
 932         adap = to_i2c_adapter(dev);
 933         root = mux_root_adapter(adap);
 934         WARN_ONCE(!root, "MCTP I2C failed to find root adapter for %s\n",
 935                   dev_name(dev));
 936         if (!root)
 937                 return NULL;
 938         if (ret_root)
 939                 *ret_root = root;
 940         return adap;
 941 }
 942
 943 /* Determines whether a device is an i2c adapter with the "mctp-controller"
 944  * devicetree property set. If adap is not an OF node, returns match_no_of
 945  */
 946 static bool mctp_i2c_adapter_match(struct i2c_adapter *adap, bool match_no_of)
 947 {
 948         if (!adap->dev.of_node)
 949                 return match_no_of;
 950         return of_property_read_bool(adap->dev.of_node, MCTP_I2C_OF_PROP);
 951 }
 952
 953 /* Called for each existing i2c device (adapter or client) when a
 954  * new mctp-i2c client is probed.
 955  */
 956 static int mctp_i2c_client_try_attach(struct device *dev, void *data)
 957 {
 958         struct i2c_adapter *adap = NULL, *root = NULL;
 959         struct mctp_i2c_client *mcli = data;
 960
 961         adap = mctp_i2c_get_adapter(dev, &root);
 962         if (!adap)
 963                 return 0;
 964         if (mcli->client->adapter != root)
 965                 return 0;
 966         /* Must either have mctp-controller property on the adapter, or
 967          * be a root adapter if it's non-devicetree
 968          */
 969         if (!mctp_i2c_adapter_match(adap, adap == root))
 970                 return 0;
 971
 972         return mctp_i2c_add_netdev(mcli, adap);
 973 }
 974
 975 static void mctp_i2c_notify_add(struct device *dev)
 976 {
 977         struct mctp_i2c_client *mcli = NULL, *m = NULL;
 978         struct i2c_adapter *root = NULL, *adap = NULL;
 979         int rc;
 980
 981         adap = mctp_i2c_get_adapter(dev, &root);
 982         if (!adap)
 983                 return;
 984         /* Check for mctp-controller property on the adapter */
 985         if (!mctp_i2c_adapter_match(adap, false))
 986                 return;
 987
 988         /* Find an existing mcli for adap's root */
 989         mutex_lock(&driver_clients_lock);
 990         list_for_each_entry(m, &driver_clients, list) {
 991                 if (m->client->adapter == root) {
 992                         mcli = m;
 993                         break;
 994                 }
 995         }
 996
 997         if (mcli) {
 998                 rc = mctp_i2c_add_netdev(mcli, adap);
 999                 if (rc < 0)
1000                         dev_warn(dev, "Failed adding mctp-i2c net device\n");
1001         }
1002         mutex_unlock(&driver_clients_lock);
1003 }
1004
1005 static void mctp_i2c_notify_del(struct device *dev)
1006 {
1007         struct i2c_adapter *root = NULL, *adap = NULL;
1008         struct mctp_i2c_client *mcli = NULL;
1009
1010         adap = mctp_i2c_get_adapter(dev, &root);
1011         if (!adap)
1012                 return;
1013
1014         mutex_lock(&driver_clients_lock);
1015         list_for_each_entry(mcli, &driver_clients, list) {
1016                 if (mcli->client->adapter == root) {
1017                         mctp_i2c_remove_netdev(mcli, adap);
1018                         break;
1019                 }
1020         }
1021         mutex_unlock(&driver_clients_lock);
1022 }
1023
1024 static int mctp_i2c_probe(struct i2c_client *client)
1025 {
1026         struct mctp_i2c_client *mcli = NULL;
1027         int rc;
1028
1029         mutex_lock(&driver_clients_lock);
1030         mcli = mctp_i2c_new_client(client);
1031         if (IS_ERR(mcli)) {
1032                 rc = PTR_ERR(mcli);
1033                 mcli = NULL;
1034                 goto out;
1035         } else {
1036                 list_add(&mcli->list, &driver_clients);
1037         }
1038
1039         /* Add a netdev for adapters that have a 'mctp-controller' property */
1040         i2c_for_each_dev(mcli, mctp_i2c_client_try_attach);
1041         rc = 0;
1042 out:
1043         mutex_unlock(&driver_clients_lock);
1044         return rc;
1045 }
1046
1047 static void mctp_i2c_remove(struct i2c_client *client)
1048 {
1049         struct mctp_i2c_client *mcli = i2c_get_clientdata(client);
1050         struct mctp_i2c_dev *midev = NULL, *tmp = NULL;
1051
1052         mutex_lock(&driver_clients_lock);
1053         list_del(&mcli->list);
1054         /* Remove all child adapter netdevs */
1055         list_for_each_entry_safe(midev, tmp, &mcli->devs, list)
1056                 mctp_i2c_unregister(midev);
1057
1058         mctp_i2c_free_client(mcli);
1059         mutex_unlock(&driver_clients_lock);
1060 }
1061
1062 /* We look for a 'mctp-controller' property on I2C busses as they are
1063  * added/deleted, creating/removing netdevs as required.
1064  */
1065 static int mctp_i2c_notifier_call(struct notifier_block *nb,
1066                                   unsigned long action, void *data)
1067 {
1068         struct device *dev = data;
1069
1070         switch (action) {
1071         case BUS_NOTIFY_ADD_DEVICE:
1072                 mctp_i2c_notify_add(dev);
1073                 break;
1074         case BUS_NOTIFY_DEL_DEVICE:
1075                 mctp_i2c_notify_del(dev);
1076                 break;
1077         }
1078         return NOTIFY_DONE;
1079 }
1080
1081 static struct notifier_block mctp_i2c_notifier = {
1082         .notifier_call = mctp_i2c_notifier_call,
1083 };
1084
1085 static const struct i2c_device_id mctp_i2c_id[] = {
1086         { "mctp-i2c-interface" },
1087         {}
1088 };
1089 MODULE_DEVICE_TABLE(i2c, mctp_i2c_id);
1090
1091 static const struct of_device_id mctp_i2c_of_match[] = {
1092         { .compatible = "mctp-i2c-controller" },
1093         {},
1094 };
1095 MODULE_DEVICE_TABLE(of, mctp_i2c_of_match);
1096
1097 static struct i2c_driver mctp_i2c_driver = {
1098         .driver = {
1099                 .name = "mctp-i2c-interface",
1100                 .of_match_table = mctp_i2c_of_match,
1101         },
1102         .probe = mctp_i2c_probe,
1103         .remove = mctp_i2c_remove,
1104         .id_table = mctp_i2c_id,
1105 };
1106
1107 static __init int mctp_i2c_mod_init(void)
1108 {
1109         int rc;
1110
1111         pr_info("MCTP I2C interface driver\n");
1112         rc = i2c_add_driver(&mctp_i2c_driver);
1113         if (rc < 0)
1114                 return rc;
1115         rc = bus_register_notifier(&i2c_bus_type, &mctp_i2c_notifier);
1116         if (rc < 0) {
1117                 i2c_del_driver(&mctp_i2c_driver);
1118                 return rc;
1119         }
1120         return 0;
1121 }
1122
1123 static __exit void mctp_i2c_mod_exit(void)
1124 {
1125         int rc;
1126
1127         rc = bus_unregister_notifier(&i2c_bus_type, &mctp_i2c_notifier);
1128         if (rc < 0)
1129                 pr_warn("MCTP I2C could not unregister notifier, %d\n", rc);
1130         i2c_del_driver(&mctp_i2c_driver);
1131 }
1132
1133 module_init(mctp_i2c_mod_init);
1134 module_exit(mctp_i2c_mod_exit);
1135
1136 MODULE_DESCRIPTION("MCTP I2C device");
1137 MODULE_LICENSE("GPL v2");
1138 MODULE_AUTHOR("Matt Johnston <[email protected]>");