// SPDX-License-Identifier: GPL-2.0-only
/*
 * The driver for BMC side of SSIF interface
 *
 * Copyright (c) 2022, Ampere Computing LLC
 *
 */

#include <linux/i2c.h>
#include <linux/miscdevice.h>
#include <linux/module.h>
#include <linux/of.h>
#include <linux/platform_device.h>
#include <linux/poll.h>
#include <linux/sched.h>
#include <linux/mutex.h>
#include <linux/spinlock.h>
#include <linux/timer.h>
#include <linux/jiffies.h>
#include <linux/ipmi_ssif_bmc.h>
#if IS_ENABLED(CONFIG_SSIF_IPMI_BMC_KUNIT_TEST)
#include <kunit/test.h>
#endif

#define DEVICE_NAME                             "ipmi-ssif-host"

#define GET_8BIT_ADDR(addr_7bit)                (((addr_7bit) << 1) & 0xff)

/* A standard SMBus Transaction is limited to 32 data bytes */
#define MAX_PAYLOAD_PER_TRANSACTION             32
/* Transaction includes the address, the command, the length and the PEC byte */
#define MAX_TRANSACTION                         (MAX_PAYLOAD_PER_TRANSACTION + 4)

#define MAX_IPMI_DATA_PER_START_TRANSACTION     30
#define MAX_IPMI_DATA_PER_MIDDLE_TRANSACTION    31

#define SSIF_IPMI_SINGLEPART_WRITE              0x2
#define SSIF_IPMI_SINGLEPART_READ               0x3
#define SSIF_IPMI_MULTIPART_WRITE_START         0x6
#define SSIF_IPMI_MULTIPART_WRITE_MIDDLE        0x7
#define SSIF_IPMI_MULTIPART_WRITE_END           0x8
#define SSIF_IPMI_MULTIPART_READ_START          0x3
#define SSIF_IPMI_MULTIPART_READ_MIDDLE         0x9

/*
 * IPMI 2.0 Spec, section 12.7 SSIF Timing,
 * Request-to-Response Time is T6max(250ms) - T1max(20ms) - 3ms = 227ms
 * Recover ssif_bmc from busy state if it takes up to 500ms
 */
#define RESPONSE_TIMEOUT                        500 /* ms */

struct ssif_part_buffer {
	u8 address;
	u8 smbus_cmd;
	u8 length;
	u8 payload[MAX_PAYLOAD_PER_TRANSACTION];
	u8 pec;
	u8 index;
};

/*
 * SSIF internal states:
 *   SSIF_READY         0x00 : Ready state
 *   SSIF_START         0x01 : Start smbus transaction
 *   SSIF_SMBUS_CMD     0x02 : Received SMBus command
 *   SSIF_REQ_RECVING   0x03 : Receiving request
 *   SSIF_RES_SENDING   0x04 : Sending response
 *   SSIF_ABORTING      0x05 : Aborting state
 */
enum ssif_state {
	SSIF_READY,
	SSIF_START,
	SSIF_SMBUS_CMD,
	SSIF_REQ_RECVING,
	SSIF_RES_SENDING,
	SSIF_ABORTING,
	SSIF_STATE_MAX
};

struct ssif_bmc_ctx {
	struct i2c_client       *client;
	struct miscdevice       miscdev;
	int                     msg_idx;
	bool                    pec_support;
	/* ssif bmc spinlock */
	spinlock_t              lock;
	wait_queue_head_t       wait_queue;
	u8                      running;
	enum ssif_state         state;
	/* Timeout waiting for response */
	struct timer_list       response_timer;
	bool                    response_timer_inited;
	/* Flag to identify a Multi-part Read Transaction */
	bool                    is_singlepart_read;
	u8                      nbytes_processed;
	u8                      remain_len;
	u8                      recv_len;
	/* Block Number of a Multi-part Read Transaction */
	u8                      block_num;
	bool                    request_available;
	bool                    response_in_progress;
	bool                    busy;
	bool                    aborting;
	/* Buffer for SSIF Transaction part*/
	struct ssif_part_buffer part_buf;
	struct ipmi_ssif_msg    response;
	struct ipmi_ssif_msg    request;
};

static inline struct ssif_bmc_ctx *to_ssif_bmc(struct file *file)
{
	return container_of(file->private_data, struct ssif_bmc_ctx, miscdev);
}

static const char *state_to_string(enum ssif_state state)
{
	switch (state) {
	case SSIF_READY:
		return "SSIF_READY";
	case SSIF_START:
		return "SSIF_START";
	case SSIF_SMBUS_CMD:
		return "SSIF_SMBUS_CMD";
	case SSIF_REQ_RECVING:
		return "SSIF_REQ_RECVING";
	case SSIF_RES_SENDING:
		return "SSIF_RES_SENDING";
	case SSIF_ABORTING:
		return "SSIF_ABORTING";
	default:
		return "SSIF_STATE_UNKNOWN";
	}
}

/* Handle SSIF message that will be sent to user */
static ssize_t ssif_bmc_read(struct file *file, char __user *buf, size_t count, loff_t *ppos)
{
	struct ssif_bmc_ctx *ssif_bmc = to_ssif_bmc(file);
	struct ipmi_ssif_msg msg;
	unsigned long flags;
	ssize_t ret;

	spin_lock_irqsave(&ssif_bmc->lock, flags);
	while (!ssif_bmc->request_available) {
		spin_unlock_irqrestore(&ssif_bmc->lock, flags);
		if (file->f_flags & O_NONBLOCK)
			return -EAGAIN;
		ret = wait_event_interruptible(ssif_bmc->wait_queue,
					       ssif_bmc->request_available);
		if (ret)
			return ret;
		spin_lock_irqsave(&ssif_bmc->lock, flags);
	}

	if (count < min_t(ssize_t,
			  sizeof_field(struct ipmi_ssif_msg, len) + ssif_bmc->request.len,
			  sizeof(struct ipmi_ssif_msg))) {
		spin_unlock_irqrestore(&ssif_bmc->lock, flags);
		ret = -EINVAL;
	} else {
		count = min_t(ssize_t,
			      sizeof_field(struct ipmi_ssif_msg, len) + ssif_bmc->request.len,
			      sizeof(struct ipmi_ssif_msg));
		memcpy(&msg, &ssif_bmc->request, count);
		ssif_bmc->request_available = false;
		spin_unlock_irqrestore(&ssif_bmc->lock, flags);

		ret = copy_to_user(buf, &msg, count);
		if (ret > 0)
			ret = -EFAULT;
	}

	return (ret < 0) ? ret : count;
}

