Orange Pi5 kernel

 // SPDX-License-Identifier: GPL-2.0
 
/*
 * IPMB driver to receive a request and send a response
 *
 * Copyright (C) 2019 Mellanox Techologies, Ltd.
 *
 * This was inspired by Brendan Higgins' ipmi-bmc-bt-i2c driver.
 */
 
#include <linux/acpi.h>
#include <linux/errno.h>
#include <linux/i2c.h>
#include <linux/miscdevice.h>
#include <linux/module.h>
#include <linux/mutex.h>
#include <linux/poll.h>
#include <linux/slab.h>
#include <linux/spinlock.h>
#include <linux/wait.h>
 
#define MAX_MSG_LEN		240
#define IPMB_REQUEST_LEN_MIN	7
#define NETFN_RSP_BIT_MASK	0x4
#define REQUEST_QUEUE_MAX_LEN	256
 
#define IPMB_MSG_LEN_IDX	0
#define RQ_SA_8BIT_IDX		1
#define NETFN_LUN_IDX		2
 
#define GET_7BIT_ADDR(addr_8bit)	(addr_8bit >> 1)
#define GET_8BIT_ADDR(addr_7bit)	((addr_7bit << 1) & 0xff)
 
#define IPMB_MSG_PAYLOAD_LEN_MAX (MAX_MSG_LEN - IPMB_REQUEST_LEN_MIN - 1)
 
#define SMBUS_MSG_HEADER_LENGTH	2
#define SMBUS_MSG_IDX_OFFSET	(SMBUS_MSG_HEADER_LENGTH + 1)
 
struct ipmb_msg {
<------>u8 len;
<------>u8 rs_sa;
<------>u8 netfn_rs_lun;
<------>u8 checksum1;
<------>u8 rq_sa;
<------>u8 rq_seq_rq_lun;
<------>u8 cmd;
<------>u8 payload[IPMB_MSG_PAYLOAD_LEN_MAX];
<------>/* checksum2 is included in payload */
} __packed;
 
struct ipmb_request_elem {
<------>struct list_head list;
<------>struct ipmb_msg request;
};
 
struct ipmb_dev {
<------>struct i2c_client *client;
<------>struct miscdevice miscdev;
<------>struct ipmb_msg request;
<------>struct list_head request_queue;
<------>atomic_t request_queue_len;
<------>size_t msg_idx;
<------>spinlock_t lock;
<------>wait_queue_head_t wait_queue;
<------>struct mutex file_mutex;
<------>bool is_i2c_protocol;
};
 
static inline struct ipmb_dev *to_ipmb_dev(struct file *file)
{
<------>return container_of(file->private_data, struct ipmb_dev, miscdev);
}
 
static ssize_t ipmb_read(struct file *file, char __user *buf, size_t count,
<------><------><------>loff_t *ppos)
{
<------>struct ipmb_dev *ipmb_dev = to_ipmb_dev(file);
<------>struct ipmb_request_elem *queue_elem;
<------>struct ipmb_msg msg;
<------>ssize_t ret = 0;
 
<------>memset(&msg, 0, sizeof(msg));
 
<------>spin_lock_irq(&ipmb_dev->lock);
 
<------>while (list_empty(&ipmb_dev->request_queue)) {
<------><------>spin_unlock_irq(&ipmb_dev->lock);
 
<------><------>if (file->f_flags & O_NONBLOCK)
<------><------><------>return -EAGAIN;
 
<------><------>ret = wait_event_interruptible(ipmb_dev->wait_queue,
<------><------><------><------>!list_empty(&ipmb_dev->request_queue));
<------><------>if (ret)
<------><------><------>return ret;
 
<------><------>spin_lock_irq(&ipmb_dev->lock);
<------>}
 
<------>queue_elem = list_first_entry(&ipmb_dev->request_queue,
<------><------><------><------><------>struct ipmb_request_elem, list);
<------>memcpy(&msg, &queue_elem->request, sizeof(msg));
<------>list_del(&queue_elem->list);
<------>kfree(queue_elem);
<------>atomic_dec(&ipmb_dev->request_queue_len);
 
<------>spin_unlock_irq(&ipmb_dev->lock);
 
<------>count = min_t(size_t, count, msg.len + 1);
<------>if (copy_to_user(buf, &msg, count))
<------><------>ret = -EFAULT;
 
<------>return ret < 0 ? ret : count;
}
 
