[linux-2.6-block.git] / drivers / char / ipmi / kcs_bmc_cdev_ipmi.c

// SPDX-License-Identifier: GPL-2.0
/*
 * Copyright (c) 2015-2018, Intel Corporation.
 */

#define pr_fmt(fmt) "kcs-bmc: " fmt

#include <linux/errno.h>
#include <linux/io.h>
#include <linux/ipmi_bmc.h>
#include <linux/list.h>
#include <linux/miscdevice.h>
#include <linux/module.h>
#include <linux/mutex.h>
#include <linux/platform_device.h>
#include <linux/poll.h>
#include <linux/sched.h>
#include <linux/slab.h>

#include "kcs_bmc_client.h"

/* Different phases of the KCS BMC module.
 *  KCS_PHASE_IDLE:
 *            BMC should not be expecting nor sending any data.
 *  KCS_PHASE_WRITE_START:
 *            BMC is receiving a WRITE_START command from system software.
 *  KCS_PHASE_WRITE_DATA:
 *            BMC is receiving a data byte from system software.
 *  KCS_PHASE_WRITE_END_CMD:
 *            BMC is waiting a last data byte from system software.
 *  KCS_PHASE_WRITE_DONE:
 *            BMC has received the whole request from system software.
 *  KCS_PHASE_WAIT_READ:
 *            BMC is waiting the response from the upper IPMI service.
 *  KCS_PHASE_READ:
 *            BMC is transferring the response to system software.
 *  KCS_PHASE_ABORT_ERROR1:
 *            BMC is waiting error status request from system software.
 *  KCS_PHASE_ABORT_ERROR2:
 *            BMC is waiting for idle status afer error from system software.
 *  KCS_PHASE_ERROR:
 *            BMC has detected a protocol violation at the interface level.
 */
enum kcs_ipmi_phases {
	KCS_PHASE_IDLE,

	KCS_PHASE_WRITE_START,
	KCS_PHASE_WRITE_DATA,
	KCS_PHASE_WRITE_END_CMD,
	KCS_PHASE_WRITE_DONE,

	KCS_PHASE_WAIT_READ,
	KCS_PHASE_READ,

	KCS_PHASE_ABORT_ERROR1,
	KCS_PHASE_ABORT_ERROR2,
	KCS_PHASE_ERROR
};

/* IPMI 2.0 - Table 9-4, KCS Interface Status Codes */
enum kcs_ipmi_errors {
	KCS_NO_ERROR                = 0x00,
	KCS_ABORTED_BY_COMMAND      = 0x01,
	KCS_ILLEGAL_CONTROL_CODE    = 0x02,
	KCS_LENGTH_ERROR            = 0x06,
	KCS_UNSPECIFIED_ERROR       = 0xFF
};

struct kcs_bmc_ipmi {
	struct list_head entry;

	struct kcs_bmc_client client;

	spinlock_t lock;

	enum kcs_ipmi_phases phase;
	enum kcs_ipmi_errors error;

	wait_queue_head_t queue;
	bool data_in_avail;
	int  data_in_idx;
	u8  *data_in;

	int  data_out_idx;
	int  data_out_len;
	u8  *data_out;

	struct mutex mutex;
	u8 *kbuffer;

	struct miscdevice miscdev;
};

#define DEVICE_NAME "ipmi-kcs"

#define KCS_MSG_BUFSIZ    1000

#define KCS_ZERO_DATA     0

/* IPMI 2.0 - Table 9-1, KCS Interface Status Register Bits */
#define KCS_STATUS_STATE(state) (state << 6)
#define KCS_STATUS_STATE_MASK   GENMASK(7, 6)
#define KCS_STATUS_CMD_DAT      BIT(3)
#define KCS_STATUS_SMS_ATN      BIT(2)
#define KCS_STATUS_IBF          BIT(1)
#define KCS_STATUS_OBF          BIT(0)

/* IPMI 2.0 - Table 9-2, KCS Interface State Bits */
enum kcs_states {
	IDLE_STATE  = 0,
	READ_STATE  = 1,
	WRITE_STATE = 2,
	ERROR_STATE = 3,
};

/* IPMI 2.0 - Table 9-3, KCS Interface Control Codes */
#define KCS_CMD_GET_STATUS_ABORT  0x60
#define KCS_CMD_WRITE_START       0x61
#define KCS_CMD_WRITE_END         0x62
#define KCS_CMD_READ_BYTE         0x68

static inline void set_state(struct kcs_bmc_ipmi *priv, u8 state)
{
	kcs_bmc_update_status(priv->client.dev, KCS_STATUS_STATE_MASK, KCS_STATUS_STATE(state));
}

static void kcs_bmc_ipmi_force_abort(struct kcs_bmc_ipmi *priv)
{
	set_state(priv, ERROR_STATE);
	kcs_bmc_read_data(priv->client.dev);
	kcs_bmc_write_data(priv->client.dev, KCS_ZERO_DATA);

	priv->phase = KCS_PHASE_ERROR;
	priv->data_in_avail = false;
	priv->data_in_idx = 0;
}