/* Handle SSIF message that is written by user */
static ssize_t ssif_bmc_write(struct file *file, const char __user *buf, size_t count,
			      loff_t *ppos)
{
	struct ssif_bmc_ctx *ssif_bmc = to_ssif_bmc(file);
	struct ipmi_ssif_msg msg;
	unsigned long flags;
	ssize_t ret;

	if (count < sizeof(msg.len) ||
	    count > sizeof(struct ipmi_ssif_msg))
		return -EINVAL;

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

	if (!msg.len || msg.len > IPMI_SSIF_PAYLOAD_MAX ||
	    count < sizeof_field(struct ipmi_ssif_msg, len) + msg.len)
		return -EINVAL;

	spin_lock_irqsave(&ssif_bmc->lock, flags);
	while (ssif_bmc->response_in_progress) {
		spin_unlock_irqrestore(&ssif_bmc->lock, flags);
		if (file->f_flags & O_NONBLOCK)
			return -EAGAIN;
		ret = wait_event_interruptible(ssif_bmc->wait_queue,
					       !ssif_bmc->response_in_progress);
		if (ret)
			return ret;
		spin_lock_irqsave(&ssif_bmc->lock, flags);
	}

	/*
	 * The write must complete before the response timeout fired, otherwise
	 * the response is aborted and wait for next request
	 * Return -EINVAL if the response is aborted
	 */
	ret = (ssif_bmc->response_timer_inited) ? 0 : -EINVAL;
	if (ret)
		goto exit;

	timer_delete(&ssif_bmc->response_timer);
	ssif_bmc->response_timer_inited = false;

	memcpy(&ssif_bmc->response, &msg, count);
	ssif_bmc->is_singlepart_read = (msg.len <= MAX_PAYLOAD_PER_TRANSACTION);

	ssif_bmc->response_in_progress = true;

	/* ssif_bmc not busy */
	ssif_bmc->busy = false;

	/* Clean old request buffer */
	memset(&ssif_bmc->request, 0, sizeof(struct ipmi_ssif_msg));
exit:
	spin_unlock_irqrestore(&ssif_bmc->lock, flags);

	return (ret < 0) ? ret : count;
}

static int ssif_bmc_open(struct inode *inode, struct file *file)
{
	struct ssif_bmc_ctx *ssif_bmc = to_ssif_bmc(file);
	int ret = 0;

	spin_lock_irq(&ssif_bmc->lock);
	if (!ssif_bmc->running)
		ssif_bmc->running = 1;
	else
		ret = -EBUSY;
	spin_unlock_irq(&ssif_bmc->lock);

	return ret;
}

static __poll_t ssif_bmc_poll(struct file *file, poll_table *wait)
{
	struct ssif_bmc_ctx *ssif_bmc = to_ssif_bmc(file);
	__poll_t mask = 0;

	poll_wait(file, &ssif_bmc->wait_queue, wait);

	spin_lock_irq(&ssif_bmc->lock);
	/* The request is available, userspace application can get the request */
	if (ssif_bmc->request_available)
		mask |= EPOLLIN;

	spin_unlock_irq(&ssif_bmc->lock);

	return mask;
}

static int ssif_bmc_release(struct inode *inode, struct file *file)
{
	struct ssif_bmc_ctx *ssif_bmc = to_ssif_bmc(file);

	spin_lock_irq(&ssif_bmc->lock);
	ssif_bmc->running = 0;
	spin_unlock_irq(&ssif_bmc->lock);

	return 0;
}

/*
 * System calls to device interface for user apps
 */
static const struct file_operations ssif_bmc_fops = {
	.owner		= THIS_MODULE,
	.open		= ssif_bmc_open,
	.read		= ssif_bmc_read,
	.write		= ssif_bmc_write,
	.release	= ssif_bmc_release,
	.poll		= ssif_bmc_poll,
};

/* Called with ssif_bmc->lock held. */
static void complete_response(struct ssif_bmc_ctx *ssif_bmc)
{
	/* Invalidate response in buffer to denote it having been sent. */
	ssif_bmc->response.len = 0;
	ssif_bmc->response_in_progress = false;
	ssif_bmc->nbytes_processed = 0;
	ssif_bmc->remain_len = 0;
	ssif_bmc->busy = false;
	wake_up_all(&ssif_bmc->wait_queue);
}

static void response_timeout(struct timer_list *t)
{
	struct ssif_bmc_ctx *ssif_bmc = timer_container_of(ssif_bmc, t,
							   response_timer);
	unsigned long flags;

	spin_lock_irqsave(&ssif_bmc->lock, flags);

	/* Do nothing if the response is in progress */
	if (!ssif_bmc->response_in_progress) {
		/* Recover ssif_bmc from busy */
		ssif_bmc->busy = false;
		ssif_bmc->response_timer_inited = false;
		/* Set aborting flag */
		ssif_bmc->aborting = true;
	}

	spin_unlock_irqrestore(&ssif_bmc->lock, flags);
}

/* Called with ssif_bmc->lock held. */
static void handle_request(struct ssif_bmc_ctx *ssif_bmc)
{
	/* set ssif_bmc to busy waiting for response */
	ssif_bmc->busy = true;
	/* Request message is available to process */
	ssif_bmc->request_available = true;
	/* Clean old response buffer */
	memset(&ssif_bmc->response, 0, sizeof(struct ipmi_ssif_msg));
	/* This is the new READ request.*/
	wake_up_all(&ssif_bmc->wait_queue);

	/* Armed timer to recover slave from busy state in case of no response */
	if (!ssif_bmc->response_timer_inited) {
		timer_setup(&ssif_bmc->response_timer, response_timeout, 0);
		ssif_bmc->response_timer_inited = true;
	}
	mod_timer(&ssif_bmc->response_timer, jiffies + msecs_to_jiffies(RESPONSE_TIMEOUT));
}

static void calculate_response_part_pec(struct ssif_part_buffer *part)
{
	u8 addr = part->address;

	/* PEC - Start Read Address */
	part->pec = i2c_smbus_pec(0, &addr, 1);
	/* PEC - SSIF Command */
	part->pec = i2c_smbus_pec(part->pec, &part->smbus_cmd, 1);
	/* PEC - Restart Write Address */
	addr = addr | 0x01;
	part->pec = i2c_smbus_pec(part->pec, &addr, 1);
	part->pec = i2c_smbus_pec(part->pec, &part->length, 1);
	if (part->length)
		part->pec = i2c_smbus_pec(part->pec, part->payload, part->length);
}

static void set_singlepart_response_buffer(struct ssif_bmc_ctx *ssif_bmc)
{
	struct ssif_part_buffer *part = &ssif_bmc->part_buf;

	part->address = GET_8BIT_ADDR(ssif_bmc->client->addr);
	part->length = (u8)ssif_bmc->response.len;

	/* Clear the rest to 0 */
	memset(part->payload + part->length, 0, MAX_PAYLOAD_PER_TRANSACTION - part->length);
	memcpy(&part->payload[0], &ssif_bmc->response.payload[0], part->length);
}

