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/dmi.h> 32 #include <linux/efi.h> 33 #include <linux/mutex.h> 34 #include <asm/bios_ebda.h> 35 36 #include <asm-generic/io-64-nonatomic-lo-hi.h> 37 38 static bool force; 39 module_param(force, bool, 0); 40 MODULE_PARM_DESC(force, "Force driver load, ignore DMI data"); 41 42 static bool debug; 43 module_param(debug, bool, 0644); 44 MODULE_PARM_DESC(debug, "Show debug output"); 45 46 MODULE_LICENSE("GPL"); 47 MODULE_AUTHOR("Keith Mannthey <kmmanth@us.ibm.com>"); 48 MODULE_AUTHOR("Vernon Mauery <vernux@us.ibm.com>"); 49 50 #define RTL_ADDR_TYPE_IO 1 51 #define RTL_ADDR_TYPE_MMIO 2 52 53 #define RTL_CMD_ENTER_PRTM 1 54 #define RTL_CMD_EXIT_PRTM 2 55 56 /* The RTL table as presented by the EBDA: */ 57 struct ibm_rtl_table { 58 char signature[5]; /* signature should be "_RTL_" */ 59 u8 version; 60 u8 rt_status; 61 u8 command; 62 u8 command_status; 63 u8 cmd_address_type; 64 u8 cmd_granularity; 65 u8 cmd_offset; 66 u16 reserve1; 67 u32 cmd_port_address; /* platform dependent address */ 68 u32 cmd_port_value; /* platform dependent value */ 69 } __attribute__((packed)); 70 71 /* to locate "_RTL_" signature do a masked 5-byte integer compare */ 72 #define RTL_SIGNATURE 0x0000005f4c54525fULL 73 #define RTL_MASK 0x000000ffffffffffULL 74 75 #define RTL_DEBUG(fmt, ...) \ 76 do { \ 77 if (debug) \ 78 pr_info(fmt, ##__VA_ARGS__); \ 79 } while (0) 80 81 static DEFINE_MUTEX(rtl_lock); 82 static struct ibm_rtl_table __iomem *rtl_table; 83 static void __iomem *ebda_map; 84 static void __iomem *rtl_cmd_addr; 85 static u8 rtl_cmd_type; 86 static u8 rtl_cmd_width; 87 88 static void __iomem *rtl_port_map(phys_addr_t addr, unsigned long len) 89 { 90 if (rtl_cmd_type == RTL_ADDR_TYPE_MMIO) 91 return ioremap(addr, len); 92 return ioport_map(addr, len); 93 } 94 95 static void rtl_port_unmap(void __iomem *addr) 96 { 97 if (addr && rtl_cmd_type == RTL_ADDR_TYPE_MMIO) 98 iounmap(addr); 99 else 100 ioport_unmap(addr); 101 } 102 103 static int ibm_rtl_write(u8 value) 104 { 105 int ret = 0, count = 0; 106 static u32 cmd_port_val; 107 108 RTL_DEBUG("%s(%d)\n", __func__, value); 109 110 value = value == 1 ? RTL_CMD_ENTER_PRTM : RTL_CMD_EXIT_PRTM; 111 112 mutex_lock(&rtl_lock); 113 114 if (ioread8(&rtl_table->rt_status) != value) { 115 iowrite8(value, &rtl_table->command); 116 117 switch (rtl_cmd_width) { 118 case 8: 119 cmd_port_val = ioread8(&rtl_table->cmd_port_value); 120 RTL_DEBUG("cmd_port_val = %u\n", cmd_port_val); 121 iowrite8((u8)cmd_port_val, rtl_cmd_addr); 122 break; 123 case 16: 124 cmd_port_val = ioread16(&rtl_table->cmd_port_value); 125 RTL_DEBUG("cmd_port_val = %u\n", cmd_port_val); 126 iowrite16((u16)cmd_port_val, rtl_cmd_addr); 127 break; 128 case 32: 129 cmd_port_val = ioread32(&rtl_table->cmd_port_value); 130 RTL_DEBUG("cmd_port_val = %u\n", cmd_port_val); 131 iowrite32(cmd_port_val, rtl_cmd_addr); 132 break; 133 } 134 135 while (ioread8(&rtl_table->command)) { 136 msleep(10); 137 if (count++ > 500) { 138 pr_err("Hardware not responding to " 139 "mode switch request\n"); 140 ret = -EIO; 141 break; 142 } 143 144 } 145 146 if (ioread8(&rtl_table->command_status)) { 147 RTL_DEBUG("command_status reports failed command\n"); 148 ret = -EIO; 149 } 150 } 151 152 mutex_unlock(&rtl_lock); 153 return ret; 154 } 155 156 static ssize_t rtl_show_version(struct device *dev, 157 struct device_attribute *attr, 158 char *buf) 159 { 160 return sprintf(buf, "%d\n", (int)ioread8(&rtl_table->version)); 161 } 162 163 static ssize_t rtl_show_state(struct device *dev, 164 struct device_attribute *attr, 165 char *buf) 166 { 167 return sprintf(buf, "%d\n", ioread8(&rtl_table->rt_status)); 168 } 169 170 static ssize_t rtl_set_state(struct device *dev, 171 struct device_attribute *attr, 172 const char *buf, 173 size_t count) 174 { 175 ssize_t ret; 176 177 if (count < 1 || count > 2) 178 return -EINVAL; 179 180 switch (buf[0]) { 181 case '0': 182 ret = ibm_rtl_write(0); 183 break; 184 case '1': 185 ret = ibm_rtl_write(1); 186 break; 187 default: 188 ret = -EINVAL; 189 } 190 if (ret >= 0) 191 ret = count; 192 193 return ret; 194 } 195 196 static struct bus_type rtl_subsys = { 197 .name = "ibm_rtl", 198 .dev_name = "ibm_rtl", 199 }; 200 201 static DEVICE_ATTR(version, S_IRUGO, rtl_show_version, NULL); 202 static DEVICE_ATTR(state, 0600, rtl_show_state, rtl_set_state); 203 204 static struct device_attribute *rtl_attributes[] = { 205 &dev_attr_version, 206 &dev_attr_state, 207 NULL 208 }; 209 210 211 static int rtl_setup_sysfs(void) { 212 int ret, i; 213 214 ret = subsys_system_register(&rtl_subsys, NULL); 215 if (!ret) { 216 for (i = 0; rtl_attributes[i]; i ++) 217 device_create_file(rtl_subsys.dev_root, rtl_attributes[i]); 218 } 219 return ret; 220 } 221 222 static void rtl_teardown_sysfs(void) { 223 int i; 224 for (i = 0; rtl_attributes[i]; i ++) 225 device_remove_file(rtl_subsys.dev_root, rtl_attributes[i]); 226 bus_unregister(&rtl_subsys); 227 } 228 229 230 static struct dmi_system_id __initdata ibm_rtl_dmi_table[] = { 231 { \ 232 .matches = { \ 233 DMI_MATCH(DMI_SYS_VENDOR, "IBM"), \ 234 }, \ 235 }, 236 { } 237 }; 238 239 static int __init ibm_rtl_init(void) { 240 unsigned long ebda_addr, ebda_size; 241 unsigned int ebda_kb; 242 int ret = -ENODEV, i; 243 244 if (force) 245 pr_warn("module loaded by force\n"); 246 /* first ensure that we are running on IBM HW */ 247 else if (efi_enabled || !dmi_check_system(ibm_rtl_dmi_table)) 248 return -ENODEV; 249 250 /* Get the address for the Extended BIOS Data Area */ 251 ebda_addr = get_bios_ebda(); 252 if (!ebda_addr) { 253 RTL_DEBUG("no BIOS EBDA found\n"); 254 return -ENODEV; 255 } 256 257 ebda_map = ioremap(ebda_addr, 4); 258 if (!ebda_map) 259 return -ENOMEM; 260 261 /* First word in the EDBA is the Size in KB */ 262 ebda_kb = ioread16(ebda_map); 263 RTL_DEBUG("EBDA is %d kB\n", ebda_kb); 264 265 if (ebda_kb == 0) 266 goto out; 267 268 iounmap(ebda_map); 269 ebda_size = ebda_kb*1024; 270 271 /* Remap the whole table */ 272 ebda_map = ioremap(ebda_addr, ebda_size); 273 if (!ebda_map) 274 return -ENOMEM; 275 276 /* search for the _RTL_ signature at the start of the table */ 277 for (i = 0 ; i < ebda_size/sizeof(unsigned int); i++) { 278 struct ibm_rtl_table __iomem * tmp; 279 tmp = (struct ibm_rtl_table __iomem *) (ebda_map+i); 280 if ((readq(&tmp->signature) & RTL_MASK) == RTL_SIGNATURE) { 281 phys_addr_t addr; 282 unsigned int plen; 283 RTL_DEBUG("found RTL_SIGNATURE at %p\n", tmp); 284 rtl_table = tmp; 285 /* The address, value, width and offset are platform 286 * dependent and found in the ibm_rtl_table */ 287 rtl_cmd_width = ioread8(&rtl_table->cmd_granularity); 288 rtl_cmd_type = ioread8(&rtl_table->cmd_address_type); 289 RTL_DEBUG("rtl_cmd_width = %u, rtl_cmd_type = %u\n", 290 rtl_cmd_width, rtl_cmd_type); 291 addr = ioread32(&rtl_table->cmd_port_address); 292 RTL_DEBUG("addr = %#llx\n", (unsigned long long)addr); 293 plen = rtl_cmd_width/sizeof(char); 294 rtl_cmd_addr = rtl_port_map(addr, plen); 295 RTL_DEBUG("rtl_cmd_addr = %p\n", rtl_cmd_addr); 296 if (!rtl_cmd_addr) { 297 ret = -ENOMEM; 298 break; 299 } 300 ret = rtl_setup_sysfs(); 301 break; 302 } 303 } 304 305 out: 306 if (ret) { 307 iounmap(ebda_map); 308 rtl_port_unmap(rtl_cmd_addr); 309 } 310 311 return ret; 312 } 313 314 static void __exit ibm_rtl_exit(void) 315 { 316 if (rtl_table) { 317 RTL_DEBUG("cleaning up"); 318 /* do not leave the machine in SMI-free mode */ 319 ibm_rtl_write(0); 320 /* unmap, unlink and remove all traces */ 321 rtl_teardown_sysfs(); 322 iounmap(ebda_map); 323 rtl_port_unmap(rtl_cmd_addr); 324 } 325 } 326 327 module_init(ibm_rtl_init); 328 module_exit(ibm_rtl_exit); 329