path: root/drivers/net/mctp/mctp-i2c.c

// SPDX-License-Identifier: GPL-2.0
/*
 * Management Controller Transport Protocol (MCTP)
 *
 * Copyright (c) 2021 Code Construct
 * Copyright (c) 2021 Google
 */

#include <linux/module.h>
#include <linux/netdevice.h>
#include <linux/i2c.h>
#include <linux/i2c-mux.h>
#include <linux/if_arp.h>
#include <net/mctp.h>
#include <net/mctpdevice.h>

/* SMBus 3.0 allows 255 data bytes (plus PEC), but the
 * first byte is taken for source slave address.
 */
#define MCTP_I2C_MAXBLOCK 255
#define MCTP_I2C_MAXMTU (MCTP_I2C_MAXBLOCK - 1)
#define MCTP_I2C_MINMTU (64 + 4)
/* Allow space for address, command, byte_count, databytes, PEC */
#define MCTP_I2C_RXBUFSZ (3 + MCTP_I2C_MAXBLOCK + 1)
#define MCTP_I2C_MINLEN 8
#define MCTP_I2C_COMMANDCODE 0x0f
#define MCTP_I2C_TX_WORK_LEN 100
// sufficient for 64kB at min mtu
#define MCTP_I2C_TX_QUEUE_LEN 1100

#define MCTP_I2C_OF_PROP "mctp-controller"

enum {
	MCTP_I2C_FLOW_STATE_NEW = 0,
	MCTP_I2C_FLOW_STATE_ACTIVE,
};

static struct {
	/* lock protects clients and also prevents adding/removing adapters
	 * during mctp_i2c_client probe/remove.
	 */
	struct mutex lock;
	// list of struct mctp_i2c_client
	struct list_head clients;
} mi_driver_state;

struct mctp_i2c_client;

// The netdev structure. One of these per I2C adapter.
struct mctp_i2c_dev {
	struct net_device *ndev;
	struct i2c_adapter *adapter;
	struct mctp_i2c_client *client;
	struct list_head list; // for mctp_i2c_client.devs

	size_t pos;
	u8 buffer[MCTP_I2C_RXBUFSZ];

	struct task_struct *tx_thread;
	wait_queue_head_t tx_wq;
	struct sk_buff_head tx_queue;

	// a fake entry in our tx queue to perform an unlock operation
	struct sk_buff unlock_marker;

	spinlock_t flow_lock; // protects i2c_lock_count and release_count
	int i2c_lock_count;
	int release_count;
};

/* The i2c client structure. One per hardware i2c bus at the top of the
 * mux tree, shared by multiple netdevs
 */
struct mctp_i2c_client {
	struct i2c_client *client;
	u8 lladdr;

	struct mctp_i2c_dev *sel;
	struct list_head devs;
	spinlock_t curr_lock; // protects sel

	struct list_head list; // for mi_driver_state.clients
};

// Header on the wire
struct mctp_i2c_hdr {
	u8 dest_slave;
	u8 command;
	u8 byte_count;
	u8 source_slave;
};

static int mctp_i2c_recv(struct mctp_i2c_dev *midev);
static int mctp_i2c_slave_cb(struct i2c_client *client,
			     enum i2c_slave_event event, u8 *val);

static struct i2c_adapter *mux_root_adapter(struct i2c_adapter *adap)
{
#if IS_ENABLED(CONFIG_I2C_MUX)
	return i2c_root_adapter(&adap->dev);
#else
	/* In non-mux config all i2c adapters are root adapters */
	return adap;
#endif
}

static ssize_t mctp_current_mux_show(struct device *dev,
				     struct device_attribute *attr, char *buf)
{
	struct mctp_i2c_client *mcli = i2c_get_clientdata(to_i2c_client(dev));
	struct net_device *ndev = NULL;
	unsigned long flags;
	ssize_t l;

	spin_lock_irqsave(&mcli->curr_lock, flags);
	if (mcli->sel) {
		ndev = mcli->sel->ndev;
		dev_hold(ndev);
	}
	spin_unlock_irqrestore(&mcli->curr_lock, flags);
	l = scnprintf(buf, PAGE_SIZE, "%s\n", ndev ? ndev->name : "(none)");
	if (ndev)
		dev_put(ndev);
	return l;
}
static DEVICE_ATTR_RO(mctp_current_mux);

