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