static void kcs_bmc_ipmi_handle_data(struct kcs_bmc_ipmi *priv)
{
	struct kcs_bmc_device *dev;
	u8 data;

	dev = priv->client.dev;

	switch (priv->phase) {
	case KCS_PHASE_WRITE_START:
		priv->phase = KCS_PHASE_WRITE_DATA;
		fallthrough;

	case KCS_PHASE_WRITE_DATA:
		if (priv->data_in_idx < KCS_MSG_BUFSIZ) {
			set_state(priv, WRITE_STATE);
			kcs_bmc_write_data(dev, KCS_ZERO_DATA);
			priv->data_in[priv->data_in_idx++] = kcs_bmc_read_data(dev);
		} else {
			kcs_bmc_ipmi_force_abort(priv);
			priv->error = KCS_LENGTH_ERROR;
		}
		break;

	case KCS_PHASE_WRITE_END_CMD:
		if (priv->data_in_idx < KCS_MSG_BUFSIZ) {
			set_state(priv, READ_STATE);
			priv->data_in[priv->data_in_idx++] = kcs_bmc_read_data(dev);
			priv->phase = KCS_PHASE_WRITE_DONE;
			priv->data_in_avail = true;
			wake_up_interruptible(&priv->queue);
		} else {
			kcs_bmc_ipmi_force_abort(priv);
			priv->error = KCS_LENGTH_ERROR;
		}
		break;

	case KCS_PHASE_READ:
		if (priv->data_out_idx == priv->data_out_len)
			set_state(priv, IDLE_STATE);

		data = kcs_bmc_read_data(dev);
		if (data != KCS_CMD_READ_BYTE) {
			set_state(priv, ERROR_STATE);
			kcs_bmc_write_data(dev, KCS_ZERO_DATA);
			break;
		}

		if (priv->data_out_idx == priv->data_out_len) {
			kcs_bmc_write_data(dev, KCS_ZERO_DATA);
			priv->phase = KCS_PHASE_IDLE;
			break;
		}

		kcs_bmc_write_data(dev, priv->data_out[priv->data_out_idx++]);
		break;

	case KCS_PHASE_ABORT_ERROR1:
		set_state(priv, READ_STATE);
		kcs_bmc_read_data(dev);
		kcs_bmc_write_data(dev, priv->error);
		priv->phase = KCS_PHASE_ABORT_ERROR2;
		break;

	case KCS_PHASE_ABORT_ERROR2:
		set_state(priv, IDLE_STATE);
		kcs_bmc_read_data(dev);
		kcs_bmc_write_data(dev, KCS_ZERO_DATA);
		priv->phase = KCS_PHASE_IDLE;
		break;

	default:
		kcs_bmc_ipmi_force_abort(priv);
		break;
	}
}

static void kcs_bmc_ipmi_handle_cmd(struct kcs_bmc_ipmi *priv)
{
	u8 cmd;

	set_state(priv, WRITE_STATE);
	kcs_bmc_write_data(priv->client.dev, KCS_ZERO_DATA);

	cmd = kcs_bmc_read_data(priv->client.dev);
	switch (cmd) {
	case KCS_CMD_WRITE_START:
		priv->phase = KCS_PHASE_WRITE_START;
		priv->error = KCS_NO_ERROR;
		priv->data_in_avail = false;
		priv->data_in_idx = 0;
		break;

	case KCS_CMD_WRITE_END:
		if (priv->phase != KCS_PHASE_WRITE_DATA) {
			kcs_bmc_ipmi_force_abort(priv);
			break;
		}

		priv->phase = KCS_PHASE_WRITE_END_CMD;
		break;

	case KCS_CMD_GET_STATUS_ABORT:
		if (priv->error == KCS_NO_ERROR)
			priv->error = KCS_ABORTED_BY_COMMAND;

		priv->phase = KCS_PHASE_ABORT_ERROR1;
		priv->data_in_avail = false;
		priv->data_in_idx = 0;
		break;

	default:
		kcs_bmc_ipmi_force_abort(priv);
		priv->error = KCS_ILLEGAL_CONTROL_CODE;
		break;
	}
}

static inline struct kcs_bmc_ipmi *client_to_kcs_bmc_ipmi(struct kcs_bmc_client *client)
{
	return container_of(client, struct kcs_bmc_ipmi, client);
}

static irqreturn_t kcs_bmc_ipmi_event(struct kcs_bmc_client *client)
{
	struct kcs_bmc_ipmi *priv;
	u8 status;
	int ret;

	priv = client_to_kcs_bmc_ipmi(client);
	if (!priv)
		return IRQ_NONE;

	spin_lock(&priv->lock);

	status = kcs_bmc_read_status(client->dev);
	if (status & KCS_STATUS_IBF) {
		if (status & KCS_STATUS_CMD_DAT)
			kcs_bmc_ipmi_handle_cmd(priv);
		else
			kcs_bmc_ipmi_handle_data(priv);

		ret = IRQ_HANDLED;
	} else {
		ret = IRQ_NONE;
	}

	spin_unlock(&priv->lock);

	return ret;
}

static const struct kcs_bmc_client_ops kcs_bmc_ipmi_client_ops = {
	.event = kcs_bmc_ipmi_event,
};

static inline struct kcs_bmc_ipmi *to_kcs_bmc(struct file *filp)
{
	return container_of(filp->private_data, struct kcs_bmc_ipmi, miscdev);
}

static int kcs_bmc_ipmi_open(struct inode *inode, struct file *filp)
{
	struct kcs_bmc_ipmi *priv = to_kcs_bmc(filp);

	return kcs_bmc_enable_device(priv->client.dev, &priv->client);
}

static __poll_t kcs_bmc_ipmi_poll(struct file *filp, poll_table *wait)
{
	struct kcs_bmc_ipmi *priv = to_kcs_bmc(filp);
	__poll_t mask = 0;

	poll_wait(filp, &priv->queue, wait);

	spin_lock_irq(&priv->lock);
	if (priv->data_in_avail)
		mask |= EPOLLIN;
	spin_unlock_irq(&priv->lock);

	return mask;
}

static ssize_t kcs_bmc_ipmi_read(struct file *filp, char __user *buf,
			    size_t count, loff_t *ppos)
{
	struct kcs_bmc_ipmi *priv = to_kcs_bmc(filp);
	bool data_avail;
	size_t data_len;
	ssize_t ret;

	if (!(filp->f_flags & O_NONBLOCK))
		wait_event_interruptible(priv->queue,
					 priv->data_in_avail);

	mutex_lock(&priv->mutex);

	spin_lock_irq(&priv->lock);
	data_avail = priv->data_in_avail;
	if (data_avail) {
		data_len = priv->data_in_idx;
		memcpy(priv->kbuffer, priv->data_in, data_len);
	}
	spin_unlock_irq(&priv->lock);

	if (!data_avail) {
		ret = -EAGAIN;
		goto out_unlock;
	}

	if (count < data_len) {
		pr_err("channel=%u with too large data : %zu\n",
			priv->client.dev->channel, data_len);

		spin_lock_irq(&priv->lock);
		kcs_bmc_ipmi_force_abort(priv);
		spin_unlock_irq(&priv->lock);

		ret = -EOVERFLOW;
		goto out_unlock;
	}

	if (copy_to_user(buf, priv->kbuffer, data_len)) {
		ret = -EFAULT;
		goto out_unlock;
	}

	ret = data_len;

	spin_lock_irq(&priv->lock);
	if (priv->phase == KCS_PHASE_WRITE_DONE) {
		priv->phase = KCS_PHASE_WAIT_READ;
		priv->data_in_avail = false;
		priv->data_in_idx = 0;
	} else {
		ret = -EAGAIN;
	}
	spin_unlock_irq(&priv->lock);

out_unlock:
	mutex_unlock(&priv->mutex);

	return ret;
}