/* Creates a new i2c slave device attached to the root adapter.
 * Sets up the slave callback.
 * Must be called with a client on a root adapter.
 */
static struct mctp_i2c_client *mctp_i2c_new_client(struct i2c_client *client)
{
	struct mctp_i2c_client *mcli = NULL;
	struct i2c_adapter *root = NULL;
	int rc;

	if (client->flags & I2C_CLIENT_TEN) {
		dev_err(&client->dev, "%s failed, MCTP requires a 7-bit I2C address, addr=0x%x",
			__func__, client->addr);
		rc = -EINVAL;
		goto err;
	}

	root = mux_root_adapter(client->adapter);
	if (!root) {
		dev_err(&client->dev, "%s failed to find root adapter\n", __func__);
		rc = -ENOENT;
		goto err;
	}
	if (root != client->adapter) {
		dev_err(&client->dev,
			"A mctp-i2c-controller client cannot be placed on an I2C mux adapter.\n"
			" It should be placed on the mux tree root adapter\n"
			" then set mctp-controller property on adapters to attach\n");
		rc = -EINVAL;
		goto err;
	}

	mcli = kzalloc(sizeof(*mcli), GFP_KERNEL);
	if (!mcli) {
		rc = -ENOMEM;
		goto err;
	}
	spin_lock_init(&mcli->curr_lock);
	INIT_LIST_HEAD(&mcli->devs);
	INIT_LIST_HEAD(&mcli->list);
	mcli->lladdr = client->addr & 0xff;
	mcli->client = client;
	i2c_set_clientdata(client, mcli);

	rc = i2c_slave_register(mcli->client, mctp_i2c_slave_cb);
	if (rc) {
		dev_err(&client->dev, "%s i2c register failed %d\n", __func__, rc);
		mcli->client = NULL;
		i2c_set_clientdata(client, NULL);
		goto err;
	}

	rc = device_create_file(&client->dev, &dev_attr_mctp_current_mux);
	if (rc) {
		dev_err(&client->dev, "%s adding sysfs \"%s\" failed %d\n", __func__,
			dev_attr_mctp_current_mux.attr.name, rc);
		// continue anyway
	}

	return mcli;
err:
	if (mcli) {
		if (mcli->client) {
			device_remove_file(&mcli->client->dev, &dev_attr_mctp_current_mux);
			i2c_unregister_device(mcli->client);
		}
		kfree(mcli);
	}
	return ERR_PTR(rc);
}

static void mctp_i2c_free_client(struct mctp_i2c_client *mcli)
{
	int rc;

	WARN_ON(!mutex_is_locked(&mi_driver_state.lock));
	WARN_ON(!list_empty(&mcli->devs));
	WARN_ON(mcli->sel); // sanity check, no locking

	device_remove_file(&mcli->client->dev, &dev_attr_mctp_current_mux);
	rc = i2c_slave_unregister(mcli->client);
	// leak if it fails, we can't propagate errors upwards
	if (rc)
		dev_err(&mcli->client->dev, "%s i2c unregister failed %d\n", __func__, rc);
	else
		kfree(mcli);
}

/* Switch the mctp i2c device to receive responses.
 * Call with curr_lock held
 */
static void __mctp_i2c_device_select(struct mctp_i2c_client *mcli,
				     struct mctp_i2c_dev *midev)
{
	assert_spin_locked(&mcli->curr_lock);
	if (midev)
		dev_hold(midev->ndev);
	if (mcli->sel)
		dev_put(mcli->sel->ndev);
	mcli->sel = midev;
}

// Switch the mctp i2c device to receive responses
static void mctp_i2c_device_select(struct mctp_i2c_client *mcli,
				   struct mctp_i2c_dev *midev)
{
	unsigned long flags;

	spin_lock_irqsave(&mcli->curr_lock, flags);
	__mctp_i2c_device_select(mcli, midev);
	spin_unlock_irqrestore(&mcli->curr_lock, flags);
}

static int mctp_i2c_slave_cb(struct i2c_client *client,
			     enum i2c_slave_event event, u8 *val)
{
	struct mctp_i2c_client *mcli = i2c_get_clientdata(client);
	struct mctp_i2c_dev *midev = NULL;
	unsigned long flags;
	int rc = 0;

