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