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/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
 57struct 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
 67static atomic_t open_count = ATOMIC_INIT(0);
 68
 69static u8 bt_inb(struct bt_bmc *bt_bmc, int reg)
 70{
 71	return readb(bt_bmc->base + reg);
 72}
 73
 74static void bt_outb(struct bt_bmc *bt_bmc, u8 data, int reg)
 75{
 76	writeb(data, bt_bmc->base + reg);
 77}
 78
 79static void clr_rd_ptr(struct bt_bmc *bt_bmc)
 80{
 81	bt_outb(bt_bmc, BT_CTRL_CLR_RD_PTR, BT_CTRL);
 82}
 83
 84static void clr_wr_ptr(struct bt_bmc *bt_bmc)
 85{
 86	bt_outb(bt_bmc, BT_CTRL_CLR_WR_PTR, BT_CTRL);
 87}
 88
 89static void clr_h2b_atn(struct bt_bmc *bt_bmc)
 90{
 91	bt_outb(bt_bmc, BT_CTRL_H2B_ATN, BT_CTRL);
 92}
 93
 94static 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
100static 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
106static void set_b2h_atn(struct bt_bmc *bt_bmc)
107{
108	bt_outb(bt_bmc, BT_CTRL_B2H_ATN, BT_CTRL);
109}
110
111static u8 bt_read(struct bt_bmc *bt_bmc)
112{
113	return bt_inb(bt_bmc, BT_BMC2HOST);
114}
115
116static 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
125static void bt_write(struct bt_bmc *bt_bmc, u8 c)
126{
127	bt_outb(bt_bmc, c, BT_BMC2HOST);
128}
129
130static 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
139static void set_sms_atn(struct bt_bmc *bt_bmc)
140{
141	bt_outb(bt_bmc, BT_CTRL_SMS_ATN, BT_CTRL);
142}
143
144static struct bt_bmc *file_bt_bmc(struct file *file)
145{
146	return container_of(file->private_data, struct bt_bmc, miscdev);
147}
148
149static 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 */
175static 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
230out_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 */
241static 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
292out_unlock:
293	mutex_unlock(&bt_bmc->mutex);
294	return ret;
295}
296
297static 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
310static 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
319static __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
338static 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
348static void poll_timer(struct timer_list *t)
349{
350	struct bt_bmc *bt_bmc = timer_container_of(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
357static 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
375static 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
407static 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
462static void 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		timer_delete_sync(&bt_bmc->poll_timer);
469}
470
471static const struct of_device_id bt_bmc_match[] = {
472	{ .compatible = "aspeed,ast2400-ibt-bmc" },
473	{ .compatible = "aspeed,ast2500-ibt-bmc" },
474	{ .compatible = "aspeed,ast2600-ibt-bmc" },
475	{ },
476};
477
478static struct platform_driver bt_bmc_driver = {
479	.driver = {
480		.name		= DEVICE_NAME,
481		.of_match_table = bt_bmc_match,
482	},
483	.probe = bt_bmc_probe,
484	.remove = bt_bmc_remove,
485};
486
487module_platform_driver(bt_bmc_driver);
488
489MODULE_DEVICE_TABLE(of, bt_bmc_match);
490MODULE_LICENSE("GPL");
491MODULE_AUTHOR("Alistair Popple <alistair@popple.id.au>");
492MODULE_DESCRIPTION("Linux device interface to the IPMI BT interface");