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         KCS_IDLE,               /* The KCS interface is currently
  64                                    doing nothing. */
  65         KCS_START_OP,           /* We are starting an operation.  The
  66                                    data is in the output buffer, but
  67                                    nothing has been done to the
  68                                    interface yet.  This was added to
  69                                    the state machine in the spec to
  70                                    wait for the initial IBF. */
  71         KCS_WAIT_WRITE_START,   /* We have written a write cmd to the
  72                                    interface. */
  73         KCS_WAIT_WRITE,         /* We are writing bytes to the
  74                                    interface. */
  75         KCS_WAIT_WRITE_END,     /* We have written the write end cmd
  76                                    to the interface, and still need to
  77                                    write the last byte. */
  78         KCS_WAIT_READ,          /* We are waiting to read data from
  79                                    the interface. */
  80         KCS_ERROR0,             /* State to transition to the error
  81                                    handler, this was added to the
  82                                    state machine in the spec to be
  83                                    sure IBF was there. */
  84         KCS_ERROR1,             /* First stage error handler, wait for
  85                                    the interface to respond. */
  86         KCS_ERROR2,             /* The abort cmd has been written,
  87                                    wait for the interface to
  88                                    respond. */
  89         KCS_ERROR3,             /* We wrote some data to the
  90                                    interface, wait for it to switch to
  91                                    read mode. */
  92         KCS_HOSED               /* The hardware failed to follow the
  93                                    state machine. */
  94 };
  95
  96 #define MAX_KCS_READ_SIZE IPMI_MAX_MSG_LENGTH
  97 #define MAX_KCS_WRITE_SIZE IPMI_MAX_MSG_LENGTH
  98
  99 /* Timeouts in microseconds. */
 100 #define IBF_RETRY_TIMEOUT 1000000
 101 #define OBF_RETRY_TIMEOUT 1000000
 102 #define MAX_ERROR_RETRIES 10
 103 #define ERROR0_OBF_WAIT_JIFFIES (2*HZ)
 104
 105 struct si_sm_data
 106 {
 107         enum kcs_states  state;
 108         struct si_sm_io *io;
 109         unsigned char    write_data[MAX_KCS_WRITE_SIZE];
 110         int              write_pos;
 111         int              write_count;
 112         int              orig_write_count;
 113         unsigned char    read_data[MAX_KCS_READ_SIZE];
 114         int              read_pos;
 115         int              truncated;
 116
 117         unsigned int  error_retries;
 118         long          ibf_timeout;
 119         long          obf_timeout;
 120         unsigned long  error0_timeout;
 121 };
 122
 123 static unsigned int init_kcs_data(struct si_sm_data *kcs,
 124                                   struct si_sm_io *io)
 125 {
 126         kcs->state = KCS_IDLE;
 127         kcs->io = io;
 128         kcs->write_pos = 0;
 129         kcs->write_count = 0;
 130         kcs->orig_write_count = 0;
 131         kcs->read_pos = 0;
 132         kcs->error_retries = 0;
 133         kcs->truncated = 0;
 134         kcs->ibf_timeout = IBF_RETRY_TIMEOUT;
 135         kcs->obf_timeout = OBF_RETRY_TIMEOUT;
 136
 137         /* Reserve 2 I/O bytes. */
 138         return 2;
 139 }
 140
 141 static inline unsigned char read_status(struct si_sm_data *kcs)
 142 {
 143         return kcs->io->inputb(kcs->io, 1);
 144 }
 145
 146 static inline unsigned char read_data(struct si_sm_data *kcs)
 147 {
 148         return kcs->io->inputb(kcs->io, 0);
 149 }
 150
 151 static inline void write_cmd(struct si_sm_data *kcs, unsigned char data)
 152 {
 153         kcs->io->outputb(kcs->io, 1, data);
 154 }
 155
 156 static inline void write_data(struct si_sm_data *kcs, unsigned char data)
 157 {
 158         kcs->io->outputb(kcs->io, 0, data);
 159 }
 160
 161 /* Control codes. */
 162 #define KCS_GET_STATUS_ABORT    0x60
 163 #define KCS_WRITE_START         0x61
 164 #define KCS_WRITE_END           0x62
 165 #define KCS_READ_BYTE           0x68
 166
 167 /* Status bits. */
 168 #define GET_STATUS_STATE(status) (((status) >> 6) & 0x03)
 169 #define KCS_IDLE_STATE  0
 170 #define KCS_READ_STATE  1
 171 #define KCS_WRITE_STATE 2
 172 #define KCS_ERROR_STATE 3
 173 #define GET_STATUS_ATN(status) ((status) & 0x04)
 174 #define GET_STATUS_IBF(status) ((status) & 0x02)
 175 #define GET_STATUS_OBF(status) ((status) & 0x01)
 176
 177
 178 static inline void write_next_byte(struct si_sm_data *kcs)
 179 {
 180         write_data(kcs, kcs->write_data[kcs->write_pos]);
 181         (kcs->write_pos)++;
 182         (kcs->write_count)--;
 183 }
 184
 185 static inline void start_error_recovery(struct si_sm_data *kcs, char *reason)
 186 {
 187         (kcs->error_retries)++;
 188         if (kcs->error_retries > MAX_ERROR_RETRIES) {
 189                 if (kcs_debug & KCS_DEBUG_ENABLE)
 190                         printk(KERN_DEBUG "ipmi_kcs_sm: kcs hosed: %s\n", reason);
 191                 kcs->state = KCS_HOSED;
 192         } else {
 193                 kcs->error0_timeout = jiffies + ERROR0_OBF_WAIT_JIFFIES;
 194                 kcs->state = KCS_ERROR0;
 195         }
 196 }
 197
 198 static inline void read_next_byte(struct si_sm_data *kcs)
 199 {
 200         if (kcs->read_pos >= MAX_KCS_READ_SIZE) {
 201                 /* Throw the data away and mark it truncated. */
 202                 read_data(kcs);
 203                 kcs->truncated = 1;
 204         } else {
 205                 kcs->read_data[kcs->read_pos] = read_data(kcs);
 206                 (kcs->read_pos)++;
 207         }
 208         write_data(kcs, KCS_READ_BYTE);
 209 }
 210
 211 static inline int check_ibf(struct si_sm_data *kcs, unsigned char status,
 212                             long time)
 213 {
 214         if (GET_STATUS_IBF(status)) {
 215                 kcs->ibf_timeout -= time;
 216                 if (kcs->ibf_timeout < 0) {
 217                         start_error_recovery(kcs, "IBF not ready in time");
 218                         kcs->ibf_timeout = IBF_RETRY_TIMEOUT;
 219                         return 1;
 220                 }
 221                 return 0;
 222         }
 223         kcs->ibf_timeout = IBF_RETRY_TIMEOUT;
 224         return 1;
 225 }
 226
 227 static inline int check_obf(struct si_sm_data *kcs, unsigned char status,
 228                             long time)
 229 {
 230         if (!GET_STATUS_OBF(status)) {
 231                 kcs->obf_timeout -= time;
 232                 if (kcs->obf_timeout < 0) {
 233                     start_error_recovery(kcs, "OBF not ready in time");
 234                     return 1;
 235                 }
 236                 return 0;
 237         }
 238         kcs->obf_timeout = OBF_RETRY_TIMEOUT;
 239         return 1;
 240 }
 241
 242 static void clear_obf(struct si_sm_data *kcs, unsigned char status)
 243 {
 244         if (GET_STATUS_OBF(status))
 245                 read_data(kcs);
 246 }
 247
 248 static void restart_kcs_transaction(struct si_sm_data *kcs)
 249 {
 250         kcs->write_count = kcs->orig_write_count;
 251         kcs->write_pos = 0;
 252         kcs->read_pos = 0;
 253         kcs->state = KCS_WAIT_WRITE_START;
 254         kcs->ibf_timeout = IBF_RETRY_TIMEOUT;
 255         kcs->obf_timeout = OBF_RETRY_TIMEOUT;
 256         write_cmd(kcs, KCS_WRITE_START);
 257 }
 258
 259 static int start_kcs_transaction(struct si_sm_data *kcs, unsigned char *data,
 260                                  unsigned int size)
 261 {
 262         unsigned int i;
 263
 264         if (size < 2)
 265                 return IPMI_REQ_LEN_INVALID_ERR;
 266         if (size > MAX_KCS_WRITE_SIZE)
 267                 return IPMI_REQ_LEN_EXCEEDED_ERR;
 268
 269         if ((kcs->state != KCS_IDLE) && (kcs->state != KCS_HOSED))
 270                 return IPMI_NOT_IN_MY_STATE_ERR;
 271
 272         if (kcs_debug & KCS_DEBUG_MSG) {
 273                 printk(KERN_DEBUG "start_kcs_transaction -");
 274                 for (i = 0; i < size; i ++) {
 275                         printk(" %02x", (unsigned char) (data [i]));
 276                 }
 277                 printk ("\n");
 278         }
 279         kcs->error_retries = 0;
 280         memcpy(kcs->write_data, data, size);
 281         kcs->write_count = size;
 282         kcs->orig_write_count = size;
 283         kcs->write_pos = 0;
 284         kcs->read_pos = 0;
 285         kcs->state = KCS_START_OP;
 286         kcs->ibf_timeout = IBF_RETRY_TIMEOUT;
 287         kcs->obf_timeout = OBF_RETRY_TIMEOUT;
 288         return 0;
 289 }
 290
 291 static int get_kcs_result(struct si_sm_data *kcs, unsigned char *data,
 292                           unsigned int length)
 293 {
 294         if (length < kcs->read_pos) {
 295                 kcs->read_pos = length;
 296                 kcs->truncated = 1;
 297         }
 298
 299         memcpy(data, kcs->read_data, kcs->read_pos);
 300
 301         if ((length >= 3) && (kcs->read_pos < 3)) {
 302                 /* Guarantee that we return at least 3 bytes, with an
 303                    error in the third byte if it is too short. */
 304                 data[2] = IPMI_ERR_UNSPECIFIED;
 305                 kcs->read_pos = 3;
 306         }
 307         if (kcs->truncated) {
 308                 /* Report a truncated error.  We might overwrite
 309                    another error, but that's too bad, the user needs
 310                    to know it was truncated. */
 311                 data[2] = IPMI_ERR_MSG_TRUNCATED;
 312                 kcs->truncated = 0;
 313         }
 314
 315         return kcs->read_pos;
 316 }
 317
 318 /* This implements the state machine defined in the IPMI manual, see
 319    that for details on how this works.  Divide that flowchart into
 320    sections delimited by "Wait for IBF" and this will become clear. */
 321 static enum si_sm_result kcs_event(struct si_sm_data *kcs, long time)
 322 {
 323         unsigned char status;
 324         unsigned char state;
 325
 326         status = read_status(kcs);
 327
 328         if (kcs_debug & KCS_DEBUG_STATES)
 329                 printk(KERN_DEBUG "KCS: State = %d, %x\n", kcs->state, status);
 330
 331         /* All states wait for ibf, so just do it here. */
 332         if (!check_ibf(kcs, status, time))
 333                 return SI_SM_CALL_WITH_DELAY;
 334
 335         /* Just about everything looks at the KCS state, so grab that, too. */
 336         state = GET_STATUS_STATE(status);
 337
 338         switch (kcs->state) {
 339         case KCS_IDLE:
 340                 /* If there's and interrupt source, turn it off. */
 341                 clear_obf(kcs, status);
 342
 343                 if (GET_STATUS_ATN(status))
 344                         return SI_SM_ATTN;
 345                 else
 346                         return SI_SM_IDLE;
 347
 348         case KCS_START_OP:
 349                 if (state != KCS_IDLE) {
 350                         start_error_recovery(kcs,
 351                                              "State machine not idle at start");
 352                         break;
 353                 }
 354
 355                 clear_obf(kcs, status);
 356                 write_cmd(kcs, KCS_WRITE_START);
 357                 kcs->state = KCS_WAIT_WRITE_START;
 358                 break;
 359
 360         case KCS_WAIT_WRITE_START:
 361                 if (state != KCS_WRITE_STATE) {
 362                         start_error_recovery(
 363                                 kcs,
 364                                 "Not in write state at write start");
 365                         break;
 366                 }
 367                 read_data(kcs);
 368                 if (kcs->write_count == 1) {
 369                         write_cmd(kcs, KCS_WRITE_END);
 370                         kcs->state = KCS_WAIT_WRITE_END;
 371                 } else {
 372                         write_next_byte(kcs);
 373                         kcs->state = KCS_WAIT_WRITE;
 374                 }
 375                 break;
 376
 377         case KCS_WAIT_WRITE:
 378                 if (state != KCS_WRITE_STATE) {
 379                         start_error_recovery(kcs,
 380                                              "Not in write state for write");
 381                         break;
 382                 }
 383                 clear_obf(kcs, status);
 384                 if (kcs->write_count == 1) {
 385                         write_cmd(kcs, KCS_WRITE_END);
 386                         kcs->state = KCS_WAIT_WRITE_END;
 387                 } else {
 388                         write_next_byte(kcs);
 389                 }
 390                 break;
 391
 392         case KCS_WAIT_WRITE_END:
 393                 if (state != KCS_WRITE_STATE) {
 394                         start_error_recovery(kcs,
 395                                              "Not in write state for write end");
 396                         break;
 397                 }
 398                 clear_obf(kcs, status);
 399                 write_next_byte(kcs);
 400                 kcs->state = KCS_WAIT_READ;
 401                 break;
 402
 403         case KCS_WAIT_READ:
 404                 if ((state != KCS_READ_STATE) && (state != KCS_IDLE_STATE)) {
 405                         start_error_recovery(
 406                                 kcs,
 407                                 "Not in read or idle in read state");
 408                         break;
 409                 }
 410
 411                 if (state == KCS_READ_STATE) {
 412                         if (!check_obf(kcs, status, time))
 413                                 return SI_SM_CALL_WITH_DELAY;
 414                         read_next_byte(kcs);
 415                 } else {
 416                         /* We don't implement this exactly like the state
 417                            machine in the spec.  Some broken hardware
 418                            does not write the final dummy byte to the
 419                            read register.  Thus obf will never go high
 420                            here.  We just go straight to idle, and we
 421                            handle clearing out obf in idle state if it
 422                            happens to come in. */
 423                         clear_obf(kcs, status);
 424                         kcs->orig_write_count = 0;
 425                         kcs->state = KCS_IDLE;
 426                         return SI_SM_TRANSACTION_COMPLETE;
 427                 }
 428                 break;
 429
 430         case KCS_ERROR0:
 431                 clear_obf(kcs, status);
 432                 status = read_status(kcs);
 433                 if  (GET_STATUS_OBF(status)) /* controller isn't responding */
 434                         if (time_before(jiffies, kcs->error0_timeout))
 435                                 return SI_SM_CALL_WITH_TICK_DELAY;
 436                 write_cmd(kcs, KCS_GET_STATUS_ABORT);
 437                 kcs->state = KCS_ERROR1;
 438                 break;
 439
 440         case KCS_ERROR1:
 441                 clear_obf(kcs, status);
 442                 write_data(kcs, 0);
 443                 kcs->state = KCS_ERROR2;
 444                 break;
 445
 446         case KCS_ERROR2:
 447                 if (state != KCS_READ_STATE) {
 448                         start_error_recovery(kcs,
 449                                              "Not in read state for error2");
 450                         break;
 451                 }
 452                 if (!check_obf(kcs, status, time))
 453                         return SI_SM_CALL_WITH_DELAY;
 454
 455                 clear_obf(kcs, status);
 456                 write_data(kcs, KCS_READ_BYTE);
 457                 kcs->state = KCS_ERROR3;
 458                 break;
 459
 460         case KCS_ERROR3:
 461                 if (state != KCS_IDLE_STATE) {
 462                         start_error_recovery(kcs,
 463                                              "Not in idle state for error3");
 464                         break;
 465                 }
 466
 467                 if (!check_obf(kcs, status, time))
 468                         return SI_SM_CALL_WITH_DELAY;
 469
 470                 clear_obf(kcs, status);
 471                 if (kcs->orig_write_count) {
 472                         restart_kcs_transaction(kcs);
 473                 } else {
 474                         kcs->state = KCS_IDLE;
 475                         return SI_SM_TRANSACTION_COMPLETE;
 476                 }
 477                 break;
 478
 479         case KCS_HOSED:
 480                 break;
 481         }
 482
 483         if (kcs->state == KCS_HOSED) {
 484                 init_kcs_data(kcs, kcs->io);
 485                 return SI_SM_HOSED;
 486         }
 487
 488         return SI_SM_CALL_WITHOUT_DELAY;
 489 }
 490
 491 static int kcs_size(void)
 492 {
 493         return sizeof(struct si_sm_data);
 494 }
 495
 496 static int kcs_detect(struct si_sm_data *kcs)
 497 {
 498         /* It's impossible for the KCS status register to be all 1's,
 499            (assuming a properly functioning, self-initialized BMC)
 500            but that's what you get from reading a bogus address, so we
 501            test that first. */
 502         if (read_status(kcs) == 0xff)
 503                 return 1;
 504
 505         return 0;
 506 }
 507
 508 static void kcs_cleanup(struct si_sm_data *kcs)
 509 {
 510 }
 511
 512 struct si_sm_handlers kcs_smi_handlers =
 513 {
 514         .init_data         = init_kcs_data,
 515         .start_transaction = start_kcs_transaction,
 516         .get_result        = get_kcs_result,
 517         .event             = kcs_event,
 518         .detect            = kcs_detect,
 519         .cleanup           = kcs_cleanup,
 520         .size              = kcs_size,
 521 };