drivers/char/ipmi/ipmi_kcs_sm.c

   1 /*
   2  * ipmi_kcs_sm.c
   3  *
   4  * State machine for handling IPMI KCS interfaces.
   5  *
   6  * Author: MontaVista Software, Inc.
   7  *         Corey Minyard <minyard@mvista.com>
   8  *         source@mvista.com
   9  *
  10  * Copyright 2002 MontaVista Software Inc.
  11  *
  12  *  This program is free software; you can redistribute it and/or modify it
  13  *  under the terms of the GNU General Public License as published by the
  14  *  Free Software Foundation; either version 2 of the License, or (at your
  15  *  option) any later version.
  16  *
  17  *
  18  *  THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED
  19  *  WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
  20  *  MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  21  *  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  22  *  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
  23  *  BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
  24  *  OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  25  *  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
  26  *  TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
  27  *  USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  28  *
  29  *  You should have received a copy of the GNU General Public License along
  30  *  with this program; if not, write to the Free Software Foundation, Inc.,
  31  *  675 Mass Ave, Cambridge, MA 02139, USA.
  32  */
  33
  34 /*
  35  * This state machine is taken from the state machine in the IPMI spec,
  36  * pretty much verbatim.  If you have questions about the states, see
  37  * that document.
  38  */
  39
  40 #include <linux/kernel.h> /* For printk. */
  41 #include <linux/module.h>
  42 #include <linux/moduleparam.h>
  43 #include <linux/string.h>
  44 #include <linux/jiffies.h>
  45 #include <linux/ipmi_msgdefs.h>         /* for completion codes */
  46 #include "ipmi_si_sm.h"
  47
  48 /* kcs_debug is a bit-field
  49  *      KCS_DEBUG_ENABLE -      turned on for now
  50  *      KCS_DEBUG_MSG    -      commands and their responses
  51  *      KCS_DEBUG_STATES -      state machine
  52  */
  53 #define KCS_DEBUG_STATES        4
  54 #define KCS_DEBUG_MSG           2
  55 #define KCS_DEBUG_ENABLE        1
  56
  57 static int kcs_debug;
  58 module_param(kcs_debug, int, 0644);
  59 MODULE_PARM_DESC(kcs_debug, "debug bitmask, 1=enable, 2=messages, 4=states");
  60
  61 /* The states the KCS driver may be in. */
  62 enum kcs_states {
  63         /* The KCS interface is currently doing nothing. */
  64         KCS_IDLE,
  65
  66         /*
  67          * We are starting an operation.  The data is in the output
  68          * buffer, but nothing has been done to the interface yet.  This
  69          * was added to the state machine in the spec to wait for the
  70          * initial IBF.
  71          */
  72         KCS_START_OP,
  73
  74         /* We have written a write cmd to the interface. */
  75         KCS_WAIT_WRITE_START,
  76
  77         /* We are writing bytes to the interface. */
  78         KCS_WAIT_WRITE,
  79
  80         /*
  81          * We have written the write end cmd to the interface, and
  82          * still need to write the last byte.
  83          */
  84         KCS_WAIT_WRITE_END,
  85
  86         /* We are waiting to read data from the interface. */
  87         KCS_WAIT_READ,
  88
  89         /*
  90          * State to transition to the error handler, this was added to
  91          * the state machine in the spec to be sure IBF was there.
  92          */
  93         KCS_ERROR0,
  94
  95         /*
  96          * First stage error handler, wait for the interface to
  97          * respond.
  98          */
  99         KCS_ERROR1,
 100
 101         /*
 102          * The abort cmd has been written, wait for the interface to
 103          * respond.
 104          */
 105         KCS_ERROR2,
 106
 107         /*
 108          * We wrote some data to the interface, wait for it to switch
 109          * to read mode.
 110          */
 111         KCS_ERROR3,
 112
 113         /* The hardware failed to follow the state machine. */
 114         KCS_HOSED
 115 };
 116
 117 #define MAX_KCS_READ_SIZE IPMI_MAX_MSG_LENGTH
 118 #define MAX_KCS_WRITE_SIZE IPMI_MAX_MSG_LENGTH
 119
 120 /* Timeouts in microseconds. */
 121 #define IBF_RETRY_TIMEOUT 1000000
 122 #define OBF_RETRY_TIMEOUT 1000000
 123 #define MAX_ERROR_RETRIES 10
 124 #define ERROR0_OBF_WAIT_JIFFIES (2*HZ)
 125
 126 struct si_sm_data {
 127         enum kcs_states  state;
 128         struct si_sm_io *io;
 129         unsigned char    write_data[MAX_KCS_WRITE_SIZE];
 130         int              write_pos;
 131         int              write_count;
 132         int              orig_write_count;
 133         unsigned char    read_data[MAX_KCS_READ_SIZE];
 134         int              read_pos;
 135         int              truncated;
 136
 137         unsigned int  error_retries;
 138         long          ibf_timeout;
 139         long          obf_timeout;
 140         unsigned long  error0_timeout;
 141 };
 142
 143 static unsigned int init_kcs_data(struct si_sm_data *kcs,
 144                                   struct si_sm_io *io)
 145 {
 146         kcs->state = KCS_IDLE;
 147         kcs->io = io;
 148         kcs->write_pos = 0;
 149         kcs->write_count = 0;
 150         kcs->orig_write_count = 0;
 151         kcs->read_pos = 0;
 152         kcs->error_retries = 0;
 153         kcs->truncated = 0;
 154         kcs->ibf_timeout = IBF_RETRY_TIMEOUT;
 155         kcs->obf_timeout = OBF_RETRY_TIMEOUT;
 156
 157         /* Reserve 2 I/O bytes. */
 158         return 2;
 159 }
 160
 161 static inline unsigned char read_status(struct si_sm_data *kcs)
 162 {
 163         return kcs->io->inputb(kcs->io, 1);
 164 }
 165
 166 static inline unsigned char read_data(struct si_sm_data *kcs)
 167 {
 168         return kcs->io->inputb(kcs->io, 0);
 169 }
 170
 171 static inline void write_cmd(struct si_sm_data *kcs, unsigned char data)
 172 {
 173         kcs->io->outputb(kcs->io, 1, data);
 174 }
 175
 176 static inline void write_data(struct si_sm_data *kcs, unsigned char data)
 177 {
 178         kcs->io->outputb(kcs->io, 0, data);
 179 }
 180
 181 /* Control codes. */
 182 #define KCS_GET_STATUS_ABORT    0x60
 183 #define KCS_WRITE_START         0x61
 184 #define KCS_WRITE_END           0x62
 185 #define KCS_READ_BYTE           0x68
 186
 187 /* Status bits. */
 188 #define GET_STATUS_STATE(status) (((status) >> 6) & 0x03)
 189 #define KCS_IDLE_STATE  0
 190 #define KCS_READ_STATE  1
 191 #define KCS_WRITE_STATE 2
 192 #define KCS_ERROR_STATE 3
 193 #define GET_STATUS_ATN(status) ((status) & 0x04)
 194 #define GET_STATUS_IBF(status) ((status) & 0x02)
 195 #define GET_STATUS_OBF(status) ((status) & 0x01)
 196
 197
 198 static inline void write_next_byte(struct si_sm_data *kcs)
 199 {
 200         write_data(kcs, kcs->write_data[kcs->write_pos]);
 201         (kcs->write_pos)++;
 202         (kcs->write_count)--;
 203 }
 204
 205 static inline void start_error_recovery(struct si_sm_data *kcs, char *reason)
 206 {
 207         (kcs->error_retries)++;
 208         if (kcs->error_retries > MAX_ERROR_RETRIES) {
 209                 if (kcs_debug & KCS_DEBUG_ENABLE)
 210                         printk(KERN_DEBUG "ipmi_kcs_sm: kcs hosed: %s\n",
 211                                reason);
 212                 kcs->state = KCS_HOSED;
 213         } else {
 214                 kcs->error0_timeout = jiffies + ERROR0_OBF_WAIT_JIFFIES;
 215                 kcs->state = KCS_ERROR0;
 216         }
 217 }
 218
 219 static inline void read_next_byte(struct si_sm_data *kcs)
 220 {
 221         if (kcs->read_pos >= MAX_KCS_READ_SIZE) {
 222                 /* Throw the data away and mark it truncated. */
 223                 read_data(kcs);
 224                 kcs->truncated = 1;
 225         } else {
 226                 kcs->read_data[kcs->read_pos] = read_data(kcs);
 227                 (kcs->read_pos)++;
 228         }
 229         write_data(kcs, KCS_READ_BYTE);
 230 }
 231
 232 static inline int check_ibf(struct si_sm_data *kcs, unsigned char status,
 233                             long time)
 234 {
 235         if (GET_STATUS_IBF(status)) {
 236                 kcs->ibf_timeout -= time;
 237                 if (kcs->ibf_timeout < 0) {
 238                         start_error_recovery(kcs, "IBF not ready in time");
 239                         kcs->ibf_timeout = IBF_RETRY_TIMEOUT;
 240                         return 1;
 241                 }
 242                 return 0;
 243         }
 244         kcs->ibf_timeout = IBF_RETRY_TIMEOUT;
 245         return 1;
 246 }
 247
 248 static inline int check_obf(struct si_sm_data *kcs, unsigned char status,
 249                             long time)
 250 {
 251         if (!GET_STATUS_OBF(status)) {
 252                 kcs->obf_timeout -= time;
 253                 if (kcs->obf_timeout < 0) {
 254                     start_error_recovery(kcs, "OBF not ready in time");
 255                     return 1;
 256                 }
 257                 return 0;
 258         }
 259         kcs->obf_timeout = OBF_RETRY_TIMEOUT;
 260         return 1;
 261 }
 262
 263 static void clear_obf(struct si_sm_data *kcs, unsigned char status)
 264 {
 265         if (GET_STATUS_OBF(status))
 266                 read_data(kcs);
 267 }
 268
 269 static void restart_kcs_transaction(struct si_sm_data *kcs)
 270 {
 271         kcs->write_count = kcs->orig_write_count;
 272         kcs->write_pos = 0;
 273         kcs->read_pos = 0;
 274         kcs->state = KCS_WAIT_WRITE_START;
 275         kcs->ibf_timeout = IBF_RETRY_TIMEOUT;
 276         kcs->obf_timeout = OBF_RETRY_TIMEOUT;
 277         write_cmd(kcs, KCS_WRITE_START);
 278 }
 279
 280 static int start_kcs_transaction(struct si_sm_data *kcs, unsigned char *data,
 281                                  unsigned int size)
 282 {
 283         unsigned int i;
 284
 285         if (size < 2)
 286                 return IPMI_REQ_LEN_INVALID_ERR;
 287         if (size > MAX_KCS_WRITE_SIZE)
 288                 return IPMI_REQ_LEN_EXCEEDED_ERR;
 289
 290         if ((kcs->state != KCS_IDLE) && (kcs->state != KCS_HOSED))
 291                 return IPMI_NOT_IN_MY_STATE_ERR;
 292
 293         if (kcs_debug & KCS_DEBUG_MSG) {
 294                 printk(KERN_DEBUG "start_kcs_transaction -");
 295                 for (i = 0; i < size; i++)
 296                         printk(" %02x", (unsigned char) (data [i]));
 297                 printk("\n");
 298         }
 299         kcs->error_retries = 0;
 300         memcpy(kcs->write_data, data, size);
 301         kcs->write_count = size;
 302         kcs->orig_write_count = size;
 303         kcs->write_pos = 0;
 304         kcs->read_pos = 0;
 305         kcs->state = KCS_START_OP;
 306         kcs->ibf_timeout = IBF_RETRY_TIMEOUT;
 307         kcs->obf_timeout = OBF_RETRY_TIMEOUT;
 308         return 0;
 309 }
 310
 311 static int get_kcs_result(struct si_sm_data *kcs, unsigned char *data,
 312                           unsigned int length)
 313 {
 314         if (length < kcs->read_pos) {
 315                 kcs->read_pos = length;
 316                 kcs->truncated = 1;
 317         }
 318
 319         memcpy(data, kcs->read_data, kcs->read_pos);
 320
 321         if ((length >= 3) && (kcs->read_pos < 3)) {
 322                 /* Guarantee that we return at least 3 bytes, with an
 323                    error in the third byte if it is too short. */
 324                 data[2] = IPMI_ERR_UNSPECIFIED;
 325                 kcs->read_pos = 3;
 326         }
 327         if (kcs->truncated) {
 328                 /*
 329                  * Report a truncated error.  We might overwrite
 330                  * another error, but that's too bad, the user needs
 331                  * to know it was truncated.
 332                  */
 333                 data[2] = IPMI_ERR_MSG_TRUNCATED;
 334                 kcs->truncated = 0;
 335         }
 336
 337         return kcs->read_pos;
 338 }
 339
 340 /*
 341  * This implements the state machine defined in the IPMI manual, see
 342  * that for details on how this works.  Divide that flowchart into
 343  * sections delimited by "Wait for IBF" and this will become clear.
 344  */
 345 static enum si_sm_result kcs_event(struct si_sm_data *kcs, long time)
 346 {
 347         unsigned char status;
 348         unsigned char state;
 349
 350         status = read_status(kcs);
 351
 352         if (kcs_debug & KCS_DEBUG_STATES)
 353                 printk(KERN_DEBUG "KCS: State = %d, %x\n", kcs->state, status);
 354
 355         /* All states wait for ibf, so just do it here. */
 356         if (!check_ibf(kcs, status, time))
 357                 return SI_SM_CALL_WITH_DELAY;
 358
 359         /* Just about everything looks at the KCS state, so grab that, too. */
 360         state = GET_STATUS_STATE(status);
 361
 362         switch (kcs->state) {
 363         case KCS_IDLE:
 364                 /* If there's and interrupt source, turn it off. */
 365                 clear_obf(kcs, status);
 366
 367                 if (GET_STATUS_ATN(status))
 368                         return SI_SM_ATTN;
 369                 else
 370                         return SI_SM_IDLE;
 371
 372         case KCS_START_OP:
 373                 if (state != KCS_IDLE_STATE) {
 374                         start_error_recovery(kcs,
 375                                              "State machine not idle at start");
 376                         break;
 377                 }
 378
 379                 clear_obf(kcs, status);
 380                 write_cmd(kcs, KCS_WRITE_START);
 381                 kcs->state = KCS_WAIT_WRITE_START;
 382                 break;
 383
 384         case KCS_WAIT_WRITE_START:
 385                 if (state != KCS_WRITE_STATE) {
 386                         start_error_recovery(
 387                                 kcs,
 388                                 "Not in write state at write start");
 389                         break;
 390                 }
 391                 read_data(kcs);
 392                 if (kcs->write_count == 1) {
 393                         write_cmd(kcs, KCS_WRITE_END);
 394                         kcs->state = KCS_WAIT_WRITE_END;
 395                 } else {
 396                         write_next_byte(kcs);
 397                         kcs->state = KCS_WAIT_WRITE;
 398                 }
 399                 break;
 400
 401         case KCS_WAIT_WRITE:
 402                 if (state != KCS_WRITE_STATE) {
 403                         start_error_recovery(kcs,
 404                                              "Not in write state for write");
 405                         break;
 406                 }
 407                 clear_obf(kcs, status);
 408                 if (kcs->write_count == 1) {
 409                         write_cmd(kcs, KCS_WRITE_END);
 410                         kcs->state = KCS_WAIT_WRITE_END;
 411                 } else {
 412                         write_next_byte(kcs);
 413                 }
 414                 break;
 415
 416         case KCS_WAIT_WRITE_END:
 417                 if (state != KCS_WRITE_STATE) {
 418                         start_error_recovery(kcs,
 419                                              "Not in write state"
 420                                              " for write end");
 421                         break;
 422                 }
 423                 clear_obf(kcs, status);
 424                 write_next_byte(kcs);
 425                 kcs->state = KCS_WAIT_READ;
 426                 break;
 427
 428         case KCS_WAIT_READ:
 429                 if ((state != KCS_READ_STATE) && (state != KCS_IDLE_STATE)) {
 430                         start_error_recovery(
 431                                 kcs,
 432                                 "Not in read or idle in read state");
 433                         break;
 434                 }
 435
 436                 if (state == KCS_READ_STATE) {
 437                         if (!check_obf(kcs, status, time))
 438                                 return SI_SM_CALL_WITH_DELAY;
 439                         read_next_byte(kcs);
 440                 } else {
 441                         /*
 442                          * We don't implement this exactly like the state
 443                          * machine in the spec.  Some broken hardware
 444                          * does not write the final dummy byte to the
 445                          * read register.  Thus obf will never go high
 446                          * here.  We just go straight to idle, and we
 447                          * handle clearing out obf in idle state if it
 448                          * happens to come in.
 449                          */
 450                         clear_obf(kcs, status);
 451                         kcs->orig_write_count = 0;
 452                         kcs->state = KCS_IDLE;
 453                         return SI_SM_TRANSACTION_COMPLETE;
 454                 }
 455                 break;
 456
 457         case KCS_ERROR0:
 458                 clear_obf(kcs, status);
 459                 status = read_status(kcs);
 460                 if (GET_STATUS_OBF(status))
 461                         /* controller isn't responding */
 462                         if (time_before(jiffies, kcs->error0_timeout))
 463                                 return SI_SM_CALL_WITH_TICK_DELAY;
 464                 write_cmd(kcs, KCS_GET_STATUS_ABORT);
 465                 kcs->state = KCS_ERROR1;
 466                 break;
 467
 468         case KCS_ERROR1:
 469                 clear_obf(kcs, status);
 470                 write_data(kcs, 0);
 471                 kcs->state = KCS_ERROR2;
 472                 break;
 473
 474         case KCS_ERROR2:
 475                 if (state != KCS_READ_STATE) {
 476                         start_error_recovery(kcs,
 477                                              "Not in read state for error2");
 478                         break;
 479                 }
 480                 if (!check_obf(kcs, status, time))
 481                         return SI_SM_CALL_WITH_DELAY;
 482
 483                 clear_obf(kcs, status);
 484                 write_data(kcs, KCS_READ_BYTE);
 485                 kcs->state = KCS_ERROR3;
 486                 break;
 487
 488         case KCS_ERROR3:
 489                 if (state != KCS_IDLE_STATE) {
 490                         start_error_recovery(kcs,
 491                                              "Not in idle state for error3");
 492                         break;
 493                 }
 494
 495                 if (!check_obf(kcs, status, time))
 496                         return SI_SM_CALL_WITH_DELAY;
 497
 498                 clear_obf(kcs, status);
 499                 if (kcs->orig_write_count) {
 500                         restart_kcs_transaction(kcs);
 501                 } else {
 502                         kcs->state = KCS_IDLE;
 503                         return SI_SM_TRANSACTION_COMPLETE;
 504                 }
 505                 break;
 506
 507         case KCS_HOSED:
 508                 break;
 509         }
 510
 511         if (kcs->state == KCS_HOSED) {
 512                 init_kcs_data(kcs, kcs->io);
 513                 return SI_SM_HOSED;
 514         }
 515
 516         return SI_SM_CALL_WITHOUT_DELAY;
 517 }
 518
 519 static int kcs_size(void)
 520 {
 521         return sizeof(struct si_sm_data);
 522 }
 523
 524 static int kcs_detect(struct si_sm_data *kcs)
 525 {
 526         /*
 527          * It's impossible for the KCS status register to be all 1's,
 528          * (assuming a properly functioning, self-initialized BMC)
 529          * but that's what you get from reading a bogus address, so we
 530          * test that first.
 531          */
 532         if (read_status(kcs) == 0xff)
 533                 return 1;
 534
 535         return 0;
 536 }
 537
 538 static void kcs_cleanup(struct si_sm_data *kcs)
 539 {
 540 }
 541
 542 struct si_sm_handlers kcs_smi_handlers = {
 543         .init_data         = init_kcs_data,
 544         .start_transaction = start_kcs_transaction,
 545         .get_result        = get_kcs_result,
 546         .event             = kcs_event,
 547         .detect            = kcs_detect,
 548         .cleanup           = kcs_cleanup,
 549         .size              = kcs_size,
 550 };