	spin_lock_irqsave(&mcli->curr_lock, flags);
	midev = mcli->sel;
	if (midev)
		dev_hold(midev->ndev);
	spin_unlock_irqrestore(&mcli->curr_lock, flags);

	if (!midev)
		return 0;

	switch (event) {
	case I2C_SLAVE_WRITE_RECEIVED:
		if (midev->pos < MCTP_I2C_RXBUFSZ) {
			midev->buffer[midev->pos] = *val;
			midev->pos++;
		} else {
			midev->ndev->stats.rx_over_errors++;
		}

		break;
	case I2C_SLAVE_WRITE_REQUESTED:
		/* dest_slave as first byte */
		midev->buffer[0] = mcli->lladdr << 1;
		midev->pos = 1;
		break;
	case I2C_SLAVE_STOP:
		rc = mctp_i2c_recv(midev);
		break;
	default:
		break;
	}

	dev_put(midev->ndev);
	return rc;
}

// Processes incoming data that has been accumulated by the slave cb
static int mctp_i2c_recv(struct mctp_i2c_dev *midev)
{
	struct net_device *ndev = midev->ndev;
	struct mctp_i2c_hdr *hdr;
	struct mctp_skb_cb *cb;
	struct sk_buff *skb;
	u8 pec, calc_pec;
	size_t recvlen;

	/* + 1 for the PEC */
	if (midev->pos < MCTP_I2C_MINLEN + 1) {
		ndev->stats.rx_length_errors++;
		return -EINVAL;
	}
	recvlen = midev->pos - 1;

	hdr = (void *)midev->buffer;
	if (hdr->command != MCTP_I2C_COMMANDCODE) {
		ndev->stats.rx_dropped++;
		return -EINVAL;
	}

	pec = midev->buffer[midev->pos - 1];
	calc_pec = i2c_smbus_pec(0, midev->buffer, recvlen);
	if (pec != calc_pec) {
		ndev->stats.rx_crc_errors++;
		return -EINVAL;
	}

	skb = netdev_alloc_skb(ndev, recvlen);
	if (!skb) {
		ndev->stats.rx_dropped++;
		return -ENOMEM;
	}

	skb->protocol = htons(ETH_P_MCTP);
	skb_put_data(skb, midev->buffer, recvlen);
	skb_reset_mac_header(skb);
	skb_pull(skb, sizeof(struct mctp_i2c_hdr));
	skb_reset_network_header(skb);

	cb = __mctp_cb(skb);
	cb->halen = 1;
	cb->haddr[0] = hdr->source_slave;

	if (netif_rx(skb) == NET_RX_SUCCESS) {
		ndev->stats.rx_packets++;
		ndev->stats.rx_bytes += skb->len;
	} else {
		ndev->stats.rx_dropped++;
	}
	return 0;
}

enum mctp_i2c_flow_state {
	MCTP_I2C_TX_FLOW_INVALID,
	MCTP_I2C_TX_FLOW_NONE,
	MCTP_I2C_TX_FLOW_NEW,
	MCTP_I2C_TX_FLOW_EXISTING,
};

static enum mctp_i2c_flow_state
mctp_i2c_get_tx_flow_state(struct mctp_i2c_dev *midev, struct sk_buff *skb)
{
	enum mctp_i2c_flow_state state;
	struct mctp_sk_key *key;
	struct mctp_flow *flow;
	unsigned long flags;

	flow = skb_ext_find(skb, SKB_EXT_MCTP);
	if (!flow)
		return MCTP_I2C_TX_FLOW_NONE;

	key = flow->key;
	if (!key)
		return MCTP_I2C_TX_FLOW_NONE;

	spin_lock_irqsave(&key->lock, flags);
	/* if the key is present but invalid, we're unlikely to be able
	 * to handle the flow at all; just drop now
	 */
	if (!key->valid) {
		state = MCTP_I2C_TX_FLOW_INVALID;

	} else if (key->dev_flow_state == MCTP_I2C_FLOW_STATE_NEW) {
		key->dev_flow_state = MCTP_I2C_FLOW_STATE_ACTIVE;
		state = MCTP_I2C_TX_FLOW_NEW;
	} else {
		state = MCTP_I2C_TX_FLOW_EXISTING;
	}

	spin_unlock_irqrestore(&key->lock, flags);

	return state;
}