static void set_multipart_response_buffer(struct ssif_bmc_ctx *ssif_bmc)
{
	struct ssif_part_buffer *part = &ssif_bmc->part_buf;
	u8 part_len = 0;

	part->address = GET_8BIT_ADDR(ssif_bmc->client->addr);
	switch (part->smbus_cmd) {
	case SSIF_IPMI_MULTIPART_READ_START:
		/*
		 * Read Start length is 32 bytes.
		 * Read Start transfer first 30 bytes of IPMI response
		 * and 2 special code 0x00, 0x01.
		 */
		ssif_bmc->nbytes_processed = 0;
		ssif_bmc->block_num = 0;
		part->length = MAX_PAYLOAD_PER_TRANSACTION;
		part_len = MAX_IPMI_DATA_PER_START_TRANSACTION;
		ssif_bmc->remain_len = ssif_bmc->response.len - part_len;

		part->payload[0] = 0x00; /* Start Flag */
		part->payload[1] = 0x01; /* Start Flag */

		memcpy(&part->payload[2], &ssif_bmc->response.payload[0], part_len);
		break;

	case SSIF_IPMI_MULTIPART_READ_MIDDLE:
		/*
		 * IPMI READ Middle or READ End messages can carry up to 31 bytes
		 * IPMI data plus block number byte.
		 */
		if (ssif_bmc->remain_len <= MAX_IPMI_DATA_PER_MIDDLE_TRANSACTION) {
			/*
			 * This is READ End message
			 *  Return length is the remaining response data length
			 *  plus block number
			 *  Block number 0xFF is to indicate this is last message
			 *
			 */
			/* Clean the buffer */
			memset(&part->payload[0], 0, MAX_PAYLOAD_PER_TRANSACTION);
			part->length = ssif_bmc->remain_len + 1;
			part_len = ssif_bmc->remain_len;
			ssif_bmc->block_num = 0xFF;
			part->payload[0] = ssif_bmc->block_num;
		} else {
			/*
			 * This is READ Middle message
			 *  Response length is the maximum SMBUS transfer length
			 *  Block number byte is incremented
			 * Return length is maximum SMBUS transfer length
			 */
			part->length = MAX_PAYLOAD_PER_TRANSACTION;
			part_len = MAX_IPMI_DATA_PER_MIDDLE_TRANSACTION;
			part->payload[0] = ssif_bmc->block_num;
			ssif_bmc->block_num++;
		}

		ssif_bmc->remain_len -= part_len;
		memcpy(&part->payload[1], ssif_bmc->response.payload + ssif_bmc->nbytes_processed,
		       part_len);
		break;

	default:
		/* Do not expect to go to this case */
		dev_err(&ssif_bmc->client->dev, "%s: Unexpected SMBus command 0x%x\n",
			__func__, part->smbus_cmd);
		break;
	}

	ssif_bmc->nbytes_processed += part_len;
}

static bool supported_read_cmd(u8 cmd)
{
	if (cmd == SSIF_IPMI_SINGLEPART_READ ||
	    cmd == SSIF_IPMI_MULTIPART_READ_START ||
	    cmd == SSIF_IPMI_MULTIPART_READ_MIDDLE)
		return true;

	return false;
}

static bool supported_write_cmd(u8 cmd)
{
	if (cmd == SSIF_IPMI_SINGLEPART_WRITE ||
	    cmd == SSIF_IPMI_MULTIPART_WRITE_START ||
	    cmd == SSIF_IPMI_MULTIPART_WRITE_MIDDLE ||
	    cmd == SSIF_IPMI_MULTIPART_WRITE_END)
		return true;

	return false;
}

static bool supported_write_start_cmd(u8 cmd)
{
	if (cmd == SSIF_IPMI_SINGLEPART_WRITE ||
	    cmd == SSIF_IPMI_MULTIPART_WRITE_START)
		return true;

	return false;
}

/* Process the IPMI response that will be read by master */
static void handle_read_processed(struct ssif_bmc_ctx *ssif_bmc, u8 *val)
{
	struct ssif_part_buffer *part = &ssif_bmc->part_buf;

	/* msg_idx start from 0 */
	if (part->index < part->length)
		*val = part->payload[part->index];
	else if (part->index == part->length && ssif_bmc->pec_support)
		*val = part->pec;
	else
		*val = 0;

	part->index++;
}

static void handle_write_received(struct ssif_bmc_ctx *ssif_bmc, u8 *val)
{
	/*
	 * The msg_idx must be 1 when first enter SSIF_REQ_RECVING state
	 * And it would never exceeded 36 bytes included the 32 bytes max payload +
	 * the address + the command + the len and the PEC.
	 */
	if (ssif_bmc->msg_idx < 1  || ssif_bmc->msg_idx > MAX_TRANSACTION)
		return;

	if (ssif_bmc->msg_idx == 1) {
		ssif_bmc->part_buf.length = *val;
		ssif_bmc->part_buf.index = 0;
	} else {
		ssif_bmc->part_buf.payload[ssif_bmc->part_buf.index++] = *val;
	}

	ssif_bmc->msg_idx++;
}

static bool validate_request_part(struct ssif_bmc_ctx *ssif_bmc)
{
	struct ssif_part_buffer *part = &ssif_bmc->part_buf;
	bool ret = true;
	u8 cpec;
	u8 addr;

	if (part->index == part->length) {
		/* PEC is not included */
		ssif_bmc->pec_support = false;
		ret = true;
		goto exit;
	}

	if (part->index != part->length + 1) {
		ret = false;
		goto exit;
	}

	/* PEC is included */
	ssif_bmc->pec_support = true;
	part->pec = part->payload[part->length];
	addr = GET_8BIT_ADDR(ssif_bmc->client->addr);
	cpec = i2c_smbus_pec(0, &addr, 1);
	cpec = i2c_smbus_pec(cpec, &part->smbus_cmd, 1);
	cpec = i2c_smbus_pec(cpec, &part->length, 1);
	/*
	 * As SMBus specification does not allow the length
	 * (byte count) in the Write-Block protocol to be zero.
	 * Therefore, it is illegal to have the last Middle
	 * transaction in the sequence carry 32-byte and have
	 * a length of ‘0’ in the End transaction.
	 * But some users may try to use this way and we should
	 * prevent ssif_bmc driver broken in this case.
	 */
	if (part->length)
		cpec = i2c_smbus_pec(cpec, part->payload, part->length);

	if (cpec != part->pec)
		ret = false;

exit:
	return ret;
}

