drivers/char/ipmi/kcs_bmc_cdev_ipmi.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * Copyright (c) 2015-2018, Intel Corporation.
   4  */
   5
   6 #define pr_fmt(fmt) "kcs-bmc: " fmt
   7
   8 #include <linux/errno.h>
   9 #include <linux/io.h>
  10 #include <linux/ipmi_bmc.h>
  11 #include <linux/list.h>
  12 #include <linux/miscdevice.h>
  13 #include <linux/module.h>
  14 #include <linux/mutex.h>
  15 #include <linux/platform_device.h>
  16 #include <linux/poll.h>
  17 #include <linux/sched.h>
  18 #include <linux/slab.h>
  19
  20 #include "kcs_bmc_client.h"
  21
  22 /* Different phases of the KCS BMC module.
  23  *  KCS_PHASE_IDLE:
  24  *            BMC should not be expecting nor sending any data.
  25  *  KCS_PHASE_WRITE_START:
  26  *            BMC is receiving a WRITE_START command from system software.
  27  *  KCS_PHASE_WRITE_DATA:
  28  *            BMC is receiving a data byte from system software.
  29  *  KCS_PHASE_WRITE_END_CMD:
  30  *            BMC is waiting a last data byte from system software.
  31  *  KCS_PHASE_WRITE_DONE:
  32  *            BMC has received the whole request from system software.
  33  *  KCS_PHASE_WAIT_READ:
  34  *            BMC is waiting the response from the upper IPMI service.
  35  *  KCS_PHASE_READ:
  36  *            BMC is transferring the response to system software.
  37  *  KCS_PHASE_ABORT_ERROR1:
  38  *            BMC is waiting error status request from system software.
  39  *  KCS_PHASE_ABORT_ERROR2:
  40  *            BMC is waiting for idle status afer error from system software.
  41  *  KCS_PHASE_ERROR:
  42  *            BMC has detected a protocol violation at the interface level.
  43  */
  44 enum kcs_ipmi_phases {
  45         KCS_PHASE_IDLE,
  46
  47         KCS_PHASE_WRITE_START,
  48         KCS_PHASE_WRITE_DATA,
  49         KCS_PHASE_WRITE_END_CMD,
  50         KCS_PHASE_WRITE_DONE,
  51
  52         KCS_PHASE_WAIT_READ,
  53         KCS_PHASE_READ,
  54
  55         KCS_PHASE_ABORT_ERROR1,
  56         KCS_PHASE_ABORT_ERROR2,
  57         KCS_PHASE_ERROR
  58 };
  59
  60 /* IPMI 2.0 - Table 9-4, KCS Interface Status Codes */
  61 enum kcs_ipmi_errors {
  62         KCS_NO_ERROR                = 0x00,
  63         KCS_ABORTED_BY_COMMAND      = 0x01,
  64         KCS_ILLEGAL_CONTROL_CODE    = 0x02,
  65         KCS_LENGTH_ERROR            = 0x06,
  66         KCS_UNSPECIFIED_ERROR       = 0xFF
  67 };
  68
  69 struct kcs_bmc_ipmi {
  70         struct list_head entry;
  71
  72         struct kcs_bmc_client client;
  73
  74         spinlock_t lock;
  75
  76         enum kcs_ipmi_phases phase;
  77         enum kcs_ipmi_errors error;
  78
  79         wait_queue_head_t queue;
  80         bool data_in_avail;
  81         int  data_in_idx;
  82         u8  *data_in;
  83
  84         int  data_out_idx;
  85         int  data_out_len;
  86         u8  *data_out;
  87
  88         struct mutex mutex;
  89         u8 *kbuffer;
  90
  91         struct miscdevice miscdev;
  92 };
  93
  94 #define DEVICE_NAME "ipmi-kcs"
  95
  96 #define KCS_MSG_BUFSIZ    1000
  97
  98 #define KCS_ZERO_DATA     0
  99
 100 /* IPMI 2.0 - Table 9-1, KCS Interface Status Register Bits */
 101 #define KCS_STATUS_STATE(state) (state << 6)
 102 #define KCS_STATUS_STATE_MASK   GENMASK(7, 6)
 103 #define KCS_STATUS_CMD_DAT      BIT(3)
 104 #define KCS_STATUS_SMS_ATN      BIT(2)
 105 #define KCS_STATUS_IBF          BIT(1)
 106 #define KCS_STATUS_OBF          BIT(0)
 107
 108 /* IPMI 2.0 - Table 9-2, KCS Interface State Bits */
 109 enum kcs_states {
 110         IDLE_STATE  = 0,
 111         READ_STATE  = 1,
 112         WRITE_STATE = 2,
 113         ERROR_STATE = 3,
 114 };
 115
 116 /* IPMI 2.0 - Table 9-3, KCS Interface Control Codes */
 117 #define KCS_CMD_GET_STATUS_ABORT  0x60
 118 #define KCS_CMD_WRITE_START       0x61
 119 #define KCS_CMD_WRITE_END         0x62
 120 #define KCS_CMD_READ_BYTE         0x68
 121
 122 static inline void set_state(struct kcs_bmc_ipmi *priv, u8 state)
 123 {
 124         kcs_bmc_update_status(priv->client.dev, KCS_STATUS_STATE_MASK, KCS_STATUS_STATE(state));
 125 }
 126
 127 static void kcs_bmc_ipmi_force_abort(struct kcs_bmc_ipmi *priv)
 128 {
 129         set_state(priv, ERROR_STATE);
 130         kcs_bmc_read_data(priv->client.dev);
 131         kcs_bmc_write_data(priv->client.dev, KCS_ZERO_DATA);
 132
 133         priv->phase = KCS_PHASE_ERROR;
 134         priv->data_in_avail = false;
 135         priv->data_in_idx = 0;
 136 }
 137
 138 static void kcs_bmc_ipmi_handle_data(struct kcs_bmc_ipmi *priv)
 139 {
 140         struct kcs_bmc_device *dev;
 141         u8 data;
 142
 143         dev = priv->client.dev;
 144
 145         switch (priv->phase) {
 146         case KCS_PHASE_WRITE_START:
 147                 priv->phase = KCS_PHASE_WRITE_DATA;
 148                 fallthrough;
 149
 150         case KCS_PHASE_WRITE_DATA:
 151                 if (priv->data_in_idx < KCS_MSG_BUFSIZ) {
 152                         set_state(priv, WRITE_STATE);
 153                         kcs_bmc_write_data(dev, KCS_ZERO_DATA);
 154                         priv->data_in[priv->data_in_idx++] = kcs_bmc_read_data(dev);
 155                 } else {
 156                         kcs_bmc_ipmi_force_abort(priv);
 157                         priv->error = KCS_LENGTH_ERROR;
 158                 }
 159                 break;
 160
 161         case KCS_PHASE_WRITE_END_CMD:
 162                 if (priv->data_in_idx < KCS_MSG_BUFSIZ) {
 163                         set_state(priv, READ_STATE);
 164                         priv->data_in[priv->data_in_idx++] = kcs_bmc_read_data(dev);
 165                         priv->phase = KCS_PHASE_WRITE_DONE;
 166                         priv->data_in_avail = true;
 167                         wake_up_interruptible(&priv->queue);
 168                 } else {
 169                         kcs_bmc_ipmi_force_abort(priv);
 170                         priv->error = KCS_LENGTH_ERROR;
 171                 }
 172                 break;
 173
 174         case KCS_PHASE_READ:
 175                 if (priv->data_out_idx == priv->data_out_len)
 176                         set_state(priv, IDLE_STATE);
 177
 178                 data = kcs_bmc_read_data(dev);
 179                 if (data != KCS_CMD_READ_BYTE) {
 180                         set_state(priv, ERROR_STATE);
 181                         kcs_bmc_write_data(dev, KCS_ZERO_DATA);
 182                         break;
 183                 }
 184
 185                 if (priv->data_out_idx == priv->data_out_len) {
 186                         kcs_bmc_write_data(dev, KCS_ZERO_DATA);
 187                         priv->phase = KCS_PHASE_IDLE;
 188                         break;
 189                 }
 190
 191                 kcs_bmc_write_data(dev, priv->data_out[priv->data_out_idx++]);
 192                 break;
 193
 194         case KCS_PHASE_ABORT_ERROR1:
 195                 set_state(priv, READ_STATE);
 196                 kcs_bmc_read_data(dev);
 197                 kcs_bmc_write_data(dev, priv->error);
 198                 priv->phase = KCS_PHASE_ABORT_ERROR2;
 199                 break;
 200
 201         case KCS_PHASE_ABORT_ERROR2:
 202                 set_state(priv, IDLE_STATE);
 203                 kcs_bmc_read_data(dev);
 204                 kcs_bmc_write_data(dev, KCS_ZERO_DATA);
 205                 priv->phase = KCS_PHASE_IDLE;
 206                 break;
 207
 208         default:
 209                 kcs_bmc_ipmi_force_abort(priv);
 210                 break;
 211         }
 212 }
 213
 214 static void kcs_bmc_ipmi_handle_cmd(struct kcs_bmc_ipmi *priv)
 215 {
 216         u8 cmd;
 217
 218         set_state(priv, WRITE_STATE);
 219         kcs_bmc_write_data(priv->client.dev, KCS_ZERO_DATA);
 220
 221         cmd = kcs_bmc_read_data(priv->client.dev);
 222         switch (cmd) {
 223         case KCS_CMD_WRITE_START:
 224                 priv->phase = KCS_PHASE_WRITE_START;
 225                 priv->error = KCS_NO_ERROR;
 226                 priv->data_in_avail = false;
 227                 priv->data_in_idx = 0;
 228                 break;
 229
 230         case KCS_CMD_WRITE_END:
 231                 if (priv->phase != KCS_PHASE_WRITE_DATA) {
 232                         kcs_bmc_ipmi_force_abort(priv);
 233                         break;
 234                 }
 235
 236                 priv->phase = KCS_PHASE_WRITE_END_CMD;
 237                 break;
 238
 239         case KCS_CMD_GET_STATUS_ABORT:
 240                 if (priv->error == KCS_NO_ERROR)
 241                         priv->error = KCS_ABORTED_BY_COMMAND;
 242
 243                 priv->phase = KCS_PHASE_ABORT_ERROR1;
 244                 priv->data_in_avail = false;
 245                 priv->data_in_idx = 0;
 246                 break;
 247
 248         default:
 249                 kcs_bmc_ipmi_force_abort(priv);
 250                 priv->error = KCS_ILLEGAL_CONTROL_CODE;
 251                 break;
 252         }
 253 }
 254
 255 static inline struct kcs_bmc_ipmi *client_to_kcs_bmc_ipmi(struct kcs_bmc_client *client)
 256 {
 257         return container_of(client, struct kcs_bmc_ipmi, client);
 258 }
 259
 260 static irqreturn_t kcs_bmc_ipmi_event(struct kcs_bmc_client *client)
 261 {
 262         struct kcs_bmc_ipmi *priv;
 263         u8 status;
 264         int ret;
 265
 266         priv = client_to_kcs_bmc_ipmi(client);
 267         if (!priv)
 268                 return IRQ_NONE;
 269
 270         spin_lock(&priv->lock);
 271
 272         status = kcs_bmc_read_status(client->dev);
 273         if (status & KCS_STATUS_IBF) {
 274                 if (status & KCS_STATUS_CMD_DAT)
 275                         kcs_bmc_ipmi_handle_cmd(priv);
 276                 else
 277                         kcs_bmc_ipmi_handle_data(priv);
 278
 279                 ret = IRQ_HANDLED;
 280         } else {
 281                 ret = IRQ_NONE;
 282         }
 283
 284         spin_unlock(&priv->lock);
 285
 286         return ret;
 287 }
 288
 289 static const struct kcs_bmc_client_ops kcs_bmc_ipmi_client_ops = {
 290         .event = kcs_bmc_ipmi_event,
 291 };
 292
 293 static inline struct kcs_bmc_ipmi *to_kcs_bmc(struct file *filp)
 294 {
 295         return container_of(filp->private_data, struct kcs_bmc_ipmi, miscdev);
 296 }
 297
 298 static int kcs_bmc_ipmi_open(struct inode *inode, struct file *filp)
 299 {
 300         struct kcs_bmc_ipmi *priv = to_kcs_bmc(filp);
 301
 302         return kcs_bmc_enable_device(priv->client.dev, &priv->client);
 303 }
 304
 305 static __poll_t kcs_bmc_ipmi_poll(struct file *filp, poll_table *wait)
 306 {
 307         struct kcs_bmc_ipmi *priv = to_kcs_bmc(filp);
 308         __poll_t mask = 0;
 309
 310         poll_wait(filp, &priv->queue, wait);
 311
 312         spin_lock_irq(&priv->lock);
 313         if (priv->data_in_avail)
 314                 mask |= EPOLLIN;
 315         spin_unlock_irq(&priv->lock);
 316
 317         return mask;
 318 }
 319
 320 static ssize_t kcs_bmc_ipmi_read(struct file *filp, char __user *buf,
 321                             size_t count, loff_t *ppos)
 322 {
 323         struct kcs_bmc_ipmi *priv = to_kcs_bmc(filp);
 324         bool data_avail;
 325         size_t data_len;
 326         ssize_t ret;
 327
 328         if (!(filp->f_flags & O_NONBLOCK))
 329                 wait_event_interruptible(priv->queue,
 330                                          priv->data_in_avail);
 331
 332         mutex_lock(&priv->mutex);
 333
 334         spin_lock_irq(&priv->lock);
 335         data_avail = priv->data_in_avail;
 336         if (data_avail) {
 337                 data_len = priv->data_in_idx;
 338                 memcpy(priv->kbuffer, priv->data_in, data_len);
 339         }
 340         spin_unlock_irq(&priv->lock);
 341
 342         if (!data_avail) {
 343                 ret = -EAGAIN;
 344                 goto out_unlock;
 345         }
 346
 347         if (count < data_len) {
 348                 pr_err("channel=%u with too large data : %zu\n",
 349                         priv->client.dev->channel, data_len);
 350
 351                 spin_lock_irq(&priv->lock);
 352                 kcs_bmc_ipmi_force_abort(priv);
 353                 spin_unlock_irq(&priv->lock);
 354
 355                 ret = -EOVERFLOW;
 356                 goto out_unlock;
 357         }
 358
 359         if (copy_to_user(buf, priv->kbuffer, data_len)) {
 360                 ret = -EFAULT;
 361                 goto out_unlock;
 362         }
 363
 364         ret = data_len;
 365
 366         spin_lock_irq(&priv->lock);
 367         if (priv->phase == KCS_PHASE_WRITE_DONE) {
 368                 priv->phase = KCS_PHASE_WAIT_READ;
 369                 priv->data_in_avail = false;
 370                 priv->data_in_idx = 0;
 371         } else {
 372                 ret = -EAGAIN;
 373         }
 374         spin_unlock_irq(&priv->lock);
 375
 376 out_unlock:
 377         mutex_unlock(&priv->mutex);
 378
 379         return ret;
 380 }
 381
 382 static ssize_t kcs_bmc_ipmi_write(struct file *filp, const char __user *buf,
 383                              size_t count, loff_t *ppos)
 384 {
 385         struct kcs_bmc_ipmi *priv = to_kcs_bmc(filp);
 386         ssize_t ret;
 387
 388         /* a minimum response size '3' : netfn + cmd + ccode */
 389         if (count < 3 || count > KCS_MSG_BUFSIZ)
 390                 return -EINVAL;
 391
 392         mutex_lock(&priv->mutex);
 393
 394         if (copy_from_user(priv->kbuffer, buf, count)) {
 395                 ret = -EFAULT;
 396                 goto out_unlock;
 397         }
 398
 399         spin_lock_irq(&priv->lock);
 400         if (priv->phase == KCS_PHASE_WAIT_READ) {
 401                 priv->phase = KCS_PHASE_READ;
 402                 priv->data_out_idx = 1;
 403                 priv->data_out_len = count;
 404                 memcpy(priv->data_out, priv->kbuffer, count);
 405                 kcs_bmc_write_data(priv->client.dev, priv->data_out[0]);
 406                 ret = count;
 407         } else {
 408                 ret = -EINVAL;
 409         }
 410         spin_unlock_irq(&priv->lock);
 411
 412 out_unlock:
 413         mutex_unlock(&priv->mutex);
 414
 415         return ret;
 416 }
 417
 418 static long kcs_bmc_ipmi_ioctl(struct file *filp, unsigned int cmd,
 419                           unsigned long arg)
 420 {
 421         struct kcs_bmc_ipmi *priv = to_kcs_bmc(filp);
 422         long ret = 0;
 423
 424         spin_lock_irq(&priv->lock);
 425
 426         switch (cmd) {
 427         case IPMI_BMC_IOCTL_SET_SMS_ATN:
 428                 kcs_bmc_update_status(priv->client.dev, KCS_STATUS_SMS_ATN, KCS_STATUS_SMS_ATN);
 429                 break;
 430
 431         case IPMI_BMC_IOCTL_CLEAR_SMS_ATN:
 432                 kcs_bmc_update_status(priv->client.dev, KCS_STATUS_SMS_ATN, 0);
 433                 break;
 434
 435         case IPMI_BMC_IOCTL_FORCE_ABORT:
 436                 kcs_bmc_ipmi_force_abort(priv);
 437                 break;
 438
 439         default:
 440                 ret = -EINVAL;
 441                 break;
 442         }
 443
 444         spin_unlock_irq(&priv->lock);
 445
 446         return ret;
 447 }
 448
 449 static int kcs_bmc_ipmi_release(struct inode *inode, struct file *filp)
 450 {
 451         struct kcs_bmc_ipmi *priv = to_kcs_bmc(filp);
 452
 453         kcs_bmc_ipmi_force_abort(priv);
 454         kcs_bmc_disable_device(priv->client.dev, &priv->client);
 455
 456         return 0;
 457 }
 458
 459 static const struct file_operations kcs_bmc_ipmi_fops = {
 460         .owner          = THIS_MODULE,
 461         .open           = kcs_bmc_ipmi_open,
 462         .read           = kcs_bmc_ipmi_read,
 463         .write          = kcs_bmc_ipmi_write,
 464         .release        = kcs_bmc_ipmi_release,
 465         .poll           = kcs_bmc_ipmi_poll,
 466         .unlocked_ioctl = kcs_bmc_ipmi_ioctl,
 467 };
 468
 469 static DEFINE_SPINLOCK(kcs_bmc_ipmi_instances_lock);
 470 static LIST_HEAD(kcs_bmc_ipmi_instances);
 471
 472 static int kcs_bmc_ipmi_add_device(struct kcs_bmc_device *kcs_bmc)
 473 {
 474         struct kcs_bmc_ipmi *priv;
 475         int rc;
 476
 477         priv = devm_kzalloc(kcs_bmc->dev, sizeof(*priv), GFP_KERNEL);
 478         if (!priv)
 479                 return -ENOMEM;
 480
 481         spin_lock_init(&priv->lock);
 482         mutex_init(&priv->mutex);
 483
 484         init_waitqueue_head(&priv->queue);
 485
 486         priv->client.dev = kcs_bmc;
 487         priv->client.ops = &kcs_bmc_ipmi_client_ops;
 488         priv->data_in = devm_kmalloc(kcs_bmc->dev, KCS_MSG_BUFSIZ, GFP_KERNEL);
 489         priv->data_out = devm_kmalloc(kcs_bmc->dev, KCS_MSG_BUFSIZ, GFP_KERNEL);
 490         priv->kbuffer = devm_kmalloc(kcs_bmc->dev, KCS_MSG_BUFSIZ, GFP_KERNEL);
 491
 492         priv->miscdev.minor = MISC_DYNAMIC_MINOR;
 493         priv->miscdev.name = devm_kasprintf(kcs_bmc->dev, GFP_KERNEL, "%s%u", DEVICE_NAME,
 494                                            kcs_bmc->channel);
 495         if (!priv->data_in || !priv->data_out || !priv->kbuffer || !priv->miscdev.name)
 496                 return -EINVAL;
 497
 498         priv->miscdev.fops = &kcs_bmc_ipmi_fops;
 499
 500         rc = misc_register(&priv->miscdev);
 501         if (rc) {
 502                 dev_err(kcs_bmc->dev, "Unable to register device: %d\n", rc);
 503                 return rc;
 504         }
 505
 506         spin_lock_irq(&kcs_bmc_ipmi_instances_lock);
 507         list_add(&priv->entry, &kcs_bmc_ipmi_instances);
 508         spin_unlock_irq(&kcs_bmc_ipmi_instances_lock);
 509
 510         dev_info(kcs_bmc->dev, "Initialised IPMI client for channel %d", kcs_bmc->channel);
 511
 512         return 0;
 513 }
 514
 515 static int kcs_bmc_ipmi_remove_device(struct kcs_bmc_device *kcs_bmc)
 516 {
 517         struct kcs_bmc_ipmi *priv = NULL, *pos;
 518
 519         spin_lock_irq(&kcs_bmc_ipmi_instances_lock);
 520         list_for_each_entry(pos, &kcs_bmc_ipmi_instances, entry) {
 521                 if (pos->client.dev == kcs_bmc) {
 522                         priv = pos;
 523                         list_del(&pos->entry);
 524                         break;
 525                 }
 526         }
 527         spin_unlock_irq(&kcs_bmc_ipmi_instances_lock);
 528
 529         if (!priv)
 530                 return -ENODEV;
 531
 532         misc_deregister(&priv->miscdev);
 533         kcs_bmc_disable_device(priv->client.dev, &priv->client);
 534         devm_kfree(kcs_bmc->dev, priv->kbuffer);
 535         devm_kfree(kcs_bmc->dev, priv->data_out);
 536         devm_kfree(kcs_bmc->dev, priv->data_in);
 537         devm_kfree(kcs_bmc->dev, priv);
 538
 539         return 0;
 540 }
 541
 542 static const struct kcs_bmc_driver_ops kcs_bmc_ipmi_driver_ops = {
 543         .add_device = kcs_bmc_ipmi_add_device,
 544         .remove_device = kcs_bmc_ipmi_remove_device,
 545 };
 546
 547 static struct kcs_bmc_driver kcs_bmc_ipmi_driver = {
 548         .ops = &kcs_bmc_ipmi_driver_ops,
 549 };
 550
 551 static int __init kcs_bmc_ipmi_init(void)
 552 {
 553         kcs_bmc_register_driver(&kcs_bmc_ipmi_driver);
 554
 555         return 0;
 556 }
 557 module_init(kcs_bmc_ipmi_init);
 558
 559 static void __exit kcs_bmc_ipmi_exit(void)
 560 {
 561         kcs_bmc_unregister_driver(&kcs_bmc_ipmi_driver);
 562 }
 563 module_exit(kcs_bmc_ipmi_exit);
 564
 565 MODULE_LICENSE("GPL v2");
 566 MODULE_AUTHOR("Haiyue Wang <haiyue.wang@linux.intel.com>");
 567 MODULE_AUTHOR("Andrew Jeffery <andrew@aj.id.au>");
 568 MODULE_DESCRIPTION("KCS BMC to handle the IPMI request from system software");