/* We're not contending with ourselves here; we only need to exclude other
 * i2c clients from using the bus. refcounts are simply to prevent
 * recursive locking.
 */
static void mctp_i2c_lock_nest(struct mctp_i2c_dev *midev)
{
	unsigned long flags;
	bool lock;

	spin_lock_irqsave(&midev->flow_lock, flags);
	lock = midev->i2c_lock_count == 0;
	midev->i2c_lock_count++;
	spin_unlock_irqrestore(&midev->flow_lock, flags);

	if (lock)
		i2c_lock_bus(midev->adapter, I2C_LOCK_SEGMENT);
}

static void mctp_i2c_unlock_nest(struct mctp_i2c_dev *midev)
{
	unsigned long flags;
	bool unlock;

	spin_lock_irqsave(&midev->flow_lock, flags);
	if (!WARN_ONCE(midev->i2c_lock_count == 0, "lock count underflow!"))
		midev->i2c_lock_count--;
	unlock = midev->i2c_lock_count == 0;
	spin_unlock_irqrestore(&midev->flow_lock, flags);

	if (unlock)
		i2c_unlock_bus(midev->adapter, I2C_LOCK_SEGMENT);
}

static void mctp_i2c_xmit(struct mctp_i2c_dev *midev, struct sk_buff *skb)
{
	struct net_device_stats *stats = &midev->ndev->stats;
	enum mctp_i2c_flow_state fs;
	union i2c_smbus_data *data;
	struct mctp_i2c_hdr *hdr;
	unsigned int len;
	u16 daddr;
	int rc;

	fs = mctp_i2c_get_tx_flow_state(midev, skb);

	len = skb->len;
	hdr = (void *)skb_mac_header(skb);
	data = (void *)&hdr->byte_count;
	daddr = hdr->dest_slave >> 1;

	switch (fs) {
	case MCTP_I2C_TX_FLOW_NONE:
		/* no flow: full lock & unlock */
		mctp_i2c_lock_nest(midev);
		mctp_i2c_device_select(midev->client, midev);
		rc = __i2c_smbus_xfer(midev->adapter, daddr, I2C_CLIENT_PEC,
				      I2C_SMBUS_WRITE, hdr->command,
				      I2C_SMBUS_BLOCK_DATA, data);
		mctp_i2c_unlock_nest(midev);
		break;

	case MCTP_I2C_TX_FLOW_NEW:
		/* new flow: lock, tx, but don't unlock; that will happen
		 * on flow release
		 */
		mctp_i2c_lock_nest(midev);
		mctp_i2c_device_select(midev->client, midev);
		fallthrough;

	case MCTP_I2C_TX_FLOW_EXISTING:
		/* existing flow: we already have the lock; just tx */
		rc = __i2c_smbus_xfer(midev->adapter, daddr, I2C_CLIENT_PEC,
				      I2C_SMBUS_WRITE, hdr->command,
				      I2C_SMBUS_BLOCK_DATA, data);
		break;

	case MCTP_I2C_TX_FLOW_INVALID:
		return;
	}

	if (rc) {
		dev_warn_ratelimited(&midev->adapter->dev,
				     "%s i2c_smbus_xfer failed %d", __func__, rc);
		stats->tx_errors++;
	} else {
		stats->tx_bytes += len;
		stats->tx_packets++;
	}
}

static void mctp_i2c_flow_release(struct mctp_i2c_dev *midev)
{
	unsigned long flags;
	bool unlock;

	spin_lock_irqsave(&midev->flow_lock, flags);
	if (midev->release_count > midev->i2c_lock_count) {
		WARN_ONCE(1, "release count overflow");
		midev->release_count = midev->i2c_lock_count;
	}

	midev->i2c_lock_count -= midev->release_count;
	unlock = midev->i2c_lock_count == 0 && midev->release_count > 0;
	midev->release_count = 0;
	spin_unlock_irqrestore(&midev->flow_lock, flags);

	if (unlock)
		i2c_unlock_bus(midev->adapter, I2C_LOCK_SEGMENT);
}