static int ipmb_i2c_write(struct i2c_client *client, u8 *msg, u8 addr)
{
<------>struct i2c_msg i2c_msg;
 
<------>/*
<------> * subtract 1 byte (rq_sa) from the length of the msg passed to
<------> * raw i2c_transfer
<------> */
<------>i2c_msg.len = msg[IPMB_MSG_LEN_IDX] - 1;
 
<------>/* Assign message to buffer except first 2 bytes (length and address) */
<------>i2c_msg.buf = msg + 2;
 
<------>i2c_msg.addr = addr;
<------>i2c_msg.flags = client->flags & I2C_CLIENT_PEC;
 
<------>return i2c_transfer(client->adapter, &i2c_msg, 1);
}
 
static ssize_t ipmb_write(struct file *file, const char __user *buf,
<------><------><------>size_t count, loff_t *ppos)
{
<------>struct ipmb_dev *ipmb_dev = to_ipmb_dev(file);
<------>u8 rq_sa, netf_rq_lun, msg_len;
<------>union i2c_smbus_data data;
<------>u8 msg[MAX_MSG_LEN];
<------>ssize_t ret;
 
<------>if (count > sizeof(msg))
<------><------>return -EINVAL;
 
<------>if (copy_from_user(&msg, buf, count))
<------><------>return -EFAULT;
 
<------>if (count < msg[0])
<------><------>return -EINVAL;
 
<------>rq_sa = GET_7BIT_ADDR(msg[RQ_SA_8BIT_IDX]);
<------>netf_rq_lun = msg[NETFN_LUN_IDX];
 
<------>/* Check i2c block transfer vs smbus */
<------>if (ipmb_dev->is_i2c_protocol) {
<------><------>ret = ipmb_i2c_write(ipmb_dev->client, msg, rq_sa);
<------><------>return (ret == 1) ? count : ret;
<------>}
 
<------>/*
<------> * subtract rq_sa and netf_rq_lun from the length of the msg passed to
<------> * i2c_smbus_xfer
<------> */
<------>msg_len = msg[IPMB_MSG_LEN_IDX] - SMBUS_MSG_HEADER_LENGTH;
<------>if (msg_len > I2C_SMBUS_BLOCK_MAX)
<------><------>msg_len = I2C_SMBUS_BLOCK_MAX;
 
<------>data.block[0] = msg_len;
<------>memcpy(&data.block[1], msg + SMBUS_MSG_IDX_OFFSET, msg_len);
<------>ret = i2c_smbus_xfer(ipmb_dev->client->adapter, rq_sa,
<------><------><------>     ipmb_dev->client->flags,
<------><------><------>     I2C_SMBUS_WRITE, netf_rq_lun,
<------><------><------>     I2C_SMBUS_BLOCK_DATA, &data);
 
<------>return ret ? : count;
}
 
static __poll_t ipmb_poll(struct file *file, poll_table *wait)
{
<------>struct ipmb_dev *ipmb_dev = to_ipmb_dev(file);
<------>__poll_t mask = EPOLLOUT;
 
<------>mutex_lock(&ipmb_dev->file_mutex);
<------>poll_wait(file, &ipmb_dev->wait_queue, wait);
 
<------>if (atomic_read(&ipmb_dev->request_queue_len))
<------><------>mask |= EPOLLIN;
<------>mutex_unlock(&ipmb_dev->file_mutex);
 
<------>return mask;
}
 
static const struct file_operations ipmb_fops = {
<------>.owner	= THIS_MODULE,
<------>.read	= ipmb_read,
<------>.write	= ipmb_write,
<------>.poll	= ipmb_poll,
};
 
/* Called with ipmb_dev->lock held. */
static void ipmb_handle_request(struct ipmb_dev *ipmb_dev)
{
<------>struct ipmb_request_elem *queue_elem;
 
<------>if (atomic_read(&ipmb_dev->request_queue_len) >=
<------><------><------>REQUEST_QUEUE_MAX_LEN)
<------><------>return;
 
<------>queue_elem = kmalloc(sizeof(*queue_elem), GFP_ATOMIC);
<------>if (!queue_elem)
<------><------>return;
 
<------>memcpy(&queue_elem->request, &ipmb_dev->request,
<------><------>sizeof(struct ipmb_msg));
<------>list_add(&queue_elem->list, &ipmb_dev->request_queue);
<------>atomic_inc(&ipmb_dev->request_queue_len);
<------>wake_up_all(&ipmb_dev->wait_queue);
}
 
