[mirror_ubuntu-focal-kernel.git] / drivers / platform / x86 / ibm_rtl.c

/*
 * IBM Real-Time Linux driver
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 *
 * Copyright (C) IBM Corporation, 2010
 *
 * Author: Keith Mannthey <kmannth@us.ibm.com>
 *         Vernon Mauery <vernux@us.ibm.com>
 *
 */

#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt

#include <linux/kernel.h>
#include <linux/delay.h>
#include <linux/module.h>
#include <linux/io.h>
#include <linux/sysdev.h>
#include <linux/dmi.h>
#include <linux/efi.h>
#include <linux/mutex.h>
#include <asm/bios_ebda.h>

static bool force;
module_param(force, bool, 0);
MODULE_PARM_DESC(force, "Force driver load, ignore DMI data");

static bool debug;
module_param(debug, bool, 0644);
MODULE_PARM_DESC(debug, "Show debug output");

MODULE_LICENSE("GPL");
MODULE_AUTHOR("Keith Mannthey <kmmanth@us.ibm.com>");
MODULE_AUTHOR("Vernon Mauery <vernux@us.ibm.com>");

#define RTL_ADDR_TYPE_IO    1
#define RTL_ADDR_TYPE_MMIO  2

#define RTL_CMD_ENTER_PRTM  1
#define RTL_CMD_EXIT_PRTM   2

/* The RTL table as presented by the EBDA: */
struct ibm_rtl_table {
	char signature[5]; /* signature should be "_RTL_" */
	u8 version;
	u8 rt_status;
	u8 command;
	u8 command_status;
	u8 cmd_address_type;
	u8 cmd_granularity;
	u8 cmd_offset;
	u16 reserve1;
	u32 cmd_port_address; /* platform dependent address */
	u32 cmd_port_value;   /* platform dependent value */
} __attribute__((packed));

/* to locate "_RTL_" signature do a masked 5-byte integer compare */
#define RTL_SIGNATURE 0x0000005f4c54525fULL
#define RTL_MASK      0x000000ffffffffffULL

