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 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 74 #define RTL_DEBUG(fmt, ...) \ 75 do { \ 76 if (debug) \ 77 pr_info(fmt, ##__VA_ARGS__); \ 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 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 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 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 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 240 241 static struct dmi_system_id __initdata ibm_rtl_dmi_table[] = { 242 { \ 243 .matches = { \ 244 DMI_MATCH(DMI_SYS_VENDOR, "IBM"), \ 245 }, \ 246 }, 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) 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 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); 340