drivers/char/ipmi/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
  97 enum 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  */
 112 enum 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
 180 struct 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
 196 struct ssif_info;
 197
 198 typedef void (*ssif_i2c_done)(struct ssif_info *ssif_info, int result,
 199                              unsigned char *data, unsigned int len);
 200
 201 struct 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
 297 static bool initialized;
 298 static bool platform_registered;
 299
 300 static void return_hosed_msg(struct ssif_info *ssif_info,
 301                              struct ipmi_smi_msg *msg);
 302 static void start_next_msg(struct ssif_info *ssif_info, unsigned long *flags);
 303 static int start_send(struct ssif_info *ssif_info,
 304                       unsigned char   *data,
 305                       unsigned int    len);
 306
 307 static 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
 315 static 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
 322 static 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
 335 static 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  */
 355 static 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
 374 static 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
 388 static 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
 402 static 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
 426 static 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  */
 455 static 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
 474 static 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                         else
 504                                 ssif_info->done_handler(ssif_info, 0,
 505                                                         ssif_info->i2c_data,
 506                                                         result);
 507                 }
 508         }
 509
 510         return 0;
 511 }
 512
 513 static 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
 528 static void msg_done_handler(struct ssif_info *ssif_info, int result,
 529                              unsigned char *data, unsigned int len);
 530
 531 static 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
 540 static void start_resend(struct ssif_info *ssif_info);
 541
 542 static 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
 566 static 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
 587 static 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
 612 static 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
 909 static 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 jiffie 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
 994 static 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