static void process_request_part(struct ssif_bmc_ctx *ssif_bmc)
{
	struct ssif_part_buffer *part = &ssif_bmc->part_buf;
	unsigned int len;

	switch (part->smbus_cmd) {
	case SSIF_IPMI_SINGLEPART_WRITE:
		/* save the whole part to request*/
		ssif_bmc->request.len = part->length;
		memcpy(ssif_bmc->request.payload, part->payload, part->length);

		break;
	case SSIF_IPMI_MULTIPART_WRITE_START:
		ssif_bmc->request.len = 0;

		fallthrough;
	case SSIF_IPMI_MULTIPART_WRITE_MIDDLE:
	case SSIF_IPMI_MULTIPART_WRITE_END:
		len = ssif_bmc->request.len + part->length;
		/* Do the bound check here, not allow the request len exceed 254 bytes */
		if (len > IPMI_SSIF_PAYLOAD_MAX) {
			dev_dbg(&ssif_bmc->client->dev,
				 "Warn: Request exceeded 254 bytes, aborting");
			/* Request too long, aborting */
			ssif_bmc->aborting =  true;
		} else {
			memcpy(ssif_bmc->request.payload + ssif_bmc->request.len,
			       part->payload, part->length);
			ssif_bmc->request.len += part->length;
		}
		break;
	default:
		/* Do not expect to go to this case */
		dev_err(&ssif_bmc->client->dev, "%s: Unexpected SMBus command 0x%x\n",
			__func__, part->smbus_cmd);
		break;
	}
}

static void process_smbus_cmd(struct ssif_bmc_ctx *ssif_bmc, u8 *val)
{
	/* SMBUS command can vary (single or multi-part) */
	ssif_bmc->part_buf.smbus_cmd = *val;
	ssif_bmc->msg_idx = 1;
	memset(&ssif_bmc->part_buf.payload[0], 0, MAX_PAYLOAD_PER_TRANSACTION);

	if (*val == SSIF_IPMI_SINGLEPART_WRITE || *val == SSIF_IPMI_MULTIPART_WRITE_START) {
		/*
		 * The response maybe not come in-time, causing host SSIF driver
		 * to timeout and resend a new request. In such case check for
		 * pending response and clear it
		 */
		if (ssif_bmc->response_in_progress)
			complete_response(ssif_bmc);

		/* This is new request, flip aborting flag if set */
		if (ssif_bmc->aborting)
			ssif_bmc->aborting = false;
	}
}

static void on_read_requested_event(struct ssif_bmc_ctx *ssif_bmc, u8 *val)
{
	if (ssif_bmc->state == SSIF_READY ||
	    ssif_bmc->state == SSIF_START ||
	    ssif_bmc->state == SSIF_REQ_RECVING ||
	    ssif_bmc->state == SSIF_RES_SENDING) {
		dev_dbg(&ssif_bmc->client->dev,
			 "Warn: %s unexpected READ REQUESTED in state=%s\n",
			 __func__, state_to_string(ssif_bmc->state));
		ssif_bmc->state = SSIF_ABORTING;
		*val = 0;
		return;

	} else if (ssif_bmc->state == SSIF_SMBUS_CMD) {
		if (!supported_read_cmd(ssif_bmc->part_buf.smbus_cmd)) {
			dev_dbg(&ssif_bmc->client->dev, "Warn: Unknown SMBus read command=0x%x",
				 ssif_bmc->part_buf.smbus_cmd);
			ssif_bmc->aborting = true;
		}

		if (ssif_bmc->aborting)
			ssif_bmc->state = SSIF_ABORTING;
		else
			ssif_bmc->state = SSIF_RES_SENDING;
	}

	ssif_bmc->msg_idx = 0;

	/* Send 0 if there is nothing to send */
	if (!ssif_bmc->response_in_progress || ssif_bmc->state == SSIF_ABORTING) {
		*val = 0;
		return;
	}

	if (ssif_bmc->is_singlepart_read)
		set_singlepart_response_buffer(ssif_bmc);
	else
		set_multipart_response_buffer(ssif_bmc);

	calculate_response_part_pec(&ssif_bmc->part_buf);
	ssif_bmc->part_buf.index = 0;
	*val = ssif_bmc->part_buf.length;
}

static void on_read_processed_event(struct ssif_bmc_ctx *ssif_bmc, u8 *val)
{
	if (ssif_bmc->state == SSIF_READY ||
	    ssif_bmc->state == SSIF_START ||
	    ssif_bmc->state == SSIF_REQ_RECVING ||
	    ssif_bmc->state == SSIF_SMBUS_CMD) {
		dev_dbg(&ssif_bmc->client->dev,
			 "Warn: %s unexpected READ PROCESSED in state=%s\n",
			 __func__, state_to_string(ssif_bmc->state));
		ssif_bmc->state = SSIF_ABORTING;
		*val = 0;
		return;
	}

	/* Send 0 if there is nothing to send */
	if (!ssif_bmc->response_in_progress || ssif_bmc->state == SSIF_ABORTING) {
		*val = 0;
		return;
	}

	handle_read_processed(ssif_bmc, val);
}

static void on_write_requested_event(struct ssif_bmc_ctx *ssif_bmc, u8 *val)
{
	if (ssif_bmc->state == SSIF_READY || ssif_bmc->state == SSIF_SMBUS_CMD) {
		ssif_bmc->state = SSIF_START;

	} else if (ssif_bmc->state == SSIF_START ||
		   ssif_bmc->state == SSIF_REQ_RECVING ||
		   ssif_bmc->state == SSIF_RES_SENDING) {
		dev_dbg(&ssif_bmc->client->dev,
			 "Warn: %s unexpected WRITE REQUEST in state=%s\n",
			 __func__, state_to_string(ssif_bmc->state));
		ssif_bmc->state = SSIF_ABORTING;
		return;
	}

	ssif_bmc->msg_idx = 0;
	ssif_bmc->part_buf.address = *val;
}

static void on_write_received_event(struct ssif_bmc_ctx *ssif_bmc, u8 *val)
{
	if (ssif_bmc->state == SSIF_READY ||
	    ssif_bmc->state == SSIF_RES_SENDING) {
		dev_dbg(&ssif_bmc->client->dev,
			 "Warn: %s unexpected WRITE RECEIVED in state=%s\n",
			 __func__, state_to_string(ssif_bmc->state));
		ssif_bmc->state = SSIF_ABORTING;

	} else if (ssif_bmc->state == SSIF_START) {
		ssif_bmc->state = SSIF_SMBUS_CMD;

	} else if (ssif_bmc->state == SSIF_SMBUS_CMD) {
		if (!supported_write_cmd(ssif_bmc->part_buf.smbus_cmd)) {
			dev_dbg(&ssif_bmc->client->dev, "Warn: Unknown SMBus write command=0x%x",
				 ssif_bmc->part_buf.smbus_cmd);
			ssif_bmc->aborting = true;
		}

		if (ssif_bmc->aborting)
			ssif_bmc->state = SSIF_ABORTING;
		else
			ssif_bmc->state = SSIF_REQ_RECVING;
	} else if (ssif_bmc->state == SSIF_ABORTING) {
		if (supported_write_start_cmd(*val)) {
			ssif_bmc->state = SSIF_SMBUS_CMD;
			ssif_bmc->aborting = false;
		}
	}

	/* This is response sending state */
	if (ssif_bmc->state == SSIF_REQ_RECVING)
		handle_write_received(ssif_bmc, val);
	else if (ssif_bmc->state == SSIF_SMBUS_CMD)
		process_smbus_cmd(ssif_bmc, val);
}