static ssize_t kcs_bmc_ipmi_write(struct file *filp, const char __user *buf,
			     size_t count, loff_t *ppos)
{
	struct kcs_bmc_ipmi *priv = to_kcs_bmc(filp);
	ssize_t ret;

	/* a minimum response size '3' : netfn + cmd + ccode */
	if (count < 3 || count > KCS_MSG_BUFSIZ)
		return -EINVAL;

	mutex_lock(&priv->mutex);

	if (copy_from_user(priv->kbuffer, buf, count)) {
		ret = -EFAULT;
		goto out_unlock;
	}

	spin_lock_irq(&priv->lock);
	if (priv->phase == KCS_PHASE_WAIT_READ) {
		priv->phase = KCS_PHASE_READ;
		priv->data_out_idx = 1;
		priv->data_out_len = count;
		memcpy(priv->data_out, priv->kbuffer, count);
		kcs_bmc_write_data(priv->client.dev, priv->data_out[0]);
		ret = count;
	} else {
		ret = -EINVAL;
	}
	spin_unlock_irq(&priv->lock);

out_unlock:
	mutex_unlock(&priv->mutex);

	return ret;
}

static long kcs_bmc_ipmi_ioctl(struct file *filp, unsigned int cmd,
			  unsigned long arg)
{
	struct kcs_bmc_ipmi *priv = to_kcs_bmc(filp);
	long ret = 0;

	spin_lock_irq(&priv->lock);

	switch (cmd) {
	case IPMI_BMC_IOCTL_SET_SMS_ATN:
		kcs_bmc_update_status(priv->client.dev, KCS_STATUS_SMS_ATN, KCS_STATUS_SMS_ATN);
		break;

	case IPMI_BMC_IOCTL_CLEAR_SMS_ATN:
		kcs_bmc_update_status(priv->client.dev, KCS_STATUS_SMS_ATN, 0);
		break;

	case IPMI_BMC_IOCTL_FORCE_ABORT:
		kcs_bmc_ipmi_force_abort(priv);
		break;

	default:
		ret = -EINVAL;
		break;
	}

	spin_unlock_irq(&priv->lock);

	return ret;
}

static int kcs_bmc_ipmi_release(struct inode *inode, struct file *filp)
{
	struct kcs_bmc_ipmi *priv = to_kcs_bmc(filp);

	kcs_bmc_ipmi_force_abort(priv);
	kcs_bmc_disable_device(priv->client.dev, &priv->client);

	return 0;
}

static const struct file_operations kcs_bmc_ipmi_fops = {
	.owner          = THIS_MODULE,
	.open           = kcs_bmc_ipmi_open,
	.read           = kcs_bmc_ipmi_read,
	.write          = kcs_bmc_ipmi_write,
	.release        = kcs_bmc_ipmi_release,
	.poll           = kcs_bmc_ipmi_poll,
	.unlocked_ioctl = kcs_bmc_ipmi_ioctl,
};

static DEFINE_SPINLOCK(kcs_bmc_ipmi_instances_lock);
static LIST_HEAD(kcs_bmc_ipmi_instances);

static int kcs_bmc_ipmi_add_device(struct kcs_bmc_device *kcs_bmc)
{
	struct kcs_bmc_ipmi *priv;
	int rc;

	priv = devm_kzalloc(kcs_bmc->dev, sizeof(*priv), GFP_KERNEL);
	if (!priv)
		return -ENOMEM;

	spin_lock_init(&priv->lock);
	mutex_init(&priv->mutex);

	init_waitqueue_head(&priv->queue);

	priv->client.dev = kcs_bmc;
	priv->client.ops = &kcs_bmc_ipmi_client_ops;
	priv->data_in = devm_kmalloc(kcs_bmc->dev, KCS_MSG_BUFSIZ, GFP_KERNEL);
	priv->data_out = devm_kmalloc(kcs_bmc->dev, KCS_MSG_BUFSIZ, GFP_KERNEL);
	priv->kbuffer = devm_kmalloc(kcs_bmc->dev, KCS_MSG_BUFSIZ, GFP_KERNEL);

	priv->miscdev.minor = MISC_DYNAMIC_MINOR;
	priv->miscdev.name = devm_kasprintf(kcs_bmc->dev, GFP_KERNEL, "%s%u", DEVICE_NAME,
					   kcs_bmc->channel);
	if (!priv->data_in || !priv->data_out || !priv->kbuffer || !priv->miscdev.name)
		return -EINVAL;

	priv->miscdev.fops = &kcs_bmc_ipmi_fops;

	rc = misc_register(&priv->miscdev);
	if (rc) {
		dev_err(kcs_bmc->dev, "Unable to register device: %d\n", rc);
		return rc;
	}

	spin_lock_irq(&kcs_bmc_ipmi_instances_lock);
	list_add(&priv->entry, &kcs_bmc_ipmi_instances);
	spin_unlock_irq(&kcs_bmc_ipmi_instances_lock);

	dev_info(kcs_bmc->dev, "Initialised IPMI client for channel %d", kcs_bmc->channel);

	return 0;
}

