Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1 | /* |
| 2 | * drivers/input/serio/gscps2.c |
| 3 | * |
Helge Deller | 5076c15 | 2006-03-27 12:52:15 -0700 | [diff] [blame] | 4 | * Copyright (c) 2004-2006 Helge Deller <deller@gmx.de> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 5 | * Copyright (c) 2002 Laurent Canet <canetl@esiee.fr> |
| 6 | * Copyright (c) 2002 Thibaut Varene <varenet@parisc-linux.org> |
| 7 | * |
| 8 | * Pieces of code based on linux-2.4's hp_mouse.c & hp_keyb.c |
Dmitry Torokhov | a0ee203 | 2009-12-11 21:50:47 -0800 | [diff] [blame] | 9 | * Copyright (c) 1999 Alex deVries <alex@onefishtwo.ca> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 10 | * Copyright (c) 1999-2000 Philipp Rumpf <prumpf@tux.org> |
| 11 | * Copyright (c) 2000 Xavier Debacker <debackex@esiee.fr> |
| 12 | * Copyright (c) 2000-2001 Thomas Marteau <marteaut@esiee.fr> |
| 13 | * |
| 14 | * HP GSC PS/2 port driver, found in PA/RISC Workstations |
| 15 | * |
| 16 | * This file is subject to the terms and conditions of the GNU General Public |
| 17 | * License. See the file "COPYING" in the main directory of this archive |
| 18 | * for more details. |
| 19 | * |
| 20 | * TODO: |
| 21 | * - Dino testing (did HP ever shipped a machine on which this port |
| 22 | * was usable/enabled ?) |
| 23 | */ |
| 24 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 25 | #include <linux/init.h> |
| 26 | #include <linux/module.h> |
Tejun Heo | 5a0e3ad | 2010-03-24 17:04:11 +0900 | [diff] [blame] | 27 | #include <linux/slab.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 28 | #include <linux/serio.h> |
| 29 | #include <linux/input.h> |
| 30 | #include <linux/interrupt.h> |
| 31 | #include <linux/spinlock.h> |
| 32 | #include <linux/delay.h> |
| 33 | #include <linux/ioport.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 34 | |
| 35 | #include <asm/irq.h> |
| 36 | #include <asm/io.h> |
| 37 | #include <asm/parisc-device.h> |
| 38 | |
| 39 | MODULE_AUTHOR("Laurent Canet <canetl@esiee.fr>, Thibaut Varene <varenet@parisc-linux.org>, Helge Deller <deller@gmx.de>"); |
| 40 | MODULE_DESCRIPTION("HP GSC PS2 port driver"); |
| 41 | MODULE_LICENSE("GPL"); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 42 | |
| 43 | #define PFX "gscps2.c: " |
| 44 | |
| 45 | /* |
| 46 | * Driver constants |
| 47 | */ |
| 48 | |
| 49 | /* various constants */ |
| 50 | #define ENABLE 1 |
| 51 | #define DISABLE 0 |
| 52 | |
| 53 | #define GSC_DINO_OFFSET 0x0800 /* offset for DINO controller versus LASI one */ |
| 54 | |
| 55 | /* PS/2 IO port offsets */ |
| 56 | #define GSC_ID 0x00 /* device ID offset (see: GSC_ID_XXX) */ |
| 57 | #define GSC_RESET 0x00 /* reset port offset */ |
| 58 | #define GSC_RCVDATA 0x04 /* receive port offset */ |
| 59 | #define GSC_XMTDATA 0x04 /* transmit port offset */ |
| 60 | #define GSC_CONTROL 0x08 /* see: Control register bits */ |
| 61 | #define GSC_STATUS 0x0C /* see: Status register bits */ |
| 62 | |
| 63 | /* Control register bits */ |
| 64 | #define GSC_CTRL_ENBL 0x01 /* enable interface */ |
| 65 | #define GSC_CTRL_LPBXR 0x02 /* loopback operation */ |
| 66 | #define GSC_CTRL_DIAG 0x20 /* directly control clock/data line */ |
| 67 | #define GSC_CTRL_DATDIR 0x40 /* data line direct control */ |
| 68 | #define GSC_CTRL_CLKDIR 0x80 /* clock line direct control */ |
| 69 | |
| 70 | /* Status register bits */ |
| 71 | #define GSC_STAT_RBNE 0x01 /* Receive Buffer Not Empty */ |
| 72 | #define GSC_STAT_TBNE 0x02 /* Transmit Buffer Not Empty */ |
| 73 | #define GSC_STAT_TERR 0x04 /* Timeout Error */ |
| 74 | #define GSC_STAT_PERR 0x08 /* Parity Error */ |
| 75 | #define GSC_STAT_CMPINTR 0x10 /* Composite Interrupt = irq on any port */ |
| 76 | #define GSC_STAT_DATSHD 0x40 /* Data Line Shadow */ |
| 77 | #define GSC_STAT_CLKSHD 0x80 /* Clock Line Shadow */ |
| 78 | |
| 79 | /* IDs returned by GSC_ID port register */ |
| 80 | #define GSC_ID_KEYBOARD 0 /* device ID values */ |
| 81 | #define GSC_ID_MOUSE 1 |
| 82 | |
| 83 | |
David Howells | 7d12e78 | 2006-10-05 14:55:46 +0100 | [diff] [blame] | 84 | static irqreturn_t gscps2_interrupt(int irq, void *dev); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 85 | |
| 86 | #define BUFFER_SIZE 0x0f |
| 87 | |
| 88 | /* GSC PS/2 port device struct */ |
| 89 | struct gscps2port { |
| 90 | struct list_head node; |
| 91 | struct parisc_device *padev; |
| 92 | struct serio *port; |
| 93 | spinlock_t lock; |
| 94 | char *addr; |
| 95 | u8 act, append; /* position in buffer[] */ |
| 96 | struct { |
| 97 | u8 data; |
| 98 | u8 str; |
| 99 | } buffer[BUFFER_SIZE+1]; |
| 100 | int id; |
| 101 | }; |
| 102 | |
| 103 | /* |
| 104 | * Various HW level routines |
| 105 | */ |
| 106 | |
| 107 | #define gscps2_readb_input(x) readb((x)+GSC_RCVDATA) |
| 108 | #define gscps2_readb_control(x) readb((x)+GSC_CONTROL) |
| 109 | #define gscps2_readb_status(x) readb((x)+GSC_STATUS) |
| 110 | #define gscps2_writeb_control(x, y) writeb((x), (y)+GSC_CONTROL) |
| 111 | |
| 112 | |
| 113 | /* |
| 114 | * wait_TBE() - wait for Transmit Buffer Empty |
| 115 | */ |
| 116 | |
| 117 | static int wait_TBE(char *addr) |
| 118 | { |
| 119 | int timeout = 25000; /* device is expected to react within 250 msec */ |
| 120 | while (gscps2_readb_status(addr) & GSC_STAT_TBNE) { |
| 121 | if (!--timeout) |
| 122 | return 0; /* This should not happen */ |
| 123 | udelay(10); |
| 124 | } |
| 125 | return 1; |
| 126 | } |
| 127 | |
| 128 | |
| 129 | /* |
| 130 | * gscps2_flush() - flush the receive buffer |
| 131 | */ |
| 132 | |
| 133 | static void gscps2_flush(struct gscps2port *ps2port) |
| 134 | { |
| 135 | while (gscps2_readb_status(ps2port->addr) & GSC_STAT_RBNE) |
| 136 | gscps2_readb_input(ps2port->addr); |
| 137 | ps2port->act = ps2port->append = 0; |
| 138 | } |
| 139 | |
| 140 | /* |
| 141 | * gscps2_writeb_output() - write a byte to the port |
| 142 | * |
Joe Perches | 5047fab | 2008-02-03 17:15:20 +0200 | [diff] [blame] | 143 | * returns 1 on success, 0 on error |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 144 | */ |
| 145 | |
| 146 | static inline int gscps2_writeb_output(struct gscps2port *ps2port, u8 data) |
| 147 | { |
| 148 | unsigned long flags; |
| 149 | char *addr = ps2port->addr; |
| 150 | |
| 151 | if (!wait_TBE(addr)) { |
| 152 | printk(KERN_DEBUG PFX "timeout - could not write byte %#x\n", data); |
| 153 | return 0; |
| 154 | } |
| 155 | |
| 156 | while (gscps2_readb_status(ps2port->addr) & GSC_STAT_RBNE) |
| 157 | /* wait */; |
| 158 | |
| 159 | spin_lock_irqsave(&ps2port->lock, flags); |
| 160 | writeb(data, addr+GSC_XMTDATA); |
| 161 | spin_unlock_irqrestore(&ps2port->lock, flags); |
| 162 | |
| 163 | /* this is ugly, but due to timing of the port it seems to be necessary. */ |
| 164 | mdelay(6); |
| 165 | |
| 166 | /* make sure any received data is returned as fast as possible */ |
| 167 | /* this is important e.g. when we set the LEDs on the keyboard */ |
Matthew Wilcox | be577a5 | 2006-10-06 20:47:23 -0600 | [diff] [blame] | 168 | gscps2_interrupt(0, NULL); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 169 | |
| 170 | return 1; |
| 171 | } |
| 172 | |
| 173 | |
| 174 | /* |
| 175 | * gscps2_enable() - enables or disables the port |
| 176 | */ |
| 177 | |
| 178 | static void gscps2_enable(struct gscps2port *ps2port, int enable) |
| 179 | { |
| 180 | unsigned long flags; |
| 181 | u8 data; |
| 182 | |
| 183 | /* now enable/disable the port */ |
| 184 | spin_lock_irqsave(&ps2port->lock, flags); |
| 185 | gscps2_flush(ps2port); |
| 186 | data = gscps2_readb_control(ps2port->addr); |
| 187 | if (enable) |
| 188 | data |= GSC_CTRL_ENBL; |
| 189 | else |
| 190 | data &= ~GSC_CTRL_ENBL; |
| 191 | gscps2_writeb_control(data, ps2port->addr); |
| 192 | spin_unlock_irqrestore(&ps2port->lock, flags); |
| 193 | wait_TBE(ps2port->addr); |
| 194 | gscps2_flush(ps2port); |
| 195 | } |
| 196 | |
| 197 | /* |
| 198 | * gscps2_reset() - resets the PS/2 port |
| 199 | */ |
| 200 | |
| 201 | static void gscps2_reset(struct gscps2port *ps2port) |
| 202 | { |
| 203 | char *addr = ps2port->addr; |
| 204 | unsigned long flags; |
| 205 | |
| 206 | /* reset the interface */ |
| 207 | spin_lock_irqsave(&ps2port->lock, flags); |
| 208 | gscps2_flush(ps2port); |
| 209 | writeb(0xff, addr+GSC_RESET); |
| 210 | gscps2_flush(ps2port); |
| 211 | spin_unlock_irqrestore(&ps2port->lock, flags); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 212 | } |
| 213 | |
| 214 | static LIST_HEAD(ps2port_list); |
| 215 | |
| 216 | /** |
| 217 | * gscps2_interrupt() - Interruption service routine |
| 218 | * |
| 219 | * This function reads received PS/2 bytes and processes them on |
| 220 | * all interfaces. |
| 221 | * The problematic part here is, that the keyboard and mouse PS/2 port |
| 222 | * share the same interrupt and it's not possible to send data if any |
| 223 | * one of them holds input data. To solve this problem we try to receive |
| 224 | * the data as fast as possible and handle the reporting to the upper layer |
| 225 | * later. |
| 226 | */ |
| 227 | |
David Howells | 7d12e78 | 2006-10-05 14:55:46 +0100 | [diff] [blame] | 228 | static irqreturn_t gscps2_interrupt(int irq, void *dev) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 229 | { |
| 230 | struct gscps2port *ps2port; |
| 231 | |
| 232 | list_for_each_entry(ps2port, &ps2port_list, node) { |
| 233 | |
| 234 | unsigned long flags; |
| 235 | spin_lock_irqsave(&ps2port->lock, flags); |
| 236 | |
| 237 | while ( (ps2port->buffer[ps2port->append].str = |
| 238 | gscps2_readb_status(ps2port->addr)) & GSC_STAT_RBNE ) { |
| 239 | ps2port->buffer[ps2port->append].data = |
| 240 | gscps2_readb_input(ps2port->addr); |
| 241 | ps2port->append = ((ps2port->append+1) & BUFFER_SIZE); |
| 242 | } |
| 243 | |
| 244 | spin_unlock_irqrestore(&ps2port->lock, flags); |
| 245 | |
| 246 | } /* list_for_each_entry */ |
| 247 | |
| 248 | /* all data was read from the ports - now report the data to upper layer */ |
| 249 | |
| 250 | list_for_each_entry(ps2port, &ps2port_list, node) { |
| 251 | |
| 252 | while (ps2port->act != ps2port->append) { |
| 253 | |
| 254 | unsigned int rxflags; |
| 255 | u8 data, status; |
| 256 | |
| 257 | /* Did new data arrived while we read existing data ? |
| 258 | If yes, exit now and let the new irq handler start over again */ |
| 259 | if (gscps2_readb_status(ps2port->addr) & GSC_STAT_CMPINTR) |
| 260 | return IRQ_HANDLED; |
| 261 | |
| 262 | status = ps2port->buffer[ps2port->act].str; |
| 263 | data = ps2port->buffer[ps2port->act].data; |
| 264 | |
| 265 | ps2port->act = ((ps2port->act+1) & BUFFER_SIZE); |
| 266 | rxflags = ((status & GSC_STAT_TERR) ? SERIO_TIMEOUT : 0 ) | |
| 267 | ((status & GSC_STAT_PERR) ? SERIO_PARITY : 0 ); |
| 268 | |
David Howells | 7d12e78 | 2006-10-05 14:55:46 +0100 | [diff] [blame] | 269 | serio_interrupt(ps2port->port, data, rxflags); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 270 | |
| 271 | } /* while() */ |
| 272 | |
| 273 | } /* list_for_each_entry */ |
| 274 | |
| 275 | return IRQ_HANDLED; |
| 276 | } |
| 277 | |
| 278 | |
| 279 | /* |
| 280 | * gscps2_write() - send a byte out through the aux interface. |
| 281 | */ |
| 282 | |
| 283 | static int gscps2_write(struct serio *port, unsigned char data) |
| 284 | { |
| 285 | struct gscps2port *ps2port = port->port_data; |
| 286 | |
| 287 | if (!gscps2_writeb_output(ps2port, data)) { |
| 288 | printk(KERN_DEBUG PFX "sending byte %#x failed.\n", data); |
| 289 | return -1; |
| 290 | } |
| 291 | return 0; |
| 292 | } |
| 293 | |
| 294 | /* |
| 295 | * gscps2_open() is called when a port is opened by the higher layer. |
| 296 | * It resets and enables the port. |
| 297 | */ |
| 298 | |
| 299 | static int gscps2_open(struct serio *port) |
| 300 | { |
| 301 | struct gscps2port *ps2port = port->port_data; |
| 302 | |
| 303 | gscps2_reset(ps2port); |
| 304 | |
Matthew Wilcox | 6ab0f5c | 2005-10-21 22:58:51 -0400 | [diff] [blame] | 305 | /* enable it */ |
| 306 | gscps2_enable(ps2port, ENABLE); |
| 307 | |
Matthew Wilcox | be577a5 | 2006-10-06 20:47:23 -0600 | [diff] [blame] | 308 | gscps2_interrupt(0, NULL); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 309 | |
| 310 | return 0; |
| 311 | } |
| 312 | |
| 313 | /* |
| 314 | * gscps2_close() disables the port |
| 315 | */ |
| 316 | |
| 317 | static void gscps2_close(struct serio *port) |
| 318 | { |
| 319 | struct gscps2port *ps2port = port->port_data; |
| 320 | gscps2_enable(ps2port, DISABLE); |
| 321 | } |
| 322 | |
| 323 | /** |
| 324 | * gscps2_probe() - Probes PS2 devices |
| 325 | * @return: success/error report |
| 326 | */ |
| 327 | |
Bill Pemberton | 5298cc4 | 2012-11-23 21:38:25 -0800 | [diff] [blame] | 328 | static int gscps2_probe(struct parisc_device *dev) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 329 | { |
| 330 | struct gscps2port *ps2port; |
| 331 | struct serio *serio; |
Matthew Wilcox | 53f01bb | 2005-10-21 22:36:40 -0400 | [diff] [blame] | 332 | unsigned long hpa = dev->hpa.start; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 333 | int ret; |
| 334 | |
| 335 | if (!dev->irq) |
| 336 | return -ENODEV; |
| 337 | |
| 338 | /* Offset for DINO PS/2. Works with LASI even */ |
| 339 | if (dev->id.sversion == 0x96) |
| 340 | hpa += GSC_DINO_OFFSET; |
| 341 | |
Mariusz Kozlowski | 7460caf | 2007-08-30 00:18:00 -0400 | [diff] [blame] | 342 | ps2port = kzalloc(sizeof(struct gscps2port), GFP_KERNEL); |
| 343 | serio = kzalloc(sizeof(struct serio), GFP_KERNEL); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 344 | if (!ps2port || !serio) { |
| 345 | ret = -ENOMEM; |
| 346 | goto fail_nomem; |
| 347 | } |
| 348 | |
| 349 | dev_set_drvdata(&dev->dev, ps2port); |
| 350 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 351 | ps2port->port = serio; |
| 352 | ps2port->padev = dev; |
Helge Deller | 5076c15 | 2006-03-27 12:52:15 -0700 | [diff] [blame] | 353 | ps2port->addr = ioremap_nocache(hpa, GSC_STATUS + 4); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 354 | spin_lock_init(&ps2port->lock); |
| 355 | |
| 356 | gscps2_reset(ps2port); |
| 357 | ps2port->id = readb(ps2port->addr + GSC_ID) & 0x0f; |
| 358 | |
Guy Martin | 7bfbeae | 2010-11-02 15:23:08 +0000 | [diff] [blame] | 359 | snprintf(serio->name, sizeof(serio->name), "gsc-ps2-%s", |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 360 | (ps2port->id == GSC_ID_KEYBOARD) ? "keyboard" : "mouse"); |
Kay Sievers | 4e8718a | 2009-01-29 22:56:08 -0800 | [diff] [blame] | 361 | strlcpy(serio->phys, dev_name(&dev->dev), sizeof(serio->phys)); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 362 | serio->id.type = SERIO_8042; |
| 363 | serio->write = gscps2_write; |
| 364 | serio->open = gscps2_open; |
| 365 | serio->close = gscps2_close; |
| 366 | serio->port_data = ps2port; |
| 367 | serio->dev.parent = &dev->dev; |
| 368 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 369 | ret = -EBUSY; |
Thomas Gleixner | dace145 | 2006-07-01 19:29:38 -0700 | [diff] [blame] | 370 | if (request_irq(dev->irq, gscps2_interrupt, IRQF_SHARED, ps2port->port->name, ps2port)) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 371 | goto fail_miserably; |
| 372 | |
| 373 | if (ps2port->id != GSC_ID_KEYBOARD && ps2port->id != GSC_ID_MOUSE) { |
| 374 | printk(KERN_WARNING PFX "Unsupported PS/2 port at 0x%08lx (id=%d) ignored\n", |
| 375 | hpa, ps2port->id); |
| 376 | ret = -ENODEV; |
| 377 | goto fail; |
| 378 | } |
| 379 | |
| 380 | #if 0 |
| 381 | if (!request_mem_region(hpa, GSC_STATUS + 4, ps2port->port.name)) |
| 382 | goto fail; |
| 383 | #endif |
| 384 | |
| 385 | printk(KERN_INFO "serio: %s port at 0x%p irq %d @ %s\n", |
| 386 | ps2port->port->name, |
| 387 | ps2port->addr, |
| 388 | ps2port->padev->irq, |
| 389 | ps2port->port->phys); |
| 390 | |
| 391 | serio_register_port(ps2port->port); |
| 392 | |
Matthew Wilcox | 6ab0f5c | 2005-10-21 22:58:51 -0400 | [diff] [blame] | 393 | list_add_tail(&ps2port->node, &ps2port_list); |
| 394 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 395 | return 0; |
| 396 | |
| 397 | fail: |
| 398 | free_irq(dev->irq, ps2port); |
| 399 | |
| 400 | fail_miserably: |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 401 | iounmap(ps2port->addr); |
Matthew Wilcox | 6ab0f5c | 2005-10-21 22:58:51 -0400 | [diff] [blame] | 402 | release_mem_region(dev->hpa.start, GSC_STATUS + 4); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 403 | |
| 404 | fail_nomem: |
| 405 | kfree(ps2port); |
| 406 | kfree(serio); |
| 407 | return ret; |
| 408 | } |
| 409 | |
| 410 | /** |
| 411 | * gscps2_remove() - Removes PS2 devices |
| 412 | * @return: success/error report |
| 413 | */ |
| 414 | |
Bill Pemberton | e2619cf | 2012-11-23 21:50:47 -0800 | [diff] [blame] | 415 | static int gscps2_remove(struct parisc_device *dev) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 416 | { |
| 417 | struct gscps2port *ps2port = dev_get_drvdata(&dev->dev); |
| 418 | |
| 419 | serio_unregister_port(ps2port->port); |
| 420 | free_irq(dev->irq, ps2port); |
| 421 | gscps2_flush(ps2port); |
| 422 | list_del(&ps2port->node); |
| 423 | iounmap(ps2port->addr); |
| 424 | #if 0 |
| 425 | release_mem_region(dev->hpa, GSC_STATUS + 4); |
| 426 | #endif |
| 427 | dev_set_drvdata(&dev->dev, NULL); |
| 428 | kfree(ps2port); |
| 429 | return 0; |
| 430 | } |
| 431 | |
| 432 | |
| 433 | static struct parisc_device_id gscps2_device_tbl[] = { |
| 434 | { HPHW_FIO, HVERSION_REV_ANY_ID, HVERSION_ANY_ID, 0x00084 }, /* LASI PS/2 */ |
| 435 | #ifdef DINO_TESTED |
| 436 | { HPHW_FIO, HVERSION_REV_ANY_ID, HVERSION_ANY_ID, 0x00096 }, /* DINO PS/2 */ |
| 437 | #endif |
| 438 | { 0, } /* 0 terminated list */ |
| 439 | }; |
Geert Uytterhoeven | 6c8afa8 | 2015-02-04 10:59:25 -0800 | [diff] [blame] | 440 | MODULE_DEVICE_TABLE(parisc, gscps2_device_tbl); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 441 | |
| 442 | static struct parisc_driver parisc_ps2_driver = { |
Matthew Wilcox | bdad1f8 | 2005-10-21 22:36:23 -0400 | [diff] [blame] | 443 | .name = "gsc_ps2", |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 444 | .id_table = gscps2_device_tbl, |
| 445 | .probe = gscps2_probe, |
Bill Pemberton | 1cb0aa8 | 2012-11-23 21:27:39 -0800 | [diff] [blame] | 446 | .remove = gscps2_remove, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 447 | }; |
| 448 | |
| 449 | static int __init gscps2_init(void) |
| 450 | { |
| 451 | register_parisc_driver(&parisc_ps2_driver); |
| 452 | return 0; |
| 453 | } |
| 454 | |
| 455 | static void __exit gscps2_exit(void) |
| 456 | { |
| 457 | unregister_parisc_driver(&parisc_ps2_driver); |
| 458 | } |
| 459 | |
| 460 | |
| 461 | module_init(gscps2_init); |
| 462 | module_exit(gscps2_exit); |
| 463 | |