Merge tag 'for-linus-6.2-1' of https://github.com/cminyard/linux-ipmi

Pull IPMI updates from Corey Minyard: "This includes a number of small fixes, as usual. It also includes a new driver for doing the i2c (SSIF) interface BMC-side, pretty much completing the BMC side interfaces" * tag 'for-linus-6.2-1' of https://github.com/cminyard/linux-ipmi: ipmi/watchdog: use strscpy() to instead of strncpy() ipmi: ssif_bmc: Convert to i2c's .probe_new() ipmi: fix use after free in _ipmi_destroy_user() ipmi/watchdog: Include <linux/kstrtox.h> when appropriate ipmi:ssif: Increase the message retry time ipmi: Fix some kernel-doc warnings ipmi: ssif_bmc: Use EPOLLIN instead of POLLIN ipmi: fix msg stack when IPMI is disconnected ipmi: fix memleak when unload ipmi driver ipmi: fix long wait in unload when IPMI disconnect ipmi: kcs: Poll OBF briefly to reduce OBE latency bindings: ipmi: Add binding for SSIF BMC driver ipmi: ssif_bmc: Add SSIF BMC driver

Linus Torvalds committed 3 years ago

Commit 90b12f42 parents 2043f9a c6f613e11 files · +1004 −23Browse files

Unified · Split

11 files

Documentation/devicetree/bindings/ipmi/ssif-bmc.yaml +38 −0
drivers/char/ipmi/Kconfig +10 −0
drivers/char/ipmi/Makefile +1 −0
drivers/char/ipmi/ipmi_kcs_sm.c +11 −5
drivers/char/ipmi/ipmi_msghandler.c +10 −4
drivers/char/ipmi/ipmi_si_intf.c +19 −8
drivers/char/ipmi/ipmi_ssif.c +1 −1
drivers/char/ipmi/ipmi_watchdog.c +2 −2
drivers/char/ipmi/kcs_bmc_aspeed.c +21 −3
drivers/char/ipmi/ssif_bmc.c +873 −0
include/uapi/linux/ipmi_ssif_bmc.h +18 −0

Documentation/devicetree/bindings/ipmi/ssif-bmc.yaml+38−0

@@ -0,0 +1,38 @@
	1	+# SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause)
	2	+%YAML 1.2
	3	+---
	4	+$id: http://devicetree.org/schemas/ipmi/ssif-bmc.yaml#
	5	+$schema: http://devicetree.org/meta-schemas/core.yaml#
	6	+
	7	+title: SSIF IPMI BMC interface
	8	+
	9	+description: SSIF IPMI BMC device bindings
	10	+
	11	+maintainers:
	12	+ - Quan Nguyen <quan@os.amperecomputing.com>
	13	+
	14	+properties:
	15	+ compatible:
	16	+ enum:
	17	+ - ssif-bmc
	18	+
	19	+ reg:
	20	+ maxItems: 1
	21	+
	22	+required:
	23	+ - compatible
	24	+ - reg
	25	+
	26	+additionalProperties: false
	27	+
	28	+examples:
	29	+ - \|
	30	+ i2c {
	31	+ #address-cells = <1>;
	32	+ #size-cells = <0>;
	33	+
	34	+ ssif-bmc@10 {
	35	+ compatible = "ssif-bmc";
	36	+ reg = <0x10>;
	37	+ };
	38	+ };

drivers/char/ipmi/Kconfig+10−0

@@ -169,6 +169,16 @@ config ASPEED_BT_IPMI_BMC · 168 unmodified lines
169	169	found on Aspeed SOCs (AST2400 and AST2500). The driver
170	170	implements the BMC side of the BT interface.
171	171
	172	+config SSIF_IPMI_BMC
	173	+ tristate "SSIF IPMI BMC driver"
	174	+ depends on I2C && I2C_SLAVE
	175	+ help
	176	+ This enables the IPMI SMBus system interface (SSIF) at the
	177	+ management (BMC) side.
	178	+
	179	+ The driver implements the BMC side of the SMBus system
	180	+ interface (SSIF).
	181	+
172	182	config IPMB_DEVICE_INTERFACE
173	183	tristate 'IPMB Interface handler'
174	184	depends on I2C

drivers/char/ipmi/Makefile+1−0

@@ -30,3 +30,4 @@ obj-$(CONFIG_ASPEED_BT_IPMI_BMC) += bt-bmc.o · 29 unmodified lines
30	30	obj-$(CONFIG_ASPEED_KCS_IPMI_BMC) += kcs_bmc_aspeed.o
31	31	obj-$(CONFIG_NPCM7XX_KCS_IPMI_BMC) += kcs_bmc_npcm7xx.o
32	32	obj-$(CONFIG_IPMB_DEVICE_INTERFACE) += ipmb_dev_int.o
	33	+obj-$(CONFIG_SSIF_IPMI_BMC) += ssif_bmc.o

drivers/char/ipmi/ipmi_kcs_sm.c+11−5

@@ -122,10 +122,10 @@ struct si_sm_data { · 121 unmodified lines
122	122	unsigned long error0_timeout;
123	123	};
124	124
125		−static unsigned int init_kcs_data(struct si_sm_data *kcs,
126		− struct si_sm_io *io)
	125	+static unsigned int init_kcs_data_with_state(struct si_sm_data *kcs,
	126	+ struct si_sm_io *io, enum kcs_states state)