#define RTL_DEBUG(fmt, ...)				\
do {							\
	if (debug)					\
		pr_info(fmt, ##__VA_ARGS__);		\
} while (0)

static DEFINE_MUTEX(rtl_lock);
static struct ibm_rtl_table __iomem *rtl_table;
static void __iomem *ebda_map;
static void __iomem *rtl_cmd_addr;
static u8 rtl_cmd_type;
static u8 rtl_cmd_width;

#ifndef readq
static inline __u64 readq(const volatile void __iomem *addr)
{
	const volatile u32 __iomem *p = addr;
	u32 low, high;

	low = readl(p);
	high = readl(p + 1);

	return low + ((u64)high << 32);
}
#endif

static void __iomem *rtl_port_map(phys_addr_t addr, unsigned long len)
{
	if (rtl_cmd_type == RTL_ADDR_TYPE_MMIO)
		return ioremap(addr, len);
	return ioport_map(addr, len);
}

static void rtl_port_unmap(void __iomem *addr)
{
	if (addr && rtl_cmd_type == RTL_ADDR_TYPE_MMIO)
		iounmap(addr);
	else
		ioport_unmap(addr);
}

static int ibm_rtl_write(u8 value)
{
	int ret = 0, count = 0;
	static u32 cmd_port_val;

	RTL_DEBUG("%s(%d)\n", __func__, value);

	value = value == 1 ? RTL_CMD_ENTER_PRTM : RTL_CMD_EXIT_PRTM;

	mutex_lock(&rtl_lock);

	if (ioread8(&rtl_table->rt_status) != value) {
		iowrite8(value, &rtl_table->command);

		switch (rtl_cmd_width) {
		case 8:
			cmd_port_val = ioread8(&rtl_table->cmd_port_value);
			RTL_DEBUG("cmd_port_val = %u\n", cmd_port_val);
			iowrite8((u8)cmd_port_val, rtl_cmd_addr);
			break;
		case 16:
			cmd_port_val = ioread16(&rtl_table->cmd_port_value);
			RTL_DEBUG("cmd_port_val = %u\n", cmd_port_val);
			iowrite16((u16)cmd_port_val, rtl_cmd_addr);
			break;
		case 32:
			cmd_port_val = ioread32(&rtl_table->cmd_port_value);
			RTL_DEBUG("cmd_port_val = %u\n", cmd_port_val);
			iowrite32(cmd_port_val, rtl_cmd_addr);
			break;
		}

		while (ioread8(&rtl_table->command)) {
			msleep(10);
			if (count++ > 500) {
				pr_err("Hardware not responding to "
				       "mode switch request\n");
				ret = -EIO;
				break;
			}

		}

		if (ioread8(&rtl_table->command_status)) {
			RTL_DEBUG("command_status reports failed command\n");
			ret = -EIO;
		}
	}

	mutex_unlock(&rtl_lock);
	return ret;
}

static ssize_t rtl_show_version(struct sysdev_class * dev,
                                struct sysdev_class_attribute *attr,
                                char *buf)
{
	return sprintf(buf, "%d\n", (int)ioread8(&rtl_table->version));
}

static ssize_t rtl_show_state(struct sysdev_class *dev,
                              struct sysdev_class_attribute *attr,
                              char *buf)
{
	return sprintf(buf, "%d\n", ioread8(&rtl_table->rt_status));
}

static ssize_t rtl_set_state(struct sysdev_class *dev,
                             struct sysdev_class_attribute *attr,
                             const char *buf,
                             size_t count)
{
	ssize_t ret;

	if (count < 1 || count > 2)
		return -EINVAL;

	switch (buf[0]) {
	case '0':
		ret = ibm_rtl_write(0);
		break;
	case '1':
		ret = ibm_rtl_write(1);
		break;
	default:
		ret = -EINVAL;
	}
	if (ret >= 0)
		ret = count;

	return ret;
}

static struct sysdev_class class_rtl = {
	.name = "ibm_rtl",
};

static SYSDEV_CLASS_ATTR(version, S_IRUGO, rtl_show_version, NULL);
static SYSDEV_CLASS_ATTR(state, 0600, rtl_show_state, rtl_set_state);

static struct sysdev_class_attribute *rtl_attributes[] = {
	&attr_version,
	&attr_state,
	NULL
};


static int rtl_setup_sysfs(void) {
	int ret, i;
	ret = sysdev_class_register(&class_rtl);

	if (!ret) {
		for (i = 0; rtl_attributes[i]; i ++)
			sysdev_class_create_file(&class_rtl, rtl_attributes[i]);
	}
	return ret;
}

static void rtl_teardown_sysfs(void) {
	int i;
	for (i = 0; rtl_attributes[i]; i ++)
		sysdev_class_remove_file(&class_rtl, rtl_attributes[i]);
	sysdev_class_unregister(&class_rtl);
}


static struct dmi_system_id __initdata ibm_rtl_dmi_table[] = {
	{                                                  \
		.matches = {                               \
			DMI_MATCH(DMI_SYS_VENDOR, "IBM"),  \
		},                                         \
	},
	{ }
};

static int __init ibm_rtl_init(void) {
	unsigned long ebda_addr, ebda_size;
	unsigned int ebda_kb;
	int ret = -ENODEV, i;

	if (force)
		pr_warn("module loaded by force\n");
	/* first ensure that we are running on IBM HW */
	else if (efi_enabled || !dmi_check_system(ibm_rtl_dmi_table))
		return -ENODEV;

	/* Get the address for the Extended BIOS Data Area */
	ebda_addr = get_bios_ebda();
	if (!ebda_addr) {
		RTL_DEBUG("no BIOS EBDA found\n");
		return -ENODEV;
	}

	ebda_map = ioremap(ebda_addr, 4);
	if (!ebda_map)
		return -ENOMEM;

	/* First word in the EDBA is the Size in KB */
	ebda_kb = ioread16(ebda_map);
	RTL_DEBUG("EBDA is %d kB\n", ebda_kb);

	if (ebda_kb == 0)
		goto out;

	iounmap(ebda_map);
	ebda_size = ebda_kb*1024;

	/* Remap the whole table */
	ebda_map = ioremap(ebda_addr, ebda_size);
	if (!ebda_map)
		return -ENOMEM;

	/* search for the _RTL_ signature at the start of the table */
	for (i = 0 ; i < ebda_size/sizeof(unsigned int); i++) {
		struct ibm_rtl_table __iomem * tmp;
		tmp = (struct ibm_rtl_table __iomem *) (ebda_map+i);
		if ((readq(&tmp->signature) & RTL_MASK) == RTL_SIGNATURE) {
			phys_addr_t addr;
			unsigned int plen;
			RTL_DEBUG("found RTL_SIGNATURE at %p\n", tmp);
			rtl_table = tmp;
			/* The address, value, width and offset are platform
			 * dependent and found in the ibm_rtl_table */
			rtl_cmd_width = ioread8(&rtl_table->cmd_granularity);
			rtl_cmd_type = ioread8(&rtl_table->cmd_address_type);
			RTL_DEBUG("rtl_cmd_width = %u, rtl_cmd_type = %u\n",
				  rtl_cmd_width, rtl_cmd_type);
			addr = ioread32(&rtl_table->cmd_port_address);
			RTL_DEBUG("addr = %#llx\n", (unsigned long long)addr);
			plen = rtl_cmd_width/sizeof(char);
			rtl_cmd_addr = rtl_port_map(addr, plen);
			RTL_DEBUG("rtl_cmd_addr = %p\n", rtl_cmd_addr);
			if (!rtl_cmd_addr) {
				ret = -ENOMEM;
				break;
			}
			ret = rtl_setup_sysfs();
			break;
		}
	}

out:
	if (ret) {
		iounmap(ebda_map);
		rtl_port_unmap(rtl_cmd_addr);
	}

	return ret;
}

static void __exit ibm_rtl_exit(void)
{
	if (rtl_table) {
		RTL_DEBUG("cleaning up");
		/* do not leave the machine in SMI-free mode */
		ibm_rtl_write(0);
		/* unmap, unlink and remove all traces */
		rtl_teardown_sysfs();
		iounmap(ebda_map);
		rtl_port_unmap(rtl_cmd_addr);
	}
}

module_init(ibm_rtl_init);
module_exit(ibm_rtl_exit);
Commit	Line	Data
35f0ce03 VM	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
323623a7 JP	25	#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
323623a7 JP	26
35f0ce03 VM	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>
1d37db77	33	#include <linux/efi.h>
35f0ce03 VM	34	#include <linux/mutex.h>
	35	#include <asm/bios_ebda.h>
	36
	37	static bool force;
	38	module_param(force, bool, 0);
	39	MODULE_PARM_DESC(force, "Force driver load, ignore DMI data");
	40
	41	static bool debug;
	42	module_param(debug, bool, 0644);
	43	MODULE_PARM_DESC(debug, "Show debug output");
	44
	45	MODULE_LICENSE("GPL");
	46	MODULE_AUTHOR("Keith Mannthey <kmmanth@us.ibm.com>");
	47	MODULE_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: */
	56	struct 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
323623a7 JP	74	#define RTL_DEBUG(fmt, ...) \
	75	do { \
	76	if (debug) \
	77	pr_info(fmt, ##__VA_ARGS__); \
35f0ce03 VM	78	} while (0)
	79
	80	static DEFINE_MUTEX(rtl_lock);
	81	static struct ibm_rtl_table __iomem *rtl_table;
	82	static void __iomem *ebda_map;
	83	static void __iomem *rtl_cmd_addr;
	84	static u8 rtl_cmd_type;
	85	static u8 rtl_cmd_width;
	86
dbee8a0a RD	87	#ifndef readq
	88	static 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
35f0ce03 VM	100	static 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
	107	static 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
	115	static int ibm_rtl_write(u8 value)
	116	{
	117	int ret = 0, count = 0;
	118	static u32 cmd_port_val;
	119
323623a7	120	RTL_DEBUG("%s(%d)\n", __func__, value);
35f0ce03 VM	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) {
323623a7 JP	150	pr_err("Hardware not responding to "
323623a7 JP	151	"mode switch request\n");
35f0ce03 VM	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
	168	static 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
	175	static 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
	182	static 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
	208	static struct sysdev_class class_rtl = {
	209	.name = "ibm_rtl",
	210	};
	211
	212	static SYSDEV_CLASS_ATTR(version, S_IRUGO, rtl_show_version, NULL);
	213	static SYSDEV_CLASS_ATTR(state, 0600, rtl_show_state, rtl_set_state);
	214
	215	static struct sysdev_class_attribute *rtl_attributes[] = {
216	&attr_version,
217	&attr_state,
218	NULL
219	};
220
221
222	static 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
233	static 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
35f0ce03 VM	240
35f0ce03 VM	241	static struct dmi_system_id __initdata ibm_rtl_dmi_table[] = {
a2262260 VM	242	{ \
	243	.matches = { \
	244	DMI_MATCH(DMI_SYS_VENDOR, "IBM"), \
	245	}, \
	246	},
35f0ce03 VM	247	{ }
	248	};
	249
	250	static 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)
323623a7	256	pr_warn("module loaded by force\n");
35f0ce03	257	/* first ensure that we are running on IBM HW */
1d37db77	258	else if (efi_enabled \|\| !dmi_check_system(ibm_rtl_dmi_table))
35f0ce03 VM	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;
3a35125f	294	RTL_DEBUG("found RTL_SIGNATURE at %p\n", tmp);
35f0ce03 VM	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",
323623a7	301	rtl_cmd_width, rtl_cmd_type);
35f0ce03	302	addr = ioread32(&rtl_table->cmd_port_address);
c72b844e	303	RTL_DEBUG("addr = %#llx\n", (unsigned long long)addr);
35f0ce03 VM	304	plen = rtl_cmd_width/sizeof(char);
35f0ce03 VM	305	rtl_cmd_addr = rtl_port_map(addr, plen);
3a35125f	306	RTL_DEBUG("rtl_cmd_addr = %p\n", rtl_cmd_addr);
35f0ce03 VM	307	if (!rtl_cmd_addr) {
	308	ret = -ENOMEM;
	309	break;
	310	}
	311	ret = rtl_setup_sysfs();
	312	break;
	313	}
	314	}
	315
	316	out:
	317	if (ret) {
	318	iounmap(ebda_map);
	319	rtl_port_unmap(rtl_cmd_addr);
	320	}
	321
	322	return ret;
	323	}
	324
	325	static 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
	338	module_init(ibm_rtl_init);
	339	module_exit(ibm_rtl_exit);