static void on_stop_event(struct ssif_bmc_ctx *ssif_bmc, u8 *val)
{
	if (ssif_bmc->state == SSIF_READY ||
	    ssif_bmc->state == SSIF_START ||
	    ssif_bmc->state == SSIF_SMBUS_CMD ||
	    ssif_bmc->state == SSIF_ABORTING) {
		dev_dbg(&ssif_bmc->client->dev,
			 "Warn: %s unexpected SLAVE STOP in state=%s\n",
			 __func__, state_to_string(ssif_bmc->state));
		ssif_bmc->state = SSIF_READY;

	} else if (ssif_bmc->state == SSIF_REQ_RECVING) {
		if (validate_request_part(ssif_bmc)) {
			process_request_part(ssif_bmc);
			if (ssif_bmc->part_buf.smbus_cmd == SSIF_IPMI_SINGLEPART_WRITE ||
			    ssif_bmc->part_buf.smbus_cmd == SSIF_IPMI_MULTIPART_WRITE_END)
				handle_request(ssif_bmc);
			ssif_bmc->state = SSIF_READY;
		} else {
			/*
			 * A BMC that receives an invalid request drop the data for the write
			 * transaction and any further transactions (read or write) until
			 * the next valid read or write Start transaction is received
			 */
			dev_err(&ssif_bmc->client->dev, "Error: invalid pec\n");
			ssif_bmc->aborting = true;
		}
	} else if (ssif_bmc->state == SSIF_RES_SENDING) {
		if (ssif_bmc->is_singlepart_read || ssif_bmc->block_num == 0xFF) {
			memset(&ssif_bmc->part_buf, 0, sizeof(struct ssif_part_buffer));
			/* Invalidate response buffer to denote it is sent */
			complete_response(ssif_bmc);
		}
		ssif_bmc->state = SSIF_READY;
	}

	/* Reset message index */
	ssif_bmc->msg_idx = 0;
}

/*
 * Callback function to handle I2C slave events
 */
static int ssif_bmc_cb(struct i2c_client *client, enum i2c_slave_event event, u8 *val)
{
	unsigned long flags;
	struct ssif_bmc_ctx *ssif_bmc = i2c_get_clientdata(client);
	int ret = 0;

	spin_lock_irqsave(&ssif_bmc->lock, flags);

	switch (event) {
	case I2C_SLAVE_READ_REQUESTED:
		on_read_requested_event(ssif_bmc, val);
		break;

	case I2C_SLAVE_WRITE_REQUESTED:
		on_write_requested_event(ssif_bmc, val);
		break;

	case I2C_SLAVE_READ_PROCESSED:
		on_read_processed_event(ssif_bmc, val);
		break;

	case I2C_SLAVE_WRITE_RECEIVED:
		on_write_received_event(ssif_bmc, val);
		break;

	case I2C_SLAVE_STOP:
		on_stop_event(ssif_bmc, val);
		break;

	default:
		dev_dbg(&ssif_bmc->client->dev, "Warn: Unknown i2c slave event\n");
		break;
	}

	if (!ssif_bmc->aborting && ssif_bmc->busy)
		ret = -EBUSY;

	spin_unlock_irqrestore(&ssif_bmc->lock, flags);

	return ret;
}

static int ssif_bmc_probe(struct i2c_client *client)
{
	struct ssif_bmc_ctx *ssif_bmc;
	int ret;

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

	spin_lock_init(&ssif_bmc->lock);

	init_waitqueue_head(&ssif_bmc->wait_queue);
	ssif_bmc->request_available = false;
	ssif_bmc->response_in_progress = false;
	ssif_bmc->busy = false;
	ssif_bmc->response_timer_inited = false;

	/* Register misc device interface */
	ssif_bmc->miscdev.minor = MISC_DYNAMIC_MINOR;
	ssif_bmc->miscdev.name = DEVICE_NAME;
	ssif_bmc->miscdev.fops = &ssif_bmc_fops;
	ssif_bmc->miscdev.parent = &client->dev;
	ret = misc_register(&ssif_bmc->miscdev);
	if (ret)
		return ret;

	ssif_bmc->client = client;
	ssif_bmc->client->flags |= I2C_CLIENT_SLAVE;

	/* Register I2C slave */
	i2c_set_clientdata(client, ssif_bmc);
	ret = i2c_slave_register(client, ssif_bmc_cb);
	if (ret)
		misc_deregister(&ssif_bmc->miscdev);

	return ret;
}

static void ssif_bmc_remove(struct i2c_client *client)
{
	struct ssif_bmc_ctx *ssif_bmc = i2c_get_clientdata(client);

	timer_delete_sync(&ssif_bmc->response_timer);
	i2c_slave_unregister(client);
	misc_deregister(&ssif_bmc->miscdev);
}

static const struct of_device_id ssif_bmc_match[] = {
	{ .compatible = "ssif-bmc" },
	{ },
};
MODULE_DEVICE_TABLE(of, ssif_bmc_match);

static const struct i2c_device_id ssif_bmc_id[] = {
	{ .name = DEVICE_NAME },
	{ }
};
MODULE_DEVICE_TABLE(i2c, ssif_bmc_id);

static struct i2c_driver ssif_bmc_driver = {
	.driver         = {
		.name           = DEVICE_NAME,
		.of_match_table = ssif_bmc_match,
	},
	.probe          = ssif_bmc_probe,
	.remove         = ssif_bmc_remove,
	.id_table       = ssif_bmc_id,
};

#if IS_ENABLED(CONFIG_SSIF_IPMI_BMC_KUNIT_TEST)
struct ssif_bmc_test_ctx {
	struct ssif_bmc_ctx ssif_bmc;
	struct i2c_client client;
	struct i2c_adapter adapter;
	struct i2c_algorithm algo;
};

