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