static int kcs_bmc_ipmi_remove_device(struct kcs_bmc_device *kcs_bmc)
{
	struct kcs_bmc_ipmi *priv = NULL, *pos;

	spin_lock_irq(&kcs_bmc_ipmi_instances_lock);
	list_for_each_entry(pos, &kcs_bmc_ipmi_instances, entry) {
		if (pos->client.dev == kcs_bmc) {
			priv = pos;
			list_del(&pos->entry);
			break;
		}
	}
	spin_unlock_irq(&kcs_bmc_ipmi_instances_lock);

	if (!priv)
		return -ENODEV;

	misc_deregister(&priv->miscdev);
	kcs_bmc_disable_device(priv->client.dev, &priv->client);
	devm_kfree(kcs_bmc->dev, priv->kbuffer);
	devm_kfree(kcs_bmc->dev, priv->data_out);
	devm_kfree(kcs_bmc->dev, priv->data_in);
	devm_kfree(kcs_bmc->dev, priv);

	return 0;
}

static const struct kcs_bmc_driver_ops kcs_bmc_ipmi_driver_ops = {
	.add_device = kcs_bmc_ipmi_add_device,
	.remove_device = kcs_bmc_ipmi_remove_device,
};

static struct kcs_bmc_driver kcs_bmc_ipmi_driver = {
	.ops = &kcs_bmc_ipmi_driver_ops,
};

static int __init kcs_bmc_ipmi_init(void)
{
	kcs_bmc_register_driver(&kcs_bmc_ipmi_driver);

	return 0;
}
module_init(kcs_bmc_ipmi_init);

static void __exit kcs_bmc_ipmi_exit(void)
{
	kcs_bmc_unregister_driver(&kcs_bmc_ipmi_driver);
}
module_exit(kcs_bmc_ipmi_exit);

MODULE_LICENSE("GPL v2");
MODULE_AUTHOR("Haiyue Wang <haiyue.wang@linux.intel.com>");
MODULE_AUTHOR("Andrew Jeffery <andrew@aj.id.au>");
MODULE_DESCRIPTION("KCS BMC to handle the IPMI request from system software");
Commit	Line	Data
55ab48b4 AJ	1	// SPDX-License-Identifier: GPL-2.0
	2	/*
	3	* Copyright (c) 2015-2018, Intel Corporation.
	4	*/
	5
	6	#define pr_fmt(fmt) "kcs-bmc: " fmt
	7
	8	#include <linux/errno.h>
	9	#include <linux/io.h>
	10	#include <linux/ipmi_bmc.h>
d4e7ac68 AJ	11	#include <linux/list.h>
d4e7ac68 AJ	12	#include <linux/miscdevice.h>
55ab48b4	13	#include <linux/module.h>
d4e7ac68	14	#include <linux/mutex.h>
55ab48b4 AJ	15	#include <linux/platform_device.h>
	16	#include <linux/poll.h>
	17	#include <linux/sched.h>
	18	#include <linux/slab.h>
	19
d4e7ac68 AJ	20	#include "kcs_bmc_client.h"
	21
	22	/* Different phases of the KCS BMC module.
	23	* KCS_PHASE_IDLE:
	24	* BMC should not be expecting nor sending any data.
	25	* KCS_PHASE_WRITE_START:
	26	* BMC is receiving a WRITE_START command from system software.
	27	* KCS_PHASE_WRITE_DATA:
	28	* BMC is receiving a data byte from system software.
	29	* KCS_PHASE_WRITE_END_CMD:
	30	* BMC is waiting a last data byte from system software.
	31	* KCS_PHASE_WRITE_DONE:
	32	* BMC has received the whole request from system software.
	33	* KCS_PHASE_WAIT_READ:
	34	* BMC is waiting the response from the upper IPMI service.
	35	* KCS_PHASE_READ:
	36	* BMC is transferring the response to system software.
	37	* KCS_PHASE_ABORT_ERROR1:
	38	* BMC is waiting error status request from system software.
	39	* KCS_PHASE_ABORT_ERROR2:
	40	* BMC is waiting for idle status afer error from system software.
	41	* KCS_PHASE_ERROR:
	42	* BMC has detected a protocol violation at the interface level.
	43	*/
	44	enum kcs_ipmi_phases {
	45	KCS_PHASE_IDLE,
	46
	47	KCS_PHASE_WRITE_START,
	48	KCS_PHASE_WRITE_DATA,
	49	KCS_PHASE_WRITE_END_CMD,
	50	KCS_PHASE_WRITE_DONE,
	51
	52	KCS_PHASE_WAIT_READ,
	53	KCS_PHASE_READ,
	54
	55	KCS_PHASE_ABORT_ERROR1,
	56	KCS_PHASE_ABORT_ERROR2,
	57	KCS_PHASE_ERROR
	58	};
	59
	60	/* IPMI 2.0 - Table 9-4, KCS Interface Status Codes */
	61	enum kcs_ipmi_errors {
	62	KCS_NO_ERROR = 0x00,
	63	KCS_ABORTED_BY_COMMAND = 0x01,
	64	KCS_ILLEGAL_CONTROL_CODE = 0x02,
	65	KCS_LENGTH_ERROR = 0x06,
	66	KCS_UNSPECIFIED_ERROR = 0xFF
	67	};
	68
	69	struct kcs_bmc_ipmi {
	70	struct list_head entry;
	71
	72	struct kcs_bmc_client client;
	73
	74	spinlock_t lock;
	75
	76	enum kcs_ipmi_phases phase;
	77	enum kcs_ipmi_errors error;
	78
	79	wait_queue_head_t queue;
	80	bool data_in_avail;
	81	int data_in_idx;
	82	u8 *data_in;
	83
84	int data_out_idx;
85	int data_out_len;
86	u8 *data_out;
87
88	struct mutex mutex;
89	u8 *kbuffer;
90
91	struct miscdevice miscdev;
92	};
55ab48b4 AJ	93
	94	#define DEVICE_NAME "ipmi-kcs"
	95
	96	#define KCS_MSG_BUFSIZ 1000
	97
	98	#define KCS_ZERO_DATA 0
	99
