2185 lines · c
1// SPDX-License-Identifier: GPL-2.0+2/*3 * ipmi_ssif.c4 *5 * The interface to the IPMI driver for SMBus access to a SMBus6 * compliant device. Called SSIF by the IPMI spec.7 *8 * Author: Intel Corporation9 * Todd Davis <todd.c.davis@intel.com>10 *11 * Rewritten by Corey Minyard <minyard@acm.org> to support the12 * non-blocking I2C interface, add support for multi-part13 * transactions, add PEC support, and general clenaup.14 *15 * Copyright 2003 Intel Corporation16 * Copyright 2005 MontaVista Software17 */18 19/*20 * This file holds the "policy" for the interface to the SSIF state21 * 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: " fmt26#define dev_fmt(fmt) "ipmi_ssif: " fmt27 28#if defined(MODVERSIONS)29#include <linux/modversions.h>30#endif31 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 0x5755 56#define SSIF_IPMI_REQUEST 257#define SSIF_IPMI_MULTI_PART_REQUEST_START 658#define SSIF_IPMI_MULTI_PART_REQUEST_MIDDLE 759#define SSIF_IPMI_MULTI_PART_REQUEST_END 860#define SSIF_IPMI_RESPONSE 361#define SSIF_IPMI_MULTI_PART_RESPONSE_MIDDLE 962 63/* ssif_debug is a bit-field64 * SSIF_DEBUG_MSG - commands and their responses65 * SSIF_DEBUG_STATES - message states66 * SSIF_DEBUG_TIMING - Measure times between events in the driver67 */68#define SSIF_DEBUG_TIMING 469#define SSIF_DEBUG_STATE 270#define SSIF_DEBUG_MSG 171#define SSIF_NODEBUG 072#define SSIF_DEFAULT_DEBUG (SSIF_NODEBUG)73 74/*75 * Timer values76 */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 583#define SSIF_RECV_RETRIES 25084 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 into118 * 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_STATS178};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 ATTN216 * is set to hold the flags until we are done handling everything217 * from the flags.218 */219#define RECEIVE_MSG_AVAIL 0x01220#define EVENT_MSG_BUFFER_FULL 0x02221#define WDT_PRE_TIMEOUT_INT 0x08222 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 are230 * 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 the240 * state machine is idle.241 */242 bool req_events;243 244 /*245 * If set to true, this will request flags the next time the246 * 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 0283#define SSIF_MULTI_2_PART 1284#define SSIF_MULTI_n_PART 2285 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 the351 * message lock. Note that the caller will check IS_SSIF_IDLE and352 * start a new operation, so there is no need to check for new353 * 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 the451 * message lock. Note that the caller will check IS_SSIF_IDLE and452 * start a new operation, so there is no need to check for new453 * 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 (ssif_info->stopping)485 break;486 if (result == -ERESTARTSYS)487 continue;488 init_completion(&ssif_info->wake_thread);489 490 if (ssif_info->i2c_read_write == I2C_SMBUS_WRITE) {491 result = i2c_smbus_write_block_data(492 ssif_info->client, ssif_info->i2c_command,493 ssif_info->i2c_data[0],494 ssif_info->i2c_data + 1);495 ssif_info->done_handler(ssif_info, result, NULL, 0);496 } else {497 result = i2c_smbus_read_block_data(498 ssif_info->client, ssif_info->i2c_command,499 ssif_info->i2c_data);500 if (result < 0)501 ssif_info->done_handler(ssif_info, result,502 NULL, 0);503 else504 ssif_info->done_handler(ssif_info, 0,505 ssif_info->i2c_data,506 result);507 }508 }509 510 return 0;511}512 513static void ssif_i2c_send(struct ssif_info *ssif_info,514 ssif_i2c_done handler,515 int read_write, int command,516 unsigned char *data, unsigned int size)517{518 ssif_info->done_handler = handler;519 520 ssif_info->i2c_read_write = read_write;521 ssif_info->i2c_command = command;522 ssif_info->i2c_data = data;523 ssif_info->i2c_size = size;524 complete(&ssif_info->wake_thread);525}526 527 528static void msg_done_handler(struct ssif_info *ssif_info, int result,529 unsigned char *data, unsigned int len);530 531static void start_get(struct ssif_info *ssif_info)532{533 ssif_info->multi_pos = 0;534 535 ssif_i2c_send(ssif_info, msg_done_handler, I2C_SMBUS_READ,536 SSIF_IPMI_RESPONSE,537 ssif_info->recv, I2C_SMBUS_BLOCK_DATA);538}539 540static void start_resend(struct ssif_info *ssif_info);541 542static void retry_timeout(struct timer_list *t)543{544 struct ssif_info *ssif_info = from_timer(ssif_info, t, retry_timer);545 unsigned long oflags, *flags;546 bool waiting, resend;547 548 if (ssif_info->stopping)549 return;550 551 flags = ipmi_ssif_lock_cond(ssif_info, &oflags);552 resend = ssif_info->do_resend;553 ssif_info->do_resend = false;554 waiting = ssif_info->waiting_alert;555 ssif_info->waiting_alert = false;556 ipmi_ssif_unlock_cond(ssif_info, flags);557 558 if (waiting)559 start_get(ssif_info);560 if (resend) {561 start_resend(ssif_info);562 ssif_inc_stat(ssif_info, send_retries);563 }564}565 566static void watch_timeout(struct timer_list *t)567{568 struct ssif_info *ssif_info = from_timer(ssif_info, t, 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 del_timer(&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 we620 * 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. Block713 * 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 else771 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) << 2787 || 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) << 2811 || 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) << 2837 || 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) << 2869 || 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 else900 start_next_msg(ssif_info, flags);901 } else902 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 comment939 * in the SSIF_MULTI_n_PART case in the probe function940 * 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 will1006 * overwrite the thing at position 32 (which was just1007 * 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 void sender(void *send_info,1072 struct ipmi_smi_msg *msg)1073{1074 struct ssif_info *ssif_info = send_info;1075 unsigned long oflags, *flags;1076 1077 BUG_ON(ssif_info->waiting_msg);1078 ssif_info->waiting_msg = msg;1079 1080 flags = ipmi_ssif_lock_cond(ssif_info, &oflags);1081 start_next_msg(ssif_info, flags);1082 1083 if (ssif_info->ssif_debug & SSIF_DEBUG_TIMING) {1084 struct timespec64 t;1085 1086 ktime_get_real_ts64(&t);1087 dev_dbg(&ssif_info->client->dev,1088 "**Enqueue %02x %02x: %lld.%6.6ld\n",1089 msg->data[0], msg->data[1],1090 (long long)t.tv_sec, (long)t.tv_nsec / NSEC_PER_USEC);1091 }1092}1093 1094static int get_smi_info(void *send_info, struct ipmi_smi_info *data)1095{1096 struct ssif_info *ssif_info = send_info;1097 1098 data->addr_src = ssif_info->addr_source;1099 data->dev = &ssif_info->client->dev;1100 data->addr_info = ssif_info->addr_info;1101 get_device(data->dev);1102 1103 return 0;1104}1105 1106/*1107 * Upper layer wants us to request events.1108 */1109static void request_events(void *send_info)1110{1111 struct ssif_info *ssif_info = send_info;1112 unsigned long oflags, *flags;1113 1114 if (!ssif_info->has_event_buffer)1115 return;1116 1117 flags = ipmi_ssif_lock_cond(ssif_info, &oflags);1118 ssif_info->req_events = true;1119 ipmi_ssif_unlock_cond(ssif_info, flags);1120}1121 1122/*1123 * Upper layer is changing the flag saying whether we need to request1124 * flags periodically or not.1125 */1126static void ssif_set_need_watch(void *send_info, unsigned int watch_mask)1127{1128 struct ssif_info *ssif_info = send_info;1129 unsigned long oflags, *flags;1130 long timeout = 0;1131 1132 if (watch_mask & IPMI_WATCH_MASK_CHECK_MESSAGES)1133 timeout = SSIF_WATCH_MSG_TIMEOUT;1134 else if (watch_mask)1135 timeout = SSIF_WATCH_WATCHDOG_TIMEOUT;1136 1137 flags = ipmi_ssif_lock_cond(ssif_info, &oflags);1138 if (timeout != ssif_info->watch_timeout) {1139 ssif_info->watch_timeout = timeout;1140 if (ssif_info->watch_timeout)1141 mod_timer(&ssif_info->watch_timer,1142 jiffies + ssif_info->watch_timeout);1143 }1144 ipmi_ssif_unlock_cond(ssif_info, flags);1145}1146 1147static int ssif_start_processing(void *send_info,1148 struct ipmi_smi *intf)1149{1150 struct ssif_info *ssif_info = send_info;1151 1152 ssif_info->intf = intf;1153 1154 return 0;1155}1156 1157#define MAX_SSIF_BMCS 41158 1159static unsigned short addr[MAX_SSIF_BMCS];1160static int num_addrs;1161module_param_array(addr, ushort, &num_addrs, 0);1162MODULE_PARM_DESC(addr, "The addresses to scan for IPMI BMCs on the SSIFs.");1163 1164static char *adapter_name[MAX_SSIF_BMCS];1165static int num_adapter_names;1166module_param_array(adapter_name, charp, &num_adapter_names, 0);1167MODULE_PARM_DESC(adapter_name, "The string name of the I2C device that has the BMC. By default all devices are scanned.");1168 1169static int slave_addrs[MAX_SSIF_BMCS];1170static int num_slave_addrs;1171module_param_array(slave_addrs, int, &num_slave_addrs, 0);1172MODULE_PARM_DESC(slave_addrs,1173 "The default IPMB slave address for the controller.");1174 1175static bool alerts_broken;1176module_param(alerts_broken, bool, 0);1177MODULE_PARM_DESC(alerts_broken, "Don't enable alerts for the controller.");1178 1179/*1180 * Bit 0 enables message debugging, bit 1 enables state debugging, and1181 * bit 2 enables timing debugging. This is an array indexed by1182 * interface number"1183 */1184static int dbg[MAX_SSIF_BMCS];1185static int num_dbg;1186module_param_array(dbg, int, &num_dbg, 0);1187MODULE_PARM_DESC(dbg, "Turn on debugging.");1188 1189static bool ssif_dbg_probe;1190module_param_named(dbg_probe, ssif_dbg_probe, bool, 0);1191MODULE_PARM_DESC(dbg_probe, "Enable debugging of probing of adapters.");1192 1193static bool ssif_tryacpi = true;1194module_param_named(tryacpi, ssif_tryacpi, bool, 0);1195MODULE_PARM_DESC(tryacpi, "Setting this to zero will disable the default scan of the interfaces identified via ACPI");1196 1197static bool ssif_trydmi = true;1198module_param_named(trydmi, ssif_trydmi, bool, 0);1199MODULE_PARM_DESC(trydmi, "Setting this to zero will disable the default scan of the interfaces identified via DMI (SMBIOS)");1200 1201static DEFINE_MUTEX(ssif_infos_mutex);1202static LIST_HEAD(ssif_infos);1203 1204#define IPMI_SSIF_ATTR(name) \1205static ssize_t ipmi_##name##_show(struct device *dev, \1206 struct device_attribute *attr, \1207 char *buf) \1208{ \1209 struct ssif_info *ssif_info = dev_get_drvdata(dev); \1210 \1211 return sysfs_emit(buf, "%u\n", ssif_get_stat(ssif_info, name));\1212} \1213static DEVICE_ATTR(name, S_IRUGO, ipmi_##name##_show, NULL)1214 1215static ssize_t ipmi_type_show(struct device *dev,1216 struct device_attribute *attr,1217 char *buf)1218{1219 return sysfs_emit(buf, "ssif\n");1220}1221static DEVICE_ATTR(type, S_IRUGO, ipmi_type_show, NULL);1222 1223IPMI_SSIF_ATTR(sent_messages);1224IPMI_SSIF_ATTR(sent_messages_parts);1225IPMI_SSIF_ATTR(send_retries);1226IPMI_SSIF_ATTR(send_errors);1227IPMI_SSIF_ATTR(received_messages);1228IPMI_SSIF_ATTR(received_message_parts);1229IPMI_SSIF_ATTR(receive_retries);1230IPMI_SSIF_ATTR(receive_errors);1231IPMI_SSIF_ATTR(flag_fetches);1232IPMI_SSIF_ATTR(hosed);1233IPMI_SSIF_ATTR(events);1234IPMI_SSIF_ATTR(watchdog_pretimeouts);1235IPMI_SSIF_ATTR(alerts);1236 1237static struct attribute *ipmi_ssif_dev_attrs[] = {1238 &dev_attr_type.attr,1239 &dev_attr_sent_messages.attr,1240 &dev_attr_sent_messages_parts.attr,1241 &dev_attr_send_retries.attr,1242 &dev_attr_send_errors.attr,1243 &dev_attr_received_messages.attr,1244 &dev_attr_received_message_parts.attr,1245 &dev_attr_receive_retries.attr,1246 &dev_attr_receive_errors.attr,1247 &dev_attr_flag_fetches.attr,1248 &dev_attr_hosed.attr,1249 &dev_attr_events.attr,1250 &dev_attr_watchdog_pretimeouts.attr,1251 &dev_attr_alerts.attr,1252 NULL1253};1254 1255static const struct attribute_group ipmi_ssif_dev_attr_group = {1256 .attrs = ipmi_ssif_dev_attrs,1257};1258 1259static void shutdown_ssif(void *send_info)1260{1261 struct ssif_info *ssif_info = send_info;1262 1263 device_remove_group(&ssif_info->client->dev, &ipmi_ssif_dev_attr_group);1264 dev_set_drvdata(&ssif_info->client->dev, NULL);1265 1266 /* make sure the driver is not looking for flags any more. */1267 while (ssif_info->ssif_state != SSIF_IDLE)1268 schedule_timeout(1);1269 1270 ssif_info->stopping = true;1271 del_timer_sync(&ssif_info->watch_timer);1272 del_timer_sync(&ssif_info->retry_timer);1273 if (ssif_info->thread) {1274 complete(&ssif_info->wake_thread);1275 kthread_stop(ssif_info->thread);1276 }1277}1278 1279static void ssif_remove(struct i2c_client *client)1280{1281 struct ssif_info *ssif_info = i2c_get_clientdata(client);1282 struct ssif_addr_info *addr_info;1283 1284 /*1285 * After this point, we won't deliver anything asynchronously1286 * to the message handler. We can unregister ourself.1287 */1288 ipmi_unregister_smi(ssif_info->intf);1289 1290 list_for_each_entry(addr_info, &ssif_infos, link) {1291 if (addr_info->client == client) {1292 addr_info->client = NULL;1293 break;1294 }1295 }1296 1297 kfree(ssif_info);1298}1299 1300static int read_response(struct i2c_client *client, unsigned char *resp)1301{1302 int ret = -ENODEV, retry_cnt = SSIF_RECV_RETRIES;1303 1304 while (retry_cnt > 0) {1305 ret = i2c_smbus_read_block_data(client, SSIF_IPMI_RESPONSE,1306 resp);1307 if (ret > 0)1308 break;1309 msleep(SSIF_MSG_MSEC);1310 retry_cnt--;1311 if (retry_cnt <= 0)1312 break;1313 }1314 1315 return ret;1316}1317 1318static int do_cmd(struct i2c_client *client, int len, unsigned char *msg,1319 int *resp_len, unsigned char *resp)1320{1321 int retry_cnt;1322 int ret;1323 1324 retry_cnt = SSIF_SEND_RETRIES;1325 retry1:1326 ret = i2c_smbus_write_block_data(client, SSIF_IPMI_REQUEST, len, msg);1327 if (ret) {1328 retry_cnt--;1329 if (retry_cnt > 0) {1330 msleep(SSIF_REQ_RETRY_MSEC);1331 goto retry1;1332 }1333 return -ENODEV;1334 }1335 1336 ret = read_response(client, resp);1337 if (ret > 0) {1338 /* Validate that the response is correct. */1339 if (ret < 3 ||1340 (resp[0] != (msg[0] | (1 << 2))) ||1341 (resp[1] != msg[1]))1342 ret = -EINVAL;1343 else if (ret > IPMI_MAX_MSG_LENGTH) {1344 ret = -E2BIG;1345 } else {1346 *resp_len = ret;1347 ret = 0;1348 }1349 }1350 1351 return ret;1352}1353 1354static int ssif_detect(struct i2c_client *client, struct i2c_board_info *info)1355{1356 unsigned char *resp;1357 unsigned char msg[3];1358 int rv;1359 int len;1360 1361 resp = kmalloc(IPMI_MAX_MSG_LENGTH, GFP_KERNEL);1362 if (!resp)1363 return -ENOMEM;1364 1365 /* Do a Get Device ID command, since it is required. */1366 msg[0] = IPMI_NETFN_APP_REQUEST << 2;1367 msg[1] = IPMI_GET_DEVICE_ID_CMD;1368 rv = do_cmd(client, 2, msg, &len, resp);1369 if (rv)1370 rv = -ENODEV;1371 else {1372 if (len < 3) {1373 rv = -ENODEV;1374 } else {1375 struct ipmi_device_id id;1376 1377 rv = ipmi_demangle_device_id(resp[0] >> 2, resp[1],1378 resp + 2, len - 2, &id);1379 if (rv)1380 rv = -ENODEV; /* Error means a BMC probably isn't there. */1381 }1382 if (!rv && info)1383 strscpy(info->type, DEVICE_NAME, I2C_NAME_SIZE);1384 }1385 kfree(resp);1386 return rv;1387}1388 1389static int strcmp_nospace(char *s1, char *s2)1390{1391 while (*s1 && *s2) {1392 while (isspace(*s1))1393 s1++;1394 while (isspace(*s2))1395 s2++;1396 if (*s1 > *s2)1397 return 1;1398 if (*s1 < *s2)1399 return -1;1400 s1++;1401 s2++;1402 }1403 return 0;1404}1405 1406static struct ssif_addr_info *ssif_info_find(unsigned short addr,1407 char *adapter_name,1408 bool match_null_name)1409{1410 struct ssif_addr_info *info, *found = NULL;1411 1412restart:1413 list_for_each_entry(info, &ssif_infos, link) {1414 if (info->binfo.addr == addr) {1415 if (info->addr_src == SI_SMBIOS && !info->adapter_name)1416 info->adapter_name = kstrdup(adapter_name,1417 GFP_KERNEL);1418 1419 if (info->adapter_name || adapter_name) {1420 if (!info->adapter_name != !adapter_name) {1421 /* One is NULL and one is not */1422 continue;1423 }1424 if (adapter_name &&1425 strcmp_nospace(info->adapter_name,1426 adapter_name))1427 /* Names do not match */1428 continue;1429 }1430 found = info;1431 break;1432 }1433 }1434 1435 if (!found && match_null_name) {1436 /* Try to get an exact match first, then try with a NULL name */1437 adapter_name = NULL;1438 match_null_name = false;1439 goto restart;1440 }1441 1442 return found;1443}1444 1445static bool check_acpi(struct ssif_info *ssif_info, struct device *dev)1446{1447#ifdef CONFIG_ACPI1448 acpi_handle acpi_handle;1449 1450 acpi_handle = ACPI_HANDLE(dev);1451 if (acpi_handle) {1452 ssif_info->addr_source = SI_ACPI;1453 ssif_info->addr_info.acpi_info.acpi_handle = acpi_handle;1454 request_module_nowait("acpi_ipmi");1455 return true;1456 }1457#endif1458 return false;1459}1460 1461static int find_slave_address(struct i2c_client *client, int slave_addr)1462{1463#ifdef CONFIG_IPMI_DMI_DECODE1464 if (!slave_addr)1465 slave_addr = ipmi_dmi_get_slave_addr(1466 SI_TYPE_INVALID,1467 i2c_adapter_id(client->adapter),1468 client->addr);1469#endif1470 1471 return slave_addr;1472}1473 1474static int start_multipart_test(struct i2c_client *client,1475 unsigned char *msg, bool do_middle)1476{1477 int retry_cnt = SSIF_SEND_RETRIES, ret;1478 1479retry_write:1480 ret = i2c_smbus_write_block_data(client,1481 SSIF_IPMI_MULTI_PART_REQUEST_START,1482 32, msg);1483 if (ret) {1484 retry_cnt--;1485 if (retry_cnt > 0) {1486 msleep(SSIF_REQ_RETRY_MSEC);1487 goto retry_write;1488 }1489 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");1490 return ret;1491 }1492 1493 if (!do_middle)1494 return 0;1495 1496 ret = i2c_smbus_write_block_data(client,1497 SSIF_IPMI_MULTI_PART_REQUEST_MIDDLE,1498 32, msg + 32);1499 if (ret) {1500 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");1501 return ret;1502 }1503 1504 return 0;1505}1506 1507static void test_multipart_messages(struct i2c_client *client,1508 struct ssif_info *ssif_info,1509 unsigned char *resp)1510{1511 unsigned char msg[65];1512 int ret;1513 bool do_middle;1514 1515 if (ssif_info->max_xmit_msg_size <= 32)1516 return;1517 1518 do_middle = ssif_info->max_xmit_msg_size > 63;1519 1520 memset(msg, 0, sizeof(msg));1521 msg[0] = IPMI_NETFN_APP_REQUEST << 2;1522 msg[1] = IPMI_GET_DEVICE_ID_CMD;1523 1524 /*1525 * The specification is all messed up dealing with sending1526 * multi-part messages. Per what the specification says, it1527 * is impossible to send a message that is a multiple of 321528 * bytes, except for 32 itself. It talks about a "start"1529 * transaction (cmd=6) that must be 32 bytes, "middle"1530 * transaction (cmd=7) that must be 32 bytes, and an "end"1531 * transaction. The "end" transaction is shown as cmd=7 in1532 * the text, but if that's the case there is no way to1533 * differentiate between a middle and end part except the1534 * length being less than 32. But there is a table at the far1535 * end of the section (that I had never noticed until someone1536 * pointed it out to me) that mentions it as cmd=8.1537 *1538 * After some thought, I think the example is wrong and the1539 * end transaction should be cmd=8. But some systems don't1540 * implement cmd=8, they use a zero-length end transaction,1541 * even though that violates the SMBus specification.1542 *1543 * So, to work around this, this code tests if cmd=8 works.1544 * If it does, then we use that. If not, it tests zero-1545 * byte end transactions. If that works, good. If not,1546 * we only allow 63-byte transactions max.1547 */1548 1549 ret = start_multipart_test(client, msg, do_middle);1550 if (ret)1551 goto out_no_multi_part;1552 1553 ret = i2c_smbus_write_block_data(client,1554 SSIF_IPMI_MULTI_PART_REQUEST_END,1555 1, msg + 64);1556 1557 if (!ret)1558 ret = read_response(client, resp);1559 1560 if (ret > 0) {1561 /* End transactions work, we are good. */1562 ssif_info->cmd8_works = true;1563 return;1564 }1565 1566 ret = start_multipart_test(client, msg, do_middle);1567 if (ret) {1568 dev_err(&client->dev, "Second multipart test failed.\n");1569 goto out_no_multi_part;1570 }1571 1572 ret = i2c_smbus_write_block_data(client,1573 SSIF_IPMI_MULTI_PART_REQUEST_MIDDLE,1574 0, msg + 64);1575 if (!ret)1576 ret = read_response(client, resp);1577 if (ret > 0)1578 /* Zero-size end parts work, use those. */1579 return;1580 1581 /* Limit to 63 bytes and use a short middle command to mark the end. */1582 if (ssif_info->max_xmit_msg_size > 63)1583 ssif_info->max_xmit_msg_size = 63;1584 return;1585 1586out_no_multi_part:1587 ssif_info->max_xmit_msg_size = 32;1588 return;1589}1590 1591/*1592 * Global enables we care about.1593 */1594#define GLOBAL_ENABLES_MASK (IPMI_BMC_EVT_MSG_BUFF | IPMI_BMC_RCV_MSG_INTR | \1595 IPMI_BMC_EVT_MSG_INTR)1596 1597static void ssif_remove_dup(struct i2c_client *client)1598{1599 struct ssif_info *ssif_info = i2c_get_clientdata(client);1600 1601 ipmi_unregister_smi(ssif_info->intf);1602 kfree(ssif_info);1603}1604 1605static int ssif_add_infos(struct i2c_client *client)1606{1607 struct ssif_addr_info *info;1608 1609 info = kzalloc(sizeof(*info), GFP_KERNEL);1610 if (!info)1611 return -ENOMEM;1612 info->addr_src = SI_ACPI;1613 info->client = client;1614 info->adapter_name = kstrdup(client->adapter->name, GFP_KERNEL);1615 if (!info->adapter_name) {1616 kfree(info);1617 return -ENOMEM;1618 }1619 1620 info->binfo.addr = client->addr;1621 list_add_tail(&info->link, &ssif_infos);1622 return 0;1623}1624 1625/*1626 * Prefer ACPI over SMBIOS, if both are available.1627 * So if we get an ACPI interface and have already registered a SMBIOS1628 * interface at the same address, remove the SMBIOS and add the ACPI one.1629 */1630static int ssif_check_and_remove(struct i2c_client *client,1631 struct ssif_info *ssif_info)1632{1633 struct ssif_addr_info *info;1634 1635 list_for_each_entry(info, &ssif_infos, link) {1636 if (!info->client)1637 return 0;1638 if (!strcmp(info->adapter_name, client->adapter->name) &&1639 info->binfo.addr == client->addr) {1640 if (info->addr_src == SI_ACPI)1641 return -EEXIST;1642 1643 if (ssif_info->addr_source == SI_ACPI &&1644 info->addr_src == SI_SMBIOS) {1645 dev_info(&client->dev,1646 "Removing %s-specified SSIF interface in favor of ACPI\n",1647 ipmi_addr_src_to_str(info->addr_src));1648 ssif_remove_dup(info->client);1649 return 0;1650 }1651 }1652 }1653 return 0;1654}1655 1656static int ssif_probe(struct i2c_client *client)1657{1658 unsigned char msg[3];1659 unsigned char *resp;1660 struct ssif_info *ssif_info;1661 int rv = 0;1662 int len = 0;1663 int i;1664 u8 slave_addr = 0;1665 struct ssif_addr_info *addr_info = NULL;1666 1667 mutex_lock(&ssif_infos_mutex);1668 resp = kmalloc(IPMI_MAX_MSG_LENGTH, GFP_KERNEL);1669 if (!resp) {1670 mutex_unlock(&ssif_infos_mutex);1671 return -ENOMEM;1672 }1673 1674 ssif_info = kzalloc(sizeof(*ssif_info), GFP_KERNEL);1675 if (!ssif_info) {1676 kfree(resp);1677 mutex_unlock(&ssif_infos_mutex);1678 return -ENOMEM;1679 }1680 1681 if (!check_acpi(ssif_info, &client->dev)) {1682 addr_info = ssif_info_find(client->addr, client->adapter->name,1683 true);1684 if (!addr_info) {1685 /* Must have come in through sysfs. */1686 ssif_info->addr_source = SI_HOTMOD;1687 } else {1688 ssif_info->addr_source = addr_info->addr_src;1689 ssif_info->ssif_debug = addr_info->debug;1690 ssif_info->addr_info = addr_info->addr_info;1691 addr_info->client = client;1692 slave_addr = addr_info->slave_addr;1693 }1694 }1695 1696 ssif_info->client = client;1697 i2c_set_clientdata(client, ssif_info);1698 1699 rv = ssif_check_and_remove(client, ssif_info);1700 /* If rv is 0 and addr source is not SI_ACPI, continue probing */1701 if (!rv && ssif_info->addr_source == SI_ACPI) {1702 rv = ssif_add_infos(client);1703 if (rv) {1704 dev_err(&client->dev, "Out of memory!, exiting ..\n");1705 goto out;1706 }1707 } else if (rv) {1708 dev_err(&client->dev, "Not probing, Interface already present\n");1709 goto out;1710 }1711 1712 slave_addr = find_slave_address(client, slave_addr);1713 1714 dev_info(&client->dev,1715 "Trying %s-specified SSIF interface at i2c address 0x%x, adapter %s, slave address 0x%x\n",1716 ipmi_addr_src_to_str(ssif_info->addr_source),1717 client->addr, client->adapter->name, slave_addr);1718 1719 /*1720 * Send a get device id command and validate its response to1721 * make sure a valid BMC is there.1722 */1723 rv = ssif_detect(client, NULL);1724 if (rv) {1725 dev_err(&client->dev, "Not present\n");1726 goto out;1727 }1728 1729 /* Now check for system interface capabilities */1730 msg[0] = IPMI_NETFN_APP_REQUEST << 2;1731 msg[1] = IPMI_GET_SYSTEM_INTERFACE_CAPABILITIES_CMD;1732 msg[2] = 0; /* SSIF */1733 rv = do_cmd(client, 3, msg, &len, resp);1734 if (!rv && (len >= 3) && (resp[2] == 0)) {1735 if (len < 7) {1736 if (ssif_dbg_probe)1737 dev_dbg(&ssif_info->client->dev,1738 "SSIF info too short: %d\n", len);1739 goto no_support;1740 }1741 1742 /* Got a good SSIF response, handle it. */1743 ssif_info->max_xmit_msg_size = resp[5];1744 ssif_info->max_recv_msg_size = resp[6];1745 ssif_info->multi_support = (resp[4] >> 6) & 0x3;1746 ssif_info->supports_pec = (resp[4] >> 3) & 0x1;1747 1748 /* Sanitize the data */1749 switch (ssif_info->multi_support) {1750 case SSIF_NO_MULTI:1751 if (ssif_info->max_xmit_msg_size > 32)1752 ssif_info->max_xmit_msg_size = 32;1753 if (ssif_info->max_recv_msg_size > 32)1754 ssif_info->max_recv_msg_size = 32;1755 break;1756 1757 case SSIF_MULTI_2_PART:1758 if (ssif_info->max_xmit_msg_size > 63)1759 ssif_info->max_xmit_msg_size = 63;1760 if (ssif_info->max_recv_msg_size > 62)1761 ssif_info->max_recv_msg_size = 62;1762 break;1763 1764 case SSIF_MULTI_n_PART:1765 /* We take whatever size given, but do some testing. */1766 break;1767 1768 default:1769 /* Data is not sane, just give up. */1770 goto no_support;1771 }1772 } else {1773 no_support:1774 /* Assume no multi-part or PEC support */1775 dev_info(&ssif_info->client->dev,1776 "Error fetching SSIF: %d %d %2.2x, your system probably doesn't support this command so using defaults\n",1777 rv, len, resp[2]);1778 1779 ssif_info->max_xmit_msg_size = 32;1780 ssif_info->max_recv_msg_size = 32;1781 ssif_info->multi_support = SSIF_NO_MULTI;1782 ssif_info->supports_pec = 0;1783 }1784 1785 test_multipart_messages(client, ssif_info, resp);1786 1787 /* Make sure the NMI timeout is cleared. */1788 msg[0] = IPMI_NETFN_APP_REQUEST << 2;1789 msg[1] = IPMI_CLEAR_MSG_FLAGS_CMD;1790 msg[2] = WDT_PRE_TIMEOUT_INT;1791 rv = do_cmd(client, 3, msg, &len, resp);1792 if (rv || (len < 3) || (resp[2] != 0))1793 dev_warn(&ssif_info->client->dev,1794 "Unable to clear message flags: %d %d %2.2x\n",1795 rv, len, resp[2]);1796 1797 /* Attempt to enable the event buffer. */1798 msg[0] = IPMI_NETFN_APP_REQUEST << 2;1799 msg[1] = IPMI_GET_BMC_GLOBAL_ENABLES_CMD;1800 rv = do_cmd(client, 2, msg, &len, resp);1801 if (rv || (len < 4) || (resp[2] != 0)) {1802 dev_warn(&ssif_info->client->dev,1803 "Error getting global enables: %d %d %2.2x\n",1804 rv, len, resp[2]);1805 rv = 0; /* Not fatal */1806 goto found;1807 }1808 1809 ssif_info->global_enables = resp[3];1810 1811 if (resp[3] & IPMI_BMC_EVT_MSG_BUFF) {1812 ssif_info->has_event_buffer = true;1813 /* buffer is already enabled, nothing to do. */1814 goto found;1815 }1816 1817 msg[0] = IPMI_NETFN_APP_REQUEST << 2;1818 msg[1] = IPMI_SET_BMC_GLOBAL_ENABLES_CMD;1819 msg[2] = ssif_info->global_enables | IPMI_BMC_EVT_MSG_BUFF;1820 rv = do_cmd(client, 3, msg, &len, resp);1821 if (rv || (len < 2)) {1822 dev_warn(&ssif_info->client->dev,1823 "Error setting global enables: %d %d %2.2x\n",1824 rv, len, resp[2]);1825 rv = 0; /* Not fatal */1826 goto found;1827 }1828 1829 if (resp[2] == 0) {1830 /* A successful return means the event buffer is supported. */1831 ssif_info->has_event_buffer = true;1832 ssif_info->global_enables |= IPMI_BMC_EVT_MSG_BUFF;1833 }1834 1835 /* Some systems don't behave well if you enable alerts. */1836 if (alerts_broken)1837 goto found;1838 1839 msg[0] = IPMI_NETFN_APP_REQUEST << 2;1840 msg[1] = IPMI_SET_BMC_GLOBAL_ENABLES_CMD;1841 msg[2] = ssif_info->global_enables | IPMI_BMC_RCV_MSG_INTR;1842 rv = do_cmd(client, 3, msg, &len, resp);1843 if (rv || (len < 2)) {1844 dev_warn(&ssif_info->client->dev,1845 "Error setting global enables: %d %d %2.2x\n",1846 rv, len, resp[2]);1847 rv = 0; /* Not fatal */1848 goto found;1849 }1850 1851 if (resp[2] == 0) {1852 /* A successful return means the alert is supported. */1853 ssif_info->supports_alert = true;1854 ssif_info->global_enables |= IPMI_BMC_RCV_MSG_INTR;1855 }1856 1857 found:1858 if (ssif_dbg_probe) {1859 dev_dbg(&ssif_info->client->dev,1860 "%s: i2c_probe found device at i2c address %x\n",1861 __func__, client->addr);1862 }1863 1864 spin_lock_init(&ssif_info->lock);1865 ssif_info->ssif_state = SSIF_IDLE;1866 timer_setup(&ssif_info->retry_timer, retry_timeout, 0);1867 timer_setup(&ssif_info->watch_timer, watch_timeout, 0);1868 1869 for (i = 0; i < SSIF_NUM_STATS; i++)1870 atomic_set(&ssif_info->stats[i], 0);1871 1872 if (ssif_info->supports_pec)1873 ssif_info->client->flags |= I2C_CLIENT_PEC;1874 1875 ssif_info->handlers.owner = THIS_MODULE;1876 ssif_info->handlers.start_processing = ssif_start_processing;1877 ssif_info->handlers.shutdown = shutdown_ssif;1878 ssif_info->handlers.get_smi_info = get_smi_info;1879 ssif_info->handlers.sender = sender;1880 ssif_info->handlers.request_events = request_events;1881 ssif_info->handlers.set_need_watch = ssif_set_need_watch;1882 1883 {1884 unsigned int thread_num;1885 1886 thread_num = ((i2c_adapter_id(ssif_info->client->adapter)1887 << 8) |1888 ssif_info->client->addr);1889 init_completion(&ssif_info->wake_thread);1890 ssif_info->thread = kthread_run(ipmi_ssif_thread, ssif_info,1891 "kssif%4.4x", thread_num);1892 if (IS_ERR(ssif_info->thread)) {1893 rv = PTR_ERR(ssif_info->thread);1894 dev_notice(&ssif_info->client->dev,1895 "Could not start kernel thread: error %d\n",1896 rv);1897 goto out;1898 }1899 }1900 1901 dev_set_drvdata(&ssif_info->client->dev, ssif_info);1902 rv = device_add_group(&ssif_info->client->dev,1903 &ipmi_ssif_dev_attr_group);1904 if (rv) {1905 dev_err(&ssif_info->client->dev,1906 "Unable to add device attributes: error %d\n",1907 rv);1908 goto out;1909 }1910 1911 rv = ipmi_register_smi(&ssif_info->handlers,1912 ssif_info,1913 &ssif_info->client->dev,1914 slave_addr);1915 if (rv) {1916 dev_err(&ssif_info->client->dev,1917 "Unable to register device: error %d\n", rv);1918 goto out_remove_attr;1919 }1920 1921 out:1922 if (rv) {1923 if (addr_info)1924 addr_info->client = NULL;1925 1926 dev_err(&ssif_info->client->dev,1927 "Unable to start IPMI SSIF: %d\n", rv);1928 i2c_set_clientdata(client, NULL);1929 kfree(ssif_info);1930 }1931 kfree(resp);1932 mutex_unlock(&ssif_infos_mutex);1933 return rv;1934 1935out_remove_attr:1936 device_remove_group(&ssif_info->client->dev, &ipmi_ssif_dev_attr_group);1937 dev_set_drvdata(&ssif_info->client->dev, NULL);1938 goto out;1939}1940 1941static int new_ssif_client(int addr, char *adapter_name,1942 int debug, int slave_addr,1943 enum ipmi_addr_src addr_src,1944 struct device *dev)1945{1946 struct ssif_addr_info *addr_info;1947 int rv = 0;1948 1949 mutex_lock(&ssif_infos_mutex);1950 if (ssif_info_find(addr, adapter_name, false)) {1951 rv = -EEXIST;1952 goto out_unlock;1953 }1954 1955 addr_info = kzalloc(sizeof(*addr_info), GFP_KERNEL);1956 if (!addr_info) {1957 rv = -ENOMEM;1958 goto out_unlock;1959 }1960 1961 if (adapter_name) {1962 addr_info->adapter_name = kstrdup(adapter_name, GFP_KERNEL);1963 if (!addr_info->adapter_name) {1964 kfree(addr_info);1965 rv = -ENOMEM;1966 goto out_unlock;1967 }1968 }1969 1970 strscpy(addr_info->binfo.type, DEVICE_NAME,1971 sizeof(addr_info->binfo.type));1972 addr_info->binfo.addr = addr;1973 addr_info->binfo.platform_data = addr_info;1974 addr_info->debug = debug;1975 addr_info->slave_addr = slave_addr;1976 addr_info->addr_src = addr_src;1977 addr_info->dev = dev;1978 1979 if (dev)1980 dev_set_drvdata(dev, addr_info);1981 1982 list_add_tail(&addr_info->link, &ssif_infos);1983 1984 /* Address list will get it */1985 1986out_unlock:1987 mutex_unlock(&ssif_infos_mutex);1988 return rv;1989}1990 1991static void free_ssif_clients(void)1992{1993 struct ssif_addr_info *info, *tmp;1994 1995 mutex_lock(&ssif_infos_mutex);1996 list_for_each_entry_safe(info, tmp, &ssif_infos, link) {1997 list_del(&info->link);1998 kfree(info->adapter_name);1999 kfree(info);2000 }2001 mutex_unlock(&ssif_infos_mutex);2002}2003 2004static unsigned short *ssif_address_list(void)2005{2006 struct ssif_addr_info *info;2007 unsigned int count = 0, i = 0;2008 unsigned short *address_list;2009 2010 list_for_each_entry(info, &ssif_infos, link)2011 count++;2012 2013 address_list = kcalloc(count + 1, sizeof(*address_list),2014 GFP_KERNEL);2015 if (!address_list)2016 return NULL;2017 2018 list_for_each_entry(info, &ssif_infos, link) {2019 unsigned short addr = info->binfo.addr;2020 int j;2021 2022 for (j = 0; j < i; j++) {2023 if (address_list[j] == addr)2024 /* Found a dup. */2025 break;2026 }2027 if (j == i) /* Didn't find it in the list. */2028 address_list[i++] = addr;2029 }2030 address_list[i] = I2C_CLIENT_END;2031 2032 return address_list;2033}2034 2035#ifdef CONFIG_ACPI2036static const struct acpi_device_id ssif_acpi_match[] = {2037 { "IPI0001", 0 },2038 { },2039};2040MODULE_DEVICE_TABLE(acpi, ssif_acpi_match);2041#endif2042 2043#ifdef CONFIG_DMI2044static int dmi_ipmi_probe(struct platform_device *pdev)2045{2046 u8 slave_addr = 0;2047 u16 i2c_addr;2048 int rv;2049 2050 if (!ssif_trydmi)2051 return -ENODEV;2052 2053 rv = device_property_read_u16(&pdev->dev, "i2c-addr", &i2c_addr);2054 if (rv) {2055 dev_warn(&pdev->dev, "No i2c-addr property\n");2056 return -ENODEV;2057 }2058 2059 rv = device_property_read_u8(&pdev->dev, "slave-addr", &slave_addr);2060 if (rv)2061 slave_addr = 0x20;2062 2063 return new_ssif_client(i2c_addr, NULL, 0,2064 slave_addr, SI_SMBIOS, &pdev->dev);2065}2066#else2067static int dmi_ipmi_probe(struct platform_device *pdev)2068{2069 return -ENODEV;2070}2071#endif2072 2073static const struct i2c_device_id ssif_id[] = {2074 { DEVICE_NAME },2075 { }2076};2077MODULE_DEVICE_TABLE(i2c, ssif_id);2078 2079static struct i2c_driver ssif_i2c_driver = {2080 .class = I2C_CLASS_HWMON,2081 .driver = {2082 .name = DEVICE_NAME2083 },2084 .probe = ssif_probe,2085 .remove = ssif_remove,2086 .alert = ssif_alert,2087 .id_table = ssif_id,2088 .detect = ssif_detect2089};2090 2091static int ssif_platform_probe(struct platform_device *dev)2092{2093 return dmi_ipmi_probe(dev);2094}2095 2096static void ssif_platform_remove(struct platform_device *dev)2097{2098 struct ssif_addr_info *addr_info = dev_get_drvdata(&dev->dev);2099 2100 mutex_lock(&ssif_infos_mutex);2101 list_del(&addr_info->link);2102 kfree(addr_info);2103 mutex_unlock(&ssif_infos_mutex);2104}2105 2106static const struct platform_device_id ssif_plat_ids[] = {2107 { "dmi-ipmi-ssif", 0 },2108 { }2109};2110MODULE_DEVICE_TABLE(platform, ssif_plat_ids);2111 2112static struct platform_driver ipmi_driver = {2113 .driver = {2114 .name = DEVICE_NAME,2115 },2116 .probe = ssif_platform_probe,2117 .remove_new = ssif_platform_remove,2118 .id_table = ssif_plat_ids2119};2120 2121static int __init init_ipmi_ssif(void)2122{2123 int i;2124 int rv;2125 2126 if (initialized)2127 return 0;2128 2129 pr_info("IPMI SSIF Interface driver\n");2130 2131 /* build list for i2c from addr list */2132 for (i = 0; i < num_addrs; i++) {2133 rv = new_ssif_client(addr[i], adapter_name[i],2134 dbg[i], slave_addrs[i],2135 SI_HARDCODED, NULL);2136 if (rv)2137 pr_err("Couldn't add hardcoded device at addr 0x%x\n",2138 addr[i]);2139 }2140 2141 if (ssif_tryacpi)2142 ssif_i2c_driver.driver.acpi_match_table =2143 ACPI_PTR(ssif_acpi_match);2144 2145 if (ssif_trydmi) {2146 rv = platform_driver_register(&ipmi_driver);2147 if (rv)2148 pr_err("Unable to register driver: %d\n", rv);2149 else2150 platform_registered = true;2151 }2152 2153 ssif_i2c_driver.address_list = ssif_address_list();2154 2155 rv = i2c_add_driver(&ssif_i2c_driver);2156 if (!rv)2157 initialized = true;2158 2159 return rv;2160}2161module_init(init_ipmi_ssif);2162 2163static void __exit cleanup_ipmi_ssif(void)2164{2165 if (!initialized)2166 return;2167 2168 initialized = false;2169 2170 i2c_del_driver(&ssif_i2c_driver);2171 2172 kfree(ssif_i2c_driver.address_list);2173 2174 if (ssif_trydmi && platform_registered)2175 platform_driver_unregister(&ipmi_driver);2176 2177 free_ssif_clients();2178}2179module_exit(cleanup_ipmi_ssif);2180 2181MODULE_ALIAS("platform:dmi-ipmi-ssif");2182MODULE_AUTHOR("Todd C Davis <todd.c.davis@intel.com>, Corey Minyard <minyard@acm.org>");2183MODULE_DESCRIPTION("IPMI driver for management controllers on a SMBus");2184MODULE_LICENSE("GPL");2185