static u8 ipmb_verify_checksum1(struct ipmb_dev *ipmb_dev, u8 rs_sa)
{
<------>/* The 8 lsb of the sum is 0 when the checksum is valid */
<------>return (rs_sa + ipmb_dev->request.netfn_rs_lun +
<------><------>ipmb_dev->request.checksum1);
}
 
/*
 * Verify if message has proper ipmb header with minimum length
 * and correct checksum byte.
 */
static bool is_ipmb_msg(struct ipmb_dev *ipmb_dev, u8 rs_sa)
{
<------>if ((ipmb_dev->msg_idx >= IPMB_REQUEST_LEN_MIN) &&
<------>   (!ipmb_verify_checksum1(ipmb_dev, rs_sa)))
<------><------>return true;
 
<------>return false;
}
 
/*
 * The IPMB protocol only supports I2C Writes so there is no need
 * to support I2C_SLAVE_READ* events.
 * This i2c callback function only monitors IPMB request messages
 * and adds them in a queue, so that they can be handled by
 * receive_ipmb_request.
 */
static int ipmb_slave_cb(struct i2c_client *client,
<------><------><------>enum i2c_slave_event event, u8 *val)
{
<------>struct ipmb_dev *ipmb_dev = i2c_get_clientdata(client);
<------>u8 *buf = (u8 *)&ipmb_dev->request;
<------>unsigned long flags;
 
<------>spin_lock_irqsave(&ipmb_dev->lock, flags);
<------>switch (event) {
<------>case I2C_SLAVE_WRITE_REQUESTED:
<------><------>memset(&ipmb_dev->request, 0, sizeof(ipmb_dev->request));
<------><------>ipmb_dev->msg_idx = 0;
 
<------><------>/*
<------><------> * At index 0, ipmb_msg stores the length of msg,
<------><------> * skip it for now.
<------><------> * The len will be populated once the whole
<------><------> * buf is populated.
<------><------> *
<------><------> * The I2C bus driver's responsibility is to pass the
<------><------> * data bytes to the backend driver; it does not
<------><------> * forward the i2c slave address.
<------><------> * Since the first byte in the IPMB message is the
<------><------> * address of the responder, it is the responsibility
<------><------> * of the IPMB driver to format the message properly.
<------><------> * So this driver prepends the address of the responder
<------><------> * to the received i2c data before the request message
<------><------> * is handled in userland.
<------><------> */
<------><------>buf[++ipmb_dev->msg_idx] = GET_8BIT_ADDR(client->addr);
<------><------>break;
 
<------>case I2C_SLAVE_WRITE_RECEIVED:
<------><------>if (ipmb_dev->msg_idx >= sizeof(struct ipmb_msg) - 1)
<------><------><------>break;
 
<------><------>buf[++ipmb_dev->msg_idx] = *val;
<------><------>break;
 
<------>case I2C_SLAVE_STOP:
<------><------>ipmb_dev->request.len = ipmb_dev->msg_idx;
<------><------>if (is_ipmb_msg(ipmb_dev, GET_8BIT_ADDR(client->addr)))
<------><------><------>ipmb_handle_request(ipmb_dev);
<------><------>break;
 
<------>default:
<------><------>break;
<------>}
<------>spin_unlock_irqrestore(&ipmb_dev->lock, flags);
 
<------>return 0;
}
 
static int ipmb_probe(struct i2c_client *client,
<------><------><------>const struct i2c_device_id *id)
{
<------>struct ipmb_dev *ipmb_dev;
<------>int ret;
 
<------>ipmb_dev = devm_kzalloc(&client->dev, sizeof(*ipmb_dev),
<------><------><------><------><------>GFP_KERNEL);
<------>if (!ipmb_dev)
<------><------>return -ENOMEM;
 
<------>spin_lock_init(&ipmb_dev->lock);
<------>init_waitqueue_head(&ipmb_dev->wait_queue);
<------>atomic_set(&ipmb_dev->request_queue_len, 0);
<------>INIT_LIST_HEAD(&ipmb_dev->request_queue);
 
<------>mutex_init(&ipmb_dev->file_mutex);
 
<------>ipmb_dev->miscdev.minor = MISC_DYNAMIC_MINOR;
 
<------>ipmb_dev->miscdev.name = devm_kasprintf(&client->dev, GFP_KERNEL,
<------><------><------><------><------><------>"%s%d", "ipmb-",
<------><------><------><------><------><------>client->adapter->nr);
<------>ipmb_dev->miscdev.fops = &ipmb_fops;
<------>ipmb_dev->miscdev.parent = &client->dev;
<------>ret = misc_register(&ipmb_dev->miscdev);
<------>if (ret)
<------><------>return ret;
 
<------>ipmb_dev->is_i2c_protocol
<------><------>= device_property_read_bool(&client->dev, "i2c-protocol");
 
<------>ipmb_dev->client = client;
<------>i2c_set_clientdata(client, ipmb_dev);
<------>ret = i2c_slave_register(client, ipmb_slave_cb);
<------>if (ret) {
<------><------>misc_deregister(&ipmb_dev->miscdev);
<------><------>return ret;
<------>}
 
<------>return 0;
}
 