static int ssif_bmc_test_init(struct kunit *test)
{
	struct ssif_bmc_test_ctx *test_ctx;

	test_ctx = kunit_kzalloc(test, sizeof(*test_ctx), GFP_KERNEL);
	if (!test_ctx)
		return -ENOMEM;

	test_ctx->adapter.algo = &test_ctx->algo;
	test_ctx->client.addr = 0x20;
	test_ctx->client.adapter = &test_ctx->adapter;

	spin_lock_init(&test_ctx->ssif_bmc.lock);
	init_waitqueue_head(&test_ctx->ssif_bmc.wait_queue);
	test_ctx->ssif_bmc.client = &test_ctx->client;
	i2c_set_clientdata(&test_ctx->client, &test_ctx->ssif_bmc);

	test->priv = test_ctx;

	return 0;
}

static void ssif_bmc_test_exit(struct kunit *test)
{
	struct ssif_bmc_test_ctx *test_ctx = test->priv;

	if (test_ctx->ssif_bmc.response_timer_inited)
		timer_delete_sync(&test_ctx->ssif_bmc.response_timer);
}

static int ssif_bmc_test_run_event_val(struct ssif_bmc_test_ctx *test_ctx,
					       enum i2c_slave_event event,
					       u8 *value)
{
	return ssif_bmc_cb(&test_ctx->client, event, value);
}

static int ssif_bmc_test_run_event(struct ssif_bmc_test_ctx *test_ctx,
					   enum i2c_slave_event event, u8 value)
{
	return ssif_bmc_test_run_event_val(test_ctx, event, &value);
}

static void ssif_bmc_test_singlepart_req(struct kunit *test)
{
	struct ssif_bmc_test_ctx *test_ctx = test->priv;
	struct ssif_bmc_ctx *ssif_bmc = &test_ctx->ssif_bmc;

	ssif_bmc_test_run_event(test_ctx, I2C_SLAVE_WRITE_REQUESTED,
				GET_8BIT_ADDR(test_ctx->client.addr));
	ssif_bmc_test_run_event(test_ctx, I2C_SLAVE_WRITE_RECEIVED,
				SSIF_IPMI_SINGLEPART_WRITE);
	ssif_bmc_test_run_event(test_ctx, I2C_SLAVE_WRITE_RECEIVED, 2);

	ssif_bmc_test_run_event(test_ctx, I2C_SLAVE_WRITE_RECEIVED, 0xaa);

	ssif_bmc_test_run_event(test_ctx, I2C_SLAVE_WRITE_RECEIVED, 0x55);
	KUNIT_EXPECT_EQ(test,
			ssif_bmc_test_run_event(test_ctx, I2C_SLAVE_STOP, 0), -EBUSY);

	KUNIT_EXPECT_EQ(test, ssif_bmc->state, SSIF_READY);
	KUNIT_EXPECT_TRUE(test, ssif_bmc->request_available);
	KUNIT_EXPECT_TRUE(test, ssif_bmc->busy);
	KUNIT_EXPECT_FALSE(test, ssif_bmc->aborting);
	KUNIT_EXPECT_EQ(test, ssif_bmc->request.len, 2);
	KUNIT_EXPECT_EQ(test, ssif_bmc->request.payload[0], 0xaa);
	KUNIT_EXPECT_EQ(test, ssif_bmc->request.payload[1], 0x55);
	KUNIT_EXPECT_TRUE(test, ssif_bmc->response_timer_inited);
}

static void ssif_bmc_test_restart_write_without_stop(struct kunit *test)
{
	struct ssif_bmc_test_ctx *test_ctx = test->priv;
	struct ssif_bmc_ctx *ssif_bmc = &test_ctx->ssif_bmc;

	KUNIT_ASSERT_EQ(test,
			ssif_bmc_test_run_event(test_ctx, I2C_SLAVE_WRITE_REQUESTED,
						GET_8BIT_ADDR(test_ctx->client.addr)), 0);
	KUNIT_ASSERT_EQ(test,
			ssif_bmc_test_run_event(test_ctx, I2C_SLAVE_WRITE_RECEIVED,
						SSIF_IPMI_SINGLEPART_WRITE), 0);
	KUNIT_ASSERT_EQ(test,
			ssif_bmc_test_run_event(test_ctx, I2C_SLAVE_WRITE_RECEIVED, 2), 0);
	KUNIT_ASSERT_EQ(test,
			ssif_bmc_test_run_event(test_ctx, I2C_SLAVE_WRITE_RECEIVED, 0xde), 0);

	KUNIT_EXPECT_EQ(test, ssif_bmc->state, SSIF_REQ_RECVING);

	/* Write transaction, without stop, and new request coming */
	ssif_bmc_test_singlepart_req(test);
}


static void ssif_bmc_test_restart_after_invalid_command(struct kunit *test)
{
	struct ssif_bmc_test_ctx *test_ctx = test->priv;
	struct ssif_bmc_ctx *ssif_bmc = &test_ctx->ssif_bmc;

	KUNIT_ASSERT_EQ(test,
			ssif_bmc_test_run_event(test_ctx, I2C_SLAVE_WRITE_REQUESTED,
						GET_8BIT_ADDR(test_ctx->client.addr)), 0);
	KUNIT_ASSERT_EQ(test,
			ssif_bmc_test_run_event(test_ctx, I2C_SLAVE_WRITE_RECEIVED, 0xff), 0);
	KUNIT_ASSERT_EQ(test,
			ssif_bmc_test_run_event(test_ctx, I2C_SLAVE_WRITE_RECEIVED, 1), 0);

	KUNIT_EXPECT_EQ(test, ssif_bmc->state, SSIF_ABORTING);
	KUNIT_EXPECT_TRUE(test, ssif_bmc->aborting);

	/* After An Invalid Command, expect could handle new request */
	ssif_bmc_test_singlepart_req(test);
}

static void ssif_bmc_test_singlepart_read_response_completion(struct kunit *test)
{
	struct ssif_bmc_test_ctx *test_ctx = test->priv;
	struct ssif_bmc_ctx *ssif_bmc = &test_ctx->ssif_bmc;
	u8 value;

	ssif_bmc->state = SSIF_SMBUS_CMD;
	ssif_bmc->part_buf.smbus_cmd = SSIF_IPMI_SINGLEPART_READ;
	ssif_bmc->response.len = 2;
	ssif_bmc->response.payload[0] = 0x11;
	ssif_bmc->response.payload[1] = 0x22;
	ssif_bmc->response_in_progress = true;
	ssif_bmc->is_singlepart_read = true;
	ssif_bmc->pec_support = true;

	value = 0;
	KUNIT_ASSERT_EQ(test,
			ssif_bmc_test_run_event_val(test_ctx, I2C_SLAVE_READ_REQUESTED,
						    &value), 0);
	KUNIT_EXPECT_EQ(test, value, 2);
	KUNIT_EXPECT_EQ(test, ssif_bmc->state, SSIF_RES_SENDING);

	value = 0;
	KUNIT_EXPECT_EQ(test,
			ssif_bmc_test_run_event_val(test_ctx, I2C_SLAVE_READ_PROCESSED,
						    &value), 0);
	KUNIT_EXPECT_EQ(test, value, 0x11);

	value = 0;
	KUNIT_EXPECT_EQ(test,
			ssif_bmc_test_run_event_val(test_ctx, I2C_SLAVE_READ_PROCESSED,
						    &value), 0);
	KUNIT_EXPECT_EQ(test, value, 0x22);

	value = 0;
	KUNIT_EXPECT_EQ(test,
			ssif_bmc_test_run_event_val(test_ctx, I2C_SLAVE_READ_PROCESSED,
						    &value), 0);
	KUNIT_EXPECT_EQ(test, value, ssif_bmc->part_buf.pec);

	KUNIT_EXPECT_EQ(test,
			ssif_bmc_test_run_event(test_ctx, I2C_SLAVE_STOP, 0), 0);
	KUNIT_EXPECT_EQ(test, ssif_bmc->state, SSIF_READY);
	KUNIT_EXPECT_FALSE(test, ssif_bmc->response_in_progress);
	KUNIT_EXPECT_EQ(test, ssif_bmc->response.len, 0);
}

