This source file includes following definitions.
- bt_inb
- bt_outb
- clr_rd_ptr
- clr_wr_ptr
- clr_h2b_atn
- set_b_busy
- clr_b_busy
- set_b2h_atn
- bt_read
- bt_readn
- bt_write
- bt_writen
- set_sms_atn
- file_bt_bmc
- bt_bmc_open
- bt_bmc_read
- bt_bmc_write
- bt_bmc_ioctl
- bt_bmc_release
- bt_bmc_poll
- poll_timer
- bt_bmc_irq
- bt_bmc_config_irq
- bt_bmc_probe
- bt_bmc_remove
1
2
3
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
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
182
183
184
185
186
187
188
189
190
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
222
223
224 kbuffer[0] = bt_read(bt_bmc);
225 len = kbuffer[0];
226
227
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
255
256
257
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
269
270 if (count < 5)
271 return -EINVAL;
272
273 WARN_ON(*ppos);
274
275
276
277
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, ®);
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
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(pdev, 0);
403 if (!bt_bmc->irq)
404 return -ENODEV;
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 = 0;
411 return rc;
412 }
413
414
415
416
417
418
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 if (!pdev || !pdev->dev.of_node)
434 return -ENODEV;
435
436 dev = &pdev->dev;
437 dev_info(dev, "Found bt bmc device\n");
438
439 bt_bmc = devm_kzalloc(dev, sizeof(*bt_bmc), GFP_KERNEL);
440 if (!bt_bmc)
441 return -ENOMEM;
442
443 dev_set_drvdata(&pdev->dev, bt_bmc);
444
445 bt_bmc->map = syscon_node_to_regmap(pdev->dev.parent->of_node);
446 if (IS_ERR(bt_bmc->map)) {
447 struct resource *res;
448 void __iomem *base;
449
450
451
452
453
454 res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
455 base = devm_ioremap_resource(&pdev->dev, res);
456 if (IS_ERR(base))
457 return PTR_ERR(base);
458
459 bt_bmc->map = devm_regmap_init_mmio(dev, base, &bt_regmap_cfg);
460 bt_bmc->offset = 0;
461 } else {
462 rc = of_property_read_u32(dev->of_node, "reg", &bt_bmc->offset);
463 if (rc)
464 return rc;
465 }
466
467 mutex_init(&bt_bmc->mutex);
468 init_waitqueue_head(&bt_bmc->queue);
469
470 bt_bmc->miscdev.minor = MISC_DYNAMIC_MINOR,
471 bt_bmc->miscdev.name = DEVICE_NAME,
472 bt_bmc->miscdev.fops = &bt_bmc_fops,
473 bt_bmc->miscdev.parent = dev;
474 rc = misc_register(&bt_bmc->miscdev);
475 if (rc) {
476 dev_err(dev, "Unable to register misc device\n");
477 return rc;
478 }
479
480 bt_bmc_config_irq(bt_bmc, pdev);
481
482 if (bt_bmc->irq) {
483 dev_info(dev, "Using IRQ %d\n", bt_bmc->irq);
484 } else {
485 dev_info(dev, "No IRQ; using timer\n");
486 timer_setup(&bt_bmc->poll_timer, poll_timer, 0);
487 bt_bmc->poll_timer.expires = jiffies + msecs_to_jiffies(10);
488 add_timer(&bt_bmc->poll_timer);
489 }
490
491 regmap_write(bt_bmc->map, bt_bmc->offset + BT_CR0,
492 (BT_IO_BASE << BT_CR0_IO_BASE) |
493 (BT_IRQ << BT_CR0_IRQ) |
494 BT_CR0_EN_CLR_SLV_RDP |
495 BT_CR0_EN_CLR_SLV_WRP |
496 BT_CR0_ENABLE_IBT);
497
498 clr_b_busy(bt_bmc);
499
500 return 0;
501 }
502
503 static int bt_bmc_remove(struct platform_device *pdev)
504 {
505 struct bt_bmc *bt_bmc = dev_get_drvdata(&pdev->dev);
506
507 misc_deregister(&bt_bmc->miscdev);
508 if (!bt_bmc->irq)
509 del_timer_sync(&bt_bmc->poll_timer);
510 return 0;
511 }
512
513 static const struct of_device_id bt_bmc_match[] = {
514 { .compatible = "aspeed,ast2400-ibt-bmc" },
515 { .compatible = "aspeed,ast2500-ibt-bmc" },
516 { },
517 };
518
519 static struct platform_driver bt_bmc_driver = {
520 .driver = {
521 .name = DEVICE_NAME,
522 .of_match_table = bt_bmc_match,
523 },
524 .probe = bt_bmc_probe,
525 .remove = bt_bmc_remove,
526 };
527
528 module_platform_driver(bt_bmc_driver);
529
530 MODULE_DEVICE_TABLE(of, bt_bmc_match);
531 MODULE_LICENSE("GPL");
532 MODULE_AUTHOR("Alistair Popple <alistair@popple.id.au>");
533 MODULE_DESCRIPTION("Linux device interface to the IPMI BT interface");