55ab48b4 AJ	100	/* IPMI 2.0 - Table 9-1, KCS Interface Status Register Bits */
	101	#define KCS_STATUS_STATE(state) (state << 6)
	102	#define KCS_STATUS_STATE_MASK GENMASK(7, 6)
	103	#define KCS_STATUS_CMD_DAT BIT(3)
	104	#define KCS_STATUS_SMS_ATN BIT(2)
	105	#define KCS_STATUS_IBF BIT(1)
	106	#define KCS_STATUS_OBF BIT(0)
	107
	108	/* IPMI 2.0 - Table 9-2, KCS Interface State Bits */
	109	enum kcs_states {
	110	IDLE_STATE = 0,
	111	READ_STATE = 1,
	112	WRITE_STATE = 2,
	113	ERROR_STATE = 3,
	114	};
	115
	116	/* IPMI 2.0 - Table 9-3, KCS Interface Control Codes */
	117	#define KCS_CMD_GET_STATUS_ABORT 0x60
	118	#define KCS_CMD_WRITE_START 0x61
	119	#define KCS_CMD_WRITE_END 0x62
	120	#define KCS_CMD_READ_BYTE 0x68
	121
d4e7ac68	122	static inline void set_state(struct kcs_bmc_ipmi *priv, u8 state)
55ab48b4	123	{
d4e7ac68	124	kcs_bmc_update_status(priv->client.dev, KCS_STATUS_STATE_MASK, KCS_STATUS_STATE(state));
55ab48b4 AJ	125	}
55ab48b4 AJ	126
d4e7ac68	127	static void kcs_bmc_ipmi_force_abort(struct kcs_bmc_ipmi *priv)
55ab48b4	128	{
d4e7ac68 AJ	129	set_state(priv, ERROR_STATE);
	130	kcs_bmc_read_data(priv->client.dev);
	131	kcs_bmc_write_data(priv->client.dev, KCS_ZERO_DATA);
55ab48b4	132
d4e7ac68 AJ	133	priv->phase = KCS_PHASE_ERROR;
	134	priv->data_in_avail = false;
	135	priv->data_in_idx = 0;
55ab48b4 AJ	136	}
55ab48b4 AJ	137
d4e7ac68	138	static void kcs_bmc_ipmi_handle_data(struct kcs_bmc_ipmi *priv)
55ab48b4	139	{
d4e7ac68	140	struct kcs_bmc_device *dev;
55ab48b4 AJ	141	u8 data;
55ab48b4 AJ	142
d4e7ac68 AJ	143	dev = priv->client.dev;
	144
	145	switch (priv->phase) {
55ab48b4	146	case KCS_PHASE_WRITE_START:
d4e7ac68	147	priv->phase = KCS_PHASE_WRITE_DATA;
55ab48b4 AJ	148	fallthrough;
	149
	150	case KCS_PHASE_WRITE_DATA:
d4e7ac68 AJ	151	if (priv->data_in_idx < KCS_MSG_BUFSIZ) {
	152	set_state(priv, WRITE_STATE);
	153	kcs_bmc_write_data(dev, KCS_ZERO_DATA);
	154	priv->data_in[priv->data_in_idx++] = kcs_bmc_read_data(dev);
55ab48b4	155	} else {
d4e7ac68 AJ	156	kcs_bmc_ipmi_force_abort(priv);
d4e7ac68 AJ	157	priv->error = KCS_LENGTH_ERROR;
55ab48b4 AJ	158	}
	159	break;
	160
	161	case KCS_PHASE_WRITE_END_CMD:
d4e7ac68 AJ	162	if (priv->data_in_idx < KCS_MSG_BUFSIZ) {
	163	set_state(priv, READ_STATE);
	164	priv->data_in[priv->data_in_idx++] = kcs_bmc_read_data(dev);
	165	priv->phase = KCS_PHASE_WRITE_DONE;
	166	priv->data_in_avail = true;
	167	wake_up_interruptible(&priv->queue);
55ab48b4	168	} else {
d4e7ac68 AJ	169	kcs_bmc_ipmi_force_abort(priv);
d4e7ac68 AJ	170	priv->error = KCS_LENGTH_ERROR;
55ab48b4 AJ	171	}
	172	break;
	173
	174	case KCS_PHASE_READ:
d4e7ac68 AJ	175	if (priv->data_out_idx == priv->data_out_len)
d4e7ac68 AJ	176	set_state(priv, IDLE_STATE);
55ab48b4	177
d4e7ac68	178	data = kcs_bmc_read_data(dev);
55ab48b4	179	if (data != KCS_CMD_READ_BYTE) {
d4e7ac68 AJ	180	set_state(priv, ERROR_STATE);
d4e7ac68 AJ	181	kcs_bmc_write_data(dev, KCS_ZERO_DATA);
55ab48b4 AJ	182	break;
	183	}
	184
d4e7ac68 AJ	185	if (priv->data_out_idx == priv->data_out_len) {
	186	kcs_bmc_write_data(dev, KCS_ZERO_DATA);
	187	priv->phase = KCS_PHASE_IDLE;
55ab48b4 AJ	188	break;
	189	}
	190
d4e7ac68	191	kcs_bmc_write_data(dev, priv->data_out[priv->data_out_idx++]);
55ab48b4 AJ	192	break;
	193
	194	case KCS_PHASE_ABORT_ERROR1:
d4e7ac68 AJ	195	set_state(priv, READ_STATE);
	196	kcs_bmc_read_data(dev);
	197	kcs_bmc_write_data(dev, priv->error);
	198	priv->phase = KCS_PHASE_ABORT_ERROR2;
55ab48b4 AJ	199	break;
	200
	201	case KCS_PHASE_ABORT_ERROR2:
d4e7ac68 AJ	202	set_state(priv, IDLE_STATE);
	203	kcs_bmc_read_data(dev);
	204	kcs_bmc_write_data(dev, KCS_ZERO_DATA);
	205	priv->phase = KCS_PHASE_IDLE;
55ab48b4 AJ	206	break;
	207
	208	default:
d4e7ac68	209	kcs_bmc_ipmi_force_abort(priv);
55ab48b4 AJ	210	break;
	211	}
	212	}
	213