static void ssif_bmc_test_stop_during_start_discards_partial_request(struct kunit *test)
{
	struct ssif_bmc_test_ctx *test_ctx = test->priv;
	struct ssif_bmc_ctx *ssif_bmc = &test_ctx->ssif_bmc;

	KUNIT_ASSERT_EQ(test,
			ssif_bmc_test_run_event(test_ctx, I2C_SLAVE_WRITE_REQUESTED,
						GET_8BIT_ADDR(test_ctx->client.addr)), 0);
	KUNIT_EXPECT_EQ(test, ssif_bmc->state, SSIF_START);

	KUNIT_EXPECT_EQ(test,
			ssif_bmc_test_run_event(test_ctx, I2C_SLAVE_STOP, 0), 0);
	KUNIT_EXPECT_EQ(test, ssif_bmc->state, SSIF_READY);
	KUNIT_EXPECT_FALSE(test, ssif_bmc->request_available);
	KUNIT_EXPECT_EQ(test, ssif_bmc->msg_idx, 0);

	KUNIT_EXPECT_EQ(test,
			ssif_bmc_test_run_event(test_ctx, I2C_SLAVE_WRITE_REQUESTED,
						GET_8BIT_ADDR(test_ctx->client.addr)), 0);
	KUNIT_EXPECT_EQ(test,
			ssif_bmc_test_run_event(test_ctx, I2C_SLAVE_WRITE_RECEIVED,
						SSIF_IPMI_SINGLEPART_WRITE), 0);
	KUNIT_EXPECT_EQ(test,
			ssif_bmc_test_run_event(test_ctx, I2C_SLAVE_WRITE_RECEIVED, 1), 0);
	KUNIT_EXPECT_EQ(test,
			ssif_bmc_test_run_event(test_ctx, I2C_SLAVE_WRITE_RECEIVED, 0x77), 0);
	KUNIT_EXPECT_EQ(test,
			ssif_bmc_test_run_event(test_ctx, I2C_SLAVE_STOP, 0), -EBUSY);

	KUNIT_EXPECT_TRUE(test, ssif_bmc->request_available);
	KUNIT_EXPECT_EQ(test, ssif_bmc->request.len, 1);
	KUNIT_EXPECT_EQ(test, ssif_bmc->request.payload[0], 0x77);
}

static void ssif_bmc_test_read_interrupts_partial_write(struct kunit *test)
{
	struct ssif_bmc_test_ctx *test_ctx = test->priv;
	struct ssif_bmc_ctx *ssif_bmc = &test_ctx->ssif_bmc;
	u8 value = 0xff;

	KUNIT_ASSERT_EQ(test,
			ssif_bmc_test_run_event(test_ctx, I2C_SLAVE_WRITE_REQUESTED,
						GET_8BIT_ADDR(test_ctx->client.addr)), 0);
	KUNIT_ASSERT_EQ(test,
			ssif_bmc_test_run_event(test_ctx, I2C_SLAVE_WRITE_RECEIVED,
						SSIF_IPMI_SINGLEPART_WRITE), 0);
	KUNIT_ASSERT_EQ(test,
			ssif_bmc_test_run_event(test_ctx, I2C_SLAVE_WRITE_RECEIVED, 2), 0);
	KUNIT_ASSERT_EQ(test,
			ssif_bmc_test_run_event(test_ctx, I2C_SLAVE_WRITE_RECEIVED, 0xab), 0);

	KUNIT_EXPECT_EQ(test, ssif_bmc->state, SSIF_REQ_RECVING);
	KUNIT_EXPECT_EQ(test,
			ssif_bmc_test_run_event_val(test_ctx, I2C_SLAVE_READ_REQUESTED,
						    &value), 0);
	KUNIT_EXPECT_EQ(test, value, 0);
	KUNIT_EXPECT_EQ(test, ssif_bmc->state, SSIF_ABORTING);

	KUNIT_EXPECT_EQ(test,
			ssif_bmc_test_run_event(test_ctx, I2C_SLAVE_STOP, 0), 0);
	KUNIT_EXPECT_EQ(test, ssif_bmc->state, SSIF_READY);
	KUNIT_EXPECT_FALSE(test, ssif_bmc->request_available);
	KUNIT_EXPECT_EQ(test, ssif_bmc->request.len, 0);

	KUNIT_EXPECT_EQ(test,
			ssif_bmc_test_run_event(test_ctx, I2C_SLAVE_WRITE_REQUESTED,
						GET_8BIT_ADDR(test_ctx->client.addr)), 0);
	KUNIT_EXPECT_EQ(test,
			ssif_bmc_test_run_event(test_ctx, I2C_SLAVE_WRITE_RECEIVED,
						SSIF_IPMI_SINGLEPART_WRITE), 0);
	KUNIT_EXPECT_EQ(test,
			ssif_bmc_test_run_event(test_ctx, I2C_SLAVE_WRITE_RECEIVED, 1), 0);
	KUNIT_EXPECT_EQ(test,
			ssif_bmc_test_run_event(test_ctx, I2C_SLAVE_WRITE_RECEIVED, 0xcd), 0);
	KUNIT_EXPECT_EQ(test,
			ssif_bmc_test_run_event(test_ctx, I2C_SLAVE_STOP, 0), -EBUSY);

	KUNIT_EXPECT_TRUE(test, ssif_bmc->request_available);
	KUNIT_EXPECT_EQ(test, ssif_bmc->request.len, 1);
	KUNIT_EXPECT_EQ(test, ssif_bmc->request.payload[0], 0xcd);
}