static int mctp_i2c_header_create(struct sk_buff *skb, struct net_device *dev,
				  unsigned short type, const void *daddr,
	   const void *saddr, unsigned int len)
{
	struct mctp_i2c_hdr *hdr;
	struct mctp_hdr *mhdr;
	u8 lldst, llsrc;

	lldst = *((u8 *)daddr);
	llsrc = *((u8 *)saddr);

	skb_push(skb, sizeof(struct mctp_i2c_hdr));
	skb_reset_mac_header(skb);
	hdr = (void *)skb_mac_header(skb);
	mhdr = mctp_hdr(skb);
	hdr->dest_slave = (lldst << 1) & 0xff;
	hdr->command = MCTP_I2C_COMMANDCODE;
	hdr->byte_count = len + 1;
	if (hdr->byte_count > MCTP_I2C_MAXBLOCK)
		return -EMSGSIZE;
	hdr->source_slave = ((llsrc << 1) & 0xff) | 0x01;
	mhdr->ver = 0x01;

	return 0;
}

static int mctp_i2c_tx_thread(void *data)
{
	struct mctp_i2c_dev *midev = data;
	struct sk_buff *skb;
	unsigned long flags;

	for (;;) {
		if (kthread_should_stop())
			break;

		spin_lock_irqsave(&midev->tx_queue.lock, flags);
		skb = __skb_dequeue(&midev->tx_queue);
		if (netif_queue_stopped(midev->ndev))
			netif_wake_queue(midev->ndev);
		spin_unlock_irqrestore(&midev->tx_queue.lock, flags);

		if (skb == &midev->unlock_marker) {
			mctp_i2c_flow_release(midev);

		} else if (skb) {
			mctp_i2c_xmit(midev, skb);
			kfree_skb(skb);

		} else {
			wait_event(midev->tx_wq,
				   !skb_queue_empty(&midev->tx_queue) ||
				   kthread_should_stop());
		}
	}

	return 0;
}

static netdev_tx_t mctp_i2c_start_xmit(struct sk_buff *skb,
				       struct net_device *dev)
{
	struct mctp_i2c_dev *midev = netdev_priv(dev);
	unsigned long flags;

	spin_lock_irqsave(&midev->tx_queue.lock, flags);
	if (skb_queue_len(&midev->tx_queue) >= MCTP_I2C_TX_WORK_LEN) {
		netif_stop_queue(dev);
		spin_unlock_irqrestore(&midev->tx_queue.lock, flags);
		netdev_err(dev, "BUG! Tx Ring full when queue awake!\n");
		return NETDEV_TX_BUSY;
	}

	__skb_queue_tail(&midev->tx_queue, skb);
	if (skb_queue_len(&midev->tx_queue) == MCTP_I2C_TX_WORK_LEN)
		netif_stop_queue(dev);
	spin_unlock_irqrestore(&midev->tx_queue.lock, flags);

	wake_up(&midev->tx_wq);
	return NETDEV_TX_OK;
}

static void mctp_i2c_release_flow(struct mctp_dev *mdev,
				  struct mctp_sk_key *key)

{
	struct mctp_i2c_dev *midev = netdev_priv(mdev->dev);
	unsigned long flags;

	spin_lock_irqsave(&midev->flow_lock, flags);
	midev->release_count++;
	spin_unlock_irqrestore(&midev->flow_lock, flags);

	/* Ensure we have a release operation queued, through the fake
	 * marker skb
	 */
	spin_lock(&midev->tx_queue.lock);
	if (!midev->unlock_marker.next)
		__skb_queue_tail(&midev->tx_queue, &midev->unlock_marker);
	spin_unlock(&midev->tx_queue.lock);

	wake_up(&midev->tx_wq);
}

static const struct net_device_ops mctp_i2c_ops = {
	.ndo_start_xmit = mctp_i2c_start_xmit,
};

static const struct header_ops mctp_i2c_headops = {
	.create = mctp_i2c_header_create,
};

static const struct mctp_netdev_ops mctp_i2c_mctp_ops = {
	.release_flow = mctp_i2c_release_flow,
};

