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