static void ssif_bmc_test_write_interrupts_response_send(struct kunit *test)
{
	struct ssif_bmc_test_ctx *test_ctx = test->priv;
	struct ssif_bmc_ctx *ssif_bmc = &test_ctx->ssif_bmc;
	u8 value = 0;

	ssif_bmc->state = SSIF_SMBUS_CMD;
	ssif_bmc->part_buf.smbus_cmd = SSIF_IPMI_SINGLEPART_READ;
	ssif_bmc->response.len = 1;
	ssif_bmc->response.payload[0] = 0x66;
	ssif_bmc->response_in_progress = true;
	ssif_bmc->is_singlepart_read = true;

	KUNIT_ASSERT_EQ(test,
			ssif_bmc_test_run_event_val(test_ctx, I2C_SLAVE_READ_REQUESTED,
						    &value), 0);
	KUNIT_EXPECT_EQ(test, ssif_bmc->state, SSIF_RES_SENDING);

	/* READ_REQUESTED transaction */
	ssif_bmc_test_singlepart_req(test);
}

static void ssif_bmc_test_write_interrupts_response_sending(struct kunit *test)
{
	struct ssif_bmc_test_ctx *test_ctx = test->priv;
	struct ssif_bmc_ctx *ssif_bmc = &test_ctx->ssif_bmc;
	u8 value = 0;

	ssif_bmc->state = SSIF_SMBUS_CMD;
	ssif_bmc->part_buf.smbus_cmd = SSIF_IPMI_SINGLEPART_READ;
	ssif_bmc->response.len = 1;
	ssif_bmc->response.payload[0] = 0x66;
	ssif_bmc->response_in_progress = true;
	ssif_bmc->is_singlepart_read = true;

	KUNIT_ASSERT_EQ(test,
			ssif_bmc_test_run_event_val(test_ctx, I2C_SLAVE_READ_REQUESTED,
						    &value), 0);
	KUNIT_EXPECT_EQ(test, ssif_bmc->state, SSIF_RES_SENDING);

	KUNIT_ASSERT_EQ(test,
			ssif_bmc_test_run_event_val(test_ctx, I2C_SLAVE_READ_PROCESSED,
						    &value), 0);
	KUNIT_EXPECT_EQ(test, value, 0x66);

	/* READ_REQUESTED transaction */
	ssif_bmc_test_singlepart_req(test);
}

static void ssif_bmc_test_timeout_interrupt_allows_retry(struct kunit *test)
{
	struct ssif_bmc_test_ctx *test_ctx = test->priv;
	struct ssif_bmc_ctx *ssif_bmc = &test_ctx->ssif_bmc;

	KUNIT_ASSERT_EQ(test,
			ssif_bmc_test_run_event(test_ctx, I2C_SLAVE_WRITE_REQUESTED,
						GET_8BIT_ADDR(test_ctx->client.addr)), 0);
	KUNIT_ASSERT_EQ(test,
			ssif_bmc_test_run_event(test_ctx, I2C_SLAVE_WRITE_RECEIVED,
						SSIF_IPMI_SINGLEPART_WRITE), 0);
	KUNIT_ASSERT_EQ(test,
			ssif_bmc_test_run_event(test_ctx, I2C_SLAVE_WRITE_RECEIVED, 1), 0);
	KUNIT_ASSERT_EQ(test,
			ssif_bmc_test_run_event(test_ctx, I2C_SLAVE_WRITE_RECEIVED, 0x21), 0);
	KUNIT_ASSERT_EQ(test,
			ssif_bmc_test_run_event(test_ctx, I2C_SLAVE_STOP, 0), -EBUSY);

	KUNIT_ASSERT_TRUE(test, timer_pending(&ssif_bmc->response_timer));
	timer_delete_sync(&ssif_bmc->response_timer);
	response_timeout(&ssif_bmc->response_timer);

	KUNIT_EXPECT_FALSE(test, ssif_bmc->busy);
	KUNIT_EXPECT_TRUE(test, ssif_bmc->aborting);
	KUNIT_EXPECT_FALSE(test, ssif_bmc->response_timer_inited);

	KUNIT_EXPECT_EQ(test,
			ssif_bmc_test_run_event(test_ctx, I2C_SLAVE_WRITE_REQUESTED,
						GET_8BIT_ADDR(test_ctx->client.addr)), 0);
	KUNIT_EXPECT_EQ(test,
			ssif_bmc_test_run_event(test_ctx, I2C_SLAVE_WRITE_RECEIVED,
						SSIF_IPMI_SINGLEPART_WRITE), 0);
	KUNIT_EXPECT_FALSE(test, ssif_bmc->aborting);
	KUNIT_EXPECT_EQ(test,
			ssif_bmc_test_run_event(test_ctx, I2C_SLAVE_WRITE_RECEIVED, 1), 0);
	KUNIT_EXPECT_EQ(test,
			ssif_bmc_test_run_event(test_ctx, I2C_SLAVE_WRITE_RECEIVED, 0x22), 0);
	KUNIT_EXPECT_EQ(test,
			ssif_bmc_test_run_event(test_ctx, I2C_SLAVE_STOP, 0), -EBUSY);

	KUNIT_EXPECT_TRUE(test, ssif_bmc->request_available);
	KUNIT_EXPECT_EQ(test, ssif_bmc->request.len, 1);
	KUNIT_EXPECT_EQ(test, ssif_bmc->request.payload[0], 0x22);
}

static struct kunit_case ssif_bmc_test_cases[] = {
	KUNIT_CASE(ssif_bmc_test_singlepart_req),
	KUNIT_CASE(ssif_bmc_test_restart_write_without_stop),
	KUNIT_CASE(ssif_bmc_test_restart_after_invalid_command),
	KUNIT_CASE(ssif_bmc_test_singlepart_read_response_completion),
	KUNIT_CASE(ssif_bmc_test_stop_during_start_discards_partial_request),
	KUNIT_CASE(ssif_bmc_test_read_interrupts_partial_write),
	KUNIT_CASE(ssif_bmc_test_write_interrupts_response_send),
	KUNIT_CASE(ssif_bmc_test_write_interrupts_response_sending),
	KUNIT_CASE(ssif_bmc_test_timeout_interrupt_allows_retry),
	{}
};

static struct kunit_suite ssif_bmc_test_suite = {
	.name = "ssif_bmc_test",
	.init = ssif_bmc_test_init,
	.exit = ssif_bmc_test_exit,
	.test_cases = ssif_bmc_test_cases,
};

kunit_test_suite(ssif_bmc_test_suite);
#endif

module_i2c_driver(ssif_bmc_driver);

MODULE_AUTHOR("Quan Nguyen <quan@os.amperecomputing.com>");
MODULE_AUTHOR("Chuong Tran <chuong@os.amperecomputing.com>");
MODULE_DESCRIPTION("Linux device driver of the BMC IPMI SSIF interface.");
MODULE_LICENSE("GPL");