static void mctp_i2c_net_setup(struct net_device *dev)
{
	dev->type = ARPHRD_MCTP;

	dev->mtu = MCTP_I2C_MAXMTU;
	dev->min_mtu = MCTP_I2C_MINMTU;
	dev->max_mtu = MCTP_I2C_MAXMTU;
	dev->tx_queue_len = MCTP_I2C_TX_QUEUE_LEN;

	dev->hard_header_len = sizeof(struct mctp_i2c_hdr);
	dev->addr_len = 1;

	dev->netdev_ops		= &mctp_i2c_ops;
	dev->header_ops		= &mctp_i2c_headops;
	dev->needs_free_netdev  = true;
}

static int mctp_i2c_add_netdev(struct mctp_i2c_client *mcli,
			       struct i2c_adapter *adap)
{
	unsigned long flags;
	struct mctp_i2c_dev *midev = NULL;
	struct net_device *ndev = NULL;
	struct i2c_adapter *root;
	char namebuf[30];
	int rc;

	root = mux_root_adapter(adap);
	if (root != mcli->client->adapter) {
		dev_err(&mcli->client->dev,
			"I2C adapter %s is not a child bus of %s",
			mcli->client->adapter->name, root->name);
		return -EINVAL;
	}

	WARN_ON(!mutex_is_locked(&mi_driver_state.lock));
	snprintf(namebuf, sizeof(namebuf), "mctpi2c%d", adap->nr);
	ndev = alloc_netdev(sizeof(*midev), namebuf, NET_NAME_ENUM, mctp_i2c_net_setup);
	if (!ndev) {
		dev_err(&mcli->client->dev, "%s alloc netdev failed\n", __func__);
		rc = -ENOMEM;
		goto err;
	}
	dev_net_set(ndev, current->nsproxy->net_ns);
	SET_NETDEV_DEV(ndev, &adap->dev);
	ndev->dev_addr = &mcli->lladdr;

	midev = netdev_priv(ndev);
	skb_queue_head_init(&midev->tx_queue);
	INIT_LIST_HEAD(&midev->list);
	midev->adapter = adap;
	midev->client = mcli;
	spin_lock_init(&midev->flow_lock);
	midev->i2c_lock_count = 0;
	midev->release_count = 0;
	/* Hold references */
	get_device(&midev->adapter->dev);
	get_device(&midev->client->client->dev);
	midev->ndev = ndev;
	init_waitqueue_head(&midev->tx_wq);
	midev->tx_thread = kthread_create(mctp_i2c_tx_thread, midev,
					  "%s/tx", namebuf);
	if (IS_ERR_OR_NULL(midev->tx_thread)) {
		rc = -ENOMEM;
		goto err_free;
	}

	rc = mctp_register_netdev(ndev, &mctp_i2c_mctp_ops);
	if (rc) {
		dev_err(&mcli->client->dev,
			"%s register netdev \"%s\" failed %d\n", __func__,
			ndev->name, rc);
		goto err_stop_kthread;
	}
	spin_lock_irqsave(&mcli->curr_lock, flags);
	list_add(&midev->list, &mcli->devs);
	// Select a device by default
	if (!mcli->sel)
		__mctp_i2c_device_select(mcli, midev);
	spin_unlock_irqrestore(&mcli->curr_lock, flags);

	wake_up_process(midev->tx_thread);

	return 0;

err_stop_kthread:
	kthread_stop(midev->tx_thread);

err_free:
	free_netdev(ndev);

err:
	return rc;
}

// Removes and unregisters a mctp-i2c netdev
static void mctp_i2c_free_netdev(struct mctp_i2c_dev *midev)
{
	struct mctp_i2c_client *mcli = midev->client;
	unsigned long flags;

	netif_stop_queue(midev->ndev);
	kthread_stop(midev->tx_thread);
	skb_queue_purge(&midev->tx_queue);

	/* Release references, used only for TX which has stopped */
	put_device(&midev->adapter->dev);
	put_device(&mcli->client->dev);

	/* Remove it from the parent mcli */
	spin_lock_irqsave(&mcli->curr_lock, flags);
	list_del(&midev->list);
	if (mcli->sel == midev) {
		struct mctp_i2c_dev *first;

		first = list_first_entry_or_null(&mcli->devs, struct mctp_i2c_dev, list);
		__mctp_i2c_device_select(mcli, first);
	}
	spin_unlock_irqrestore(&mcli->curr_lock, flags);

	/* Remove netdev. mctp_i2c_slave_cb() takes a dev_hold() so removing
	 * it now is safe. unregister_netdev() frees ndev and midev.
	 */
	mctp_unregister_netdev(midev->ndev);
}

