ipmi_ssif.c

   1// SPDX-License-Identifier: GPL-2.0+
   2/*
   3 * ipmi_ssif.c
   4 *
   5 * The interface to the IPMI driver for SMBus access to a SMBus
   6 * compliant device.  Called SSIF by the IPMI spec.
   7 *
   8 * Author: Intel Corporation
   9 *         Todd Davis <todd.c.davis@intel.com>
  10 *
  11 * Rewritten by Corey Minyard <minyard@acm.org> to support the
  12 * non-blocking I2C interface, add support for multi-part
  13 * transactions, add PEC support, and general clenaup.
  14 *
  15 * Copyright 2003 Intel Corporation
  16 * Copyright 2005 MontaVista Software
  17 */
  18
  19/*
  20 * This file holds the "policy" for the interface to the SSIF state
  21 * machine.  It does the configuration, handles timers and interrupts,
  22 * and drives the real SSIF state machine.
  23 */
  24
  25#define pr_fmt(fmt) "ipmi_ssif: " fmt
  26#define dev_fmt(fmt) "ipmi_ssif: " fmt
  27
  28#if defined(MODVERSIONS)
  29#include <linux/modversions.h>
  30#endif
  31
  32#include <linux/module.h>
  33#include <linux/moduleparam.h>
  34#include <linux/sched.h>
  35#include <linux/seq_file.h>
  36#include <linux/timer.h>
  37#include <linux/delay.h>
  38#include <linux/errno.h>
  39#include <linux/spinlock.h>
  40#include <linux/slab.h>
  41#include <linux/list.h>
  42#include <linux/i2c.h>
  43#include <linux/ipmi_smi.h>
  44#include <linux/init.h>
  45#include <linux/dmi.h>
  46#include <linux/kthread.h>
  47#include <linux/acpi.h>
  48#include <linux/ctype.h>
  49#include <linux/time64.h>
  50#include "ipmi_dmi.h"
  51
  52#define DEVICE_NAME "ipmi_ssif"
  53
  54#define IPMI_GET_SYSTEM_INTERFACE_CAPABILITIES_CMD	0x57
  55
  56#define	SSIF_IPMI_REQUEST			2
  57#define	SSIF_IPMI_MULTI_PART_REQUEST_START	6
  58#define	SSIF_IPMI_MULTI_PART_REQUEST_MIDDLE	7
  59#define	SSIF_IPMI_MULTI_PART_REQUEST_END	8
  60#define	SSIF_IPMI_RESPONSE			3
  61#define	SSIF_IPMI_MULTI_PART_RESPONSE_MIDDLE	9
  62
  63/* ssif_debug is a bit-field
  64 *	SSIF_DEBUG_MSG -	commands and their responses
  65 *	SSIF_DEBUG_STATES -	message states
  66 *	SSIF_DEBUG_TIMING -	 Measure times between events in the driver
  67 */
  68#define SSIF_DEBUG_TIMING	4
  69#define SSIF_DEBUG_STATE	2
  70#define SSIF_DEBUG_MSG		1
  71#define SSIF_NODEBUG		0
  72#define SSIF_DEFAULT_DEBUG	(SSIF_NODEBUG)
  73
  74/*
  75 * Timer values
  76 */
  77#define SSIF_MSG_USEC		60000	/* 60ms between message tries (T3). */
  78#define SSIF_REQ_RETRY_USEC	60000	/* 60ms between send retries (T6). */
  79#define SSIF_MSG_PART_USEC	5000	/* 5ms for a message part */
  80
  81/* How many times to we retry sending/receiving the message. */
  82#define	SSIF_SEND_RETRIES	5
  83#define	SSIF_RECV_RETRIES	250
  84
  85#define SSIF_MSG_MSEC		(SSIF_MSG_USEC / 1000)
  86#define SSIF_REQ_RETRY_MSEC	(SSIF_REQ_RETRY_USEC / 1000)
  87#define SSIF_MSG_JIFFIES	((SSIF_MSG_USEC * 1000) / TICK_NSEC)
  88#define SSIF_REQ_RETRY_JIFFIES	((SSIF_REQ_RETRY_USEC * 1000) / TICK_NSEC)
  89#define SSIF_MSG_PART_JIFFIES	((SSIF_MSG_PART_USEC * 1000) / TICK_NSEC)
  90
  91/*
  92 * Timeout for the watch, only used for get flag timer.
  93 */
  94#define SSIF_WATCH_MSG_TIMEOUT		msecs_to_jiffies(10)
  95#define SSIF_WATCH_WATCHDOG_TIMEOUT	msecs_to_jiffies(250)
  96
  97enum ssif_intf_state {
  98	SSIF_IDLE,
  99	SSIF_GETTING_FLAGS,
 100	SSIF_GETTING_EVENTS,
 101	SSIF_CLEARING_FLAGS,
 102	SSIF_GETTING_MESSAGES,
 103	/* FIXME - add watchdog stuff. */
 104};
 105
 106#define IS_SSIF_IDLE(ssif) ((ssif)->ssif_state == SSIF_IDLE \
 107			    && (ssif)->curr_msg == NULL)
 108
 109/*
 110 * Indexes into stats[] in ssif_info below.
 111 */
 112enum ssif_stat_indexes {
 113	/* Number of total messages sent. */
 114	SSIF_STAT_sent_messages = 0,
 115
 116	/*
 117	 * Number of message parts sent.  Messages may be broken into
 118	 * parts if they are long.
 119	 */
 120	SSIF_STAT_sent_messages_parts,
 121
 122	/*
 123	 * Number of time a message was retried.
 124	 */
 125	SSIF_STAT_send_retries,
 126
 127	/*
 128	 * Number of times the send of a message failed.
 129	 */
 130	SSIF_STAT_send_errors,
 131
 132	/*
 133	 * Number of message responses received.
 134	 */
 135	SSIF_STAT_received_messages,
 136
 137	/*
 138	 * Number of message fragments received.
 139	 */
 140	SSIF_STAT_received_message_parts,
 141
 142	/*
 143	 * Number of times the receive of a message was retried.
 144	 */
 145	SSIF_STAT_receive_retries,
 146
 147	/*
 148	 * Number of errors receiving messages.
 149	 */
 150	SSIF_STAT_receive_errors,
 151
 152	/*
 153	 * Number of times a flag fetch was requested.
 154	 */
 155	SSIF_STAT_flag_fetches,
 156
 157	/*
 158	 * Number of times the hardware didn't follow the state machine.
 159	 */
 160	SSIF_STAT_hosed,
 161
 162	/*
 163	 * Number of received events.
 164	 */
 165	SSIF_STAT_events,
 166
 167	/* Number of asyncronous messages received. */
 168	SSIF_STAT_incoming_messages,
 169
 170	/* Number of watchdog pretimeouts. */
 171	SSIF_STAT_watchdog_pretimeouts,
 172
 173	/* Number of alers received. */
 174	SSIF_STAT_alerts,
 175
 176	/* Always add statistics before this value, it must be last. */
 177	SSIF_NUM_STATS
 178};
 179
 180struct ssif_addr_info {
 181	struct i2c_board_info binfo;
 182	char *adapter_name;
 183	int debug;
 184	int slave_addr;
 185	enum ipmi_addr_src addr_src;
 186	union ipmi_smi_info_union addr_info;
 187	struct device *dev;
 188	struct i2c_client *client;
 189
 190	struct mutex clients_mutex;
 191	struct list_head clients;
 192
 193	struct list_head link;
 194};
 195
 196struct ssif_info;
 197
 198typedef void (*ssif_i2c_done)(struct ssif_info *ssif_info, int result,
 199			     unsigned char *data, unsigned int len);
 200
 201struct ssif_info {
 202	struct ipmi_smi     *intf;
 203	spinlock_t	    lock;
 204	struct ipmi_smi_msg *waiting_msg;
 205	struct ipmi_smi_msg *curr_msg;
 206	enum ssif_intf_state ssif_state;
 207	unsigned long       ssif_debug;
 208
 209	struct ipmi_smi_handlers handlers;
 210
 211	enum ipmi_addr_src addr_source; /* ACPI, PCI, SMBIOS, hardcode, etc. */
 212	union ipmi_smi_info_union addr_info;
 213
 214	/*
 215	 * Flags from the last GET_MSG_FLAGS command, used when an ATTN
 216	 * is set to hold the flags until we are done handling everything
 217	 * from the flags.
 218	 */
 219#define RECEIVE_MSG_AVAIL	0x01
 220#define EVENT_MSG_BUFFER_FULL	0x02
 221#define WDT_PRE_TIMEOUT_INT	0x08
 222	unsigned char       msg_flags;
 223
 224	u8		    global_enables;
 225	bool		    has_event_buffer;
 226	bool		    supports_alert;
 227
 228	/*
 229	 * Used to tell what we should do with alerts.  If we are
 230	 * waiting on a response, read the data immediately.
 231	 */
 232	bool		    got_alert;
 233	bool		    waiting_alert;
 234
 235	/* Used to inform the timeout that it should do a resend. */
 236	bool		    do_resend;
 237
 238	/*
 239	 * If set to true, this will request events the next time the
 240	 * state machine is idle.
 241	 */
 242	bool                req_events;
 243
 244	/*
 245	 * If set to true, this will request flags the next time the
 246	 * state machine is idle.
 247	 */
 248	bool                req_flags;
 249
 250	/* Used for sending/receiving data.  +1 for the length. */
 251	unsigned char data[IPMI_MAX_MSG_LENGTH + 1];
 252	unsigned int  data_len;
 253
 254	/* Temp receive buffer, gets copied into data. */
 255	unsigned char recv[I2C_SMBUS_BLOCK_MAX];
 256
 257	struct i2c_client *client;
 258	ssif_i2c_done done_handler;
 259
 260	/* Thread interface handling */
 261	struct task_struct *thread;
 262	struct completion wake_thread;
 263	bool stopping;
 264	int i2c_read_write;
 265	int i2c_command;
 266	unsigned char *i2c_data;
 267	unsigned int i2c_size;
 268
 269	struct timer_list retry_timer;
 270	int retries_left;
 271
 272	long watch_timeout;		/* Timeout for flags check, 0 if off. */
 273	struct timer_list watch_timer;	/* Flag fetch timer. */
 274
 275	/* Info from SSIF cmd */
 276	unsigned char max_xmit_msg_size;
 277	unsigned char max_recv_msg_size;
 278	bool cmd8_works; /* See test_multipart_messages() for details. */
 279	unsigned int  multi_support;
 280	int           supports_pec;
 281
 282#define SSIF_NO_MULTI		0
 283#define SSIF_MULTI_2_PART	1
 284#define SSIF_MULTI_n_PART	2
 285	unsigned char *multi_data;
 286	unsigned int  multi_len;
 287	unsigned int  multi_pos;
 288
 289	atomic_t stats[SSIF_NUM_STATS];
 290};
 291
 292#define ssif_inc_stat(ssif, stat) \
 293	atomic_inc(&(ssif)->stats[SSIF_STAT_ ## stat])
 294#define ssif_get_stat(ssif, stat) \
 295	((unsigned int) atomic_read(&(ssif)->stats[SSIF_STAT_ ## stat]))
 296
 297static bool initialized;
 298static bool platform_registered;
 299
 300static void return_hosed_msg(struct ssif_info *ssif_info,
 301			     struct ipmi_smi_msg *msg);
 302static void start_next_msg(struct ssif_info *ssif_info, unsigned long *flags);
 303static int start_send(struct ssif_info *ssif_info,
 304		      unsigned char   *data,
 305		      unsigned int    len);
 306
 307static unsigned long *ipmi_ssif_lock_cond(struct ssif_info *ssif_info,
 308					  unsigned long *flags)
 309	__acquires(&ssif_info->lock)
 310{
 311	spin_lock_irqsave(&ssif_info->lock, *flags);
 312	return flags;
 313}
 314
 315static void ipmi_ssif_unlock_cond(struct ssif_info *ssif_info,
 316				  unsigned long *flags)
 317	__releases(&ssif_info->lock)
 318{
 319	spin_unlock_irqrestore(&ssif_info->lock, *flags);
 320}
 321
 322static void deliver_recv_msg(struct ssif_info *ssif_info,
 323			     struct ipmi_smi_msg *msg)
 324{
 325	if (msg->rsp_size < 0) {
 326		return_hosed_msg(ssif_info, msg);
 327		dev_err(&ssif_info->client->dev,
 328			"%s: Malformed message: rsp_size = %d\n",
 329		       __func__, msg->rsp_size);
 330	} else {
 331		ipmi_smi_msg_received(ssif_info->intf, msg);
 332	}
 333}
 334
 335static void return_hosed_msg(struct ssif_info *ssif_info,
 336			     struct ipmi_smi_msg *msg)
 337{
 338	ssif_inc_stat(ssif_info, hosed);
 339
 340	/* Make it a response */
 341	msg->rsp[0] = msg->data[0] | 4;
 342	msg->rsp[1] = msg->data[1];
 343	msg->rsp[2] = 0xFF; /* Unknown error. */
 344	msg->rsp_size = 3;
 345
 346	deliver_recv_msg(ssif_info, msg);
 347}
 348
 349/*
 350 * Must be called with the message lock held.  This will release the
 351 * message lock.  Note that the caller will check IS_SSIF_IDLE and
 352 * start a new operation, so there is no need to check for new
 353 * messages to start in here.
 354 */
 355static void start_clear_flags(struct ssif_info *ssif_info, unsigned long *flags)
 356{
 357	unsigned char msg[3];
 358
 359	ssif_info->msg_flags &= ~WDT_PRE_TIMEOUT_INT;
 360	ssif_info->ssif_state = SSIF_CLEARING_FLAGS;
 361	ipmi_ssif_unlock_cond(ssif_info, flags);
 362
 363	/* Make sure the watchdog pre-timeout flag is not set at startup. */
 364	msg[0] = (IPMI_NETFN_APP_REQUEST << 2);
 365	msg[1] = IPMI_CLEAR_MSG_FLAGS_CMD;
 366	msg[2] = WDT_PRE_TIMEOUT_INT;
 367
 368	if (start_send(ssif_info, msg, 3) != 0) {
 369		/* Error, just go to normal state. */
 370		ssif_info->ssif_state = SSIF_IDLE;
 371	}
 372}
 373
 374static void start_flag_fetch(struct ssif_info *ssif_info, unsigned long *flags)
 375{
 376	unsigned char mb[2];
 377
 378	ssif_info->req_flags = false;
 379	ssif_info->ssif_state = SSIF_GETTING_FLAGS;
 380	ipmi_ssif_unlock_cond(ssif_info, flags);
 381
 382	mb[0] = (IPMI_NETFN_APP_REQUEST << 2);
 383	mb[1] = IPMI_GET_MSG_FLAGS_CMD;
 384	if (start_send(ssif_info, mb, 2) != 0)
 385		ssif_info->ssif_state = SSIF_IDLE;
 386}
 387
 388static void check_start_send(struct ssif_info *ssif_info, unsigned long *flags,
 389			     struct ipmi_smi_msg *msg)
 390{
 391	if (start_send(ssif_info, msg->data, msg->data_size) != 0) {
 392		unsigned long oflags;
 393
 394		flags = ipmi_ssif_lock_cond(ssif_info, &oflags);
 395		ssif_info->curr_msg = NULL;
 396		ssif_info->ssif_state = SSIF_IDLE;
 397		ipmi_ssif_unlock_cond(ssif_info, flags);
 398		ipmi_free_smi_msg(msg);
 399	}
 400}
 401
 402static void start_event_fetch(struct ssif_info *ssif_info, unsigned long *flags)
 403{
 404	struct ipmi_smi_msg *msg;
 405
 406	ssif_info->req_events = false;
 407
 408	msg = ipmi_alloc_smi_msg();
 409	if (!msg) {
 410		ssif_info->ssif_state = SSIF_IDLE;
 411		ipmi_ssif_unlock_cond(ssif_info, flags);
 412		return;
 413	}
 414
 415	ssif_info->curr_msg = msg;
 416	ssif_info->ssif_state = SSIF_GETTING_EVENTS;
 417	ipmi_ssif_unlock_cond(ssif_info, flags);
 418
 419	msg->data[0] = (IPMI_NETFN_APP_REQUEST << 2);
 420	msg->data[1] = IPMI_READ_EVENT_MSG_BUFFER_CMD;
 421	msg->data_size = 2;
 422
 423	check_start_send(ssif_info, flags, msg);
 424}
 425
 426static void start_recv_msg_fetch(struct ssif_info *ssif_info,
 427				 unsigned long *flags)
 428{
 429	struct ipmi_smi_msg *msg;
 430
 431	msg = ipmi_alloc_smi_msg();
 432	if (!msg) {
 433		ssif_info->ssif_state = SSIF_IDLE;
 434		ipmi_ssif_unlock_cond(ssif_info, flags);
 435		return;
 436	}
 437
 438	ssif_info->curr_msg = msg;
 439	ssif_info->ssif_state = SSIF_GETTING_MESSAGES;
 440	ipmi_ssif_unlock_cond(ssif_info, flags);
 441
 442	msg->data[0] = (IPMI_NETFN_APP_REQUEST << 2);
 443	msg->data[1] = IPMI_GET_MSG_CMD;
 444	msg->data_size = 2;
 445
 446	check_start_send(ssif_info, flags, msg);
 447}
 448
 449/*
 450 * Must be called with the message lock held.  This will release the
 451 * message lock.  Note that the caller will check IS_SSIF_IDLE and
 452 * start a new operation, so there is no need to check for new
 453 * messages to start in here.
 454 */
 455static void handle_flags(struct ssif_info *ssif_info, unsigned long *flags)
 456{
 457	if (ssif_info->msg_flags & WDT_PRE_TIMEOUT_INT) {
 458		/* Watchdog pre-timeout */
 459		ssif_inc_stat(ssif_info, watchdog_pretimeouts);
 460		start_clear_flags(ssif_info, flags);
 461		ipmi_smi_watchdog_pretimeout(ssif_info->intf);
 462	} else if (ssif_info->msg_flags & RECEIVE_MSG_AVAIL)
 463		/* Messages available. */
 464		start_recv_msg_fetch(ssif_info, flags);
 465	else if (ssif_info->msg_flags & EVENT_MSG_BUFFER_FULL)
 466		/* Events available. */
 467		start_event_fetch(ssif_info, flags);
 468	else {
 469		ssif_info->ssif_state = SSIF_IDLE;
 470		ipmi_ssif_unlock_cond(ssif_info, flags);
 471	}
 472}
 473
 474static int ipmi_ssif_thread(void *data)
 475{
 476	struct ssif_info *ssif_info = data;
 477
 478	while (!kthread_should_stop()) {
 479		int result;
 480
 481		/* Wait for something to do */
 482		result = wait_for_completion_interruptible(
 483						&ssif_info->wake_thread);
 484		if (result == -ERESTARTSYS)
 485			continue;
 486		init_completion(&ssif_info->wake_thread);
 487
 488		if (ssif_info->i2c_read_write == I2C_SMBUS_WRITE) {
 489			result = i2c_smbus_write_block_data(
 490				ssif_info->client, ssif_info->i2c_command,
 491				ssif_info->i2c_data[0],
 492				ssif_info->i2c_data + 1);
 493			ssif_info->done_handler(ssif_info, result, NULL, 0);
 494		} else {
 495			result = i2c_smbus_read_block_data(
 496				ssif_info->client, ssif_info->i2c_command,
 497				ssif_info->i2c_data);
 498			if (result < 0)
 499				ssif_info->done_handler(ssif_info, result,
 500							NULL, 0);
 501			else
 502				ssif_info->done_handler(ssif_info, 0,
 503							ssif_info->i2c_data,
 504							result);
 505		}
 506	}
 507
 508	return 0;
 509}
 510
 511static void ssif_i2c_send(struct ssif_info *ssif_info,
 512			ssif_i2c_done handler,
 513			int read_write, int command,
 514			unsigned char *data, unsigned int size)
 515{
 516	ssif_info->done_handler = handler;
 517
 518	ssif_info->i2c_read_write = read_write;
 519	ssif_info->i2c_command = command;
 520	ssif_info->i2c_data = data;
 521	ssif_info->i2c_size = size;
 522	complete(&ssif_info->wake_thread);
 523}
 524
 525
 526static void msg_done_handler(struct ssif_info *ssif_info, int result,
 527			     unsigned char *data, unsigned int len);
 528
 529static void start_get(struct ssif_info *ssif_info)
 530{
 531	ssif_info->multi_pos = 0;
 532
 533	ssif_i2c_send(ssif_info, msg_done_handler, I2C_SMBUS_READ,
 534		  SSIF_IPMI_RESPONSE,
 535		  ssif_info->recv, I2C_SMBUS_BLOCK_DATA);
 536}
 537
 538static void start_resend(struct ssif_info *ssif_info);
 539
 540static void retry_timeout(struct timer_list *t)
 541{
 542	struct ssif_info *ssif_info = timer_container_of(ssif_info, t,
 543							 retry_timer);
 544	unsigned long oflags, *flags;
 545	bool waiting, resend;
 546
 547	if (ssif_info->stopping)
 548		return;
 549
 550	flags = ipmi_ssif_lock_cond(ssif_info, &oflags);
 551	resend = ssif_info->do_resend;
 552	ssif_info->do_resend = false;
 553	waiting = ssif_info->waiting_alert;
 554	ssif_info->waiting_alert = false;
 555	ipmi_ssif_unlock_cond(ssif_info, flags);
 556
 557	if (waiting)
 558		start_get(ssif_info);
 559	if (resend) {
 560		start_resend(ssif_info);
 561		ssif_inc_stat(ssif_info, send_retries);
 562	}
 563}
 564
 565static void watch_timeout(struct timer_list *t)
 566{
 567	struct ssif_info *ssif_info = timer_container_of(ssif_info, t,
 568							 watch_timer);
 569	unsigned long oflags, *flags;
 570
 571	if (ssif_info->stopping)
 572		return;
 573
 574	flags = ipmi_ssif_lock_cond(ssif_info, &oflags);
 575	if (ssif_info->watch_timeout) {
 576		mod_timer(&ssif_info->watch_timer,
 577			  jiffies + ssif_info->watch_timeout);
 578		if (IS_SSIF_IDLE(ssif_info)) {
 579			start_flag_fetch(ssif_info, flags); /* Releases lock */
 580			return;
 581		}
 582		ssif_info->req_flags = true;
 583	}
 584	ipmi_ssif_unlock_cond(ssif_info, flags);
 585}
 586
 587static void ssif_alert(struct i2c_client *client, enum i2c_alert_protocol type,
 588		       unsigned int data)
 589{
 590	struct ssif_info *ssif_info = i2c_get_clientdata(client);
 591	unsigned long oflags, *flags;
 592	bool do_get = false;
 593
 594	if (type != I2C_PROTOCOL_SMBUS_ALERT)
 595		return;
 596
 597	ssif_inc_stat(ssif_info, alerts);
 598
 599	flags = ipmi_ssif_lock_cond(ssif_info, &oflags);
 600	if (ssif_info->waiting_alert) {
 601		ssif_info->waiting_alert = false;
 602		timer_delete(&ssif_info->retry_timer);
 603		do_get = true;
 604	} else if (ssif_info->curr_msg) {
 605		ssif_info->got_alert = true;
 606	}
 607	ipmi_ssif_unlock_cond(ssif_info, flags);
 608	if (do_get)
 609		start_get(ssif_info);
 610}
 611
 612static void msg_done_handler(struct ssif_info *ssif_info, int result,
 613			     unsigned char *data, unsigned int len)
 614{
 615	struct ipmi_smi_msg *msg;
 616	unsigned long oflags, *flags;
 617
 618	/*
 619	 * We are single-threaded here, so no need for a lock until we
 620	 * start messing with driver states or the queues.
 621	 */
 622
 623	if (result < 0) {
 624		ssif_info->retries_left--;
 625		if (ssif_info->retries_left > 0) {
 626			ssif_inc_stat(ssif_info, receive_retries);
 627
 628			flags = ipmi_ssif_lock_cond(ssif_info, &oflags);
 629			ssif_info->waiting_alert = true;
 630			if (!ssif_info->stopping)
 631				mod_timer(&ssif_info->retry_timer,
 632					  jiffies + SSIF_MSG_JIFFIES);
 633			ipmi_ssif_unlock_cond(ssif_info, flags);
 634			return;
 635		}
 636
 637		ssif_inc_stat(ssif_info, receive_errors);
 638
 639		if  (ssif_info->ssif_debug & SSIF_DEBUG_MSG)
 640			dev_dbg(&ssif_info->client->dev,
 641				"%s: Error %d\n", __func__, result);
 642		len = 0;
 643		goto continue_op;
 644	}
 645
 646	if ((len > 1) && (ssif_info->multi_pos == 0)
 647				&& (data[0] == 0x00) && (data[1] == 0x01)) {
 648		/* Start of multi-part read.  Start the next transaction. */
 649		int i;
 650
 651		ssif_inc_stat(ssif_info, received_message_parts);
 652
 653		/* Remove the multi-part read marker. */
 654		len -= 2;
 655		data += 2;
 656		for (i = 0; i < len; i++)
 657			ssif_info->data[i] = data[i];
 658		ssif_info->multi_len = len;
 659		ssif_info->multi_pos = 1;
 660
 661		ssif_i2c_send(ssif_info, msg_done_handler, I2C_SMBUS_READ,
 662			 SSIF_IPMI_MULTI_PART_RESPONSE_MIDDLE,
 663			 ssif_info->recv, I2C_SMBUS_BLOCK_DATA);
 664		return;
 665	} else if (ssif_info->multi_pos) {
 666		/* Middle of multi-part read.  Start the next transaction. */
 667		int i;
 668		unsigned char blocknum;
 669
 670		if (len == 0) {
 671			result = -EIO;
 672			if (ssif_info->ssif_debug & SSIF_DEBUG_MSG)
 673				dev_dbg(&ssif_info->client->dev,
 674					"Middle message with no data\n");
 675
 676			goto continue_op;
 677		}
 678
 679		blocknum = data[0];
 680		len--;
 681		data++;
 682
 683		if (blocknum != 0xff && len != 31) {
 684		    /* All blocks but the last must have 31 data bytes. */
 685			result = -EIO;
 686			if (ssif_info->ssif_debug & SSIF_DEBUG_MSG)
 687				dev_dbg(&ssif_info->client->dev,
 688					"Received middle message <31\n");
 689
 690			goto continue_op;
 691		}
 692
 693		if (ssif_info->multi_len + len > IPMI_MAX_MSG_LENGTH) {
 694			/* Received message too big, abort the operation. */
 695			result = -E2BIG;
 696			if (ssif_info->ssif_debug & SSIF_DEBUG_MSG)
 697				dev_dbg(&ssif_info->client->dev,
 698					"Received message too big\n");
 699
 700			goto continue_op;
 701		}
 702
 703		for (i = 0; i < len; i++)
 704			ssif_info->data[i + ssif_info->multi_len] = data[i];
 705		ssif_info->multi_len += len;
 706		if (blocknum == 0xff) {
 707			/* End of read */
 708			len = ssif_info->multi_len;
 709			data = ssif_info->data;
 710		} else if (blocknum + 1 != ssif_info->multi_pos) {
 711			/*
 712			 * Out of sequence block, just abort.  Block
 713			 * numbers start at zero for the second block,
 714			 * but multi_pos starts at one, so the +1.
 715			 */
 716			if (ssif_info->ssif_debug & SSIF_DEBUG_MSG)
 717				dev_dbg(&ssif_info->client->dev,
 718					"Received message out of sequence, expected %u, got %u\n",
 719					ssif_info->multi_pos - 1, blocknum);
 720			result = -EIO;
 721		} else {
 722			ssif_inc_stat(ssif_info, received_message_parts);
 723
 724			ssif_info->multi_pos++;
 725
 726			ssif_i2c_send(ssif_info, msg_done_handler,
 727				  I2C_SMBUS_READ,
 728				  SSIF_IPMI_MULTI_PART_RESPONSE_MIDDLE,
 729				  ssif_info->recv,
 730				  I2C_SMBUS_BLOCK_DATA);
 731			return;
 732		}
 733	}
 734
 735 continue_op:
 736	if (result < 0) {
 737		ssif_inc_stat(ssif_info, receive_errors);
 738	} else {
 739		ssif_inc_stat(ssif_info, received_messages);
 740		ssif_inc_stat(ssif_info, received_message_parts);
 741	}
 742
 743	if (ssif_info->ssif_debug & SSIF_DEBUG_STATE)
 744		dev_dbg(&ssif_info->client->dev,
 745			"DONE 1: state = %d, result=%d\n",
 746			ssif_info->ssif_state, result);
 747
 748	flags = ipmi_ssif_lock_cond(ssif_info, &oflags);
 749	msg = ssif_info->curr_msg;
 750	if (msg) {
 751		if (data) {
 752			if (len > IPMI_MAX_MSG_LENGTH)
 753				len = IPMI_MAX_MSG_LENGTH;
 754			memcpy(msg->rsp, data, len);
 755		} else {
 756			len = 0;
 757		}
 758		msg->rsp_size = len;
 759		ssif_info->curr_msg = NULL;
 760	}
 761
 762	switch (ssif_info->ssif_state) {
 763	case SSIF_IDLE:
 764		ipmi_ssif_unlock_cond(ssif_info, flags);
 765		if (!msg)
 766			break;
 767
 768		if (result < 0)
 769			return_hosed_msg(ssif_info, msg);
 770		else
 771			deliver_recv_msg(ssif_info, msg);
 772		break;
 773
 774	case SSIF_GETTING_FLAGS:
 775		/* We got the flags from the SSIF, now handle them. */
 776		if ((result < 0) || (len < 4) || (data[2] != 0)) {
 777			/*
 778			 * Error fetching flags, or invalid length,
 779			 * just give up for now.
 780			 */
 781			ssif_info->ssif_state = SSIF_IDLE;
 782			ipmi_ssif_unlock_cond(ssif_info, flags);
 783			dev_warn(&ssif_info->client->dev,
 784				 "Error getting flags: %d %d, %x\n",
 785				 result, len, (len >= 3) ? data[2] : 0);
 786		} else if (data[0] != (IPMI_NETFN_APP_REQUEST | 1) << 2
 787			   || data[1] != IPMI_GET_MSG_FLAGS_CMD) {
 788			/*
 789			 * Recv error response, give up.
 790			 */
 791			ssif_info->ssif_state = SSIF_IDLE;
 792			ipmi_ssif_unlock_cond(ssif_info, flags);
 793			dev_warn(&ssif_info->client->dev,
 794				 "Invalid response getting flags: %x %x\n",
 795				 data[0], data[1]);
 796		} else {
 797			ssif_inc_stat(ssif_info, flag_fetches);
 798			ssif_info->msg_flags = data[3];
 799			handle_flags(ssif_info, flags);
 800		}
 801		break;
 802
 803	case SSIF_CLEARING_FLAGS:
 804		/* We cleared the flags. */
 805		if ((result < 0) || (len < 3) || (data[2] != 0)) {
 806			/* Error clearing flags */
 807			dev_warn(&ssif_info->client->dev,
 808				 "Error clearing flags: %d %d, %x\n",
 809				 result, len, (len >= 3) ? data[2] : 0);
 810		} else if (data[0] != (IPMI_NETFN_APP_REQUEST | 1) << 2
 811			   || data[1] != IPMI_CLEAR_MSG_FLAGS_CMD) {
 812			dev_warn(&ssif_info->client->dev,
 813				 "Invalid response clearing flags: %x %x\n",
 814				 data[0], data[1]);
 815		}
 816		ssif_info->ssif_state = SSIF_IDLE;
 817		ipmi_ssif_unlock_cond(ssif_info, flags);
 818		break;
 819
 820	case SSIF_GETTING_EVENTS:
 821		if (!msg) {
 822			/* Should never happen, but just in case. */
 823			dev_warn(&ssif_info->client->dev,
 824				 "No message set while getting events\n");
 825			ipmi_ssif_unlock_cond(ssif_info, flags);
 826			break;
 827		}
 828
 829		if ((result < 0) || (len < 3) || (msg->rsp[2] != 0)) {
 830			/* Error getting event, probably done. */
 831			msg->done(msg);
 832
 833			/* Take off the event flag. */
 834			ssif_info->msg_flags &= ~EVENT_MSG_BUFFER_FULL;
 835			handle_flags(ssif_info, flags);
 836		} else if (msg->rsp[0] != (IPMI_NETFN_APP_REQUEST | 1) << 2
 837			   || msg->rsp[1] != IPMI_READ_EVENT_MSG_BUFFER_CMD) {
 838			dev_warn(&ssif_info->client->dev,
 839				 "Invalid response getting events: %x %x\n",
 840				 msg->rsp[0], msg->rsp[1]);
 841			msg->done(msg);
 842			/* Take off the event flag. */
 843			ssif_info->msg_flags &= ~EVENT_MSG_BUFFER_FULL;
 844			handle_flags(ssif_info, flags);
 845		} else {
 846			handle_flags(ssif_info, flags);
 847			ssif_inc_stat(ssif_info, events);
 848			deliver_recv_msg(ssif_info, msg);
 849		}
 850		break;
 851
 852	case SSIF_GETTING_MESSAGES:
 853		if (!msg) {
 854			/* Should never happen, but just in case. */
 855			dev_warn(&ssif_info->client->dev,
 856				 "No message set while getting messages\n");
 857			ipmi_ssif_unlock_cond(ssif_info, flags);
 858			break;
 859		}
 860
 861		if ((result < 0) || (len < 3) || (msg->rsp[2] != 0)) {
 862			/* Error getting event, probably done. */
 863			msg->done(msg);
 864
 865			/* Take off the msg flag. */
 866			ssif_info->msg_flags &= ~RECEIVE_MSG_AVAIL;
 867			handle_flags(ssif_info, flags);
 868		} else if (msg->rsp[0] != (IPMI_NETFN_APP_REQUEST | 1) << 2
 869			   || msg->rsp[1] != IPMI_GET_MSG_CMD) {
 870			dev_warn(&ssif_info->client->dev,
 871				 "Invalid response clearing flags: %x %x\n",
 872				 msg->rsp[0], msg->rsp[1]);
 873			msg->done(msg);
 874
 875			/* Take off the msg flag. */
 876			ssif_info->msg_flags &= ~RECEIVE_MSG_AVAIL;
 877			handle_flags(ssif_info, flags);
 878		} else {
 879			ssif_inc_stat(ssif_info, incoming_messages);
 880			handle_flags(ssif_info, flags);
 881			deliver_recv_msg(ssif_info, msg);
 882		}
 883		break;
 884
 885	default:
 886		/* Should never happen, but just in case. */
 887		dev_warn(&ssif_info->client->dev,
 888			 "Invalid state in message done handling: %d\n",
 889			 ssif_info->ssif_state);
 890		ipmi_ssif_unlock_cond(ssif_info, flags);
 891	}
 892
 893	flags = ipmi_ssif_lock_cond(ssif_info, &oflags);
 894	if (IS_SSIF_IDLE(ssif_info) && !ssif_info->stopping) {
 895		if (ssif_info->req_events)
 896			start_event_fetch(ssif_info, flags);
 897		else if (ssif_info->req_flags)
 898			start_flag_fetch(ssif_info, flags);
 899		else
 900			start_next_msg(ssif_info, flags);
 901	} else
 902		ipmi_ssif_unlock_cond(ssif_info, flags);
 903
 904	if (ssif_info->ssif_debug & SSIF_DEBUG_STATE)
 905		dev_dbg(&ssif_info->client->dev,
 906			"DONE 2: state = %d.\n", ssif_info->ssif_state);
 907}
 908
 909static void msg_written_handler(struct ssif_info *ssif_info, int result,
 910				unsigned char *data, unsigned int len)
 911{
 912	/* We are single-threaded here, so no need for a lock. */
 913	if (result < 0) {
 914		ssif_info->retries_left--;
 915		if (ssif_info->retries_left > 0) {
 916			/*
 917			 * Wait the retry timeout time per the spec,
 918			 * then redo the send.
 919			 */
 920			ssif_info->do_resend = true;
 921			mod_timer(&ssif_info->retry_timer,
 922				  jiffies + SSIF_REQ_RETRY_JIFFIES);
 923			return;
 924		}
 925
 926		ssif_inc_stat(ssif_info, send_errors);
 927
 928		if (ssif_info->ssif_debug & SSIF_DEBUG_MSG)
 929			dev_dbg(&ssif_info->client->dev,
 930				"%s: Out of retries\n", __func__);
 931
 932		msg_done_handler(ssif_info, -EIO, NULL, 0);
 933		return;
 934	}
 935
 936	if (ssif_info->multi_data) {
 937		/*
 938		 * In the middle of a multi-data write.  See the comment
 939		 * in the SSIF_MULTI_n_PART case in the probe function
 940		 * for details on the intricacies of this.
 941		 */
 942		int left, to_write;
 943		unsigned char *data_to_send;
 944		unsigned char cmd;
 945
 946		ssif_inc_stat(ssif_info, sent_messages_parts);
 947
 948		left = ssif_info->multi_len - ssif_info->multi_pos;
 949		to_write = left;
 950		if (to_write > 32)
 951			to_write = 32;
 952		/* Length byte. */
 953		ssif_info->multi_data[ssif_info->multi_pos] = to_write;
 954		data_to_send = ssif_info->multi_data + ssif_info->multi_pos;
 955		ssif_info->multi_pos += to_write;
 956		cmd = SSIF_IPMI_MULTI_PART_REQUEST_MIDDLE;
 957		if (ssif_info->cmd8_works) {
 958			if (left == to_write) {
 959				cmd = SSIF_IPMI_MULTI_PART_REQUEST_END;
 960				ssif_info->multi_data = NULL;
 961			}
 962		} else if (to_write < 32) {
 963			ssif_info->multi_data = NULL;
 964		}
 965
 966		ssif_i2c_send(ssif_info, msg_written_handler,
 967			  I2C_SMBUS_WRITE, cmd,
 968			  data_to_send, I2C_SMBUS_BLOCK_DATA);
 969	} else {
 970		/* Ready to request the result. */
 971		unsigned long oflags, *flags;
 972
 973		ssif_inc_stat(ssif_info, sent_messages);
 974		ssif_inc_stat(ssif_info, sent_messages_parts);
 975
 976		flags = ipmi_ssif_lock_cond(ssif_info, &oflags);
 977		if (ssif_info->got_alert) {
 978			/* The result is already ready, just start it. */
 979			ssif_info->got_alert = false;
 980			ipmi_ssif_unlock_cond(ssif_info, flags);
 981			start_get(ssif_info);
 982		} else {
 983			/* Wait a jiffy then request the next message */
 984			ssif_info->waiting_alert = true;
 985			ssif_info->retries_left = SSIF_RECV_RETRIES;
 986			if (!ssif_info->stopping)
 987				mod_timer(&ssif_info->retry_timer,
 988					  jiffies + SSIF_MSG_PART_JIFFIES);
 989			ipmi_ssif_unlock_cond(ssif_info, flags);
 990		}
 991	}
 992}
 993
 994static void start_resend(struct ssif_info *ssif_info)
 995{
 996	int command;
 997
 998	ssif_info->got_alert = false;
 999
1000	if (ssif_info->data_len > 32) {
1001		command = SSIF_IPMI_MULTI_PART_REQUEST_START;
1002		ssif_info->multi_data = ssif_info->data;
1003		ssif_info->multi_len = ssif_info->data_len;
1004		/*
1005		 * Subtle thing, this is 32, not 33, because we will
1006		 * overwrite the thing at position 32 (which was just
1007		 * transmitted) with the new length.
1008		 */
1009		ssif_info->multi_pos = 32;
1010		ssif_info->data[0] = 32;
1011	} else {
1012		ssif_info->multi_data = NULL;
1013		command = SSIF_IPMI_REQUEST;
1014		ssif_info->data[0] = ssif_info->data_len;
1015	}
1016
1017	ssif_i2c_send(ssif_info, msg_written_handler, I2C_SMBUS_WRITE,
1018		   command, ssif_info->data, I2C_SMBUS_BLOCK_DATA);
1019}
1020
1021static int start_send(struct ssif_info *ssif_info,
1022		      unsigned char   *data,
1023		      unsigned int    len)
1024{
1025	if (len > IPMI_MAX_MSG_LENGTH)
1026		return -E2BIG;
1027	if (len > ssif_info->max_xmit_msg_size)
1028		return -E2BIG;
1029
1030	ssif_info->retries_left = SSIF_SEND_RETRIES;
1031	memcpy(ssif_info->data + 1, data, len);
1032	ssif_info->data_len = len;
1033	start_resend(ssif_info);
1034	return 0;
1035}
1036
1037/* Must be called with the message lock held. */
1038static void start_next_msg(struct ssif_info *ssif_info, unsigned long *flags)
1039{
1040	struct ipmi_smi_msg *msg;
1041	unsigned long oflags;
1042
1043 restart:
1044	if (!IS_SSIF_IDLE(ssif_info)) {
1045		ipmi_ssif_unlock_cond(ssif_info, flags);
1046		return;
1047	}
1048
1049	if (!ssif_info->waiting_msg) {
1050		ssif_info->curr_msg = NULL;
1051		ipmi_ssif_unlock_cond(ssif_info, flags);
1052	} else {
1053		int rv;
1054
1055		ssif_info->curr_msg = ssif_info->waiting_msg;
1056		ssif_info->waiting_msg = NULL;
1057		ipmi_ssif_unlock_cond(ssif_info, flags);
1058		rv = start_send(ssif_info,
1059				ssif_info->curr_msg->data,
1060				ssif_info->curr_msg->data_size);
1061		if (rv) {
1062			msg = ssif_info->curr_msg;
1063			ssif_info->curr_msg = NULL;
1064			return_hosed_msg(ssif_info, msg);
1065			flags = ipmi_ssif_lock_cond(ssif_info, &oflags);
1066			goto restart;
1067		}
1068	}
1069}
1070
1071static int sender(void *send_info, struct ipmi_smi_msg *msg)
1072{
1073	struct ssif_info *ssif_info = send_info;
1074	unsigned long oflags, *flags;
1075
1076	BUG_ON(ssif_info->waiting_msg);
1077	ssif_info->waiting_msg = msg;
1078
1079	flags = ipmi_ssif_lock_cond(ssif_info, &oflags);
1080	start_next_msg(ssif_info, flags);
1081
1082	if (ssif_info->ssif_debug & SSIF_DEBUG_TIMING) {
1083		struct timespec64 t;
1084
1085		ktime_get_real_ts64(&t);
1086		dev_dbg(&ssif_info->client->dev, "**Enqueue %02x %02x: %ptSp\n",
1087			msg->data[0], msg->data[1], &t);
1088	}
1089	return IPMI_CC_NO_ERROR;
1090}
1091
1092static int get_smi_info(void *send_info, struct ipmi_smi_info *data)
1093{
1094	struct ssif_info *ssif_info = send_info;
1095
1096	data->addr_src = ssif_info->addr_source;
1097	data->dev = &ssif_info->client->dev;
1098	data->addr_info = ssif_info->addr_info;
1099	get_device(data->dev);
1100
1101	return 0;
1102}
1103
1104/*
1105 * Upper layer wants us to request events.
1106 */
1107static void request_events(void *send_info)
1108{
1109	struct ssif_info *ssif_info = send_info;
1110	unsigned long oflags, *flags;
1111
1112	if (!ssif_info->has_event_buffer)
1113		return;
1114
1115	flags = ipmi_ssif_lock_cond(ssif_info, &oflags);
1116	ssif_info->req_events = true;
1117	ipmi_ssif_unlock_cond(ssif_info, flags);
1118}
1119
1120/*
1121 * Upper layer is changing the flag saying whether we need to request
1122 * flags periodically or not.
1123 */
1124static void ssif_set_need_watch(void *send_info, unsigned int watch_mask)
1125{
1126	struct ssif_info *ssif_info = send_info;
1127	unsigned long oflags, *flags;
1128	long timeout = 0;
1129
1130	if (watch_mask & IPMI_WATCH_MASK_CHECK_MESSAGES)
1131		timeout = SSIF_WATCH_MSG_TIMEOUT;
1132	else if (watch_mask)
1133		timeout = SSIF_WATCH_WATCHDOG_TIMEOUT;
1134
1135	flags = ipmi_ssif_lock_cond(ssif_info, &oflags);
1136	if (timeout != ssif_info->watch_timeout) {
1137		ssif_info->watch_timeout = timeout;
1138		if (ssif_info->watch_timeout)
1139			mod_timer(&ssif_info->watch_timer,
1140				  jiffies + ssif_info->watch_timeout);
1141	}
1142	ipmi_ssif_unlock_cond(ssif_info, flags);
1143}
1144
1145static int ssif_start_processing(void            *send_info,
1146				 struct ipmi_smi *intf)
1147{
1148	struct ssif_info *ssif_info = send_info;
1149
1150	ssif_info->intf = intf;
1151
1152	return 0;
1153}
1154
1155#define MAX_SSIF_BMCS 4
1156
1157static unsigned short addr[MAX_SSIF_BMCS];
1158static int num_addrs;
1159module_param_array(addr, ushort, &num_addrs, 0);
1160MODULE_PARM_DESC(addr, "The addresses to scan for IPMI BMCs on the SSIFs.");
1161
1162static char *adapter_name[MAX_SSIF_BMCS];
1163static int num_adapter_names;
1164module_param_array(adapter_name, charp, &num_adapter_names, 0);
1165MODULE_PARM_DESC(adapter_name, "The string name of the I2C device that has the BMC.  By default all devices are scanned.");
1166
1167static int slave_addrs[MAX_SSIF_BMCS];
1168static int num_slave_addrs;
1169module_param_array(slave_addrs, int, &num_slave_addrs, 0);
1170MODULE_PARM_DESC(slave_addrs,
1171		 "The default IPMB slave address for the controller.");
1172
1173static bool alerts_broken;
1174module_param(alerts_broken, bool, 0);
1175MODULE_PARM_DESC(alerts_broken, "Don't enable alerts for the controller.");
1176
1177/*
1178 * Bit 0 enables message debugging, bit 1 enables state debugging, and
1179 * bit 2 enables timing debugging.  This is an array indexed by
1180 * interface number"
1181 */
1182static int dbg[MAX_SSIF_BMCS];
1183static int num_dbg;
1184module_param_array(dbg, int, &num_dbg, 0);
1185MODULE_PARM_DESC(dbg, "Turn on debugging.");
1186
1187static bool ssif_dbg_probe;
1188module_param_named(dbg_probe, ssif_dbg_probe, bool, 0);
1189MODULE_PARM_DESC(dbg_probe, "Enable debugging of probing of adapters.");
1190
1191static bool ssif_tryacpi = true;
1192module_param_named(tryacpi, ssif_tryacpi, bool, 0);
1193MODULE_PARM_DESC(tryacpi, "Setting this to zero will disable the default scan of the interfaces identified via ACPI");
1194
1195static bool ssif_trydmi = true;
1196module_param_named(trydmi, ssif_trydmi, bool, 0);
1197MODULE_PARM_DESC(trydmi, "Setting this to zero will disable the default scan of the interfaces identified via DMI (SMBIOS)");
1198
1199static DEFINE_MUTEX(ssif_infos_mutex);
1200static LIST_HEAD(ssif_infos);
1201
1202#define IPMI_SSIF_ATTR(name) \
1203static ssize_t ipmi_##name##_show(struct device *dev,			\
1204				  struct device_attribute *attr,	\
1205				  char *buf)				\
1206{									\
1207	struct ssif_info *ssif_info = dev_get_drvdata(dev);		\
1208									\
1209	return sysfs_emit(buf, "%u\n", ssif_get_stat(ssif_info, name));\
1210}									\
1211static DEVICE_ATTR(name, S_IRUGO, ipmi_##name##_show, NULL)
1212
1213static ssize_t ipmi_type_show(struct device *dev,
1214			      struct device_attribute *attr,
1215			      char *buf)
1216{
1217	return sysfs_emit(buf, "ssif\n");
1218}
1219static DEVICE_ATTR(type, S_IRUGO, ipmi_type_show, NULL);
1220
1221IPMI_SSIF_ATTR(sent_messages);
1222IPMI_SSIF_ATTR(sent_messages_parts);
1223IPMI_SSIF_ATTR(send_retries);
1224IPMI_SSIF_ATTR(send_errors);
1225IPMI_SSIF_ATTR(received_messages);
1226IPMI_SSIF_ATTR(received_message_parts);
1227IPMI_SSIF_ATTR(receive_retries);
1228IPMI_SSIF_ATTR(receive_errors);
1229IPMI_SSIF_ATTR(flag_fetches);
1230IPMI_SSIF_ATTR(hosed);
1231IPMI_SSIF_ATTR(events);
1232IPMI_SSIF_ATTR(watchdog_pretimeouts);
1233IPMI_SSIF_ATTR(alerts);
1234
1235static struct attribute *ipmi_ssif_dev_attrs[] = {
1236	&dev_attr_type.attr,
1237	&dev_attr_sent_messages.attr,
1238	&dev_attr_sent_messages_parts.attr,
1239	&dev_attr_send_retries.attr,
1240	&dev_attr_send_errors.attr,
1241	&dev_attr_received_messages.attr,
1242	&dev_attr_received_message_parts.attr,
1243	&dev_attr_receive_retries.attr,
1244	&dev_attr_receive_errors.attr,
1245	&dev_attr_flag_fetches.attr,
1246	&dev_attr_hosed.attr,
1247	&dev_attr_events.attr,
1248	&dev_attr_watchdog_pretimeouts.attr,
1249	&dev_attr_alerts.attr,
1250	NULL
1251};
1252
1253static const struct attribute_group ipmi_ssif_dev_attr_group = {
1254	.attrs		= ipmi_ssif_dev_attrs,
1255};
1256
1257static void shutdown_ssif(void *send_info)
1258{
1259	struct ssif_info *ssif_info = send_info;
1260
1261	device_remove_group(&ssif_info->client->dev, &ipmi_ssif_dev_attr_group);
1262	dev_set_drvdata(&ssif_info->client->dev, NULL);
1263
1264	/* make sure the driver is not looking for flags any more. */
1265	while (ssif_info->ssif_state != SSIF_IDLE)
1266		schedule_timeout(1);
1267
1268	ssif_info->stopping = true;
1269	timer_delete_sync(&ssif_info->watch_timer);
1270	timer_delete_sync(&ssif_info->retry_timer);
1271	if (ssif_info->thread)
1272		kthread_stop(ssif_info->thread);
1273}
1274
1275static void ssif_remove(struct i2c_client *client)
1276{
1277	struct ssif_info *ssif_info = i2c_get_clientdata(client);
1278	struct ssif_addr_info *addr_info;
1279
1280	/*
1281	 * After this point, we won't deliver anything asynchronously
1282	 * to the message handler.  We can unregister ourself.
1283	 */
1284	ipmi_unregister_smi(ssif_info->intf);
1285
1286	list_for_each_entry(addr_info, &ssif_infos, link) {
1287		if (addr_info->client == client) {
1288			addr_info->client = NULL;
1289			break;
1290		}
1291	}
1292
1293	kfree(ssif_info);
1294}
1295
1296static int read_response(struct i2c_client *client, unsigned char *resp)
1297{
1298	int ret = -ENODEV, retry_cnt = SSIF_RECV_RETRIES;
1299
1300	while (retry_cnt > 0) {
1301		ret = i2c_smbus_read_block_data(client, SSIF_IPMI_RESPONSE,
1302						resp);
1303		if (ret > 0)
1304			break;
1305		msleep(SSIF_MSG_MSEC);
1306		retry_cnt--;
1307		if (retry_cnt <= 0)
1308			break;
1309	}
1310
1311	return ret;
1312}
1313
1314static int do_cmd(struct i2c_client *client, int len, unsigned char *msg,
1315		  int *resp_len, unsigned char *resp)
1316{
1317	int retry_cnt;
1318	int ret;
1319
1320	retry_cnt = SSIF_SEND_RETRIES;
1321 retry1:
1322	ret = i2c_smbus_write_block_data(client, SSIF_IPMI_REQUEST, len, msg);
1323	if (ret) {
1324		retry_cnt--;
1325		if (retry_cnt > 0) {
1326			msleep(SSIF_REQ_RETRY_MSEC);
1327			goto retry1;
1328		}
1329		return -ENODEV;
1330	}
1331
1332	ret = read_response(client, resp);
1333	if (ret > 0) {
1334		/* Validate that the response is correct. */
1335		if (ret < 3 ||
1336		    (resp[0] != (msg[0] | (1 << 2))) ||
1337		    (resp[1] != msg[1]))
1338			ret = -EINVAL;
1339		else if (ret > IPMI_MAX_MSG_LENGTH) {
1340			ret = -E2BIG;
1341		} else {
1342			*resp_len = ret;
1343			ret = 0;
1344		}
1345	}
1346
1347	return ret;
1348}
1349
1350static int ssif_detect(struct i2c_client *client, struct i2c_board_info *info)
1351{
1352	unsigned char *resp;
1353	unsigned char msg[3];
1354	int           rv;
1355	int           len;
1356
1357	resp = kmalloc(IPMI_MAX_MSG_LENGTH, GFP_KERNEL);
1358	if (!resp)
1359		return -ENOMEM;
1360
1361	/* Do a Get Device ID command, since it is required. */
1362	msg[0] = IPMI_NETFN_APP_REQUEST << 2;
1363	msg[1] = IPMI_GET_DEVICE_ID_CMD;
1364	rv = do_cmd(client, 2, msg, &len, resp);
1365	if (rv)
1366		rv = -ENODEV;
1367	else {
1368	    if (len < 3) {
1369		rv = -ENODEV;
1370	    } else {
1371		struct ipmi_device_id id;
1372
1373		rv = ipmi_demangle_device_id(resp[0] >> 2, resp[1],
1374					     resp + 2, len - 2, &id);
1375		if (rv)
1376		    rv = -ENODEV; /* Error means a BMC probably isn't there. */
1377	    }
1378	    if (!rv && info)
1379		strscpy(info->type, DEVICE_NAME, I2C_NAME_SIZE);
1380	}
1381	kfree(resp);
1382	return rv;
1383}
1384
1385static int strcmp_nospace(char *s1, char *s2)
1386{
1387	while (*s1 && *s2) {
1388		while (isspace(*s1))
1389			s1++;
1390		while (isspace(*s2))
1391			s2++;
1392		if (*s1 > *s2)
1393			return 1;
1394		if (*s1 < *s2)
1395			return -1;
1396		s1++;
1397		s2++;
1398	}
1399	return 0;
1400}
1401
1402static struct ssif_addr_info *ssif_info_find(unsigned short addr,
1403					     char *adapter_name,
1404					     bool match_null_name)
1405{
1406	struct ssif_addr_info *info, *found = NULL;
1407
1408restart:
1409	list_for_each_entry(info, &ssif_infos, link) {
1410		if (info->binfo.addr == addr) {
1411			if (info->addr_src == SI_SMBIOS && !info->adapter_name)
1412				info->adapter_name = kstrdup(adapter_name,
1413							     GFP_KERNEL);
1414
1415			if (info->adapter_name || adapter_name) {
1416				if (!info->adapter_name != !adapter_name) {
1417					/* One is NULL and one is not */
1418					continue;
1419				}
1420				if (adapter_name &&
1421				    strcmp_nospace(info->adapter_name,
1422						   adapter_name))
1423					/* Names do not match */
1424					continue;
1425			}
1426			found = info;
1427			break;
1428		}
1429	}
1430
1431	if (!found && match_null_name) {
1432		/* Try to get an exact match first, then try with a NULL name */
1433		adapter_name = NULL;
1434		match_null_name = false;
1435		goto restart;
1436	}
1437
1438	return found;
1439}
1440
1441static bool check_acpi(struct ssif_info *ssif_info, struct device *dev)
1442{
1443#ifdef CONFIG_ACPI
1444	acpi_handle acpi_handle;
1445
1446	acpi_handle = ACPI_HANDLE(dev);
1447	if (acpi_handle) {
1448		ssif_info->addr_source = SI_ACPI;
1449		ssif_info->addr_info.acpi_info.acpi_handle = acpi_handle;
1450		request_module_nowait("acpi_ipmi");
1451		return true;
1452	}
1453#endif
1454	return false;
1455}
1456
1457static int find_slave_address(struct i2c_client *client, int slave_addr)
1458{
1459#ifdef CONFIG_IPMI_DMI_DECODE
1460	if (!slave_addr)
1461		slave_addr = ipmi_dmi_get_slave_addr(
1462			SI_TYPE_INVALID,
1463			i2c_adapter_id(client->adapter),
1464			client->addr);
1465#endif
1466
1467	return slave_addr;
1468}
1469
1470static int start_multipart_test(struct i2c_client *client,
1471				unsigned char *msg, bool do_middle)
1472{
1473	int retry_cnt = SSIF_SEND_RETRIES, ret;
1474
1475retry_write:
1476	ret = i2c_smbus_write_block_data(client,
1477					 SSIF_IPMI_MULTI_PART_REQUEST_START,
1478					 32, msg);
1479	if (ret) {
1480		retry_cnt--;
1481		if (retry_cnt > 0) {
1482			msleep(SSIF_REQ_RETRY_MSEC);
1483			goto retry_write;
1484		}
1485		dev_err(&client->dev, "Could not write multi-part start, though the BMC said it could handle it.  Just limit sends to one part.\n");
1486		return ret;
1487	}
1488
1489	if (!do_middle)
1490		return 0;
1491
1492	ret = i2c_smbus_write_block_data(client,
1493					 SSIF_IPMI_MULTI_PART_REQUEST_MIDDLE,
1494					 32, msg + 32);
1495	if (ret) {
1496		dev_err(&client->dev, "Could not write multi-part middle, though the BMC said it could handle it.  Just limit sends to one part.\n");
1497		return ret;
1498	}
1499
1500	return 0;
1501}
1502
1503static void test_multipart_messages(struct i2c_client *client,
1504				    struct ssif_info *ssif_info,
1505				    unsigned char *resp)
1506{
1507	unsigned char msg[65];
1508	int ret;
1509	bool do_middle;
1510
1511	if (ssif_info->max_xmit_msg_size <= 32)
1512		return;
1513
1514	do_middle = ssif_info->max_xmit_msg_size > 63;
1515
1516	memset(msg, 0, sizeof(msg));
1517	msg[0] = IPMI_NETFN_APP_REQUEST << 2;
1518	msg[1] = IPMI_GET_DEVICE_ID_CMD;
1519
1520	/*
1521	 * The specification is all messed up dealing with sending
1522	 * multi-part messages.  Per what the specification says, it
1523	 * is impossible to send a message that is a multiple of 32
1524	 * bytes, except for 32 itself.  It talks about a "start"
1525	 * transaction (cmd=6) that must be 32 bytes, "middle"
1526	 * transaction (cmd=7) that must be 32 bytes, and an "end"
1527	 * transaction.  The "end" transaction is shown as cmd=7 in
1528	 * the text, but if that's the case there is no way to
1529	 * differentiate between a middle and end part except the
1530	 * length being less than 32.  But there is a table at the far
1531	 * end of the section (that I had never noticed until someone
1532	 * pointed it out to me) that mentions it as cmd=8.
1533	 *
1534	 * After some thought, I think the example is wrong and the
1535	 * end transaction should be cmd=8.  But some systems don't
1536	 * implement cmd=8, they use a zero-length end transaction,
1537	 * even though that violates the SMBus specification.
1538	 *
1539	 * So, to work around this, this code tests if cmd=8 works.
1540	 * If it does, then we use that.  If not, it tests zero-
1541	 * byte end transactions.  If that works, good.  If not,
1542	 * we only allow 63-byte transactions max.
1543	 */
1544
1545	ret = start_multipart_test(client, msg, do_middle);
1546	if (ret)
1547		goto out_no_multi_part;
1548
1549	ret = i2c_smbus_write_block_data(client,
1550					 SSIF_IPMI_MULTI_PART_REQUEST_END,
1551					 1, msg + 64);
1552
1553	if (!ret)
1554		ret = read_response(client, resp);
1555
1556	if (ret > 0) {
1557		/* End transactions work, we are good. */
1558		ssif_info->cmd8_works = true;
1559		return;
1560	}
1561
1562	ret = start_multipart_test(client, msg, do_middle);
1563	if (ret) {
1564		dev_err(&client->dev, "Second multipart test failed.\n");
1565		goto out_no_multi_part;
1566	}
1567
1568	ret = i2c_smbus_write_block_data(client,
1569					 SSIF_IPMI_MULTI_PART_REQUEST_MIDDLE,
1570					 0, msg + 64);
1571	if (!ret)
1572		ret = read_response(client, resp);
1573	if (ret > 0)
1574		/* Zero-size end parts work, use those. */
1575		return;
1576
1577	/* Limit to 63 bytes and use a short middle command to mark the end. */
1578	if (ssif_info->max_xmit_msg_size > 63)
1579		ssif_info->max_xmit_msg_size = 63;
1580	return;
1581
1582out_no_multi_part:
1583	ssif_info->max_xmit_msg_size = 32;
1584	return;
1585}
1586
1587/*
1588 * Global enables we care about.
1589 */
1590#define GLOBAL_ENABLES_MASK (IPMI_BMC_EVT_MSG_BUFF | IPMI_BMC_RCV_MSG_INTR | \
1591			     IPMI_BMC_EVT_MSG_INTR)
1592
1593static void ssif_remove_dup(struct i2c_client *client)
1594{
1595	struct ssif_info *ssif_info = i2c_get_clientdata(client);
1596
1597	ipmi_unregister_smi(ssif_info->intf);
1598	kfree(ssif_info);
1599}
1600
1601static int ssif_add_infos(struct i2c_client *client)
1602{
1603	struct ssif_addr_info *info;
1604
1605	info = kzalloc(sizeof(*info), GFP_KERNEL);
1606	if (!info)
1607		return -ENOMEM;
1608	info->addr_src = SI_ACPI;
1609	info->client = client;
1610	info->adapter_name = kstrdup(client->adapter->name, GFP_KERNEL);
1611	if (!info->adapter_name) {
1612		kfree(info);
1613		return -ENOMEM;
1614	}
1615
1616	info->binfo.addr = client->addr;
1617	list_add_tail(&info->link, &ssif_infos);
1618	return 0;
1619}
1620
1621/*
1622 * Prefer ACPI over SMBIOS, if both are available.
1623 * So if we get an ACPI interface and have already registered a SMBIOS
1624 * interface at the same address, remove the SMBIOS and add the ACPI one.
1625 */
1626static int ssif_check_and_remove(struct i2c_client *client,
1627			      struct ssif_info *ssif_info)
1628{
1629	struct ssif_addr_info *info;
1630
1631	list_for_each_entry(info, &ssif_infos, link) {
1632		if (!info->client)
1633			return 0;
1634		if (!strcmp(info->adapter_name, client->adapter->name) &&
1635		    info->binfo.addr == client->addr) {
1636			if (info->addr_src == SI_ACPI)
1637				return -EEXIST;
1638
1639			if (ssif_info->addr_source == SI_ACPI &&
1640			    info->addr_src == SI_SMBIOS) {
1641				dev_info(&client->dev,
1642					 "Removing %s-specified SSIF interface in favor of ACPI\n",
1643					 ipmi_addr_src_to_str(info->addr_src));
1644				ssif_remove_dup(info->client);
1645				return 0;
1646			}
1647		}
1648	}
1649	return 0;
1650}
1651
1652static int ssif_probe(struct i2c_client *client)
1653{
1654	unsigned char     msg[3];
1655	unsigned char     *resp;
1656	struct ssif_info   *ssif_info;
1657	int               rv = 0;
1658	int               len = 0;
1659	int               i;
1660	u8		  slave_addr = 0;
1661	struct ssif_addr_info *addr_info = NULL;
1662
1663	mutex_lock(&ssif_infos_mutex);
1664	resp = kmalloc(IPMI_MAX_MSG_LENGTH, GFP_KERNEL);
1665	if (!resp) {
1666		mutex_unlock(&ssif_infos_mutex);
1667		return -ENOMEM;
1668	}
1669
1670	ssif_info = kzalloc(sizeof(*ssif_info), GFP_KERNEL);
1671	if (!ssif_info) {
1672		kfree(resp);
1673		mutex_unlock(&ssif_infos_mutex);
1674		return -ENOMEM;
1675	}
1676
1677	if (!check_acpi(ssif_info, &client->dev)) {
1678		addr_info = ssif_info_find(client->addr, client->adapter->name,
1679					   true);
1680		if (!addr_info) {
1681			/* Must have come in through sysfs. */
1682			ssif_info->addr_source = SI_HOTMOD;
1683		} else {
1684			ssif_info->addr_source = addr_info->addr_src;
1685			ssif_info->ssif_debug = addr_info->debug;
1686			ssif_info->addr_info = addr_info->addr_info;
1687			addr_info->client = client;
1688			slave_addr = addr_info->slave_addr;
1689		}
1690	}
1691
1692	ssif_info->client = client;
1693	i2c_set_clientdata(client, ssif_info);
1694
1695	rv = ssif_check_and_remove(client, ssif_info);
1696	/* If rv is 0 and addr source is not SI_ACPI, continue probing */
1697	if (!rv && ssif_info->addr_source == SI_ACPI) {
1698		rv = ssif_add_infos(client);
1699		if (rv) {
1700			dev_err(&client->dev, "Out of memory!, exiting ..\n");
1701			goto out;
1702		}
1703	} else if (rv) {
1704		dev_err(&client->dev, "Not probing, Interface already present\n");
1705		goto out;
1706	}
1707
1708	slave_addr = find_slave_address(client, slave_addr);
1709
1710	dev_info(&client->dev,
1711		 "Trying %s-specified SSIF interface at i2c address 0x%x, adapter %s, slave address 0x%x\n",
1712		ipmi_addr_src_to_str(ssif_info->addr_source),
1713		client->addr, client->adapter->name, slave_addr);
1714
1715	/*
1716	 * Send a get device id command and validate its response to
1717	 * make sure a valid BMC is there.
1718	 */
1719	rv = ssif_detect(client, NULL);
1720	if (rv) {
1721		dev_err(&client->dev, "Not present\n");
1722		goto out;
1723	}
1724
1725	/* Now check for system interface capabilities */
1726	msg[0] = IPMI_NETFN_APP_REQUEST << 2;
1727	msg[1] = IPMI_GET_SYSTEM_INTERFACE_CAPABILITIES_CMD;
1728	msg[2] = 0; /* SSIF */
1729	rv = do_cmd(client, 3, msg, &len, resp);
1730	if (!rv && (len >= 3) && (resp[2] == 0)) {
1731		if (len < 7) {
1732			if (ssif_dbg_probe)
1733				dev_dbg(&ssif_info->client->dev,
1734					"SSIF info too short: %d\n", len);
1735			goto no_support;
1736		}
1737
1738		/* Got a good SSIF response, handle it. */
1739		ssif_info->max_xmit_msg_size = resp[5];
1740		ssif_info->max_recv_msg_size = resp[6];
1741		ssif_info->multi_support = (resp[4] >> 6) & 0x3;
1742		ssif_info->supports_pec = (resp[4] >> 3) & 0x1;
1743
1744		/* Sanitize the data */
1745		switch (ssif_info->multi_support) {
1746		case SSIF_NO_MULTI:
1747			if (ssif_info->max_xmit_msg_size > 32)
1748				ssif_info->max_xmit_msg_size = 32;
1749			if (ssif_info->max_recv_msg_size > 32)
1750				ssif_info->max_recv_msg_size = 32;
1751			break;
1752
1753		case SSIF_MULTI_2_PART:
1754			if (ssif_info->max_xmit_msg_size > 63)
1755				ssif_info->max_xmit_msg_size = 63;
1756			if (ssif_info->max_recv_msg_size > 62)
1757				ssif_info->max_recv_msg_size = 62;
1758			break;
1759
1760		case SSIF_MULTI_n_PART:
1761			/* We take whatever size given, but do some testing. */
1762			break;
1763
1764		default:
1765			/* Data is not sane, just give up. */
1766			goto no_support;
1767		}
1768	} else {
1769 no_support:
1770		/* Assume no multi-part or PEC support */
1771		dev_info(&ssif_info->client->dev,
1772			 "Error fetching SSIF: %d %d %2.2x, your system probably doesn't support this command so using defaults\n",
1773			rv, len, resp[2]);
1774
1775		ssif_info->max_xmit_msg_size = 32;
1776		ssif_info->max_recv_msg_size = 32;
1777		ssif_info->multi_support = SSIF_NO_MULTI;
1778		ssif_info->supports_pec = 0;
1779	}
1780
1781	test_multipart_messages(client, ssif_info, resp);
1782
1783	/* Make sure the NMI timeout is cleared. */
1784	msg[0] = IPMI_NETFN_APP_REQUEST << 2;
1785	msg[1] = IPMI_CLEAR_MSG_FLAGS_CMD;
1786	msg[2] = WDT_PRE_TIMEOUT_INT;
1787	rv = do_cmd(client, 3, msg, &len, resp);
1788	if (rv || (len < 3) || (resp[2] != 0))
1789		dev_warn(&ssif_info->client->dev,
1790			 "Unable to clear message flags: %d %d %2.2x\n",
1791			 rv, len, resp[2]);
1792
1793	/* Attempt to enable the event buffer. */
1794	msg[0] = IPMI_NETFN_APP_REQUEST << 2;
1795	msg[1] = IPMI_GET_BMC_GLOBAL_ENABLES_CMD;
1796	rv = do_cmd(client, 2, msg, &len, resp);
1797	if (rv || (len < 4) || (resp[2] != 0)) {
1798		dev_warn(&ssif_info->client->dev,
1799			 "Error getting global enables: %d %d %2.2x\n",
1800			 rv, len, resp[2]);
1801		rv = 0; /* Not fatal */
1802		goto found;
1803	}
1804
1805	ssif_info->global_enables = resp[3];
1806
1807	if (resp[3] & IPMI_BMC_EVT_MSG_BUFF) {
1808		ssif_info->has_event_buffer = true;
1809		/* buffer is already enabled, nothing to do. */
1810		goto found;
1811	}
1812
1813	msg[0] = IPMI_NETFN_APP_REQUEST << 2;
1814	msg[1] = IPMI_SET_BMC_GLOBAL_ENABLES_CMD;
1815	msg[2] = ssif_info->global_enables | IPMI_BMC_EVT_MSG_BUFF;
1816	rv = do_cmd(client, 3, msg, &len, resp);
1817	if (rv || (len < 2)) {
1818		dev_warn(&ssif_info->client->dev,
1819			 "Error setting global enables: %d %d %2.2x\n",
1820			 rv, len, resp[2]);
1821		rv = 0; /* Not fatal */
1822		goto found;
1823	}
1824
1825	if (resp[2] == 0) {
1826		/* A successful return means the event buffer is supported. */
1827		ssif_info->has_event_buffer = true;
1828		ssif_info->global_enables |= IPMI_BMC_EVT_MSG_BUFF;
1829	}
1830
1831	/* Some systems don't behave well if you enable alerts. */
1832	if (alerts_broken)
1833		goto found;
1834
1835	msg[0] = IPMI_NETFN_APP_REQUEST << 2;
1836	msg[1] = IPMI_SET_BMC_GLOBAL_ENABLES_CMD;
1837	msg[2] = ssif_info->global_enables | IPMI_BMC_RCV_MSG_INTR;
1838	rv = do_cmd(client, 3, msg, &len, resp);
1839	if (rv || (len < 2)) {
1840		dev_warn(&ssif_info->client->dev,
1841			 "Error setting global enables: %d %d %2.2x\n",
1842			 rv, len, resp[2]);
1843		rv = 0; /* Not fatal */
1844		goto found;
1845	}
1846
1847	if (resp[2] == 0) {
1848		/* A successful return means the alert is supported. */
1849		ssif_info->supports_alert = true;
1850		ssif_info->global_enables |= IPMI_BMC_RCV_MSG_INTR;
1851	}
1852
1853 found:
1854	if (ssif_dbg_probe) {
1855		dev_dbg(&ssif_info->client->dev,
1856		       "%s: i2c_probe found device at i2c address %x\n",
1857		       __func__, client->addr);
1858	}
1859
1860	spin_lock_init(&ssif_info->lock);
1861	ssif_info->ssif_state = SSIF_IDLE;
1862	timer_setup(&ssif_info->retry_timer, retry_timeout, 0);
1863	timer_setup(&ssif_info->watch_timer, watch_timeout, 0);
1864
1865	for (i = 0; i < SSIF_NUM_STATS; i++)
1866		atomic_set(&ssif_info->stats[i], 0);
1867
1868	if (ssif_info->supports_pec)
1869		ssif_info->client->flags |= I2C_CLIENT_PEC;
1870
1871	ssif_info->handlers.owner = THIS_MODULE;
1872	ssif_info->handlers.start_processing = ssif_start_processing;
1873	ssif_info->handlers.shutdown = shutdown_ssif;
1874	ssif_info->handlers.get_smi_info = get_smi_info;
1875	ssif_info->handlers.sender = sender;
1876	ssif_info->handlers.request_events = request_events;
1877	ssif_info->handlers.set_need_watch = ssif_set_need_watch;
1878
1879	{
1880		unsigned int thread_num;
1881
1882		thread_num = ((i2c_adapter_id(ssif_info->client->adapter)
1883			       << 8) |
1884			      ssif_info->client->addr);
1885		init_completion(&ssif_info->wake_thread);
1886		ssif_info->thread = kthread_run(ipmi_ssif_thread, ssif_info,
1887					       "kssif%4.4x", thread_num);
1888		if (IS_ERR(ssif_info->thread)) {
1889			rv = PTR_ERR(ssif_info->thread);
1890			dev_notice(&ssif_info->client->dev,
1891				   "Could not start kernel thread: error %d\n",
1892				   rv);
1893			goto out;
1894		}
1895	}
1896
1897	dev_set_drvdata(&ssif_info->client->dev, ssif_info);
1898	rv = device_add_group(&ssif_info->client->dev,
1899			      &ipmi_ssif_dev_attr_group);
1900	if (rv) {
1901		dev_err(&ssif_info->client->dev,
1902			"Unable to add device attributes: error %d\n",
1903			rv);
1904		goto out;
1905	}
1906
1907	rv = ipmi_register_smi(&ssif_info->handlers,
1908			       ssif_info,
1909			       &ssif_info->client->dev,
1910			       slave_addr);
1911	if (rv) {
1912		dev_err(&ssif_info->client->dev,
1913			"Unable to register device: error %d\n", rv);
1914		goto out_remove_attr;
1915	}
1916
1917 out:
1918	if (rv) {
1919		if (addr_info)
1920			addr_info->client = NULL;
1921
1922		dev_err(&ssif_info->client->dev,
1923			"Unable to start IPMI SSIF: %d\n", rv);
1924		i2c_set_clientdata(client, NULL);
1925		kfree(ssif_info);
1926	}
1927	kfree(resp);
1928	mutex_unlock(&ssif_infos_mutex);
1929	return rv;
1930
1931out_remove_attr:
1932	device_remove_group(&ssif_info->client->dev, &ipmi_ssif_dev_attr_group);
1933	dev_set_drvdata(&ssif_info->client->dev, NULL);
1934	goto out;
1935}
1936
1937static int new_ssif_client(int addr, char *adapter_name,
1938			   int debug, int slave_addr,
1939			   enum ipmi_addr_src addr_src,
1940			   struct device *dev)
1941{
1942	struct ssif_addr_info *addr_info;
1943	int rv = 0;
1944
1945	mutex_lock(&ssif_infos_mutex);
1946	if (ssif_info_find(addr, adapter_name, false)) {
1947		rv = -EEXIST;
1948		goto out_unlock;
1949	}
1950
1951	addr_info = kzalloc(sizeof(*addr_info), GFP_KERNEL);
1952	if (!addr_info) {
1953		rv = -ENOMEM;
1954		goto out_unlock;
1955	}
1956
1957	if (adapter_name) {
1958		addr_info->adapter_name = kstrdup(adapter_name, GFP_KERNEL);
1959		if (!addr_info->adapter_name) {
1960			kfree(addr_info);
1961			rv = -ENOMEM;
1962			goto out_unlock;
1963		}
1964	}
1965
1966	strscpy(addr_info->binfo.type, DEVICE_NAME,
1967		sizeof(addr_info->binfo.type));
1968	addr_info->binfo.addr = addr;
1969	addr_info->binfo.platform_data = addr_info;
1970	addr_info->debug = debug;
1971	addr_info->slave_addr = slave_addr;
1972	addr_info->addr_src = addr_src;
1973	addr_info->dev = dev;
1974
1975	if (dev)
1976		dev_set_drvdata(dev, addr_info);
1977
1978	list_add_tail(&addr_info->link, &ssif_infos);
1979
1980	/* Address list will get it */
1981
1982out_unlock:
1983	mutex_unlock(&ssif_infos_mutex);
1984	return rv;
1985}
1986
1987static void free_ssif_clients(void)
1988{
1989	struct ssif_addr_info *info, *tmp;
1990
1991	mutex_lock(&ssif_infos_mutex);
1992	list_for_each_entry_safe(info, tmp, &ssif_infos, link) {
1993		list_del(&info->link);
1994		kfree(info->adapter_name);
1995		kfree(info);
1996	}
1997	mutex_unlock(&ssif_infos_mutex);
1998}
1999
2000static unsigned short *ssif_address_list(void)
2001{
2002	struct ssif_addr_info *info;
2003	unsigned int count = 0, i = 0;
2004	unsigned short *address_list;
2005
2006	list_for_each_entry(info, &ssif_infos, link)
2007		count++;
2008
2009	address_list = kcalloc(count + 1, sizeof(*address_list),
2010			       GFP_KERNEL);
2011	if (!address_list)
2012		return NULL;
2013
2014	list_for_each_entry(info, &ssif_infos, link) {
2015		unsigned short addr = info->binfo.addr;
2016		int j;
2017
2018		for (j = 0; j < i; j++) {
2019			if (address_list[j] == addr)
2020				/* Found a dup. */
2021				break;
2022		}
2023		if (j == i) /* Didn't find it in the list. */
2024			address_list[i++] = addr;
2025	}
2026	address_list[i] = I2C_CLIENT_END;
2027
2028	return address_list;
2029}
2030
2031#ifdef CONFIG_ACPI
2032static const struct acpi_device_id ssif_acpi_match[] = {
2033	{ "IPI0001", 0 },
2034	{ },
2035};
2036MODULE_DEVICE_TABLE(acpi, ssif_acpi_match);
2037#endif
2038
2039#ifdef CONFIG_DMI
2040static int dmi_ipmi_probe(struct platform_device *pdev)
2041{
2042	u8 slave_addr = 0;
2043	u16 i2c_addr;
2044	int rv;
2045
2046	if (!ssif_trydmi)
2047		return -ENODEV;
2048
2049	rv = device_property_read_u16(&pdev->dev, "i2c-addr", &i2c_addr);
2050	if (rv) {
2051		dev_warn(&pdev->dev, "No i2c-addr property\n");
2052		return -ENODEV;
2053	}
2054
2055	rv = device_property_read_u8(&pdev->dev, "slave-addr", &slave_addr);
2056	if (rv)
2057		slave_addr = 0x20;
2058
2059	return new_ssif_client(i2c_addr, NULL, 0,
2060			       slave_addr, SI_SMBIOS, &pdev->dev);
2061}
2062#else
2063static int dmi_ipmi_probe(struct platform_device *pdev)
2064{
2065	return -ENODEV;
2066}
2067#endif
2068
2069static const struct i2c_device_id ssif_id[] = {
2070	{ DEVICE_NAME },
2071	{ }
2072};
2073MODULE_DEVICE_TABLE(i2c, ssif_id);
2074
2075static struct i2c_driver ssif_i2c_driver = {
2076	.class		= I2C_CLASS_HWMON,
2077	.driver		= {
2078		.name			= DEVICE_NAME
2079	},
2080	.probe		= ssif_probe,
2081	.remove		= ssif_remove,
2082	.alert		= ssif_alert,
2083	.id_table	= ssif_id,
2084	.detect		= ssif_detect
2085};
2086
2087static int ssif_platform_probe(struct platform_device *dev)
2088{
2089	return dmi_ipmi_probe(dev);
2090}
2091
2092static void ssif_platform_remove(struct platform_device *dev)
2093{
2094	struct ssif_addr_info *addr_info = dev_get_drvdata(&dev->dev);
2095
2096	mutex_lock(&ssif_infos_mutex);
2097	list_del(&addr_info->link);
2098	kfree(addr_info);
2099	mutex_unlock(&ssif_infos_mutex);
2100}
2101
2102static const struct platform_device_id ssif_plat_ids[] = {
2103    { "dmi-ipmi-ssif", 0 },
2104    { }
2105};
2106MODULE_DEVICE_TABLE(platform, ssif_plat_ids);
2107
2108static struct platform_driver ipmi_driver = {
2109	.driver = {
2110		.name = DEVICE_NAME,
2111	},
2112	.probe		= ssif_platform_probe,
2113	.remove		= ssif_platform_remove,
2114	.id_table       = ssif_plat_ids
2115};
2116
2117static int __init init_ipmi_ssif(void)
2118{
2119	int i;
2120	int rv;
2121
2122	if (initialized)
2123		return 0;
2124
2125	pr_info("IPMI SSIF Interface driver\n");
2126
2127	/* build list for i2c from addr list */
2128	for (i = 0; i < num_addrs; i++) {
2129		rv = new_ssif_client(addr[i], adapter_name[i],
2130				     dbg[i], slave_addrs[i],
2131				     SI_HARDCODED, NULL);
2132		if (rv)
2133			pr_err("Couldn't add hardcoded device at addr 0x%x\n",
2134			       addr[i]);
2135	}
2136
2137	if (ssif_tryacpi)
2138		ssif_i2c_driver.driver.acpi_match_table	=
2139			ACPI_PTR(ssif_acpi_match);
2140
2141	if (ssif_trydmi) {
2142		rv = platform_driver_register(&ipmi_driver);
2143		if (rv)
2144			pr_err("Unable to register driver: %d\n", rv);
2145		else
2146			platform_registered = true;
2147	}
2148
2149	ssif_i2c_driver.address_list = ssif_address_list();
2150
2151	rv = i2c_add_driver(&ssif_i2c_driver);
2152	if (!rv)
2153		initialized = true;
2154
2155	return rv;
2156}
2157module_init(init_ipmi_ssif);
2158
2159static void __exit cleanup_ipmi_ssif(void)
2160{
2161	if (!initialized)
2162		return;
2163
2164	initialized = false;
2165
2166	i2c_del_driver(&ssif_i2c_driver);
2167
2168	kfree(ssif_i2c_driver.address_list);
2169
2170	if (ssif_trydmi && platform_registered)
2171		platform_driver_unregister(&ipmi_driver);
2172
2173	free_ssif_clients();
2174}
2175module_exit(cleanup_ipmi_ssif);
2176
2177MODULE_ALIAS("platform:dmi-ipmi-ssif");
2178MODULE_AUTHOR("Todd C Davis <todd.c.davis@intel.com>, Corey Minyard <minyard@acm.org>");
2179MODULE_DESCRIPTION("IPMI driver for management controllers on a SMBus");
2180MODULE_LICENSE("GPL");