d4e7ac68	214	static void kcs_bmc_ipmi_handle_cmd(struct kcs_bmc_ipmi *priv)
55ab48b4 AJ	215	{
	216	u8 cmd;
	217
d4e7ac68 AJ	218	set_state(priv, WRITE_STATE);
d4e7ac68 AJ	219	kcs_bmc_write_data(priv->client.dev, KCS_ZERO_DATA);
55ab48b4	220
d4e7ac68	221	cmd = kcs_bmc_read_data(priv->client.dev);
55ab48b4 AJ	222	switch (cmd) {
55ab48b4 AJ	223	case KCS_CMD_WRITE_START:
d4e7ac68 AJ	224	priv->phase = KCS_PHASE_WRITE_START;
	225	priv->error = KCS_NO_ERROR;
	226	priv->data_in_avail = false;
	227	priv->data_in_idx = 0;
55ab48b4 AJ	228	break;
	229
	230	case KCS_CMD_WRITE_END:
d4e7ac68 AJ	231	if (priv->phase != KCS_PHASE_WRITE_DATA) {
d4e7ac68 AJ	232	kcs_bmc_ipmi_force_abort(priv);
55ab48b4 AJ	233	break;
	234	}
	235
d4e7ac68	236	priv->phase = KCS_PHASE_WRITE_END_CMD;
55ab48b4 AJ	237	break;
	238
	239	case KCS_CMD_GET_STATUS_ABORT:
d4e7ac68 AJ	240	if (priv->error == KCS_NO_ERROR)
d4e7ac68 AJ	241	priv->error = KCS_ABORTED_BY_COMMAND;
55ab48b4	242
d4e7ac68 AJ	243	priv->phase = KCS_PHASE_ABORT_ERROR1;
	244	priv->data_in_avail = false;
	245	priv->data_in_idx = 0;
55ab48b4 AJ	246	break;
	247
	248	default:
d4e7ac68 AJ	249	kcs_bmc_ipmi_force_abort(priv);
d4e7ac68 AJ	250	priv->error = KCS_ILLEGAL_CONTROL_CODE;
55ab48b4 AJ	251	break;
	252	}
	253	}
	254
d4e7ac68	255	static inline struct kcs_bmc_ipmi client_to_kcs_bmc_ipmi(struct kcs_bmc_client client)
faae6e39	256	{
d4e7ac68	257	return container_of(client, struct kcs_bmc_ipmi, client);
faae6e39 AJ	258	}
	259
	260	static irqreturn_t kcs_bmc_ipmi_event(struct kcs_bmc_client *client)
55ab48b4	261	{
d4e7ac68	262	struct kcs_bmc_ipmi *priv;
55ab48b4	263	u8 status;
faae6e39 AJ	264	int ret;
faae6e39 AJ	265
d4e7ac68 AJ	266	priv = client_to_kcs_bmc_ipmi(client);
	267	if (!priv)
	268	return IRQ_NONE;
55ab48b4	269
d4e7ac68	270	spin_lock(&priv->lock);
55ab48b4	271
d4e7ac68	272	status = kcs_bmc_read_status(client->dev);
55ab48b4	273	if (status & KCS_STATUS_IBF) {
d4e7ac68 AJ	274	if (status & KCS_STATUS_CMD_DAT)
d4e7ac68 AJ	275	kcs_bmc_ipmi_handle_cmd(priv);
55ab48b4	276	else
d4e7ac68	277	kcs_bmc_ipmi_handle_data(priv);
55ab48b4	278
faae6e39 AJ	279	ret = IRQ_HANDLED;
	280	} else {
	281	ret = IRQ_NONE;
55ab48b4 AJ	282	}
55ab48b4 AJ	283
d4e7ac68	284	spin_unlock(&priv->lock);
55ab48b4 AJ	285
	286	return ret;
	287	}
55ab48b4	288
faae6e39 AJ	289	static const struct kcs_bmc_client_ops kcs_bmc_ipmi_client_ops = {
	290	.event = kcs_bmc_ipmi_event,
	291	};
	292
