drivers/char/ipmi/bt-bmc.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * Copyright (c) 2015-2016, IBM Corporation.
   4  */
   5
   6 #include <linux/atomic.h>
   7 #include <linux/bt-bmc.h>
   8 #include <linux/errno.h>
   9 #include <linux/interrupt.h>
  10 #include <linux/io.h>
  11 #include <linux/mfd/syscon.h>
  12 #include <linux/miscdevice.h>
  13 #include <linux/module.h>
  14 #include <linux/of.h>
  15 #include <linux/platform_device.h>
  16 #include <linux/poll.h>
  17 #include <linux/regmap.h>
  18 #include <linux/sched.h>
  19 #include <linux/timer.h>
  20
  21 /*
  22  * This is a BMC device used to communicate to the host
  23  */
  24 #define DEVICE_NAME     "ipmi-bt-host"
  25
  26 #define BT_IO_BASE      0xe4
  27 #define BT_IRQ          10
  28
  29 #define BT_CR0          0x0
  30 #define   BT_CR0_IO_BASE                16
  31 #define   BT_CR0_IRQ                    12
  32 #define   BT_CR0_EN_CLR_SLV_RDP         0x8
  33 #define   BT_CR0_EN_CLR_SLV_WRP         0x4
  34 #define   BT_CR0_ENABLE_IBT             0x1
  35 #define BT_CR1          0x4
  36 #define   BT_CR1_IRQ_H2B        0x01
  37 #define   BT_CR1_IRQ_HBUSY      0x40
  38 #define BT_CR2          0x8
  39 #define   BT_CR2_IRQ_H2B        0x01
  40 #define   BT_CR2_IRQ_HBUSY      0x40
  41 #define BT_CR3          0xc
  42 #define BT_CTRL         0x10
  43 #define   BT_CTRL_B_BUSY                0x80
  44 #define   BT_CTRL_H_BUSY                0x40
  45 #define   BT_CTRL_OEM0                  0x20
  46 #define   BT_CTRL_SMS_ATN               0x10
  47 #define   BT_CTRL_B2H_ATN               0x08
  48 #define   BT_CTRL_H2B_ATN               0x04
  49 #define   BT_CTRL_CLR_RD_PTR            0x02
  50 #define   BT_CTRL_CLR_WR_PTR            0x01
  51 #define BT_BMC2HOST     0x14
  52 #define BT_INTMASK      0x18
  53 #define   BT_INTMASK_B2H_IRQEN          0x01
  54 #define   BT_INTMASK_B2H_IRQ            0x02
  55 #define   BT_INTMASK_BMC_HWRST          0x80
  56
  57 #define BT_BMC_BUFFER_SIZE 256
  58
  59 struct bt_bmc {
  60         struct device           dev;
  61         struct miscdevice       miscdev;
  62         struct regmap           *map;
  63         int                     offset;
  64         int                     irq;
  65         wait_queue_head_t       queue;
  66         struct timer_list       poll_timer;
  67         struct mutex            mutex;
  68 };
  69
  70 static atomic_t open_count = ATOMIC_INIT(0);
  71
  72 static const struct regmap_config bt_regmap_cfg = {
  73         .reg_bits = 32,
  74         .val_bits = 32,
  75         .reg_stride = 4,
  76 };
  77
  78 static u8 bt_inb(struct bt_bmc *bt_bmc, int reg)
  79 {
  80         uint32_t val = 0;
  81         int rc;
  82
  83         rc = regmap_read(bt_bmc->map, bt_bmc->offset + reg, &val);
  84         WARN(rc != 0, "regmap_read() failed: %d\n", rc);
  85
  86         return rc == 0 ? (u8) val : 0;
  87 }
  88
  89 static void bt_outb(struct bt_bmc *bt_bmc, u8 data, int reg)
  90 {
  91         int rc;
  92
  93         rc = regmap_write(bt_bmc->map, bt_bmc->offset + reg, data);
  94         WARN(rc != 0, "regmap_write() failed: %d\n", rc);
  95 }
  96
  97 static void clr_rd_ptr(struct bt_bmc *bt_bmc)
  98 {
  99         bt_outb(bt_bmc, BT_CTRL_CLR_RD_PTR, BT_CTRL);
 100 }
 101
 102 static void clr_wr_ptr(struct bt_bmc *bt_bmc)
 103 {
 104         bt_outb(bt_bmc, BT_CTRL_CLR_WR_PTR, BT_CTRL);
 105 }
 106
 107 static void clr_h2b_atn(struct bt_bmc *bt_bmc)
 108 {
 109         bt_outb(bt_bmc, BT_CTRL_H2B_ATN, BT_CTRL);
 110 }
 111
 112 static void set_b_busy(struct bt_bmc *bt_bmc)
 113 {
 114         if (!(bt_inb(bt_bmc, BT_CTRL) & BT_CTRL_B_BUSY))
 115                 bt_outb(bt_bmc, BT_CTRL_B_BUSY, BT_CTRL);
 116 }
 117
 118 static void clr_b_busy(struct bt_bmc *bt_bmc)
 119 {
 120         if (bt_inb(bt_bmc, BT_CTRL) & BT_CTRL_B_BUSY)
 121                 bt_outb(bt_bmc, BT_CTRL_B_BUSY, BT_CTRL);
 122 }
 123
 124 static void set_b2h_atn(struct bt_bmc *bt_bmc)
 125 {
 126         bt_outb(bt_bmc, BT_CTRL_B2H_ATN, BT_CTRL);
 127 }
 128
 129 static u8 bt_read(struct bt_bmc *bt_bmc)
 130 {
 131         return bt_inb(bt_bmc, BT_BMC2HOST);
 132 }
 133
 134 static ssize_t bt_readn(struct bt_bmc *bt_bmc, u8 *buf, size_t n)
 135 {
 136         int i;
 137
 138         for (i = 0; i < n; i++)
 139                 buf[i] = bt_read(bt_bmc);
 140         return n;
 141 }
 142
 143 static void bt_write(struct bt_bmc *bt_bmc, u8 c)
 144 {
 145         bt_outb(bt_bmc, c, BT_BMC2HOST);
 146 }
 147
 148 static ssize_t bt_writen(struct bt_bmc *bt_bmc, u8 *buf, size_t n)
 149 {
 150         int i;
 151
 152         for (i = 0; i < n; i++)
 153                 bt_write(bt_bmc, buf[i]);
 154         return n;
 155 }
 156
 157 static void set_sms_atn(struct bt_bmc *bt_bmc)
 158 {
 159         bt_outb(bt_bmc, BT_CTRL_SMS_ATN, BT_CTRL);
 160 }
 161
 162 static struct bt_bmc *file_bt_bmc(struct file *file)
 163 {
 164         return container_of(file->private_data, struct bt_bmc, miscdev);
 165 }
 166
 167 static int bt_bmc_open(struct inode *inode, struct file *file)
 168 {
 169         struct bt_bmc *bt_bmc = file_bt_bmc(file);
 170
 171         if (atomic_inc_return(&open_count) == 1) {
 172                 clr_b_busy(bt_bmc);
 173                 return 0;
 174         }
 175
 176         atomic_dec(&open_count);
 177         return -EBUSY;
 178 }
 179
 180 /*
 181  * The BT (Block Transfer) interface means that entire messages are
 182  * buffered by the host before a notification is sent to the BMC that
 183  * there is data to be read. The first byte is the length and the
 184  * message data follows. The read operation just tries to capture the
 185  * whole before returning it to userspace.
 186  *
 187  * BT Message format :
 188  *
 189  *    Byte 1  Byte 2     Byte 3  Byte 4  Byte 5:N
 190  *    Length  NetFn/LUN  Seq     Cmd     Data
 191  *
 192  */
 193 static ssize_t bt_bmc_read(struct file *file, char __user *buf,
 194                            size_t count, loff_t *ppos)
 195 {
 196         struct bt_bmc *bt_bmc = file_bt_bmc(file);
 197         u8 len;
 198         int len_byte = 1;
 199         u8 kbuffer[BT_BMC_BUFFER_SIZE];
 200         ssize_t ret = 0;
 201         ssize_t nread;
 202
 203         WARN_ON(*ppos);
 204
 205         if (wait_event_interruptible(bt_bmc->queue,
 206                                      bt_inb(bt_bmc, BT_CTRL) & BT_CTRL_H2B_ATN))
 207                 return -ERESTARTSYS;
 208
 209         mutex_lock(&bt_bmc->mutex);
 210
 211         if (unlikely(!(bt_inb(bt_bmc, BT_CTRL) & BT_CTRL_H2B_ATN))) {
 212                 ret = -EIO;
 213                 goto out_unlock;
 214         }
 215
 216         set_b_busy(bt_bmc);
 217         clr_h2b_atn(bt_bmc);
 218         clr_rd_ptr(bt_bmc);
 219
 220         /*
 221          * The BT frames start with the message length, which does not
 222          * include the length byte.
 223          */
 224         kbuffer[0] = bt_read(bt_bmc);
 225         len = kbuffer[0];
 226
 227         /* We pass the length back to userspace as well */
 228         if (len + 1 > count)
 229                 len = count - 1;
 230
 231         while (len) {
 232                 nread = min_t(ssize_t, len, sizeof(kbuffer) - len_byte);
 233
 234                 bt_readn(bt_bmc, kbuffer + len_byte, nread);
 235
 236                 if (copy_to_user(buf, kbuffer, nread + len_byte)) {
 237                         ret = -EFAULT;
 238                         break;
 239                 }
 240                 len -= nread;
 241                 buf += nread + len_byte;
 242                 ret += nread + len_byte;
 243                 len_byte = 0;
 244         }
 245
 246         clr_b_busy(bt_bmc);
 247
 248 out_unlock:
 249         mutex_unlock(&bt_bmc->mutex);
 250         return ret;
 251 }
 252
 253 /*
 254  * BT Message response format :
 255  *
 256  *    Byte 1  Byte 2     Byte 3  Byte 4  Byte 5  Byte 6:N
 257  *    Length  NetFn/LUN  Seq     Cmd     Code    Data
 258  */
 259 static ssize_t bt_bmc_write(struct file *file, const char __user *buf,
 260                             size_t count, loff_t *ppos)
 261 {
 262         struct bt_bmc *bt_bmc = file_bt_bmc(file);
 263         u8 kbuffer[BT_BMC_BUFFER_SIZE];
 264         ssize_t ret = 0;
 265         ssize_t nwritten;
 266
 267         /*
 268          * send a minimum response size
 269          */
 270         if (count < 5)
 271                 return -EINVAL;
 272
 273         WARN_ON(*ppos);
 274
 275         /*
 276          * There's no interrupt for clearing bmc busy so we have to
 277          * poll
 278          */
 279         if (wait_event_interruptible(bt_bmc->queue,
 280                                      !(bt_inb(bt_bmc, BT_CTRL) &
 281                                        (BT_CTRL_H_BUSY | BT_CTRL_B2H_ATN))))
 282                 return -ERESTARTSYS;
 283
 284         mutex_lock(&bt_bmc->mutex);
 285
 286         if (unlikely(bt_inb(bt_bmc, BT_CTRL) &
 287                      (BT_CTRL_H_BUSY | BT_CTRL_B2H_ATN))) {
 288                 ret = -EIO;
 289                 goto out_unlock;
 290         }
 291
 292         clr_wr_ptr(bt_bmc);
 293
 294         while (count) {
 295                 nwritten = min_t(ssize_t, count, sizeof(kbuffer));
 296                 if (copy_from_user(&kbuffer, buf, nwritten)) {
 297                         ret = -EFAULT;
 298                         break;
 299                 }
 300
 301                 bt_writen(bt_bmc, kbuffer, nwritten);
 302
 303                 count -= nwritten;
 304                 buf += nwritten;
 305                 ret += nwritten;
 306         }
 307
 308         set_b2h_atn(bt_bmc);
 309
 310 out_unlock:
 311         mutex_unlock(&bt_bmc->mutex);
 312         return ret;
 313 }
 314
 315 static long bt_bmc_ioctl(struct file *file, unsigned int cmd,
 316                          unsigned long param)
 317 {
 318         struct bt_bmc *bt_bmc = file_bt_bmc(file);
 319
 320         switch (cmd) {
 321         case BT_BMC_IOCTL_SMS_ATN:
 322                 set_sms_atn(bt_bmc);
 323                 return 0;
 324         }
 325         return -EINVAL;
 326 }
 327
 328 static int bt_bmc_release(struct inode *inode, struct file *file)
 329 {
 330         struct bt_bmc *bt_bmc = file_bt_bmc(file);
 331
 332         atomic_dec(&open_count);
 333         set_b_busy(bt_bmc);
 334         return 0;
 335 }
 336
 337 static __poll_t bt_bmc_poll(struct file *file, poll_table *wait)
 338 {
 339         struct bt_bmc *bt_bmc = file_bt_bmc(file);
 340         __poll_t mask = 0;
 341         u8 ctrl;
 342
 343         poll_wait(file, &bt_bmc->queue, wait);
 344
 345         ctrl = bt_inb(bt_bmc, BT_CTRL);
 346
 347         if (ctrl & BT_CTRL_H2B_ATN)
 348                 mask |= EPOLLIN;
 349
 350         if (!(ctrl & (BT_CTRL_H_BUSY | BT_CTRL_B2H_ATN)))
 351                 mask |= EPOLLOUT;
 352
 353         return mask;
 354 }
 355
 356 static const struct file_operations bt_bmc_fops = {
 357         .owner          = THIS_MODULE,
 358         .open           = bt_bmc_open,
 359         .read           = bt_bmc_read,
 360         .write          = bt_bmc_write,
 361         .release        = bt_bmc_release,
 362         .poll           = bt_bmc_poll,
 363         .unlocked_ioctl = bt_bmc_ioctl,
 364 };
 365
 366 static void poll_timer(struct timer_list *t)
 367 {
 368         struct bt_bmc *bt_bmc = from_timer(bt_bmc, t, poll_timer);
 369
 370         bt_bmc->poll_timer.expires += msecs_to_jiffies(500);
 371         wake_up(&bt_bmc->queue);
 372         add_timer(&bt_bmc->poll_timer);
 373 }
 374
 375 static irqreturn_t bt_bmc_irq(int irq, void *arg)
 376 {
 377         struct bt_bmc *bt_bmc = arg;
 378         u32 reg;
 379         int rc;
 380
 381         rc = regmap_read(bt_bmc->map, bt_bmc->offset + BT_CR2, &reg);
 382         if (rc)
 383                 return IRQ_NONE;
 384
 385         reg &= BT_CR2_IRQ_H2B | BT_CR2_IRQ_HBUSY;
 386         if (!reg)
 387                 return IRQ_NONE;
 388
 389         /* ack pending IRQs */
 390         regmap_write(bt_bmc->map, bt_bmc->offset + BT_CR2, reg);
 391
 392         wake_up(&bt_bmc->queue);
 393         return IRQ_HANDLED;
 394 }
 395
 396 static int bt_bmc_config_irq(struct bt_bmc *bt_bmc,
 397                              struct platform_device *pdev)
 398 {
 399         struct device *dev = &pdev->dev;
 400         int rc;
 401
 402         bt_bmc->irq = platform_get_irq_optional(pdev, 0);
 403         if (bt_bmc->irq < 0)
 404                 return bt_bmc->irq;
 405
 406         rc = devm_request_irq(dev, bt_bmc->irq, bt_bmc_irq, IRQF_SHARED,
 407                               DEVICE_NAME, bt_bmc);
 408         if (rc < 0) {
 409                 dev_warn(dev, "Unable to request IRQ %d\n", bt_bmc->irq);
 410                 bt_bmc->irq = rc;
 411                 return rc;
 412         }
 413
 414         /*
 415          * Configure IRQs on the bmc clearing the H2B and HBUSY bits;
 416          * H2B will be asserted when the bmc has data for us; HBUSY
 417          * will be cleared (along with B2H) when we can write the next
 418          * message to the BT buffer
 419          */
 420         rc = regmap_update_bits(bt_bmc->map, bt_bmc->offset + BT_CR1,
 421                                 (BT_CR1_IRQ_H2B | BT_CR1_IRQ_HBUSY),
 422                                 (BT_CR1_IRQ_H2B | BT_CR1_IRQ_HBUSY));
 423
 424         return rc;
 425 }
 426
 427 static int bt_bmc_probe(struct platform_device *pdev)
 428 {
 429         struct bt_bmc *bt_bmc;
 430         struct device *dev;
 431         int rc;
 432
 433         dev = &pdev->dev;
 434         dev_info(dev, "Found bt bmc device\n");
 435
 436         bt_bmc = devm_kzalloc(dev, sizeof(*bt_bmc), GFP_KERNEL);
 437         if (!bt_bmc)
 438                 return -ENOMEM;
 439
 440         dev_set_drvdata(&pdev->dev, bt_bmc);
 441
 442         bt_bmc->map = syscon_node_to_regmap(pdev->dev.parent->of_node);
 443         if (IS_ERR(bt_bmc->map)) {
 444                 void __iomem *base;
 445
 446                 /*
 447                  * Assume it's not the MFD-based devicetree description, in
 448                  * which case generate a regmap ourselves
 449                  */
 450                 base = devm_platform_ioremap_resource(pdev, 0);
 451                 if (IS_ERR(base))
 452                         return PTR_ERR(base);
 453
 454                 bt_bmc->map = devm_regmap_init_mmio(dev, base, &bt_regmap_cfg);
 455                 bt_bmc->offset = 0;
 456         } else {
 457                 rc = of_property_read_u32(dev->of_node, "reg", &bt_bmc->offset);
 458                 if (rc)
 459                         return rc;
 460         }
 461
 462         mutex_init(&bt_bmc->mutex);
 463         init_waitqueue_head(&bt_bmc->queue);
 464
 465         bt_bmc->miscdev.minor   = MISC_DYNAMIC_MINOR;
 466         bt_bmc->miscdev.name    = DEVICE_NAME;
 467         bt_bmc->miscdev.fops    = &bt_bmc_fops;
 468         bt_bmc->miscdev.parent = dev;
 469         rc = misc_register(&bt_bmc->miscdev);
 470         if (rc) {
 471                 dev_err(dev, "Unable to register misc device\n");
 472                 return rc;
 473         }
 474
 475         bt_bmc_config_irq(bt_bmc, pdev);
 476
 477         if (bt_bmc->irq >= 0) {
 478                 dev_info(dev, "Using IRQ %d\n", bt_bmc->irq);
 479         } else {
 480                 dev_info(dev, "No IRQ; using timer\n");
 481                 timer_setup(&bt_bmc->poll_timer, poll_timer, 0);
 482                 bt_bmc->poll_timer.expires = jiffies + msecs_to_jiffies(10);
 483                 add_timer(&bt_bmc->poll_timer);
 484         }
 485
 486         regmap_write(bt_bmc->map, bt_bmc->offset + BT_CR0,
 487                      (BT_IO_BASE << BT_CR0_IO_BASE) |
 488                      (BT_IRQ << BT_CR0_IRQ) |
 489                      BT_CR0_EN_CLR_SLV_RDP |
 490                      BT_CR0_EN_CLR_SLV_WRP |
 491                      BT_CR0_ENABLE_IBT);
 492
 493         clr_b_busy(bt_bmc);
 494
 495         return 0;
 496 }
 497
 498 static int bt_bmc_remove(struct platform_device *pdev)
 499 {
 500         struct bt_bmc *bt_bmc = dev_get_drvdata(&pdev->dev);
 501
 502         misc_deregister(&bt_bmc->miscdev);
 503         if (bt_bmc->irq < 0)
 504                 del_timer_sync(&bt_bmc->poll_timer);
 505         return 0;
 506 }
 507
 508 static const struct of_device_id bt_bmc_match[] = {
 509         { .compatible = "aspeed,ast2400-ibt-bmc" },
 510         { .compatible = "aspeed,ast2500-ibt-bmc" },
 511         { },
 512 };
 513
 514 static struct platform_driver bt_bmc_driver = {
 515         .driver = {
 516                 .name           = DEVICE_NAME,
 517                 .of_match_table = bt_bmc_match,
 518         },
 519         .probe = bt_bmc_probe,
 520         .remove = bt_bmc_remove,
 521 };
 522
 523 module_platform_driver(bt_bmc_driver);
 524
 525 MODULE_DEVICE_TABLE(of, bt_bmc_match);
 526 MODULE_LICENSE("GPL");
 527 MODULE_AUTHOR("Alistair Popple <alistair@popple.id.au>");
 528 MODULE_DESCRIPTION("Linux device interface to the IPMI BT interface");