1021 static 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. */
1038 static 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
1071 static 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
1094 static 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  */
1109 static 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 request
1124  * flags periodically or not.
1125  */
1126 static 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
1147 static 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 4
1158
1159 static unsigned short addr[MAX_SSIF_BMCS];
1160 static int num_addrs;
1161 module_param_array(addr, ushort, &num_addrs, 0);
1162 MODULE_PARM_DESC(addr, "The addresses to scan for IPMI BMCs on the SSIFs.");
1163
1164 static char *adapter_name[MAX_SSIF_BMCS];
1165 static int num_adapter_names;
1166 module_param_array(adapter_name, charp, &num_adapter_names, 0);
1167 MODULE_PARM_DESC(adapter_name, "The string name of the I2C device that has the BMC.  By default all devices are scanned.");
1168
1169 static int slave_addrs[MAX_SSIF_BMCS];
1170 static int num_slave_addrs;
1171 module_param_array(slave_addrs, int, &num_slave_addrs, 0);
1172 MODULE_PARM_DESC(slave_addrs,
1173                  "The default IPMB slave address for the controller.");
1174
1175 static bool alerts_broken;
1176 module_param(alerts_broken, bool, 0);
1177 MODULE_PARM_DESC(alerts_broken, "Don't enable alerts for the controller.");
1178
1179 /*
1180  * Bit 0 enables message debugging, bit 1 enables state debugging, and
1181  * bit 2 enables timing debugging.  This is an array indexed by
1182  * interface number"
1183  */
1184 static int dbg[MAX_SSIF_BMCS];
1185 static int num_dbg;
1186 module_param_array(dbg, int, &num_dbg, 0);
1187 MODULE_PARM_DESC(dbg, "Turn on debugging.");
1188
1189 static bool ssif_dbg_probe;
1190 module_param_named(dbg_probe, ssif_dbg_probe, bool, 0);
1191 MODULE_PARM_DESC(dbg_probe, "Enable debugging of probing of adapters.");
1192
1193 static bool ssif_tryacpi = true;
1194 module_param_named(tryacpi, ssif_tryacpi, bool, 0);
1195 MODULE_PARM_DESC(tryacpi, "Setting this to zero will disable the default scan of the interfaces identified via ACPI");
1196
1197 static bool ssif_trydmi = true;
1198 module_param_named(trydmi, ssif_trydmi, bool, 0);
1199 MODULE_PARM_DESC(trydmi, "Setting this to zero will disable the default scan of the interfaces identified via DMI (SMBIOS)");
1200
1201 static DEFINE_MUTEX(ssif_infos_mutex);
1202 static LIST_HEAD(ssif_infos);
1203
1204 #define IPMI_SSIF_ATTR(name) \
1205 static 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 }                                                                       \
1213 static DEVICE_ATTR(name, S_IRUGO, ipmi_##name##_show, NULL)
1214
1215 static 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 }
1221 static DEVICE_ATTR(type, S_IRUGO, ipmi_type_show, NULL);
1222
1223 IPMI_SSIF_ATTR(sent_messages);
1224 IPMI_SSIF_ATTR(sent_messages_parts);
1225 IPMI_SSIF_ATTR(send_retries);
1226 IPMI_SSIF_ATTR(send_errors);
1227 IPMI_SSIF_ATTR(received_messages);
1228 IPMI_SSIF_ATTR(received_message_parts);
1229 IPMI_SSIF_ATTR(receive_retries);
1230 IPMI_SSIF_ATTR(receive_errors);
1231 IPMI_SSIF_ATTR(flag_fetches);
1232 IPMI_SSIF_ATTR(hosed);
1233 IPMI_SSIF_ATTR(events);
1234 IPMI_SSIF_ATTR(watchdog_pretimeouts);
1235 IPMI_SSIF_ATTR(alerts);
1236
1237 static 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         NULL
1253 };
1254
1255 static const struct attribute_group ipmi_ssif_dev_attr_group = {
1256         .attrs          = ipmi_ssif_dev_attrs,
1257 };
1258
1259 static 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
1279 static 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 asynchronously
1286          * 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
1300 static 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
1318 static 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
1354 static 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                 strscpy(info->type, DEVICE_NAME, I2C_NAME_SIZE);
1373         kfree(resp);
1374         return rv;
1375 }
1376
1377 static int strcmp_nospace(char *s1, char *s2)
1378 {
1379         while (*s1 && *s2) {
1380                 while (isspace(*s1))
1381                         s1++;
1382                 while (isspace(*s2))
1383                         s2++;
1384                 if (*s1 > *s2)
1385                         return 1;
1386                 if (*s1 < *s2)
1387                         return -1;
1388                 s1++;
1389                 s2++;
1390         }
1391         return 0;
1392 }
1393
1394 static struct ssif_addr_info *ssif_info_find(unsigned short addr,
1395                                              char *adapter_name,
1396                                              bool match_null_name)
1397 {
1398         struct ssif_addr_info *info, *found = NULL;
1399
1400 restart:
1401         list_for_each_entry(info, &ssif_infos, link) {
1402                 if (info->binfo.addr == addr) {
1403                         if (info->addr_src == SI_SMBIOS && !info->adapter_name)
1404                                 info->adapter_name = kstrdup(adapter_name,
1405                                                              GFP_KERNEL);
1406
1407                         if (info->adapter_name || adapter_name) {
1408                                 if (!info->adapter_name != !adapter_name) {
1409                                         /* One is NULL and one is not */
1410                                         continue;
1411                                 }
1412                                 if (adapter_name &&
1413                                     strcmp_nospace(info->adapter_name,
1414                                                    adapter_name))
1415                                         /* Names do not match */
1416                                         continue;
1417                         }
1418                         found = info;
1419                         break;
1420                 }
1421         }
1422
1423         if (!found && match_null_name) {
1424                 /* Try to get an exact match first, then try with a NULL name */
1425                 adapter_name = NULL;
1426                 match_null_name = false;
1427                 goto restart;
1428         }
1429
1430         return found;
1431 }
1432
1433 static bool check_acpi(struct ssif_info *ssif_info, struct device *dev)
1434 {
1435 #ifdef CONFIG_ACPI
1436         acpi_handle acpi_handle;
1437
1438         acpi_handle = ACPI_HANDLE(dev);
1439         if (acpi_handle) {
1440                 ssif_info->addr_source = SI_ACPI;
1441                 ssif_info->addr_info.acpi_info.acpi_handle = acpi_handle;
1442                 request_module_nowait("acpi_ipmi");
1443                 return true;
1444         }
1445 #endif
1446         return false;
1447 }
1448
1449 static int find_slave_address(struct i2c_client *client, int slave_addr)
1450 {
1451 #ifdef CONFIG_IPMI_DMI_DECODE
1452         if (!slave_addr)
1453                 slave_addr = ipmi_dmi_get_slave_addr(
1454                         SI_TYPE_INVALID,
1455                         i2c_adapter_id(client->adapter),
1456                         client->addr);
1457 #endif
1458
1459         return slave_addr;
1460 }
1461
1462 static int start_multipart_test(struct i2c_client *client,
1463                                 unsigned char *msg, bool do_middle)
1464 {
1465         int retry_cnt = SSIF_SEND_RETRIES, ret;
1466
1467 retry_write:
1468         ret = i2c_smbus_write_block_data(client,
1469                                          SSIF_IPMI_MULTI_PART_REQUEST_START,
1470                                          32, msg);
1471         if (ret) {
1472                 retry_cnt--;
1473                 if (retry_cnt > 0) {
1474                         msleep(SSIF_REQ_RETRY_MSEC);
1475                         goto retry_write;
1476                 }
1477                 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");
1478                 return ret;
1479         }
1480
1481         if (!do_middle)
1482                 return 0;
1483
1484         ret = i2c_smbus_write_block_data(client,
1485                                          SSIF_IPMI_MULTI_PART_REQUEST_MIDDLE,
1486                                          32, msg + 32);
1487         if (ret) {
1488                 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");
1489                 return ret;
1490         }
1491
1492         return 0;
1493 }
1494
1495 static void test_multipart_messages(struct i2c_client *client,
1496                                     struct ssif_info *ssif_info,
1497                                     unsigned char *resp)
1498 {
1499         unsigned char msg[65];
1500         int ret;
1501         bool do_middle;
1502
1503         if (ssif_info->max_xmit_msg_size <= 32)
1504                 return;
1505
1506         do_middle = ssif_info->max_xmit_msg_size > 63;
1507
1508         memset(msg, 0, sizeof(msg));
1509         msg[0] = IPMI_NETFN_APP_REQUEST << 2;
1510         msg[1] = IPMI_GET_DEVICE_ID_CMD;
1511
1512         /*
1513          * The specification is all messed up dealing with sending
1514          * multi-part messages.  Per what the specification says, it
1515          * is impossible to send a message that is a multiple of 32
1516          * bytes, except for 32 itself.  It talks about a "start"
1517          * transaction (cmd=6) that must be 32 bytes, "middle"
1518          * transaction (cmd=7) that must be 32 bytes, and an "end"
1519          * transaction.  The "end" transaction is shown as cmd=7 in
1520          * the text, but if that's the case there is no way to
1521          * differentiate between a middle and end part except the
1522          * length being less than 32.  But there is a table at the far
1523          * end of the section (that I had never noticed until someone
1524          * pointed it out to me) that mentions it as cmd=8.
1525          *
1526          * After some thought, I think the example is wrong and the
1527          * end transaction should be cmd=8.  But some systems don't
1528          * implement cmd=8, they use a zero-length end transaction,
1529          * even though that violates the SMBus specification.
1530          *
1531          * So, to work around this, this code tests if cmd=8 works.
1532          * If it does, then we use that.  If not, it tests zero-
1533          * byte end transactions.  If that works, good.  If not,
1534          * we only allow 63-byte transactions max.
1535          */
1536
1537         ret = start_multipart_test(client, msg, do_middle);
1538         if (ret)
1539                 goto out_no_multi_part;
1540
1541         ret = i2c_smbus_write_block_data(client,
1542                                          SSIF_IPMI_MULTI_PART_REQUEST_END,
1543                                          1, msg + 64);
1544
1545         if (!ret)
1546                 ret = read_response(client, resp);
1547
1548         if (ret > 0) {
1549                 /* End transactions work, we are good. */
1550                 ssif_info->cmd8_works = true;
1551                 return;
1552         }
1553
1554         ret = start_multipart_test(client, msg, do_middle);
1555         if (ret) {
1556                 dev_err(&client->dev, "Second multipart test failed.\n");
1557                 goto out_no_multi_part;
1558         }
1559
1560         ret = i2c_smbus_write_block_data(client,
1561                                          SSIF_IPMI_MULTI_PART_REQUEST_MIDDLE,
1562                                          0, msg + 64);
1563         if (!ret)
1564                 ret = read_response(client, resp);
1565         if (ret > 0)
1566                 /* Zero-size end parts work, use those. */
1567                 return;
1568
1569         /* Limit to 63 bytes and use a short middle command to mark the end. */
1570         if (ssif_info->max_xmit_msg_size > 63)
1571                 ssif_info->max_xmit_msg_size = 63;
1572         return;
1573
1574 out_no_multi_part:
1575         ssif_info->max_xmit_msg_size = 32;
1576         return;
1577 }
1578
1579 /*
1580  * Global enables we care about.
1581  */
1582 #define GLOBAL_ENABLES_MASK (IPMI_BMC_EVT_MSG_BUFF | IPMI_BMC_RCV_MSG_INTR | \
1583                              IPMI_BMC_EVT_MSG_INTR)
1584
1585 static void ssif_remove_dup(struct i2c_client *client)
1586 {
1587         struct ssif_info *ssif_info = i2c_get_clientdata(client);
1588
1589         ipmi_unregister_smi(ssif_info->intf);
1590         kfree(ssif_info);
1591 }
1592
1593 static int ssif_add_infos(struct i2c_client *client)
1594 {
1595         struct ssif_addr_info *info;
1596
1597         info = kzalloc(sizeof(*info), GFP_KERNEL);
1598         if (!info)
1599                 return -ENOMEM;
1600         info->addr_src = SI_ACPI;
1601         info->client = client;
1602         info->adapter_name = kstrdup(client->adapter->name, GFP_KERNEL);
1603         if (!info->adapter_name) {
1604                 kfree(info);
1605                 return -ENOMEM;
1606         }
1607
1608         info->binfo.addr = client->addr;
1609         list_add_tail(&info->link, &ssif_infos);
1610         return 0;
1611 }
1612
1613 /*
1614  * Prefer ACPI over SMBIOS, if both are available.
1615  * So if we get an ACPI interface and have already registered a SMBIOS
1616  * interface at the same address, remove the SMBIOS and add the ACPI one.
1617  */
1618 static int ssif_check_and_remove(struct i2c_client *client,
1619                               struct ssif_info *ssif_info)
1620 {
1621         struct ssif_addr_info *info;
1622
1623         list_for_each_entry(info, &ssif_infos, link) {
1624                 if (!info->client)
1625                         return 0;
1626                 if (!strcmp(info->adapter_name, client->adapter->name) &&
1627                     info->binfo.addr == client->addr) {
1628                         if (info->addr_src == SI_ACPI)
1629                                 return -EEXIST;
1630
1631                         if (ssif_info->addr_source == SI_ACPI &&
1632                             info->addr_src == SI_SMBIOS) {
1633                                 dev_info(&client->dev,
1634                                          "Removing %s-specified SSIF interface in favor of ACPI\n",
1635                                          ipmi_addr_src_to_str(info->addr_src));
1636                                 ssif_remove_dup(info->client);
1637                                 return 0;
1638                         }
1639                 }
1640         }
1641         return 0;
1642 }
1643
1644 static int ssif_probe(struct i2c_client *client)
1645 {
1646         unsigned char     msg[3];
1647         unsigned char     *resp;
1648         struct ssif_info   *ssif_info;
1649         int               rv = 0;
1650         int               len = 0;
1651         int               i;
1652         u8                slave_addr = 0;
1653         struct ssif_addr_info *addr_info = NULL;
1654
1655         mutex_lock(&ssif_infos_mutex);
1656         resp = kmalloc(IPMI_MAX_MSG_LENGTH, GFP_KERNEL);
1657         if (!resp) {
1658                 mutex_unlock(&ssif_infos_mutex);
1659                 return -ENOMEM;
1660         }
1661
1662         ssif_info = kzalloc(sizeof(*ssif_info), GFP_KERNEL);
1663         if (!ssif_info) {
1664                 kfree(resp);
1665                 mutex_unlock(&ssif_infos_mutex);
1666                 return -ENOMEM;
1667         }
1668
1669         if (!check_acpi(ssif_info, &client->dev)) {
1670                 addr_info = ssif_info_find(client->addr, client->adapter->name,
1671                                            true);
1672                 if (!addr_info) {
1673                         /* Must have come in through sysfs. */
1674                         ssif_info->addr_source = SI_HOTMOD;
1675                 } else {
1676                         ssif_info->addr_source = addr_info->addr_src;
1677                         ssif_info->ssif_debug = addr_info->debug;
1678                         ssif_info->addr_info = addr_info->addr_info;
1679                         addr_info->client = client;
1680                         slave_addr = addr_info->slave_addr;
1681                 }
1682         }
1683
1684         ssif_info->client = client;
1685         i2c_set_clientdata(client, ssif_info);
1686
1687         rv = ssif_check_and_remove(client, ssif_info);
1688         /* If rv is 0 and addr source is not SI_ACPI, continue probing */
1689         if (!rv && ssif_info->addr_source == SI_ACPI) {
1690                 rv = ssif_add_infos(client);
1691                 if (rv) {
1692                         dev_err(&client->dev, "Out of memory!, exiting ..\n");
1693                         goto out;
1694                 }
1695         } else if (rv) {
1696                 dev_err(&client->dev, "Not probing, Interface already present\n");
1697                 goto out;
1698         }
1699
1700         slave_addr = find_slave_address(client, slave_addr);
1701
1702         dev_info(&client->dev,
1703                  "Trying %s-specified SSIF interface at i2c address 0x%x, adapter %s, slave address 0x%x\n",
1704                 ipmi_addr_src_to_str(ssif_info->addr_source),
1705                 client->addr, client->adapter->name, slave_addr);
1706
1707         /* Now check for system interface capabilities */
1708         msg[0] = IPMI_NETFN_APP_REQUEST << 2;
1709         msg[1] = IPMI_GET_SYSTEM_INTERFACE_CAPABILITIES_CMD;
1710         msg[2] = 0; /* SSIF */
1711         rv = do_cmd(client, 3, msg, &len, resp);
1712         if (!rv && (len >= 3) && (resp[2] == 0)) {
1713                 if (len < 7) {
1714                         if (ssif_dbg_probe)
1715                                 dev_dbg(&ssif_info->client->dev,
1716                                         "SSIF info too short: %d\n", len);
1717                         goto no_support;
1718                 }
1719
1720                 /* Got a good SSIF response, handle it. */
1721                 ssif_info->max_xmit_msg_size = resp[5];
1722                 ssif_info->max_recv_msg_size = resp[6];
1723                 ssif_info->multi_support = (resp[4] >> 6) & 0x3;
1724                 ssif_info->supports_pec = (resp[4] >> 3) & 0x1;
1725
1726                 /* Sanitize the data */
1727                 switch (ssif_info->multi_support) {
1728                 case SSIF_NO_MULTI:
1729                         if (ssif_info->max_xmit_msg_size > 32)
1730                                 ssif_info->max_xmit_msg_size = 32;
1731                         if (ssif_info->max_recv_msg_size > 32)
1732                                 ssif_info->max_recv_msg_size = 32;
1733                         break;
1734
1735                 case SSIF_MULTI_2_PART:
1736                         if (ssif_info->max_xmit_msg_size > 63)
1737                                 ssif_info->max_xmit_msg_size = 63;
1738                         if (ssif_info->max_recv_msg_size > 62)
1739                                 ssif_info->max_recv_msg_size = 62;
1740                         break;
1741
1742                 case SSIF_MULTI_n_PART:
1743                         /* We take whatever size given, but do some testing. */
1744                         break;
1745
1746                 default:
1747                         /* Data is not sane, just give up. */
1748                         goto no_support;
1749                 }
1750         } else {
1751  no_support:
1752                 /* Assume no multi-part or PEC support */
1753                 dev_info(&ssif_info->client->dev,
1754                          "Error fetching SSIF: %d %d %2.2x, your system probably doesn't support this command so using defaults\n",
1755                         rv, len, resp[2]);
1756
1757                 ssif_info->max_xmit_msg_size = 32;
1758                 ssif_info->max_recv_msg_size = 32;
1759                 ssif_info->multi_support = SSIF_NO_MULTI;
1760                 ssif_info->supports_pec = 0;
1761         }
1762
1763         test_multipart_messages(client, ssif_info, resp);
1764
1765         /* Make sure the NMI timeout is cleared. */
1766         msg[0] = IPMI_NETFN_APP_REQUEST << 2;
1767         msg[1] = IPMI_CLEAR_MSG_FLAGS_CMD;
1768         msg[2] = WDT_PRE_TIMEOUT_INT;
1769         rv = do_cmd(client, 3, msg, &len, resp);
1770         if (rv || (len < 3) || (resp[2] != 0))
1771                 dev_warn(&ssif_info->client->dev,
1772                          "Unable to clear message flags: %d %d %2.2x\n",
1773                          rv, len, resp[2]);
1774
1775         /* Attempt to enable the event buffer. */
1776         msg[0] = IPMI_NETFN_APP_REQUEST << 2;
1777         msg[1] = IPMI_GET_BMC_GLOBAL_ENABLES_CMD;
1778         rv = do_cmd(client, 2, msg, &len, resp);
1779         if (rv || (len < 4) || (resp[2] != 0)) {
1780                 dev_warn(&ssif_info->client->dev,
1781                          "Error getting global enables: %d %d %2.2x\n",
1782                          rv, len, resp[2]);
1783                 rv = 0; /* Not fatal */
1784                 goto found;
1785         }
1786
1787         ssif_info->global_enables = resp[3];
1788
1789         if (resp[3] & IPMI_BMC_EVT_MSG_BUFF) {
1790                 ssif_info->has_event_buffer = true;
1791                 /* buffer is already enabled, nothing to do. */
1792                 goto found;
1793         }
1794
1795         msg[0] = IPMI_NETFN_APP_REQUEST << 2;
1796         msg[1] = IPMI_SET_BMC_GLOBAL_ENABLES_CMD;
1797         msg[2] = ssif_info->global_enables | IPMI_BMC_EVT_MSG_BUFF;
1798         rv = do_cmd(client, 3, msg, &len, resp);
1799         if (rv || (len < 2)) {
1800                 dev_warn(&ssif_info->client->dev,
1801                          "Error setting global enables: %d %d %2.2x\n",
1802                          rv, len, resp[2]);
1803                 rv = 0; /* Not fatal */
1804                 goto found;
1805         }
1806
1807         if (resp[2] == 0) {
1808                 /* A successful return means the event buffer is supported. */
1809                 ssif_info->has_event_buffer = true;
1810                 ssif_info->global_enables |= IPMI_BMC_EVT_MSG_BUFF;
1811         }
1812
1813         /* Some systems don't behave well if you enable alerts. */
1814         if (alerts_broken)
1815                 goto found;
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_RCV_MSG_INTR;
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 alert is supported. */
1831                 ssif_info->supports_alert = true;
1832                 ssif_info->global_enables |= IPMI_BMC_RCV_MSG_INTR;
1833         }
1834
1835  found:
1836         if (ssif_dbg_probe) {
1837                 dev_dbg(&ssif_info->client->dev,
1838                        "%s: i2c_probe found device at i2c address %x\n",
1839                        __func__, client->addr);
1840         }
1841
1842         spin_lock_init(&ssif_info->lock);
1843         ssif_info->ssif_state = SSIF_IDLE;
1844         timer_setup(&ssif_info->retry_timer, retry_timeout, 0);
1845         timer_setup(&ssif_info->watch_timer, watch_timeout, 0);
1846
1847         for (i = 0; i < SSIF_NUM_STATS; i++)
1848                 atomic_set(&ssif_info->stats[i], 0);
1849
1850         if (ssif_info->supports_pec)
1851                 ssif_info->client->flags |= I2C_CLIENT_PEC;
1852
1853         ssif_info->handlers.owner = THIS_MODULE;
1854         ssif_info->handlers.start_processing = ssif_start_processing;
1855         ssif_info->handlers.shutdown = shutdown_ssif;
1856         ssif_info->handlers.get_smi_info = get_smi_info;
1857         ssif_info->handlers.sender = sender;
1858         ssif_info->handlers.request_events = request_events;
1859         ssif_info->handlers.set_need_watch = ssif_set_need_watch;
1860
1861         {
1862                 unsigned int thread_num;
1863
1864                 thread_num = ((i2c_adapter_id(ssif_info->client->adapter)
1865                                << 8) |
1866                               ssif_info->client->addr);
1867                 init_completion(&ssif_info->wake_thread);
1868                 ssif_info->thread = kthread_run(ipmi_ssif_thread, ssif_info,
1869                                                "kssif%4.4x", thread_num);
1870                 if (IS_ERR(ssif_info->thread)) {
1871                         rv = PTR_ERR(ssif_info->thread);
1872                         dev_notice(&ssif_info->client->dev,
1873                                    "Could not start kernel thread: error %d\n",
1874                                    rv);
1875                         goto out;
1876                 }
1877         }
1878
1879         dev_set_drvdata(&ssif_info->client->dev, ssif_info);
1880         rv = device_add_group(&ssif_info->client->dev,
1881                               &ipmi_ssif_dev_attr_group);
1882         if (rv) {
1883                 dev_err(&ssif_info->client->dev,
1884                         "Unable to add device attributes: error %d\n",
1885                         rv);
1886                 goto out;
1887         }
1888
1889         rv = ipmi_register_smi(&ssif_info->handlers,
1890                                ssif_info,
1891                                &ssif_info->client->dev,
1892                                slave_addr);
1893         if (rv) {
1894                 dev_err(&ssif_info->client->dev,
1895                         "Unable to register device: error %d\n", rv);
1896                 goto out_remove_attr;
1897         }
1898
1899  out:
1900         if (rv) {
1901                 if (addr_info)
1902                         addr_info->client = NULL;
1903
1904                 dev_err(&ssif_info->client->dev,
1905                         "Unable to start IPMI SSIF: %d\n", rv);
1906                 i2c_set_clientdata(client, NULL);
1907                 kfree(ssif_info);
1908         }
1909         kfree(resp);
1910         mutex_unlock(&ssif_infos_mutex);
1911         return rv;
1912
1913 out_remove_attr:
1914         device_remove_group(&ssif_info->client->dev, &ipmi_ssif_dev_attr_group);
1915         dev_set_drvdata(&ssif_info->client->dev, NULL);
1916         goto out;
1917 }
1918
1919 static int new_ssif_client(int addr, char *adapter_name,
1920                            int debug, int slave_addr,
1921                            enum ipmi_addr_src addr_src,
1922                            struct device *dev)
1923 {
1924         struct ssif_addr_info *addr_info;
1925         int rv = 0;
1926
1927         mutex_lock(&ssif_infos_mutex);
1928         if (ssif_info_find(addr, adapter_name, false)) {
1929                 rv = -EEXIST;
1930                 goto out_unlock;
1931         }
1932
1933         addr_info = kzalloc(sizeof(*addr_info), GFP_KERNEL);
1934         if (!addr_info) {
1935                 rv = -ENOMEM;
1936                 goto out_unlock;
1937         }
1938
1939         if (adapter_name) {
1940                 addr_info->adapter_name = kstrdup(adapter_name, GFP_KERNEL);
1941                 if (!addr_info->adapter_name) {
1942                         kfree(addr_info);
1943                         rv = -ENOMEM;
1944                         goto out_unlock;
1945                 }
1946         }
1947
1948         strscpy(addr_info->binfo.type, DEVICE_NAME,
1949                 sizeof(addr_info->binfo.type));
1950         addr_info->binfo.addr = addr;
1951         addr_info->binfo.platform_data = addr_info;
1952         addr_info->debug = debug;
1953         addr_info->slave_addr = slave_addr;
1954         addr_info->addr_src = addr_src;
1955         addr_info->dev = dev;
1956
1957         if (dev)
1958                 dev_set_drvdata(dev, addr_info);
1959
1960         list_add_tail(&addr_info->link, &ssif_infos);
1961
1962         /* Address list will get it */
1963
1964 out_unlock:
1965         mutex_unlock(&ssif_infos_mutex);
1966         return rv;
1967 }
1968
1969 static void free_ssif_clients(void)
1970 {
1971         struct ssif_addr_info *info, *tmp;
1972
1973         mutex_lock(&ssif_infos_mutex);
1974         list_for_each_entry_safe(info, tmp, &ssif_infos, link) {
1975                 list_del(&info->link);
1976                 kfree(info->adapter_name);
1977                 kfree(info);
1978         }
1979         mutex_unlock(&ssif_infos_mutex);
1980 }
1981
1982 static unsigned short *ssif_address_list(void)
1983 {
1984         struct ssif_addr_info *info;
1985         unsigned int count = 0, i = 0;
1986         unsigned short *address_list;
1987
1988         list_for_each_entry(info, &ssif_infos, link)
1989                 count++;
1990
1991         address_list = kcalloc(count + 1, sizeof(*address_list),
1992                                GFP_KERNEL);
1993         if (!address_list)
1994                 return NULL;
1995
1996         list_for_each_entry(info, &ssif_infos, link) {
1997                 unsigned short addr = info->binfo.addr;
1998                 int j;
1999
2000                 for (j = 0; j < i; j++) {
2001                         if (address_list[j] == addr)
2002                                 /* Found a dup. */
2003                                 break;
2004                 }
2005                 if (j == i) /* Didn't find it in the list. */
2006                         address_list[i++] = addr;
2007         }
2008         address_list[i] = I2C_CLIENT_END;
2009
2010         return address_list;
2011 }
2012
2013 #ifdef CONFIG_ACPI
2014 static const struct acpi_device_id ssif_acpi_match[] = {
2015         { "IPI0001", 0 },
2016         { },
2017 };
2018 MODULE_DEVICE_TABLE(acpi, ssif_acpi_match);
2019 #endif
2020
2021 #ifdef CONFIG_DMI
2022 static int dmi_ipmi_probe(struct platform_device *pdev)
2023 {
2024         u8 slave_addr = 0;
2025         u16 i2c_addr;
2026         int rv;
2027
2028         if (!ssif_trydmi)
2029                 return -ENODEV;
2030
2031         rv = device_property_read_u16(&pdev->dev, "i2c-addr", &i2c_addr);
2032         if (rv) {
2033                 dev_warn(&pdev->dev, "No i2c-addr property\n");
2034                 return -ENODEV;
2035         }
2036
2037         rv = device_property_read_u8(&pdev->dev, "slave-addr", &slave_addr);
2038         if (rv)
2039                 slave_addr = 0x20;
2040
2041         return new_ssif_client(i2c_addr, NULL, 0,
2042                                slave_addr, SI_SMBIOS, &pdev->dev);
2043 }
2044 #else
2045 static int dmi_ipmi_probe(struct platform_device *pdev)
2046 {
2047         return -ENODEV;
2048 }
2049 #endif
2050
2051 static const struct i2c_device_id ssif_id[] = {
2052         { DEVICE_NAME, 0 },
2053         { }
2054 };
2055 MODULE_DEVICE_TABLE(i2c, ssif_id);
2056
2057 static struct i2c_driver ssif_i2c_driver = {
2058         .class          = I2C_CLASS_HWMON,
2059         .driver         = {
2060                 .name                   = DEVICE_NAME
2061         },
2062         .probe          = ssif_probe,
2063         .remove         = ssif_remove,
2064         .alert          = ssif_alert,
2065         .id_table       = ssif_id,
2066         .detect         = ssif_detect
2067 };
2068
2069 static int ssif_platform_probe(struct platform_device *dev)
2070 {
2071         return dmi_ipmi_probe(dev);
2072 }
2073
2074 static void ssif_platform_remove(struct platform_device *dev)
2075 {
2076         struct ssif_addr_info *addr_info = dev_get_drvdata(&dev->dev);
2077
2078         mutex_lock(&ssif_infos_mutex);
2079         list_del(&addr_info->link);
2080         kfree(addr_info);
2081         mutex_unlock(&ssif_infos_mutex);
2082 }
2083
2084 static const struct platform_device_id ssif_plat_ids[] = {
2085     { "dmi-ipmi-ssif", 0 },
2086     { }
2087 };
2088
2089 static struct platform_driver ipmi_driver = {
2090         .driver = {
2091                 .name = DEVICE_NAME,
2092         },
2093         .probe          = ssif_platform_probe,
2094         .remove_new     = ssif_platform_remove,
2095         .id_table       = ssif_plat_ids
2096 };
2097
2098 static int __init init_ipmi_ssif(void)
2099 {
2100         int i;
2101         int rv;
2102
2103         if (initialized)
2104                 return 0;
2105
2106         pr_info("IPMI SSIF Interface driver\n");
2107
2108         /* build list for i2c from addr list */
2109         for (i = 0; i < num_addrs; i++) {
2110                 rv = new_ssif_client(addr[i], adapter_name[i],
2111                                      dbg[i], slave_addrs[i],
2112                                      SI_HARDCODED, NULL);
2113                 if (rv)
2114                         pr_err("Couldn't add hardcoded device at addr 0x%x\n",
2115                                addr[i]);
2116         }
2117
2118         if (ssif_tryacpi)
2119                 ssif_i2c_driver.driver.acpi_match_table =
2120                         ACPI_PTR(ssif_acpi_match);
2121
2122         if (ssif_trydmi) {
2123                 rv = platform_driver_register(&ipmi_driver);
2124                 if (rv)
2125                         pr_err("Unable to register driver: %d\n", rv);
2126                 else
2127                         platform_registered = true;
2128         }
2129
2130         ssif_i2c_driver.address_list = ssif_address_list();
2131
2132         rv = i2c_add_driver(&ssif_i2c_driver);
2133         if (!rv)
2134                 initialized = true;
2135
2136         return rv;
2137 }
2138 module_init(init_ipmi_ssif);
2139
2140 static void __exit cleanup_ipmi_ssif(void)
2141 {
2142         if (!initialized)
2143                 return;
2144
2145         initialized = false;
2146
2147         i2c_del_driver(&ssif_i2c_driver);
2148
2149         kfree(ssif_i2c_driver.address_list);
2150
2151         if (ssif_trydmi && platform_registered)
2152                 platform_driver_unregister(&ipmi_driver);
2153
2154         free_ssif_clients();
2155 }
2156 module_exit(cleanup_ipmi_ssif);
2157
2158 MODULE_ALIAS("platform:dmi-ipmi-ssif");
2159 MODULE_AUTHOR("Todd C Davis <todd.c.davis@intel.com>, Corey Minyard <minyard@acm.org>");
2160 MODULE_DESCRIPTION("IPMI driver for management controllers on a SMBus");
2161 MODULE_LICENSE("GPL");