drivers/char/ipmi/ipmb_dev_int.c - linux/kernel/git/bpf/bpf - Git at Google

 // 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");