// Removes any netdev for adap. mcli is the parent root i2c client
static void mctp_i2c_remove_netdev(struct mctp_i2c_client *mcli,
				   struct i2c_adapter *adap)
{
	unsigned long flags;
	struct mctp_i2c_dev *midev = NULL, *m = NULL;

	WARN_ON(!mutex_is_locked(&mi_driver_state.lock));
	spin_lock_irqsave(&mcli->curr_lock, flags);
	// list size is limited by number of MCTP netdevs on a single hardware bus
	list_for_each_entry(m, &mcli->devs, list)
		if (m->adapter == adap) {
			midev = m;
			break;
		}
	spin_unlock_irqrestore(&mcli->curr_lock, flags);

	if (midev)
		mctp_i2c_free_netdev(midev);
}

/* Determines whether a device is an i2c adapter.
 * Optionally returns the root i2c_adapter
 */
static struct i2c_adapter *mctp_i2c_get_adapter(struct device *dev,
						struct i2c_adapter **ret_root)
{
	struct i2c_adapter *root, *adap;

	if (dev->type != &i2c_adapter_type)
		return NULL;
	adap = to_i2c_adapter(dev);
	root = mux_root_adapter(adap);
	WARN_ONCE(!root, "%s failed to find root adapter for %s\n",
		  __func__, dev_name(dev));
	if (!root)
		return NULL;
	if (ret_root)
		*ret_root = root;
	return adap;
}

/* Determines whether a device is an i2c adapter with the "mctp-controller"
 * devicetree property set. If adap is not an OF node, returns match_no_of
 */
static bool mctp_i2c_adapter_match(struct i2c_adapter *adap, bool match_no_of)
{
	if (!adap->dev.of_node)
		return match_no_of;
	return of_property_read_bool(adap->dev.of_node, MCTP_I2C_OF_PROP);
}

/* Called for each existing i2c device (adapter or client) when a
 * new mctp-i2c client is probed.
 */
static int mctp_i2c_client_try_attach(struct device *dev, void *data)
{
	struct i2c_adapter *adap = NULL, *root = NULL;
	struct mctp_i2c_client *mcli = data;

	adap = mctp_i2c_get_adapter(dev, &root);
	if (!adap)
		return 0;
	if (mcli->client->adapter != root)
		return 0;
	// Must either have mctp-controller property on the adapter, or
	// be a root adapter if it's non-devicetree
	if (!mctp_i2c_adapter_match(adap, adap == root))
		return 0;

	return mctp_i2c_add_netdev(mcli, adap);
}

static void mctp_i2c_notify_add(struct device *dev)
{
	struct mctp_i2c_client *mcli = NULL, *m = NULL;
	struct i2c_adapter *root = NULL, *adap = NULL;
	int rc;

	adap = mctp_i2c_get_adapter(dev, &root);
	if (!adap)
		return;
	// Check for mctp-controller property on the adapter
	if (!mctp_i2c_adapter_match(adap, false))
		return;

	/* Find an existing mcli for adap's root */
	mutex_lock(&mi_driver_state.lock);
	list_for_each_entry(m, &mi_driver_state.clients, list) {
		if (m->client->adapter == root) {
			mcli = m;
			break;
		}
	}

	if (mcli) {
		rc = mctp_i2c_add_netdev(mcli, adap);
		if (rc)
			dev_warn(dev, "%s Failed adding mctp-i2c device",
				 __func__);
	}
	mutex_unlock(&mi_driver_state.lock);
}

static void mctp_i2c_notify_del(struct device *dev)
{
	struct i2c_adapter *root = NULL, *adap = NULL;
	struct mctp_i2c_client *mcli = NULL;

	adap = mctp_i2c_get_adapter(dev, &root);
	if (!adap)
		return;

	mutex_lock(&mi_driver_state.lock);
	list_for_each_entry(mcli, &mi_driver_state.clients, list) {
		if (mcli->client->adapter == root) {
			mctp_i2c_remove_netdev(mcli, adap);
			break;
		}
	}
	mutex_unlock(&mi_driver_state.lock);
}