d4e7ac68	293	static inline struct kcs_bmc_ipmi to_kcs_bmc(struct file filp)
55ab48b4	294	{
d4e7ac68	295	return container_of(filp->private_data, struct kcs_bmc_ipmi, miscdev);
55ab48b4 AJ	296	}
	297
	298	static int kcs_bmc_ipmi_open(struct inode inode, struct file filp)
	299	{
d4e7ac68	300	struct kcs_bmc_ipmi *priv = to_kcs_bmc(filp);
55ab48b4	301
d4e7ac68	302	return kcs_bmc_enable_device(priv->client.dev, &priv->client);
55ab48b4 AJ	303	}
	304
	305	static __poll_t kcs_bmc_ipmi_poll(struct file filp, poll_table wait)
	306	{
d4e7ac68	307	struct kcs_bmc_ipmi *priv = to_kcs_bmc(filp);
55ab48b4 AJ	308	__poll_t mask = 0;
55ab48b4 AJ	309
d4e7ac68	310	poll_wait(filp, &priv->queue, wait);
55ab48b4	311
d4e7ac68 AJ	312	spin_lock_irq(&priv->lock);
d4e7ac68 AJ	313	if (priv->data_in_avail)
55ab48b4	314	mask \|= EPOLLIN;
d4e7ac68	315	spin_unlock_irq(&priv->lock);
55ab48b4 AJ	316
	317	return mask;
	318	}
	319
	320	static ssize_t kcs_bmc_ipmi_read(struct file filp, char __user buf,
	321	size_t count, loff_t *ppos)
	322	{
d4e7ac68	323	struct kcs_bmc_ipmi *priv = to_kcs_bmc(filp);
55ab48b4 AJ	324	bool data_avail;
	325	size_t data_len;
	326	ssize_t ret;
	327
	328	if (!(filp->f_flags & O_NONBLOCK))
d4e7ac68 AJ	329	wait_event_interruptible(priv->queue,
d4e7ac68 AJ	330	priv->data_in_avail);
55ab48b4	331
d4e7ac68	332	mutex_lock(&priv->mutex);
55ab48b4	333
d4e7ac68 AJ	334	spin_lock_irq(&priv->lock);
d4e7ac68 AJ	335	data_avail = priv->data_in_avail;
55ab48b4	336	if (data_avail) {
d4e7ac68 AJ	337	data_len = priv->data_in_idx;
d4e7ac68 AJ	338	memcpy(priv->kbuffer, priv->data_in, data_len);
55ab48b4	339	}
d4e7ac68	340	spin_unlock_irq(&priv->lock);
55ab48b4 AJ	341
	342	if (!data_avail) {
	343	ret = -EAGAIN;
	344	goto out_unlock;
	345	}
	346
	347	if (count < data_len) {
	348	pr_err("channel=%u with too large data : %zu\n",
d4e7ac68	349	priv->client.dev->channel, data_len);
55ab48b4	350
d4e7ac68 AJ	351	spin_lock_irq(&priv->lock);
	352	kcs_bmc_ipmi_force_abort(priv);
	353	spin_unlock_irq(&priv->lock);
55ab48b4 AJ	354
	355	ret = -EOVERFLOW;
	356	goto out_unlock;
	357	}
	358
d4e7ac68	359	if (copy_to_user(buf, priv->kbuffer, data_len)) {
55ab48b4 AJ	360	ret = -EFAULT;
	361	goto out_unlock;
	362	}
	363
	364	ret = data_len;
	365
d4e7ac68 AJ	366	spin_lock_irq(&priv->lock);
	367	if (priv->phase == KCS_PHASE_WRITE_DONE) {
	368	priv->phase = KCS_PHASE_WAIT_READ;
	369	priv->data_in_avail = false;
	370	priv->data_in_idx = 0;
55ab48b4 AJ	371	} else {
	372	ret = -EAGAIN;
	373	}
d4e7ac68	374	spin_unlock_irq(&priv->lock);
55ab48b4 AJ	375
55ab48b4 AJ	376	out_unlock:
d4e7ac68	377	mutex_unlock(&priv->mutex);
55ab48b4 AJ	378
	379	return ret;
	380	}
	381
	382	static ssize_t kcs_bmc_ipmi_write(struct file filp, const char __user buf,
	383	size_t count, loff_t *ppos)
	384	{
d4e7ac68	385	struct kcs_bmc_ipmi *priv = to_kcs_bmc(filp);
55ab48b4 AJ	386	ssize_t ret;
	387
	388	/* a minimum response size '3' : netfn + cmd + ccode */
	389	if (count < 3 \|\| count > KCS_MSG_BUFSIZ)
	390	return -EINVAL;
	391
d4e7ac68	392	mutex_lock(&priv->mutex);
55ab48b4	393
d4e7ac68	394	if (copy_from_user(priv->kbuffer, buf, count)) {
55ab48b4 AJ	395	ret = -EFAULT;
	396	goto out_unlock;
	397	}
	398
d4e7ac68 AJ	399	spin_lock_irq(&priv->lock);
	400	if (priv->phase == KCS_PHASE_WAIT_READ) {
	401	priv->phase = KCS_PHASE_READ;
	402	priv->data_out_idx = 1;
	403	priv->data_out_len = count;
	404	memcpy(priv->data_out, priv->kbuffer, count);
	405	kcs_bmc_write_data(priv->client.dev, priv->data_out[0]);
55ab48b4 AJ	406	ret = count;
	407	} else {
	408	ret = -EINVAL;
	409	}
d4e7ac68	410	spin_unlock_irq(&priv->lock);
55ab48b4 AJ	411
55ab48b4 AJ	412	out_unlock:
d4e7ac68	413	mutex_unlock(&priv->mutex);
55ab48b4 AJ	414
	415	return ret;
	416	}
	417
	418	static long kcs_bmc_ipmi_ioctl(struct file *filp, unsigned int cmd,
	419	unsigned long arg)
	420	{
d4e7ac68	421	struct kcs_bmc_ipmi *priv = to_kcs_bmc(filp);
55ab48b4 AJ	422	long ret = 0;
55ab48b4 AJ	423
d4e7ac68	424	spin_lock_irq(&priv->lock);
55ab48b4 AJ	425
	426	switch (cmd) {
	427	case IPMI_BMC_IOCTL_SET_SMS_ATN:
d4e7ac68	428	kcs_bmc_update_status(priv->client.dev, KCS_STATUS_SMS_ATN, KCS_STATUS_SMS_ATN);
55ab48b4 AJ	429	break;
	430
	431	case IPMI_BMC_IOCTL_CLEAR_SMS_ATN:
d4e7ac68	432	kcs_bmc_update_status(priv->client.dev, KCS_STATUS_SMS_ATN, 0);
55ab48b4 AJ	433	break;
	434
	435	case IPMI_BMC_IOCTL_FORCE_ABORT:
d4e7ac68	436	kcs_bmc_ipmi_force_abort(priv);
55ab48b4 AJ	437	break;
	438
	439	default:
	440	ret = -EINVAL;
	441	break;
	442	}
	443
d4e7ac68	444	spin_unlock_irq(&priv->lock);
55ab48b4 AJ	445
	446	return ret;
	447	}
	448
	449	static int kcs_bmc_ipmi_release(struct inode inode, struct file filp)
	450	{
d4e7ac68	451	struct kcs_bmc_ipmi *priv = to_kcs_bmc(filp);
55ab48b4	452
d4e7ac68 AJ	453	kcs_bmc_ipmi_force_abort(priv);
d4e7ac68 AJ	454	kcs_bmc_disable_device(priv->client.dev, &priv->client);
55ab48b4 AJ	455
	456	return 0;
	457	}
	458
