/drivers/platform/x86/ibm_rtl.c

  1/*
  2 * IBM Real-Time Linux driver
  3 *
  4 * This program is free software; you can redistribute it and/or modify
  5 * it under the terms of the GNU General Public License as published by
  6 * the Free Software Foundation; either version 2 of the License, or
  7 * (at your option) any later version.
  8 *
  9 * This program is distributed in the hope that it will be useful,
 10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 12 * GNU General Public License for more details.
 13 *
 14 * You should have received a copy of the GNU General Public License
 15 * along with this program; if not, write to the Free Software
 16 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 17 *
 18 * Copyright (C) IBM Corporation, 2010
 19 *
 20 * Author: Keith Mannthey <kmannth@us.ibm.com>
 21 *         Vernon Mauery <vernux@us.ibm.com>
 22 *
 23 */
 24
 25#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
 26
 27#include <linux/kernel.h>
 28#include <linux/delay.h>
 29#include <linux/module.h>
 30#include <linux/io.h>
 31#include <linux/sysdev.h>
 32#include <linux/dmi.h>
 33#include <linux/efi.h>
 34#include <linux/mutex.h>
 35#include <asm/bios_ebda.h>
 36
 37static bool force;
 38module_param(force, bool, 0);
 39MODULE_PARM_DESC(force, "Force driver load, ignore DMI data");
 40
 41static bool debug;
 42module_param(debug, bool, 0644);
 43MODULE_PARM_DESC(debug, "Show debug output");
 44
 45MODULE_LICENSE("GPL");
 46MODULE_AUTHOR("Keith Mannthey <kmmanth@us.ibm.com>");
 47MODULE_AUTHOR("Vernon Mauery <vernux@us.ibm.com>");
 48
 49#define RTL_ADDR_TYPE_IO    1
 50#define RTL_ADDR_TYPE_MMIO  2
 51
 52#define RTL_CMD_ENTER_PRTM  1
 53#define RTL_CMD_EXIT_PRTM   2
 54
 55/* The RTL table as presented by the EBDA: */
 56struct ibm_rtl_table {
 57	char signature[5]; /* signature should be "_RTL_" */
 58	u8 version;
 59	u8 rt_status;
 60	u8 command;
 61	u8 command_status;
 62	u8 cmd_address_type;
 63	u8 cmd_granularity;
 64	u8 cmd_offset;
 65	u16 reserve1;
 66	u32 cmd_port_address; /* platform dependent address */
 67	u32 cmd_port_value;   /* platform dependent value */
 68} __attribute__((packed));
 69
 70/* to locate "_RTL_" signature do a masked 5-byte integer compare */
 71#define RTL_SIGNATURE 0x0000005f4c54525fULL
 72#define RTL_MASK      0x000000ffffffffffULL
 73
 74#define RTL_DEBUG(fmt, ...)				\
 75do {							\
 76	if (debug)					\
 77		pr_info(fmt, ##__VA_ARGS__);		\
 78} while (0)
 79
 80static DEFINE_MUTEX(rtl_lock);
 81static struct ibm_rtl_table __iomem *rtl_table;
 82static void __iomem *ebda_map;
 83static void __iomem *rtl_cmd_addr;
 84static u8 rtl_cmd_type;
 85static u8 rtl_cmd_width;
 86
 87#ifndef readq
 88static inline __u64 readq(const volatile void __iomem *addr)
 89{
 90	const volatile u32 __iomem *p = addr;
 91	u32 low, high;
 92
 93	low = readl(p);
 94	high = readl(p + 1);
 95
 96	return low + ((u64)high << 32);
 97}
 98#endif
 99
100static void __iomem *rtl_port_map(phys_addr_t addr, unsigned long len)
101{
102	if (rtl_cmd_type == RTL_ADDR_TYPE_MMIO)
103		return ioremap(addr, len);
104	return ioport_map(addr, len);
105}
106
107static void rtl_port_unmap(void __iomem *addr)
108{
109	if (addr && rtl_cmd_type == RTL_ADDR_TYPE_MMIO)
110		iounmap(addr);
111	else
112		ioport_unmap(addr);
113}
114
115static int ibm_rtl_write(u8 value)
116{
117	int ret = 0, count = 0;
118	static u32 cmd_port_val;
119
120	RTL_DEBUG("%s(%d)\n", __func__, value);
121
122	value = value == 1 ? RTL_CMD_ENTER_PRTM : RTL_CMD_EXIT_PRTM;
123
124	mutex_lock(&rtl_lock);
125
126	if (ioread8(&rtl_table->rt_status) != value) {
127		iowrite8(value, &rtl_table->command);
128
129		switch (rtl_cmd_width) {
130		case 8:
131			cmd_port_val = ioread8(&rtl_table->cmd_port_value);
132			RTL_DEBUG("cmd_port_val = %u\n", cmd_port_val);
133			iowrite8((u8)cmd_port_val, rtl_cmd_addr);
134			break;
135		case 16:
136			cmd_port_val = ioread16(&rtl_table->cmd_port_value);
137			RTL_DEBUG("cmd_port_val = %u\n", cmd_port_val);
138			iowrite16((u16)cmd_port_val, rtl_cmd_addr);
139			break;
140		case 32:
141			cmd_port_val = ioread32(&rtl_table->cmd_port_value);
142			RTL_DEBUG("cmd_port_val = %u\n", cmd_port_val);
143			iowrite32(cmd_port_val, rtl_cmd_addr);
144			break;
145		}
146
147		while (ioread8(&rtl_table->command)) {
148			msleep(10);
149			if (count++ > 500) {
150				pr_err("Hardware not responding to "
151				       "mode switch request\n");
152				ret = -EIO;
153				break;
154			}
155
156		}
157
158		if (ioread8(&rtl_table->command_status)) {
159			RTL_DEBUG("command_status reports failed command\n");
160			ret = -EIO;
161		}
162	}
163
164	mutex_unlock(&rtl_lock);
165	return ret;
166}
167
168static ssize_t rtl_show_version(struct sysdev_class * dev,
169                                struct sysdev_class_attribute *attr,
170                                char *buf)
171{
172	return sprintf(buf, "%d\n", (int)ioread8(&rtl_table->version));
173}
174
175static ssize_t rtl_show_state(struct sysdev_class *dev,
176                              struct sysdev_class_attribute *attr,
177                              char *buf)
178{
179	return sprintf(buf, "%d\n", ioread8(&rtl_table->rt_status));
180}
181
182static ssize_t rtl_set_state(struct sysdev_class *dev,
183                             struct sysdev_class_attribute *attr,
184                             const char *buf,
185                             size_t count)
186{
187	ssize_t ret;
188
189	if (count < 1 || count > 2)
190		return -EINVAL;
191
192	switch (buf[0]) {
193	case '0':
194		ret = ibm_rtl_write(0);
195		break;
196	case '1':
197		ret = ibm_rtl_write(1);
198		break;
199	default:
200		ret = -EINVAL;
201	}
202	if (ret >= 0)
203		ret = count;
204
205	return ret;
206}
207
208static struct sysdev_class class_rtl = {
209	.name = "ibm_rtl",
210};
211
212static SYSDEV_CLASS_ATTR(version, S_IRUGO, rtl_show_version, NULL);
213static SYSDEV_CLASS_ATTR(state, 0600, rtl_show_state, rtl_set_state);
214
215static struct sysdev_class_attribute *rtl_attributes[] = {
216	&attr_version,
217	&attr_state,
218	NULL
219};
220
221
222static int rtl_setup_sysfs(void) {
223	int ret, i;
224	ret = sysdev_class_register(&class_rtl);
225
226	if (!ret) {
227		for (i = 0; rtl_attributes[i]; i ++)
228			sysdev_class_create_file(&class_rtl, rtl_attributes[i]);
229	}
230	return ret;
231}
232
233static void rtl_teardown_sysfs(void) {
234	int i;
235	for (i = 0; rtl_attributes[i]; i ++)
236		sysdev_class_remove_file(&class_rtl, rtl_attributes[i]);
237	sysdev_class_unregister(&class_rtl);
238}
239
240
241static struct dmi_system_id __initdata ibm_rtl_dmi_table[] = {
242	{                                                  \
243		.matches = {                               \
244			DMI_MATCH(DMI_SYS_VENDOR, "IBM"),  \
245		},                                         \
246	},
247	{ }
248};
249
250static int __init ibm_rtl_init(void) {
251	unsigned long ebda_addr, ebda_size;
252	unsigned int ebda_kb;
253	int ret = -ENODEV, i;
254
255	if (force)
256		pr_warn("module loaded by force\n");
257	/* first ensure that we are running on IBM HW */
258	else if (efi_enabled || !dmi_check_system(ibm_rtl_dmi_table))
259		return -ENODEV;
260
261	/* Get the address for the Extended BIOS Data Area */
262	ebda_addr = get_bios_ebda();
263	if (!ebda_addr) {
264		RTL_DEBUG("no BIOS EBDA found\n");
265		return -ENODEV;
266	}
267
268	ebda_map = ioremap(ebda_addr, 4);
269	if (!ebda_map)
270		return -ENOMEM;
271
272	/* First word in the EDBA is the Size in KB */
273	ebda_kb = ioread16(ebda_map);
274	RTL_DEBUG("EBDA is %d kB\n", ebda_kb);
275
276	if (ebda_kb == 0)
277		goto out;
278
279	iounmap(ebda_map);
280	ebda_size = ebda_kb*1024;
281
282	/* Remap the whole table */
283	ebda_map = ioremap(ebda_addr, ebda_size);
284	if (!ebda_map)
285		return -ENOMEM;
286
287	/* search for the _RTL_ signature at the start of the table */
288	for (i = 0 ; i < ebda_size/sizeof(unsigned int); i++) {
289		struct ibm_rtl_table __iomem * tmp;
290		tmp = (struct ibm_rtl_table __iomem *) (ebda_map+i);
291		if ((readq(&tmp->signature) & RTL_MASK) == RTL_SIGNATURE) {
292			phys_addr_t addr;
293			unsigned int plen;
294			RTL_DEBUG("found RTL_SIGNATURE at %p\n", tmp);
295			rtl_table = tmp;
296			/* The address, value, width and offset are platform
297			 * dependent and found in the ibm_rtl_table */
298			rtl_cmd_width = ioread8(&rtl_table->cmd_granularity);
299			rtl_cmd_type = ioread8(&rtl_table->cmd_address_type);
300			RTL_DEBUG("rtl_cmd_width = %u, rtl_cmd_type = %u\n",
301				  rtl_cmd_width, rtl_cmd_type);
302			addr = ioread32(&rtl_table->cmd_port_address);
303			RTL_DEBUG("addr = %#llx\n", (unsigned long long)addr);
304			plen = rtl_cmd_width/sizeof(char);
305			rtl_cmd_addr = rtl_port_map(addr, plen);
306			RTL_DEBUG("rtl_cmd_addr = %p\n", rtl_cmd_addr);
307			if (!rtl_cmd_addr) {
308				ret = -ENOMEM;
309				break;
310			}
311			ret = rtl_setup_sysfs();
312			break;
313		}
314	}
315
316out:
317	if (ret) {
318		iounmap(ebda_map);
319		rtl_port_unmap(rtl_cmd_addr);
320	}
321
322	return ret;
323}
324
325static void __exit ibm_rtl_exit(void)
326{
327	if (rtl_table) {
328		RTL_DEBUG("cleaning up");
329		/* do not leave the machine in SMI-free mode */
330		ibm_rtl_write(0);
331		/* unmap, unlink and remove all traces */
332		rtl_teardown_sysfs();
333		iounmap(ebda_map);
334		rtl_port_unmap(rtl_cmd_addr);
335	}
336}
337
338module_init(ibm_rtl_init);
339module_exit(ibm_rtl_exit);