drivers/char/ipmi/bt-bmc.c

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