d7096970	459	static const struct file_operations kcs_bmc_ipmi_fops = {
55ab48b4 AJ	460	.owner = THIS_MODULE,
	461	.open = kcs_bmc_ipmi_open,
	462	.read = kcs_bmc_ipmi_read,
	463	.write = kcs_bmc_ipmi_write,
	464	.release = kcs_bmc_ipmi_release,
	465	.poll = kcs_bmc_ipmi_poll,
	466	.unlocked_ioctl = kcs_bmc_ipmi_ioctl,
	467	};
	468
d4e7ac68 AJ	469	static DEFINE_SPINLOCK(kcs_bmc_ipmi_instances_lock);
	470	static LIST_HEAD(kcs_bmc_ipmi_instances);
	471
7cafff99	472	static int kcs_bmc_ipmi_add_device(struct kcs_bmc_device *kcs_bmc)
55ab48b4	473	{
d4e7ac68	474	struct kcs_bmc_ipmi *priv;
d7096970	475	int rc;
55ab48b4	476
d4e7ac68 AJ	477	priv = devm_kzalloc(kcs_bmc->dev, sizeof(*priv), GFP_KERNEL);
d4e7ac68 AJ	478	if (!priv)
d7096970 AJ	479	return -ENOMEM;
d7096970 AJ	480
d4e7ac68 AJ	481	spin_lock_init(&priv->lock);
	482	mutex_init(&priv->mutex);
	483
	484	init_waitqueue_head(&priv->queue);
d7096970	485
d4e7ac68 AJ	486	priv->client.dev = kcs_bmc;
	487	priv->client.ops = &kcs_bmc_ipmi_client_ops;
	488	priv->data_in = devm_kmalloc(kcs_bmc->dev, KCS_MSG_BUFSIZ, GFP_KERNEL);
	489	priv->data_out = devm_kmalloc(kcs_bmc->dev, KCS_MSG_BUFSIZ, GFP_KERNEL);
	490	priv->kbuffer = devm_kmalloc(kcs_bmc->dev, KCS_MSG_BUFSIZ, GFP_KERNEL);
	491
	492	priv->miscdev.minor = MISC_DYNAMIC_MINOR;
	493	priv->miscdev.name = devm_kasprintf(kcs_bmc->dev, GFP_KERNEL, "%s%u", DEVICE_NAME,
	494	kcs_bmc->channel);
	495	if (!priv->data_in \|\| !priv->data_out \|\| !priv->kbuffer \|\| !priv->miscdev.name)
	496	return -EINVAL;
	497
	498	priv->miscdev.fops = &kcs_bmc_ipmi_fops;
	499
	500	rc = misc_register(&priv->miscdev);
d7096970 AJ	501	if (rc) {
	502	dev_err(kcs_bmc->dev, "Unable to register device: %d\n", rc);
	503	return rc;
	504	}
	505
d4e7ac68 AJ	506	spin_lock_irq(&kcs_bmc_ipmi_instances_lock);
	507	list_add(&priv->entry, &kcs_bmc_ipmi_instances);
	508	spin_unlock_irq(&kcs_bmc_ipmi_instances_lock);
	509
d7096970 AJ	510	dev_info(kcs_bmc->dev, "Initialised IPMI client for channel %d", kcs_bmc->channel);
	511
	512	return 0;
	513	}
55ab48b4	514
7cafff99	515	static int kcs_bmc_ipmi_remove_device(struct kcs_bmc_device *kcs_bmc)
d7096970	516	{
d4e7ac68 AJ	517	struct kcs_bmc_ipmi priv = NULL, pos;
	518
	519	spin_lock_irq(&kcs_bmc_ipmi_instances_lock);
	520	list_for_each_entry(pos, &kcs_bmc_ipmi_instances, entry) {
	521	if (pos->client.dev == kcs_bmc) {
	522	priv = pos;
	523	list_del(&pos->entry);
	524	break;
	525	}
	526	}
	527	spin_unlock_irq(&kcs_bmc_ipmi_instances_lock);
d7096970	528
d4e7ac68 AJ	529	if (!priv)
d4e7ac68 AJ	530	return -ENODEV;
d7096970	531
d4e7ac68 AJ	532	misc_deregister(&priv->miscdev);
	533	kcs_bmc_disable_device(priv->client.dev, &priv->client);
	534	devm_kfree(kcs_bmc->dev, priv->kbuffer);
	535	devm_kfree(kcs_bmc->dev, priv->data_out);
	536	devm_kfree(kcs_bmc->dev, priv->data_in);
	537	devm_kfree(kcs_bmc->dev, priv);
d7096970 AJ	538
d7096970 AJ	539	return 0;
55ab48b4	540	}
7cafff99 AJ	541
	542	static const struct kcs_bmc_driver_ops kcs_bmc_ipmi_driver_ops = {
	543	.add_device = kcs_bmc_ipmi_add_device,
	544	.remove_device = kcs_bmc_ipmi_remove_device,
	545	};
	546
	547	static struct kcs_bmc_driver kcs_bmc_ipmi_driver = {
	548	.ops = &kcs_bmc_ipmi_driver_ops,
	549	};
	550
ec7174f6	551	static int __init kcs_bmc_ipmi_init(void)
7cafff99 AJ	552	{
	553	kcs_bmc_register_driver(&kcs_bmc_ipmi_driver);
	554
	555	return 0;
	556	}
	557	module_init(kcs_bmc_ipmi_init);
	558
ec7174f6	559	static void __exit kcs_bmc_ipmi_exit(void)
7cafff99 AJ	560	{
	561	kcs_bmc_unregister_driver(&kcs_bmc_ipmi_driver);
	562	}
	563	module_exit(kcs_bmc_ipmi_exit);
55ab48b4 AJ	564
	565	MODULE_LICENSE("GPL v2");
	566	MODULE_AUTHOR("Haiyue Wang <haiyue.wang@linux.intel.com>");
d4e7ac68	567	MODULE_AUTHOR("Andrew Jeffery <andrew@aj.id.au>");
55ab48b4	568	MODULE_DESCRIPTION("KCS BMC to handle the IPMI request from system software");