static int mctp_i2c_probe(struct i2c_client *client)
{
	struct mctp_i2c_client *mcli = NULL;
	int rc;

	/* Check for >32 byte block support required for MCTP */
	if (!i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_V3_BLOCK)) {
		dev_err(&client->dev,
			"%s failed, I2C bus driver does not support 255 byte block transfer\n",
			__func__);
		return -EOPNOTSUPP;
	}

	mutex_lock(&mi_driver_state.lock);
	mcli = mctp_i2c_new_client(client);
	if (IS_ERR(mcli)) {
		rc = PTR_ERR(mcli);
		mcli = NULL;
		goto out;
	} else {
		list_add(&mcli->list, &mi_driver_state.clients);
	}

	// Add a netdev for adapters that have a 'mctp-controller' property
	i2c_for_each_dev(mcli, mctp_i2c_client_try_attach);
	rc = 0;
out:
	mutex_unlock(&mi_driver_state.lock);
	return rc;
}

static int mctp_i2c_remove(struct i2c_client *client)
{
	struct mctp_i2c_client *mcli = i2c_get_clientdata(client);
	struct mctp_i2c_dev *midev = NULL, *tmp = NULL;

	mutex_lock(&mi_driver_state.lock);
	list_del(&mcli->list);
	// Remove all child adapter netdevs
	list_for_each_entry_safe(midev, tmp, &mcli->devs, list)
		mctp_i2c_free_netdev(midev);

	mctp_i2c_free_client(mcli);
	mutex_unlock(&mi_driver_state.lock);
	// Callers ignore return code
	return 0;
}

/* We look for a 'mctp-controller' property on I2C busses as they are
 * added/deleted, creating/removing netdevs as required.
 */
static int mctp_i2c_notifier_call(struct notifier_block *nb,
				  unsigned long action, void *data)
{
	struct device *dev = data;

	switch (action) {
	case BUS_NOTIFY_ADD_DEVICE:
		mctp_i2c_notify_add(dev);
		break;
	case BUS_NOTIFY_DEL_DEVICE:
		mctp_i2c_notify_del(dev);
		break;
	}
	return NOTIFY_DONE;
}

static struct notifier_block mctp_i2c_notifier = {
	.notifier_call = mctp_i2c_notifier_call,
};

static const struct i2c_device_id mctp_i2c_id[] = {
	{ "mctp-i2c", 0 },
	{},
};
MODULE_DEVICE_TABLE(i2c, mctp_i2c_id);

static const struct of_device_id mctp_i2c_of_match[] = {
	{ .compatible = "mctp-i2c-controller" },
	{},
};
MODULE_DEVICE_TABLE(of, mctp_i2c_of_match);

static struct i2c_driver mctp_i2c_driver = {
	.driver = {
		.name = "mctp-i2c",
		.of_match_table = mctp_i2c_of_match,
	},
	.probe_new = mctp_i2c_probe,
	.remove = mctp_i2c_remove,
	.id_table = mctp_i2c_id,
};

static __init int mctp_i2c_init(void)
{
	int rc;

	INIT_LIST_HEAD(&mi_driver_state.clients);
	mutex_init(&mi_driver_state.lock);
	pr_info("MCTP SMBus/I2C transport driver\n");
	rc = i2c_add_driver(&mctp_i2c_driver);
	if (rc)
		return rc;
	rc = bus_register_notifier(&i2c_bus_type, &mctp_i2c_notifier);
	if (rc) {
		i2c_del_driver(&mctp_i2c_driver);
		return rc;
	}
	return 0;
}

static __exit void mctp_i2c_exit(void)
{
	int rc;

	rc = bus_unregister_notifier(&i2c_bus_type, &mctp_i2c_notifier);
	if (rc)
		pr_warn("%s Could not unregister notifier, %d", __func__, rc);
	i2c_del_driver(&mctp_i2c_driver);
}

module_init(mctp_i2c_init);
module_exit(mctp_i2c_exit);

MODULE_DESCRIPTION("MCTP SMBus/I2C device");
MODULE_LICENSE("GPL v2");
MODULE_AUTHOR("Matt Johnston <matt@codeconstruct.com.au>");