127	127	{
128		− kcs->state = KCS_IDLE;
	128	+ kcs->state = state;
129	129	kcs->io = io;
130	130	kcs->write_pos = 0;
131	131	kcs->write_count = 0;
@@ -140,6 +140,12 @@ static unsigned int init_kcs_data(struct si_sm_data *kcs, · 8 unmodified lines
140	140	return 2;
141	141	}
142	142
	143	+static unsigned int init_kcs_data(struct si_sm_data *kcs,
	144	+ struct si_sm_io *io)
	145	+{
	146	+ return init_kcs_data_with_state(kcs, io, KCS_IDLE);
	147	+}
	148	+
143	149	static inline unsigned char read_status(struct si_sm_data *kcs)
144	150	{
145	151	return kcs->io->inputb(kcs->io, 1);
@@ -270,7 +276,7 @@ static int start_kcs_transaction(struct si_sm_data kcs, unsigned char data, · 124 unmodified lines
270	276	if (size > MAX_KCS_WRITE_SIZE)
271	277	return IPMI_REQ_LEN_EXCEEDED_ERR;
272	278
273		− if ((kcs->state != KCS_IDLE) && (kcs->state != KCS_HOSED)) {
	279	+ if (kcs->state != KCS_IDLE) {
274	280	dev_warn(kcs->io->dev, "KCS in invalid state %d\n", kcs->state);
275	281	return IPMI_NOT_IN_MY_STATE_ERR;
276	282	}
@@ -495,7 +501,7 @@ static enum si_sm_result kcs_event(struct si_sm_data *kcs, long time) · 218 unmodified lines
495	501	}
496	502
497	503	if (kcs->state == KCS_HOSED) {
498		− init_kcs_data(kcs, kcs->io);
	504	+ init_kcs_data_with_state(kcs, kcs->io, KCS_ERROR0);
499	505	return SI_SM_HOSED;
500	506	}
501	507

drivers/char/ipmi/ipmi_msghandler.c+10−4

@@ -614,7 +614,7 @@ static int __ipmi_bmc_register(struct ipmi_smi *intf, · 613 unmodified lines
614	614	static int __scan_channels(struct ipmi_smi intf, struct ipmi_device_id id);
615	615
616	616
617		−/**
	617	+/*
618	618	* The driver model view of the IPMI messaging driver.
619	619	*/
620	620	static struct platform_driver ipmidriver = {
@@ -1330,6 +1330,7 @@ static void _ipmi_destroy_user(struct ipmi_user *user) · 709 unmodified lines
1330	1330	unsigned long flags;
1331	1331	struct cmd_rcvr *rcvr;
1332	1332	struct cmd_rcvr *rcvrs = NULL;
	1333	+ struct module *owner;
1333	1334
1334	1335	if (!acquire_ipmi_user(user, &i)) {
1335	1336	/*
@@ -1392,8 +1393,9 @@ static void _ipmi_destroy_user(struct ipmi_user *user) · 56 unmodified lines
1392	1393	kfree(rcvr);
1393	1394	}
1394	1395
	1396	+ owner = intf->owner;
1395	1397	kref_put(&intf->refcount, intf_free);
1396		− module_put(intf->owner);
	1398	+ module_put(owner);
1397	1399	}
1398	1400
1399	1401	int ipmi_destroy_user(struct ipmi_user *user)
@@ -3704,12 +3706,16 @@ static void deliver_smi_err_response(struct ipmi_smi *intf, · 2304 unmodified lines
3704	3706	struct ipmi_smi_msg *msg,
3705	3707	unsigned char err)
3706	3708	{
	3709	+ int rv;
3707	3710	msg->rsp[0] = msg->data[0] \| 4;
3708	3711	msg->rsp[1] = msg->data[1];
3709	3712	msg->rsp[2] = err;
3710	3713	msg->rsp_size = 3;
3711		− /* It's an error, so it will never requeue, no need to check return. */
3712		− handle_one_recv_msg(intf, msg);
	3714	+
	3715	+ /* This will never requeue, but it may ask us to free the message. */
	3716	+ rv = handle_one_recv_msg(intf, msg);
	3717	+ if (rv == 0)
	3718	+ ipmi_free_smi_msg(msg);
3713	3719	}
3714	3720
3715	3721	static void cleanup_smi_msgs(struct ipmi_smi *intf)

drivers/char/ipmi/ipmi_si_intf.c+19−8

@@ -2153,6 +2153,20 @@ skip_fallback_noirq: · 2152 unmodified lines
2153	2153	}
2154	2154	module_init(init_ipmi_si);
2155	2155
	2156	+static void wait_msg_processed(struct smi_info *smi_info)
	2157	+{
	2158	+ unsigned long jiffies_now;
	2159	+ long time_diff;
	2160	+
	2161	+ while (smi_info->curr_msg \|\| (smi_info->si_state != SI_NORMAL)) {
	2162	+ jiffies_now = jiffies;
	2163	+ time_diff = (((long)jiffies_now - (long)smi_info->last_timeout_jiffies)
	2164	+ * SI_USEC_PER_JIFFY);
	2165	+ smi_event_handler(smi_info, time_diff);
	2166	+ schedule_timeout_uninterruptible(1);
	2167	+ }
	2168	+}
	2169	+
2156	2170	static void shutdown_smi(void *send_info)
2157	2171	{
2158	2172	struct smi_info *smi_info = send_info;
@@ -2187,16 +2201,13 @@ static void shutdown_smi(void *send_info) · 28 unmodified lines
2187	2201	* in the BMC. Note that timers and CPU interrupts are off,
2188	2202	* so no need for locks.
2189	2203	*/
2190		− while (smi_info->curr_msg \|\| (smi_info->si_state != SI_NORMAL)) {
2191		− poll(smi_info);
2192		− schedule_timeout_uninterruptible(1);
2193		− }
	2204	+ wait_msg_processed(smi_info);
	2205	+
2194	2206	if (smi_info->handlers)
2195	2207	disable_si_irq(smi_info);
2196		− while (smi_info->curr_msg \|\| (smi_info->si_state != SI_NORMAL)) {
2197		− poll(smi_info);
2198		− schedule_timeout_uninterruptible(1);
2199		− }
	2208	+
	2209	+ wait_msg_processed(smi_info);
	2210	+
2200	2211	if (smi_info->handlers)
2201	2212	smi_info->handlers->cleanup(smi_info->si_sm);
2202	2213

drivers/char/ipmi/ipmi_ssif.c+1−1

@@ -74,7 +74,7 @@ · 73 unmodified lines
74	74	/*
75	75	* Timer values
76	76	*/
77		−#define SSIF_MSG_USEC 20000 /* 20ms between message tries. */
	77	+#define SSIF_MSG_USEC 60000 /* 60ms between message tries. */
78	78	#define SSIF_MSG_PART_USEC 5000 /* 5ms for a message part */
79	79
80	80	/* How many times to we retry sending/receiving the message. */

drivers/char/ipmi/ipmi_watchdog.c+2−2

@@ -23,6 +23,7 @@ · 22 unmodified lines
23	23	#include <linux/init.h>
24	24	#include <linux/completion.h>
25	25	#include <linux/kdebug.h>
	26	+#include <linux/kstrtox.h>
26	27	#include <linux/rwsem.h>
27	28	#include <linux/errno.h>
28	29	#include <linux/uaccess.h>
@@ -212,8 +213,7 @@ static int set_param_str(const char val, const struct kernel_param kp) · 183 unmodified lines
212	213	char valcp[16];
213	214	char *s;
214	215
215		− strncpy(valcp, val, 15);
216		− valcp[15] = '\0';
	216	+ strscpy(valcp, val, 16);
217	217
218	218	s = strstrip(valcp);
219	219

drivers/char/ipmi/kcs_bmc_aspeed.c+21−3

@@ -406,13 +406,31 @@ static void aspeed_kcs_check_obe(struct timer_list *timer) · 405 unmodified lines
406	406	static void aspeed_kcs_irq_mask_update(struct kcs_bmc_device *kcs_bmc, u8 mask, u8 state)
407	407	{
408	408	struct aspeed_kcs_bmc *priv = to_aspeed_kcs_bmc(kcs_bmc);
	409	+ int rc;
	410	+ u8 str;
409	411
410	412	/* We don't have an OBE IRQ, emulate it */
411	413	if (mask & KCS_BMC_EVENT_TYPE_OBE) {
412		− if (KCS_BMC_EVENT_TYPE_OBE & state)
413		− mod_timer(&priv->obe.timer, jiffies + OBE_POLL_PERIOD);
414		− else
	414	+ if (KCS_BMC_EVENT_TYPE_OBE & state) {
	415	+ /*
	416	+ * Given we don't have an OBE IRQ, delay by polling briefly to see if we can
	417	+ * observe such an event before returning to the caller. This is not
	418	+ * incorrect because OBF may have already become clear before enabling the
	419	+ * IRQ if we had one, under which circumstance no event will be propagated
	420	+ * anyway.
	421	+ *
	422	+ * The onus is on the client to perform a race-free check that it hasn't
	423	+ * missed the event.
	424	+ */
	425	+ rc = read_poll_timeout_atomic(aspeed_kcs_inb, str,
	426	+ !(str & KCS_BMC_STR_OBF), 1, 100, false,
	427	+ &priv->kcs_bmc, priv->kcs_bmc.ioreg.str);
	428	+ /* Time for the slow path? */
	429	+ if (rc == -ETIMEDOUT)
	430	+ mod_timer(&priv->obe.timer, jiffies + OBE_POLL_PERIOD);
	431	+ } else {
415	432	del_timer(&priv->obe.timer);
	433	+ }
416	434	}
417	435
418	436	if (mask & KCS_BMC_EVENT_TYPE_IBF) {

drivers/char/ipmi/ssif_bmc.c+873−0

@@ -0,0 +1,873 @@
	1	+// SPDX-License-Identifier: GPL-2.0-only
	2	+/*
	3	+ * The driver for BMC side of SSIF interface
	4	+ *
	5	+ * Copyright (c) 2022, Ampere Computing LLC
	6	+ *
	7	+ */
	8	+
	9	+#include <linux/i2c.h>
	10	+#include <linux/miscdevice.h>
	11	+#include <linux/module.h>
	12	+#include <linux/of.h>
	13	+#include <linux/platform_device.h>
	14	+#include <linux/poll.h>
	15	+#include <linux/sched.h>
	16	+#include <linux/mutex.h>
	17	+#include <linux/spinlock.h>
	18	+#include <linux/timer.h>
	19	+#include <linux/jiffies.h>
	20	+#include <linux/ipmi_ssif_bmc.h>
	21	+
	22	+#define DEVICE_NAME "ipmi-ssif-host"
	23	+
	24	+#define GET_8BIT_ADDR(addr_7bit) (((addr_7bit) << 1) & 0xff)
	25	+
	26	+/* A standard SMBus Transaction is limited to 32 data bytes */
	27	+#define MAX_PAYLOAD_PER_TRANSACTION 32
	28	+/* Transaction includes the address, the command, the length and the PEC byte */
	29	+#define MAX_TRANSACTION (MAX_PAYLOAD_PER_TRANSACTION + 4)
	30	+
	31	+#define MAX_IPMI_DATA_PER_START_TRANSACTION 30
	32	+#define MAX_IPMI_DATA_PER_MIDDLE_TRANSACTION 31
	33	+
	34	+#define SSIF_IPMI_SINGLEPART_WRITE 0x2
	35	+#define SSIF_IPMI_SINGLEPART_READ 0x3
	36	+#define SSIF_IPMI_MULTIPART_WRITE_START 0x6
	37	+#define SSIF_IPMI_MULTIPART_WRITE_MIDDLE 0x7
	38	+#define SSIF_IPMI_MULTIPART_WRITE_END 0x8
	39	+#define SSIF_IPMI_MULTIPART_READ_START 0x3
	40	+#define SSIF_IPMI_MULTIPART_READ_MIDDLE 0x9
	41	+
	42	+/*
	43	+ * IPMI 2.0 Spec, section 12.7 SSIF Timing,
	44	+ * Request-to-Response Time is T6max(250ms) - T1max(20ms) - 3ms = 227ms
	45	+ * Recover ssif_bmc from busy state if it takes up to 500ms
	46	+ */
	47	+#define RESPONSE_TIMEOUT 500 /* ms */
	48	+
	49	+struct ssif_part_buffer {
	50	+ u8 address;
	51	+ u8 smbus_cmd;
	52	+ u8 length;
	53	+ u8 payload[MAX_PAYLOAD_PER_TRANSACTION];
	54	+ u8 pec;
	55	+ u8 index;
	56	+};
	57	+
	58	+/*
	59	+ * SSIF internal states:
	60	+ * SSIF_READY 0x00 : Ready state
	61	+ * SSIF_START 0x01 : Start smbus transaction
	62	+ * SSIF_SMBUS_CMD 0x02 : Received SMBus command
	63	+ * SSIF_REQ_RECVING 0x03 : Receiving request
	64	+ * SSIF_RES_SENDING 0x04 : Sending response
	65	+ * SSIF_ABORTING 0x05 : Aborting state
	66	+ */
	67	+enum ssif_state {
	68	+ SSIF_READY,
	69	+ SSIF_START,
	70	+ SSIF_SMBUS_CMD,
	71	+ SSIF_REQ_RECVING,
	72	+ SSIF_RES_SENDING,
	73	+ SSIF_ABORTING,
	74	+ SSIF_STATE_MAX
	75	+};
	76	+
	77	+struct ssif_bmc_ctx {
	78	+ struct i2c_client *client;
	79	+ struct miscdevice miscdev;
	80	+ int msg_idx;
	81	+ bool pec_support;
	82	+ /* ssif bmc spinlock */
	83	+ spinlock_t lock;
	84	+ wait_queue_head_t wait_queue;
	85	+ u8 running;
	86	+ enum ssif_state state;
	87	+ /* Timeout waiting for response */
	88	+ struct timer_list response_timer;
	89	+ bool response_timer_inited;
	90	+ /* Flag to identify a Multi-part Read Transaction */
	91	+ bool is_singlepart_read;
	92	+ u8 nbytes_processed;
	93	+ u8 remain_len;
	94	+ u8 recv_len;
	95	+ /* Block Number of a Multi-part Read Transaction */
	96	+ u8 block_num;
	97	+ bool request_available;
	98	+ bool response_in_progress;
	99	+ bool busy;
	100	+ bool aborting;
	101	+ /* Buffer for SSIF Transaction part*/
	102	+ struct ssif_part_buffer part_buf;
	103	+ struct ipmi_ssif_msg response;
	104	+ struct ipmi_ssif_msg request;
	105	+};
	106	+
	107	+static inline struct ssif_bmc_ctx to_ssif_bmc(struct file file)
	108	+{
	109	+ return container_of(file->private_data, struct ssif_bmc_ctx, miscdev);
	110	+}
	111	+
	112	+static const char *state_to_string(enum ssif_state state)
	113	+{
	114	+ switch (state) {
	115	+ case SSIF_READY:
	116	+ return "SSIF_READY";
	117	+ case SSIF_START:
	118	+ return "SSIF_START";
	119	+ case SSIF_SMBUS_CMD:
	120	+ return "SSIF_SMBUS_CMD";
	121	+ case SSIF_REQ_RECVING:
	122	+ return "SSIF_REQ_RECVING";
	123	+ case SSIF_RES_SENDING:
	124	+ return "SSIF_RES_SENDING";
	125	+ case SSIF_ABORTING:
	126	+ return "SSIF_ABORTING";
	127	+ default:
	128	+ return "SSIF_STATE_UNKNOWN";
	129	+ }
	130	+}
	131	+
	132	+/* Handle SSIF message that will be sent to user */
	133	+static ssize_t ssif_bmc_read(struct file file, char __user buf, size_t count, loff_t *ppos)
	134	+{
	135	+ struct ssif_bmc_ctx *ssif_bmc = to_ssif_bmc(file);
	136	+ struct ipmi_ssif_msg msg;
	137	+ unsigned long flags;
	138	+ ssize_t ret;
	139	+
	140	+ spin_lock_irqsave(&ssif_bmc->lock, flags);
	141	+ while (!ssif_bmc->request_available) {
	142	+ spin_unlock_irqrestore(&ssif_bmc->lock, flags);
	143	+ if (file->f_flags & O_NONBLOCK)
	144	+ return -EAGAIN;
	145	+ ret = wait_event_interruptible(ssif_bmc->wait_queue,
	146	+ ssif_bmc->request_available);
	147	+ if (ret)
	148	+ return ret;
	149	+ spin_lock_irqsave(&ssif_bmc->lock, flags);
	150	+ }
	151	+
	152	+ if (count < min_t(ssize_t,
	153	+ sizeof_field(struct ipmi_ssif_msg, len) + ssif_bmc->request.len,
	154	+ sizeof(struct ipmi_ssif_msg))) {
	155	+ spin_unlock_irqrestore(&ssif_bmc->lock, flags);
	156	+ ret = -EINVAL;
	157	+ } else {
	158	+ count = min_t(ssize_t,
	159	+ sizeof_field(struct ipmi_ssif_msg, len) + ssif_bmc->request.len,
	160	+ sizeof(struct ipmi_ssif_msg));
	161	+ memcpy(&msg, &ssif_bmc->request, count);
	162	+ ssif_bmc->request_available = false;
	163	+ spin_unlock_irqrestore(&ssif_bmc->lock, flags);
	164	+
	165	+ ret = copy_to_user(buf, &msg, count);
	166	+ }
	167	+
	168	+ return (ret < 0) ? ret : count;
	169	+}
	170	+
	171	+/* Handle SSIF message that is written by user */
	172	+static ssize_t ssif_bmc_write(struct file file, const char __user buf, size_t count,
	173	+ loff_t *ppos)
	174	+{
	175	+ struct ssif_bmc_ctx *ssif_bmc = to_ssif_bmc(file);
	176	+ struct ipmi_ssif_msg msg;
	177	+ unsigned long flags;
	178	+ ssize_t ret;
	179	+
	180	+ if (count > sizeof(struct ipmi_ssif_msg))
	181	+ return -EINVAL;
	182	+
	183	+ if (copy_from_user(&msg, buf, count))
	184	+ return -EFAULT;
	185	+
	186	+ if (!msg.len \|\| count < sizeof_field(struct ipmi_ssif_msg, len) + msg.len)
	187	+ return -EINVAL;
	188	+
	189	+ spin_lock_irqsave(&ssif_bmc->lock, flags);
	190	+ while (ssif_bmc->response_in_progress) {
	191	+ spin_unlock_irqrestore(&ssif_bmc->lock, flags);
	192	+ if (file->f_flags & O_NONBLOCK)
	193	+ return -EAGAIN;
	194	+ ret = wait_event_interruptible(ssif_bmc->wait_queue,
	195	+ !ssif_bmc->response_in_progress);
	196	+ if (ret)
	197	+ return ret;
	198	+ spin_lock_irqsave(&ssif_bmc->lock, flags);
	199	+ }
	200	+
	201	+ /*
	202	+ * The write must complete before the response timeout fired, otherwise
	203	+ * the response is aborted and wait for next request
	204	+ * Return -EINVAL if the response is aborted
	205	+ */
	206	+ ret = (ssif_bmc->response_timer_inited) ? 0 : -EINVAL;
	207	+ if (ret)
	208	+ goto exit;
	209	+
	210	+ del_timer(&ssif_bmc->response_timer);
	211	+ ssif_bmc->response_timer_inited = false;
	212	+
	213	+ memcpy(&ssif_bmc->response, &msg, count);
	214	+ ssif_bmc->is_singlepart_read = (msg.len <= MAX_PAYLOAD_PER_TRANSACTION);
	215	+
	216	+ ssif_bmc->response_in_progress = true;
	217	+
	218	+ /* ssif_bmc not busy */
	219	+ ssif_bmc->busy = false;
	220	+
	221	+ /* Clean old request buffer */
	222	+ memset(&ssif_bmc->request, 0, sizeof(struct ipmi_ssif_msg));
	223	+exit:
	224	+ spin_unlock_irqrestore(&ssif_bmc->lock, flags);
	225	+
	226	+ return (ret < 0) ? ret : count;
	227	+}
	228	+
	229	+static int ssif_bmc_open(struct inode inode, struct file file)
	230	+{
	231	+ struct ssif_bmc_ctx *ssif_bmc = to_ssif_bmc(file);
	232	+ int ret = 0;
	233	+
	234	+ spin_lock_irq(&ssif_bmc->lock);
	235	+ if (!ssif_bmc->running)
	236	+ ssif_bmc->running = 1;
	237	+ else
	238	+ ret = -EBUSY;
	239	+ spin_unlock_irq(&ssif_bmc->lock);
	240	+
	241	+ return ret;
	242	+}
	243	+
	244	+static __poll_t ssif_bmc_poll(struct file file, poll_table wait)
	245	+{
	246	+ struct ssif_bmc_ctx *ssif_bmc = to_ssif_bmc(file);
	247	+ __poll_t mask = 0;
	248	+
	249	+ poll_wait(file, &ssif_bmc->wait_queue, wait);
	250	+
	251	+ spin_lock_irq(&ssif_bmc->lock);
	252	+ /* The request is available, userspace application can get the request */
	253	+ if (ssif_bmc->request_available)
	254	+ mask \|= EPOLLIN;
	255	+
	256	+ spin_unlock_irq(&ssif_bmc->lock);
	257	+
	258	+ return mask;
	259	+}
	260	+
	261	+static int ssif_bmc_release(struct inode inode, struct file file)
	262	+{
	263	+ struct ssif_bmc_ctx *ssif_bmc = to_ssif_bmc(file);
	264	+
	265	+ spin_lock_irq(&ssif_bmc->lock);
	266	+ ssif_bmc->running = 0;
	267	+ spin_unlock_irq(&ssif_bmc->lock);
	268	+
	269	+ return 0;
	270	+}
	271	+
	272	+/*
	273	+ * System calls to device interface for user apps
	274	+ */
	275	+static const struct file_operations ssif_bmc_fops = {
	276	+ .owner = THIS_MODULE,
	277	+ .open = ssif_bmc_open,
	278	+ .read = ssif_bmc_read,
	279	+ .write = ssif_bmc_write,
	280	+ .release = ssif_bmc_release,
	281	+ .poll = ssif_bmc_poll,
	282	+};
	283	+
	284	+/* Called with ssif_bmc->lock held. */
	285	+static void complete_response(struct ssif_bmc_ctx *ssif_bmc)
	286	+{
	287	+ /* Invalidate response in buffer to denote it having been sent. */
	288	+ ssif_bmc->response.len = 0;
	289	+ ssif_bmc->response_in_progress = false;
	290	+ ssif_bmc->nbytes_processed = 0;
	291	+ ssif_bmc->remain_len = 0;
	292	+ ssif_bmc->busy = false;
	293	+ memset(&ssif_bmc->part_buf, 0, sizeof(struct ssif_part_buffer));
	294	+ wake_up_all(&ssif_bmc->wait_queue);
	295	+}
	296	+
	297	+static void response_timeout(struct timer_list *t)
	298	+{
	299	+ struct ssif_bmc_ctx *ssif_bmc = from_timer(ssif_bmc, t, response_timer);
	300	+ unsigned long flags;
	301	+
	302	+ spin_lock_irqsave(&ssif_bmc->lock, flags);
	303	+
	304	+ /* Do nothing if the response is in progress */
	305	+ if (!ssif_bmc->response_in_progress) {
	306	+ /* Recover ssif_bmc from busy */
	307	+ ssif_bmc->busy = false;
	308	+ ssif_bmc->response_timer_inited = false;
	309	+ /* Set aborting flag */
	310	+ ssif_bmc->aborting = true;
	311	+ }
	312	+
	313	+ spin_unlock_irqrestore(&ssif_bmc->lock, flags);
	314	+}
	315	+
	316	+/* Called with ssif_bmc->lock held. */
	317	+static void handle_request(struct ssif_bmc_ctx *ssif_bmc)
	318	+{
	319	+ /* set ssif_bmc to busy waiting for response */
	320	+ ssif_bmc->busy = true;
	321	+ /* Request message is available to process */
	322	+ ssif_bmc->request_available = true;
	323	+ /* Clean old response buffer */
	324	+ memset(&ssif_bmc->response, 0, sizeof(struct ipmi_ssif_msg));
	325	+ /* This is the new READ request.*/
	326	+ wake_up_all(&ssif_bmc->wait_queue);
	327	+
	328	+ /* Armed timer to recover slave from busy state in case of no response */
	329	+ if (!ssif_bmc->response_timer_inited) {
	330	+ timer_setup(&ssif_bmc->response_timer, response_timeout, 0);
	331	+ ssif_bmc->response_timer_inited = true;
	332	+ }
	333	+ mod_timer(&ssif_bmc->response_timer, jiffies + msecs_to_jiffies(RESPONSE_TIMEOUT));
	334	+}
	335	+
	336	+static void calculate_response_part_pec(struct ssif_part_buffer *part)
	337	+{
	338	+ u8 addr = part->address;
	339	+
	340	+ /* PEC - Start Read Address */
	341	+ part->pec = i2c_smbus_pec(0, &addr, 1);
	342	+ /* PEC - SSIF Command */
	343	+ part->pec = i2c_smbus_pec(part->pec, &part->smbus_cmd, 1);
	344	+ /* PEC - Restart Write Address */
	345	+ addr = addr \| 0x01;
	346	+ part->pec = i2c_smbus_pec(part->pec, &addr, 1);
	347	+ part->pec = i2c_smbus_pec(part->pec, &part->length, 1);
	348	+ if (part->length)
	349	+ part->pec = i2c_smbus_pec(part->pec, part->payload, part->length);
	350	+}
	351	+
	352	+static void set_singlepart_response_buffer(struct ssif_bmc_ctx *ssif_bmc)
	353	+{
	354	+ struct ssif_part_buffer *part = &ssif_bmc->part_buf;
	355	+
	356	+ part->address = GET_8BIT_ADDR(ssif_bmc->client->addr);
	357	+ part->length = (u8)ssif_bmc->response.len;
	358	+
	359	+ /* Clear the rest to 0 */
	360	+ memset(part->payload + part->length, 0, MAX_PAYLOAD_PER_TRANSACTION - part->length);
	361	+ memcpy(&part->payload[0], &ssif_bmc->response.payload[0], part->length);
	362	+}
	363	+
	364	+static void set_multipart_response_buffer(struct ssif_bmc_ctx *ssif_bmc)
	365	+{
	366	+ struct ssif_part_buffer *part = &ssif_bmc->part_buf;
	367	+ u8 part_len = 0;
	368	+
	369	+ part->address = GET_8BIT_ADDR(ssif_bmc->client->addr);
	370	+ switch (part->smbus_cmd) {
	371	+ case SSIF_IPMI_MULTIPART_READ_START:
	372	+ /*
	373	+ * Read Start length is 32 bytes.
	374	+ * Read Start transfer first 30 bytes of IPMI response
	375	+ * and 2 special code 0x00, 0x01.
	376	+ */
	377	+ ssif_bmc->nbytes_processed = 0;
	378	+ ssif_bmc->block_num = 0;
	379	+ part->length = MAX_PAYLOAD_PER_TRANSACTION;
	380	+ part_len = MAX_IPMI_DATA_PER_START_TRANSACTION;
	381	+ ssif_bmc->remain_len = ssif_bmc->response.len - part_len;
	382	+
	383	+ part->payload[0] = 0x00; /* Start Flag */
	384	+ part->payload[1] = 0x01; /* Start Flag */
	385	+
	386	+ memcpy(&part->payload[2], &ssif_bmc->response.payload[0], part_len);
	387	+ break;
	388	+
	389	+ case SSIF_IPMI_MULTIPART_READ_MIDDLE:
	390	+ /*
	391	+ * IPMI READ Middle or READ End messages can carry up to 31 bytes
	392	+ * IPMI data plus block number byte.
	393	+ */
	394	+ if (ssif_bmc->remain_len <= MAX_IPMI_DATA_PER_MIDDLE_TRANSACTION) {
	395	+ /*
	396	+ * This is READ End message
	397	+ * Return length is the remaining response data length
	398	+ * plus block number
	399	+ * Block number 0xFF is to indicate this is last message
	400	+ *
	401	+ */
	402	+ /* Clean the buffer */
	403	+ memset(&part->payload[0], 0, MAX_PAYLOAD_PER_TRANSACTION);
	404	+ part->length = ssif_bmc->remain_len + 1;
	405	+ part_len = ssif_bmc->remain_len;
	406	+ ssif_bmc->block_num = 0xFF;
	407	+ part->payload[0] = ssif_bmc->block_num;
	408	+ } else {
	409	+ /*
	410	+ * This is READ Middle message
	411	+ * Response length is the maximum SMBUS transfer length
	412	+ * Block number byte is incremented
	413	+ * Return length is maximum SMBUS transfer length
	414	+ */
	415	+ part->length = MAX_PAYLOAD_PER_TRANSACTION;
	416	+ part_len = MAX_IPMI_DATA_PER_MIDDLE_TRANSACTION;
	417	+ part->payload[0] = ssif_bmc->block_num;
	418	+ ssif_bmc->block_num++;
	419	+ }
	420	+
	421	+ ssif_bmc->remain_len -= part_len;
	422	+ memcpy(&part->payload[1], ssif_bmc->response.payload + ssif_bmc->nbytes_processed,
	423	+ part_len);
	424	+ break;
	425	+
	426	+ default:
	427	+ /* Do not expect to go to this case */
	428	+ dev_err(&ssif_bmc->client->dev, "%s: Unexpected SMBus command 0x%x\n",
	429	+ __func__, part->smbus_cmd);
	430	+ break;
	431	+ }
	432	+
	433	+ ssif_bmc->nbytes_processed += part_len;
	434	+}
	435	+
	436	+static bool supported_read_cmd(u8 cmd)
	437	+{
	438	+ if (cmd == SSIF_IPMI_SINGLEPART_READ \|\|
	439	+ cmd == SSIF_IPMI_MULTIPART_READ_START \|\|
	440	+ cmd == SSIF_IPMI_MULTIPART_READ_MIDDLE)
	441	+ return true;
	442	+
	443	+ return false;
	444	+}
	445	+
	446	+static bool supported_write_cmd(u8 cmd)
	447	+{
	448	+ if (cmd == SSIF_IPMI_SINGLEPART_WRITE \|\|
	449	+ cmd == SSIF_IPMI_MULTIPART_WRITE_START \|\|
	450	+ cmd == SSIF_IPMI_MULTIPART_WRITE_MIDDLE \|\|
	451	+ cmd == SSIF_IPMI_MULTIPART_WRITE_END)
	452	+ return true;
	453	+
	454	+ return false;
	455	+}
	456	+
	457	+/* Process the IPMI response that will be read by master */
	458	+static void handle_read_processed(struct ssif_bmc_ctx ssif_bmc, u8 val)
	459	+{
	460	+ struct ssif_part_buffer *part = &ssif_bmc->part_buf;
	461	+
	462	+ /* msg_idx start from 0 */
	463	+ if (part->index < part->length)
	464	+ *val = part->payload[part->index];
	465	+ else if (part->index == part->length && ssif_bmc->pec_support)
	466	+ *val = part->pec;
	467	+ else
	468	+ *val = 0;
	469	+
	470	+ part->index++;
	471	+}
	472	+
	473	+static void handle_write_received(struct ssif_bmc_ctx ssif_bmc, u8 val)
	474	+{
	475	+ /*
	476	+ * The msg_idx must be 1 when first enter SSIF_REQ_RECVING state
	477	+ * And it would never exceeded 36 bytes included the 32 bytes max payload +
	478	+ * the address + the command + the len and the PEC.
	479	+ */
	480	+ if (ssif_bmc->msg_idx < 1 \|\| ssif_bmc->msg_idx > MAX_TRANSACTION)
	481	+ return;
	482	+
	483	+ if (ssif_bmc->msg_idx == 1) {
	484	+ ssif_bmc->part_buf.length = *val;
	485	+ ssif_bmc->part_buf.index = 0;
	486	+ } else {
	487	+ ssif_bmc->part_buf.payload[ssif_bmc->part_buf.index++] = *val;
	488	+ }
	489	+
	490	+ ssif_bmc->msg_idx++;
	491	+}
	492	+
	493	+static bool validate_request_part(struct ssif_bmc_ctx *ssif_bmc)
	494	+{
	495	+ struct ssif_part_buffer *part = &ssif_bmc->part_buf;
	496	+ bool ret = true;
	497	+ u8 cpec;
	498	+ u8 addr;
	499	+
	500	+ if (part->index == part->length) {
	501	+ /* PEC is not included */
	502	+ ssif_bmc->pec_support = false;
	503	+ ret = true;
	504	+ goto exit;
	505	+ }
	506	+
	507	+ if (part->index != part->length + 1) {
	508	+ ret = false;
	509	+ goto exit;
	510	+ }
	511	+
	512	+ /* PEC is included */
	513	+ ssif_bmc->pec_support = true;
	514	+ part->pec = part->payload[part->length];
	515	+ addr = GET_8BIT_ADDR(ssif_bmc->client->addr);
	516	+ cpec = i2c_smbus_pec(0, &addr, 1);
	517	+ cpec = i2c_smbus_pec(cpec, &part->smbus_cmd, 1);
	518	+ cpec = i2c_smbus_pec(cpec, &part->length, 1);
	519	+ /*
	520	+ * As SMBus specification does not allow the length
	521	+ * (byte count) in the Write-Block protocol to be zero.
	522	+ * Therefore, it is illegal to have the last Middle
	523	+ * transaction in the sequence carry 32-byte and have
	524	+ * a length of ‘0’ in the End transaction.
	525	+ * But some users may try to use this way and we should
	526	+ * prevent ssif_bmc driver broken in this case.
	527	+ */
	528	+ if (part->length)
	529	+ cpec = i2c_smbus_pec(cpec, part->payload, part->length);
	530	+
	531	+ if (cpec != part->pec)
	532	+ ret = false;
	533	+
	534	+exit:
	535	+ return ret;
	536	+}
	537	+
	538	+static void process_request_part(struct ssif_bmc_ctx *ssif_bmc)
	539	+{
	540	+ struct ssif_part_buffer *part = &ssif_bmc->part_buf;
	541	+ unsigned int len;
	542	+
	543	+ switch (part->smbus_cmd) {
	544	+ case SSIF_IPMI_SINGLEPART_WRITE:
	545	+ /* save the whole part to request*/
	546	+ ssif_bmc->request.len = part->length;
	547	+ memcpy(ssif_bmc->request.payload, part->payload, part->length);
	548	+
	549	+ break;
	550	+ case SSIF_IPMI_MULTIPART_WRITE_START:
	551	+ ssif_bmc->request.len = 0;
	552	+
	553	+ fallthrough;
	554	+ case SSIF_IPMI_MULTIPART_WRITE_MIDDLE:
	555	+ case SSIF_IPMI_MULTIPART_WRITE_END:
	556	+ len = ssif_bmc->request.len + part->length;
	557	+ /* Do the bound check here, not allow the request len exceed 254 bytes */
	558	+ if (len > IPMI_SSIF_PAYLOAD_MAX) {
	559	+ dev_warn(&ssif_bmc->client->dev,
	560	+ "Warn: Request exceeded 254 bytes, aborting");
	561	+ /* Request too long, aborting */
	562	+ ssif_bmc->aborting = true;
	563	+ } else {
	564	+ memcpy(ssif_bmc->request.payload + ssif_bmc->request.len,
	565	+ part->payload, part->length);
	566	+ ssif_bmc->request.len += part->length;
	567	+ }
	568	+ break;
	569	+ default:
	570	+ /* Do not expect to go to this case */
	571	+ dev_err(&ssif_bmc->client->dev, "%s: Unexpected SMBus command 0x%x\n",
	572	+ __func__, part->smbus_cmd);
	573	+ break;
	574	+ }
	575	+}
	576	+
	577	+static void process_smbus_cmd(struct ssif_bmc_ctx ssif_bmc, u8 val)
	578	+{
	579	+ /* SMBUS command can vary (single or multi-part) */
	580	+ ssif_bmc->part_buf.smbus_cmd = *val;
	581	+ ssif_bmc->msg_idx = 1;
	582	+ memset(&ssif_bmc->part_buf.payload[0], 0, MAX_PAYLOAD_PER_TRANSACTION);
	583	+
	584	+ if (val == SSIF_IPMI_SINGLEPART_WRITE \|\| val == SSIF_IPMI_MULTIPART_WRITE_START) {
	585	+ /*
	586	+ * The response maybe not come in-time, causing host SSIF driver
	587	+ * to timeout and resend a new request. In such case check for
	588	+ * pending response and clear it
	589	+ */
	590	+ if (ssif_bmc->response_in_progress)
	591	+ complete_response(ssif_bmc);
	592	+
	593	+ /* This is new request, flip aborting flag if set */
	594	+ if (ssif_bmc->aborting)
	595	+ ssif_bmc->aborting = false;
	596	+ }
	597	+}
	598	+
	599	+static void on_read_requested_event(struct ssif_bmc_ctx ssif_bmc, u8 val)
	600	+{
	601	+ if (ssif_bmc->state == SSIF_READY \|\|
	602	+ ssif_bmc->state == SSIF_START \|\|
	603	+ ssif_bmc->state == SSIF_REQ_RECVING \|\|
	604	+ ssif_bmc->state == SSIF_RES_SENDING) {
	605	+ dev_warn(&ssif_bmc->client->dev,
	606	+ "Warn: %s unexpected READ REQUESTED in state=%s\n",
	607	+ __func__, state_to_string(ssif_bmc->state));
	608	+ ssif_bmc->state = SSIF_ABORTING;
	609	+ *val = 0;
	610	+ return;
	611	+
	612	+ } else if (ssif_bmc->state == SSIF_SMBUS_CMD) {
	613	+ if (!supported_read_cmd(ssif_bmc->part_buf.smbus_cmd)) {
	614	+ dev_warn(&ssif_bmc->client->dev, "Warn: Unknown SMBus read command=0x%x",
	615	+ ssif_bmc->part_buf.smbus_cmd);
	616	+ ssif_bmc->aborting = true;
	617	+ }
	618	+
	619	+ if (ssif_bmc->aborting)
	620	+ ssif_bmc->state = SSIF_ABORTING;
	621	+ else
	622	+ ssif_bmc->state = SSIF_RES_SENDING;
	623	+ }
	624	+
	625	+ ssif_bmc->msg_idx = 0;
	626	+
	627	+ /* Send 0 if there is nothing to send */
	628	+ if (!ssif_bmc->response_in_progress \|\| ssif_bmc->state == SSIF_ABORTING) {
	629	+ *val = 0;
	630	+ return;
	631	+ }
	632	+
	633	+ if (ssif_bmc->is_singlepart_read)
	634	+ set_singlepart_response_buffer(ssif_bmc);
	635	+ else
	636	+ set_multipart_response_buffer(ssif_bmc);
	637	+
	638	+ calculate_response_part_pec(&ssif_bmc->part_buf);
	639	+ ssif_bmc->part_buf.index = 0;
	640	+ *val = ssif_bmc->part_buf.length;
	641	+}
	642	+
	643	+static void on_read_processed_event(struct ssif_bmc_ctx ssif_bmc, u8 val)
	644	+{
	645	+ if (ssif_bmc->state == SSIF_READY \|\|
	646	+ ssif_bmc->state == SSIF_START \|\|
	647	+ ssif_bmc->state == SSIF_REQ_RECVING \|\|
	648	+ ssif_bmc->state == SSIF_SMBUS_CMD) {
	649	+ dev_warn(&ssif_bmc->client->dev,
	650	+ "Warn: %s unexpected READ PROCESSED in state=%s\n",
	651	+ __func__, state_to_string(ssif_bmc->state));
	652	+ ssif_bmc->state = SSIF_ABORTING;
	653	+ *val = 0;
	654	+ return;
	655	+ }
	656	+
	657	+ /* Send 0 if there is nothing to send */
	658	+ if (!ssif_bmc->response_in_progress \|\| ssif_bmc->state == SSIF_ABORTING) {
	659	+ *val = 0;
	660	+ return;
	661	+ }
	662	+
	663	+ handle_read_processed(ssif_bmc, val);
	664	+}
	665	+
	666	+static void on_write_requested_event(struct ssif_bmc_ctx ssif_bmc, u8 val)
	667	+{
	668	+ if (ssif_bmc->state == SSIF_READY \|\| ssif_bmc->state == SSIF_SMBUS_CMD) {
	669	+ ssif_bmc->state = SSIF_START;
	670	+
	671	+ } else if (ssif_bmc->state == SSIF_START \|\|
	672	+ ssif_bmc->state == SSIF_REQ_RECVING \|\|
	673	+ ssif_bmc->state == SSIF_RES_SENDING) {
	674	+ dev_warn(&ssif_bmc->client->dev,
	675	+ "Warn: %s unexpected WRITE REQUEST in state=%s\n",
	676	+ __func__, state_to_string(ssif_bmc->state));
	677	+ ssif_bmc->state = SSIF_ABORTING;
	678	+ return;
	679	+ }
	680	+
	681	+ ssif_bmc->msg_idx = 0;
	682	+ ssif_bmc->part_buf.address = *val;
	683	+}
	684	+
	685	+static void on_write_received_event(struct ssif_bmc_ctx ssif_bmc, u8 val)
	686	+{
	687	+ if (ssif_bmc->state == SSIF_READY \|\|
	688	+ ssif_bmc->state == SSIF_RES_SENDING) {
	689	+ dev_warn(&ssif_bmc->client->dev,
	690	+ "Warn: %s unexpected WRITE RECEIVED in state=%s\n",
	691	+ __func__, state_to_string(ssif_bmc->state));
	692	+ ssif_bmc->state = SSIF_ABORTING;
	693	+
	694	+ } else if (ssif_bmc->state == SSIF_START) {
	695	+ ssif_bmc->state = SSIF_SMBUS_CMD;
	696	+
	697	+ } else if (ssif_bmc->state == SSIF_SMBUS_CMD) {
	698	+ if (!supported_write_cmd(ssif_bmc->part_buf.smbus_cmd)) {
	699	+ dev_warn(&ssif_bmc->client->dev, "Warn: Unknown SMBus write command=0x%x",
	700	+ ssif_bmc->part_buf.smbus_cmd);
	701	+ ssif_bmc->aborting = true;
	702	+ }
	703	+
	704	+ if (ssif_bmc->aborting)
	705	+ ssif_bmc->state = SSIF_ABORTING;
	706	+ else
	707	+ ssif_bmc->state = SSIF_REQ_RECVING;
	708	+ }
	709	+
	710	+ /* This is response sending state */
	711	+ if (ssif_bmc->state == SSIF_REQ_RECVING)
	712	+ handle_write_received(ssif_bmc, val);
	713	+ else if (ssif_bmc->state == SSIF_SMBUS_CMD)
	714	+ process_smbus_cmd(ssif_bmc, val);
	715	+}
	716	+
	717	+static void on_stop_event(struct ssif_bmc_ctx ssif_bmc, u8 val)
	718	+{
	719	+ if (ssif_bmc->state == SSIF_READY \|\|
	720	+ ssif_bmc->state == SSIF_START \|\|
	721	+ ssif_bmc->state == SSIF_SMBUS_CMD \|\|
	722	+ ssif_bmc->state == SSIF_ABORTING) {
	723	+ dev_warn(&ssif_bmc->client->dev,
	724	+ "Warn: %s unexpected SLAVE STOP in state=%s\n",
	725	+ __func__, state_to_string(ssif_bmc->state));
	726	+ ssif_bmc->state = SSIF_READY;
	727	+
	728	+ } else if (ssif_bmc->state == SSIF_REQ_RECVING) {
	729	+ if (validate_request_part(ssif_bmc)) {
	730	+ process_request_part(ssif_bmc);
	731	+ if (ssif_bmc->part_buf.smbus_cmd == SSIF_IPMI_SINGLEPART_WRITE \|\|
	732	+ ssif_bmc->part_buf.smbus_cmd == SSIF_IPMI_MULTIPART_WRITE_END)
	733	+ handle_request(ssif_bmc);
	734	+ ssif_bmc->state = SSIF_READY;
	735	+ } else {
	736	+ /*
	737	+ * A BMC that receives an invalid request drop the data for the write
	738	+ * transaction and any further transactions (read or write) until
	739	+ * the next valid read or write Start transaction is received
	740	+ */
	741	+ dev_err(&ssif_bmc->client->dev, "Error: invalid pec\n");
	742	+ ssif_bmc->aborting = true;
	743	+ }
	744	+ } else if (ssif_bmc->state == SSIF_RES_SENDING) {
	745	+ if (ssif_bmc->is_singlepart_read \|\| ssif_bmc->block_num == 0xFF)
	746	+ /* Invalidate response buffer to denote it is sent */
	747	+ complete_response(ssif_bmc);
	748	+ ssif_bmc->state = SSIF_READY;
	749	+ }
	750	+
	751	+ /* Reset message index */
	752	+ ssif_bmc->msg_idx = 0;
	753	+}
	754	+
	755	+/*
	756	+ * Callback function to handle I2C slave events
	757	+ */
	758	+static int ssif_bmc_cb(struct i2c_client client, enum i2c_slave_event event, u8 val)
	759	+{
	760	+ unsigned long flags;
	761	+ struct ssif_bmc_ctx *ssif_bmc = i2c_get_clientdata(client);
	762	+ int ret = 0;
	763	+
	764	+ spin_lock_irqsave(&ssif_bmc->lock, flags);
	765	+
	766	+ switch (event) {
	767	+ case I2C_SLAVE_READ_REQUESTED:
	768	+ on_read_requested_event(ssif_bmc, val);
	769	+ break;
	770	+
	771	+ case I2C_SLAVE_WRITE_REQUESTED:
	772	+ on_write_requested_event(ssif_bmc, val);
	773	+ break;
	774	+
	775	+ case I2C_SLAVE_READ_PROCESSED:
	776	+ on_read_processed_event(ssif_bmc, val);
	777	+ break;
	778	+
	779	+ case I2C_SLAVE_WRITE_RECEIVED:
	780	+ on_write_received_event(ssif_bmc, val);
	781	+ break;
	782	+
	783	+ case I2C_SLAVE_STOP:
	784	+ on_stop_event(ssif_bmc, val);
	785	+ break;
	786	+
	787	+ default:
	788	+ dev_warn(&ssif_bmc->client->dev, "Warn: Unknown i2c slave event\n");
	789	+ break;
	790	+ }
	791	+
	792	+ if (!ssif_bmc->aborting && ssif_bmc->busy)
	793	+ ret = -EBUSY;
	794	+
	795	+ spin_unlock_irqrestore(&ssif_bmc->lock, flags);
	796	+
	797	+ return ret;
	798	+}
	799	+
	800	+static int ssif_bmc_probe(struct i2c_client *client)
	801	+{
	802	+ struct ssif_bmc_ctx *ssif_bmc;
	803	+ int ret;
	804	+
	805	+ ssif_bmc = devm_kzalloc(&client->dev, sizeof(*ssif_bmc), GFP_KERNEL);
	806	+ if (!ssif_bmc)
	807	+ return -ENOMEM;
	808	+
	809	+ spin_lock_init(&ssif_bmc->lock);
	810	+
	811	+ init_waitqueue_head(&ssif_bmc->wait_queue);
	812	+ ssif_bmc->request_available = false;
	813	+ ssif_bmc->response_in_progress = false;
	814	+ ssif_bmc->busy = false;
	815	+ ssif_bmc->response_timer_inited = false;
	816	+
	817	+ /* Register misc device interface */
	818	+ ssif_bmc->miscdev.minor = MISC_DYNAMIC_MINOR;
	819	+ ssif_bmc->miscdev.name = DEVICE_NAME;
	820	+ ssif_bmc->miscdev.fops = &ssif_bmc_fops;
	821	+ ssif_bmc->miscdev.parent = &client->dev;
	822	+ ret = misc_register(&ssif_bmc->miscdev);
	823	+ if (ret)
	824	+ return ret;
	825	+
	826	+ ssif_bmc->client = client;
	827	+ ssif_bmc->client->flags \|= I2C_CLIENT_SLAVE;
	828	+
	829	+ /* Register I2C slave */
	830	+ i2c_set_clientdata(client, ssif_bmc);
	831	+ ret = i2c_slave_register(client, ssif_bmc_cb);
	832	+ if (ret)
	833	+ misc_deregister(&ssif_bmc->miscdev);
	834	+
	835	+ return ret;
	836	+}
	837	+
	838	+static void ssif_bmc_remove(struct i2c_client *client)
	839	+{
	840	+ struct ssif_bmc_ctx *ssif_bmc = i2c_get_clientdata(client);
	841	+
	842	+ i2c_slave_unregister(client);
	843	+ misc_deregister(&ssif_bmc->miscdev);
	844	+}
	845	+
	846	+static const struct of_device_id ssif_bmc_match[] = {
	847	+ { .compatible = "ssif-bmc" },
	848	+ { },
	849	+};
	850	+MODULE_DEVICE_TABLE(of, ssif_bmc_match);
	851	+
	852	+static const struct i2c_device_id ssif_bmc_id[] = {
	853	+ { DEVICE_NAME, 0 },
	854	+ { },
	855	+};
	856	+MODULE_DEVICE_TABLE(i2c, ssif_bmc_id);
	857	+
	858	+static struct i2c_driver ssif_bmc_driver = {
	859	+ .driver = {
	860	+ .name = DEVICE_NAME,
	861	+ .of_match_table = ssif_bmc_match,
	862	+ },
	863	+ .probe_new = ssif_bmc_probe,
	864	+ .remove = ssif_bmc_remove,
	865	+ .id_table = ssif_bmc_id,
	866	+};
	867	+
	868	+module_i2c_driver(ssif_bmc_driver);
	869	+
	870	+MODULE_AUTHOR("Quan Nguyen <quan@os.amperecomputing.com>");
	871	+MODULE_AUTHOR("Chuong Tran <chuong@os.amperecomputing.com>");
	872	+MODULE_DESCRIPTION("Linux device driver of the BMC IPMI SSIF interface.");
	873	+MODULE_LICENSE("GPL");

include/uapi/linux/ipmi_ssif_bmc.h+18−0

@@ -0,0 +1,18 @@
	1	+/* SPDX-License-Identifier: GPL-2.0-only WITH Linux-syscall-note*/
	2	+/*
	3	+ * Copyright (c) 2022, Ampere Computing LLC.
	4	+ */
	5	+
	6	+#ifndef _UAPI_LINUX_IPMI_SSIF_BMC_H
	7	+#define _UAPI_LINUX_IPMI_SSIF_BMC_H
	8	+
	9	+#include <linux/types.h>
	10	+
	11	+/* Max length of ipmi ssif message included netfn and cmd field */
	12	+#define IPMI_SSIF_PAYLOAD_MAX 254
	13	+struct ipmi_ssif_msg {
	14	+ unsigned int len;
	15	+ __u8 payload[IPMI_SSIF_PAYLOAD_MAX];
	16	+};
	17	+
	18	+#endif /* _UAPI_LINUX_IPMI_SSIF_BMC_H */