static int ipmb_remove(struct i2c_client *client)
{
<------>struct ipmb_dev *ipmb_dev = i2c_get_clientdata(client);
 
<------>i2c_slave_unregister(client);
<------>misc_deregister(&ipmb_dev->miscdev);
 
<------>return 0;
}
 
static const struct i2c_device_id ipmb_id[] = {
<------>{ "ipmb-dev", 0 },
<------>{},
};
MODULE_DEVICE_TABLE(i2c, ipmb_id);
 
static const struct acpi_device_id acpi_ipmb_id[] = {
<------>{ "IPMB0001", 0 },
<------>{},
};
MODULE_DEVICE_TABLE(acpi, acpi_ipmb_id);
 
static struct i2c_driver ipmb_driver = {
<------>.driver = {
<------><------>.name = "ipmb-dev",
<------><------>.acpi_match_table = ACPI_PTR(acpi_ipmb_id),
<------>},
<------>.probe = ipmb_probe,
<------>.remove = ipmb_remove,
<------>.id_table = ipmb_id,
};
module_i2c_driver(ipmb_driver);
 
MODULE_AUTHOR("Mellanox Technologies");
MODULE_DESCRIPTION("IPMB driver");
MODULE_LICENSE("GPL v2");

	// SPDX-License-Identifier: GPL-2.0

	/*
	* IPMB driver to receive a request and send a response
	*
	* Copyright (C) 2019 Mellanox Techologies, Ltd.
	*
	* This was inspired by Brendan Higgins' ipmi-bmc-bt-i2c driver.
	*/

	#include <linux/acpi.h>
	#include <linux/errno.h>
	#include <linux/i2c.h>
	#include <linux/miscdevice.h>
	#include <linux/module.h>
	#include <linux/mutex.h>
	#include <linux/poll.h>
	#include <linux/slab.h>
	#include <linux/spinlock.h>
	#include <linux/wait.h>

	#define MAX_MSG_LEN 240
	#define IPMB_REQUEST_LEN_MIN 7
	#define NETFN_RSP_BIT_MASK 0x4
	#define REQUEST_QUEUE_MAX_LEN 256

	#define IPMB_MSG_LEN_IDX 0
	#define RQ_SA_8BIT_IDX 1
	#define NETFN_LUN_IDX 2

	#define GET_7BIT_ADDR(addr_8bit) (addr_8bit >> 1)
	#define GET_8BIT_ADDR(addr_7bit) ((addr_7bit << 1) & 0xff)

	#define IPMB_MSG_PAYLOAD_LEN_MAX (MAX_MSG_LEN - IPMB_REQUEST_LEN_MIN - 1)

	#define SMBUS_MSG_HEADER_LENGTH 2
	#define SMBUS_MSG_IDX_OFFSET (SMBUS_MSG_HEADER_LENGTH + 1)

	struct ipmb_msg {
	<------>u8 len;
	<------>u8 rs_sa;
	<------>u8 netfn_rs_lun;
	<------>u8 checksum1;
	<------>u8 rq_sa;
	<------>u8 rq_seq_rq_lun;
	<------>u8 cmd;
	<------>u8 payload[IPMB_MSG_PAYLOAD_LEN_MAX];
	<------>/* checksum2 is included in payload */
	} __packed;

	struct ipmb_request_elem {
	<------>struct list_head list;
	<------>struct ipmb_msg request;
	};

	struct ipmb_dev {
	<------>struct i2c_client *client;
	<------>struct miscdevice miscdev;
	<------>struct ipmb_msg request;
	<------>struct list_head request_queue;
	<------>atomic_t request_queue_len;
	<------>size_t msg_idx;
	<------>spinlock_t lock;
	<------>wait_queue_head_t wait_queue;
	<------>struct mutex file_mutex;
	<------>bool is_i2c_protocol;
	};

	static inline struct ipmb_dev to_ipmb_dev(struct file file)
	{
	<------>return container_of(file->private_data, struct ipmb_dev, miscdev);
	}

	static ssize_t ipmb_read(struct file file, char __user buf, size_t count,
	<------><------><------>loff_t *ppos)
	{
	<------>struct ipmb_dev *ipmb_dev = to_ipmb_dev(file);
	<------>struct ipmb_request_elem *queue_elem;
	<------>struct ipmb_msg msg;
	<------>ssize_t ret = 0;

	<------>memset(&msg, 0, sizeof(msg));

	<------>spin_lock_irq(&ipmb_dev->lock);

	<------>while (list_empty(&ipmb_dev->request_queue)) {
	<------><------>spin_unlock_irq(&ipmb_dev->lock);

	<------><------>if (file->f_flags & O_NONBLOCK)
	<------><------><------>return -EAGAIN;

	<------><------>ret = wait_event_interruptible(ipmb_dev->wait_queue,
	<------><------><------><------>!list_empty(&ipmb_dev->request_queue));
	<------><------>if (ret)
	<------><------><------>return ret;

	<------><------>spin_lock_irq(&ipmb_dev->lock);
	<------>}

	<------>queue_elem = list_first_entry(&ipmb_dev->request_queue,
	<------><------><------><------><------>struct ipmb_request_elem, list);
	<------>memcpy(&msg, &queue_elem->request, sizeof(msg));
	<------>list_del(&queue_elem->list);
	<------>kfree(queue_elem);
	<------>atomic_dec(&ipmb_dev->request_queue_len);

	<------>spin_unlock_irq(&ipmb_dev->lock);

	<------>count = min_t(size_t, count, msg.len + 1);
	<------>if (copy_to_user(buf, &msg, count))
	<------><------>ret = -EFAULT;

	<------>return ret < 0 ? ret : count;
	}

	static int ipmb_i2c_write(struct i2c_client client, u8 msg, u8 addr)
	{
	<------>struct i2c_msg i2c_msg;

	<------>/*
	<------> * subtract 1 byte (rq_sa) from the length of the msg passed to
	<------> * raw i2c_transfer
	<------> */
	<------>i2c_msg.len = msg[IPMB_MSG_LEN_IDX] - 1;

	<------>/* Assign message to buffer except first 2 bytes (length and address) */
	<------>i2c_msg.buf = msg + 2;

	<------>i2c_msg.addr = addr;
	<------>i2c_msg.flags = client->flags & I2C_CLIENT_PEC;

	<------>return i2c_transfer(client->adapter, &i2c_msg, 1);
	}

	static ssize_t ipmb_write(struct file file, const char __user buf,
	<------><------><------>size_t count, loff_t *ppos)
	{
	<------>struct ipmb_dev *ipmb_dev = to_ipmb_dev(file);
	<------>u8 rq_sa, netf_rq_lun, msg_len;
	<------>union i2c_smbus_data data;
	<------>u8 msg[MAX_MSG_LEN];
	<------>ssize_t ret;

	<------>if (count > sizeof(msg))
	<------><------>return -EINVAL;

	<------>if (copy_from_user(&msg, buf, count))
	<------><------>return -EFAULT;

	<------>if (count < msg[0])
	<------><------>return -EINVAL;

	<------>rq_sa = GET_7BIT_ADDR(msg[RQ_SA_8BIT_IDX]);
	<------>netf_rq_lun = msg[NETFN_LUN_IDX];

	<------>/* Check i2c block transfer vs smbus */
	<------>if (ipmb_dev->is_i2c_protocol) {
	<------><------>ret = ipmb_i2c_write(ipmb_dev->client, msg, rq_sa);
	<------><------>return (ret == 1) ? count : ret;
	<------>}

	<------>/*
	<------> * subtract rq_sa and netf_rq_lun from the length of the msg passed to
	<------> * i2c_smbus_xfer
	<------> */
	<------>msg_len = msg[IPMB_MSG_LEN_IDX] - SMBUS_MSG_HEADER_LENGTH;
	<------>if (msg_len > I2C_SMBUS_BLOCK_MAX)
	<------><------>msg_len = I2C_SMBUS_BLOCK_MAX;

	<------>data.block[0] = msg_len;
	<------>memcpy(&data.block[1], msg + SMBUS_MSG_IDX_OFFSET, msg_len);
	<------>ret = i2c_smbus_xfer(ipmb_dev->client->adapter, rq_sa,
	<------><------><------> ipmb_dev->client->flags,
	<------><------><------> I2C_SMBUS_WRITE, netf_rq_lun,
	<------><------><------> I2C_SMBUS_BLOCK_DATA, &data);

	<------>return ret ? : count;
	}

	static __poll_t ipmb_poll(struct file file, poll_table wait)
	{
	<------>struct ipmb_dev *ipmb_dev = to_ipmb_dev(file);
	<------>__poll_t mask = EPOLLOUT;

	<------>mutex_lock(&ipmb_dev->file_mutex);
	<------>poll_wait(file, &ipmb_dev->wait_queue, wait);

	<------>if (atomic_read(&ipmb_dev->request_queue_len))
	<------><------>mask \|= EPOLLIN;
	<------>mutex_unlock(&ipmb_dev->file_mutex);

	<------>return mask;
	}

	static const struct file_operations ipmb_fops = {
	<------>.owner = THIS_MODULE,
	<------>.read = ipmb_read,
	<------>.write = ipmb_write,
	<------>.poll = ipmb_poll,
	};

	/* Called with ipmb_dev->lock held. */
	static void ipmb_handle_request(struct ipmb_dev *ipmb_dev)
	{
	<------>struct ipmb_request_elem *queue_elem;

	<------>if (atomic_read(&ipmb_dev->request_queue_len) >=
	<------><------><------>REQUEST_QUEUE_MAX_LEN)
	<------><------>return;

	<------>queue_elem = kmalloc(sizeof(*queue_elem), GFP_ATOMIC);
	<------>if (!queue_elem)
	<------><------>return;

	<------>memcpy(&queue_elem->request, &ipmb_dev->request,
	<------><------>sizeof(struct ipmb_msg));
	<------>list_add(&queue_elem->list, &ipmb_dev->request_queue);
	<------>atomic_inc(&ipmb_dev->request_queue_len);
	<------>wake_up_all(&ipmb_dev->wait_queue);
	}

	static u8 ipmb_verify_checksum1(struct ipmb_dev *ipmb_dev, u8 rs_sa)
	{
	<------>/* The 8 lsb of the sum is 0 when the checksum is valid */
	<------>return (rs_sa + ipmb_dev->request.netfn_rs_lun +
	<------><------>ipmb_dev->request.checksum1);
	}

	/*
	* Verify if message has proper ipmb header with minimum length
	* and correct checksum byte.
	*/
	static bool is_ipmb_msg(struct ipmb_dev *ipmb_dev, u8 rs_sa)
	{
	<------>if ((ipmb_dev->msg_idx >= IPMB_REQUEST_LEN_MIN) &&
	<------> (!ipmb_verify_checksum1(ipmb_dev, rs_sa)))
	<------><------>return true;

	<------>return false;
	}

	/*
	* The IPMB protocol only supports I2C Writes so there is no need
	* to support I2C_SLAVE_READ* events.
	* This i2c callback function only monitors IPMB request messages
	* and adds them in a queue, so that they can be handled by
	* receive_ipmb_request.
	*/
	static int ipmb_slave_cb(struct i2c_client *client,
	<------><------><------>enum i2c_slave_event event, u8 *val)
	{
	<------>struct ipmb_dev *ipmb_dev = i2c_get_clientdata(client);
	<------>u8 buf = (u8 )&ipmb_dev->request;
	<------>unsigned long flags;

	<------>spin_lock_irqsave(&ipmb_dev->lock, flags);
	<------>switch (event) {
	<------>case I2C_SLAVE_WRITE_REQUESTED:
	<------><------>memset(&ipmb_dev->request, 0, sizeof(ipmb_dev->request));
	<------><------>ipmb_dev->msg_idx = 0;

	<------><------>/*
	<------><------> * At index 0, ipmb_msg stores the length of msg,
	<------><------> * skip it for now.
	<------><------> * The len will be populated once the whole
	<------><------> * buf is populated.
	<------><------> *
	<------><------> * The I2C bus driver's responsibility is to pass the
	<------><------> * data bytes to the backend driver; it does not
	<------><------> * forward the i2c slave address.
	<------><------> * Since the first byte in the IPMB message is the
	<------><------> * address of the responder, it is the responsibility
	<------><------> * of the IPMB driver to format the message properly.
	<------><------> * So this driver prepends the address of the responder
	<------><------> * to the received i2c data before the request message
	<------><------> * is handled in userland.
	<------><------> */
	<------><------>buf[++ipmb_dev->msg_idx] = GET_8BIT_ADDR(client->addr);
	<------><------>break;

	<------>case I2C_SLAVE_WRITE_RECEIVED:
	<------><------>if (ipmb_dev->msg_idx >= sizeof(struct ipmb_msg) - 1)
	<------><------><------>break;

	<------><------>buf[++ipmb_dev->msg_idx] = *val;
	<------><------>break;

	<------>case I2C_SLAVE_STOP:
	<------><------>ipmb_dev->request.len = ipmb_dev->msg_idx;
	<------><------>if (is_ipmb_msg(ipmb_dev, GET_8BIT_ADDR(client->addr)))
	<------><------><------>ipmb_handle_request(ipmb_dev);
	<------><------>break;

	<------>default:
	<------><------>break;
	<------>}
	<------>spin_unlock_irqrestore(&ipmb_dev->lock, flags);

	<------>return 0;
	}

	static int ipmb_probe(struct i2c_client *client,
	<------><------><------>const struct i2c_device_id *id)
	{
	<------>struct ipmb_dev *ipmb_dev;
	<------>int ret;

	<------>ipmb_dev = devm_kzalloc(&client->dev, sizeof(*ipmb_dev),
	<------><------><------><------><------>GFP_KERNEL);
	<------>if (!ipmb_dev)
	<------><------>return -ENOMEM;

	<------>spin_lock_init(&ipmb_dev->lock);
	<------>init_waitqueue_head(&ipmb_dev->wait_queue);
	<------>atomic_set(&ipmb_dev->request_queue_len, 0);
	<------>INIT_LIST_HEAD(&ipmb_dev->request_queue);

	<------>mutex_init(&ipmb_dev->file_mutex);

	<------>ipmb_dev->miscdev.minor = MISC_DYNAMIC_MINOR;

	<------>ipmb_dev->miscdev.name = devm_kasprintf(&client->dev, GFP_KERNEL,
	<------><------><------><------><------><------>"%s%d", "ipmb-",
	<------><------><------><------><------><------>client->adapter->nr);
	<------>ipmb_dev->miscdev.fops = &ipmb_fops;
	<------>ipmb_dev->miscdev.parent = &client->dev;
	<------>ret = misc_register(&ipmb_dev->miscdev);
	<------>if (ret)
	<------><------>return ret;

	<------>ipmb_dev->is_i2c_protocol
	<------><------>= device_property_read_bool(&client->dev, "i2c-protocol");

	<------>ipmb_dev->client = client;
	<------>i2c_set_clientdata(client, ipmb_dev);
	<------>ret = i2c_slave_register(client, ipmb_slave_cb);
	<------>if (ret) {
	<------><------>misc_deregister(&ipmb_dev->miscdev);
	<------><------>return ret;
	<------>}

	<------>return 0;
	}

	static int ipmb_remove(struct i2c_client *client)
	{
	<------>struct ipmb_dev *ipmb_dev = i2c_get_clientdata(client);

	<------>i2c_slave_unregister(client);
	<------>misc_deregister(&ipmb_dev->miscdev);

	<------>return 0;
	}

	static const struct i2c_device_id ipmb_id[] = {
	<------>{ "ipmb-dev", 0 },
	<------>{},
	};
	MODULE_DEVICE_TABLE(i2c, ipmb_id);

	static const struct acpi_device_id acpi_ipmb_id[] = {
	<------>{ "IPMB0001", 0 },
	<------>{},
	};
	MODULE_DEVICE_TABLE(acpi, acpi_ipmb_id);

	static struct i2c_driver ipmb_driver = {
	<------>.driver = {
	<------><------>.name = "ipmb-dev",
	<------><------>.acpi_match_table = ACPI_PTR(acpi_ipmb_id),
	<------>},
	<------>.probe = ipmb_probe,
	<------>.remove = ipmb_remove,
	<------>.id_table = ipmb_id,
	};
	module_i2c_driver(ipmb_driver);

	MODULE_AUTHOR("Mellanox Technologies");
	MODULE_DESCRIPTION("IPMB driver");
	MODULE_LICENSE("GPL v2");