spitzkbd.c 14 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495
  1. /*
  2. * Keyboard driver for Sharp Spitz, Borzoi and Akita (SL-Cxx00 series)
  3. *
  4. * Copyright (c) 2005 Richard Purdie
  5. *
  6. * Based on corgikbd.c
  7. *
  8. * This program is free software; you can redistribute it and/or modify
  9. * it under the terms of the GNU General Public License version 2 as
  10. * published by the Free Software Foundation.
  11. *
  12. */
  13. #include <linux/delay.h>
  14. #include <linux/platform_device.h>
  15. #include <linux/init.h>
  16. #include <linux/input.h>
  17. #include <linux/interrupt.h>
  18. #include <linux/jiffies.h>
  19. #include <linux/module.h>
  20. #include <linux/slab.h>
  21. #include <asm/arch/spitz.h>
  22. #include <asm/arch/hardware.h>
  23. #include <asm/arch/pxa-regs.h>
  24. #define KB_ROWS 7
  25. #define KB_COLS 11
  26. #define KB_ROWMASK(r) (1 << (r))
  27. #define SCANCODE(r,c) (((r)<<4) + (c) + 1)
  28. #define NR_SCANCODES ((KB_ROWS<<4) + 1)
  29. #define SCAN_INTERVAL (50) /* ms */
  30. #define HINGE_SCAN_INTERVAL (150) /* ms */
  31. #define SPITZ_KEY_CALENDER KEY_F1
  32. #define SPITZ_KEY_ADDRESS KEY_F2
  33. #define SPITZ_KEY_FN KEY_F3
  34. #define SPITZ_KEY_CANCEL KEY_F4
  35. #define SPITZ_KEY_EXOK KEY_F5
  36. #define SPITZ_KEY_EXCANCEL KEY_F6
  37. #define SPITZ_KEY_EXJOGDOWN KEY_F7
  38. #define SPITZ_KEY_EXJOGUP KEY_F8
  39. #define SPITZ_KEY_JAP1 KEY_LEFTALT
  40. #define SPITZ_KEY_JAP2 KEY_RIGHTCTRL
  41. #define SPITZ_KEY_SYNC KEY_F9
  42. #define SPITZ_KEY_MAIL KEY_F10
  43. #define SPITZ_KEY_OK KEY_F11
  44. #define SPITZ_KEY_MENU KEY_F12
  45. static unsigned char spitzkbd_keycode[NR_SCANCODES] = {
  46. 0, /* 0 */
  47. KEY_LEFTCTRL, KEY_1, KEY_3, KEY_5, KEY_6, KEY_7, KEY_9, KEY_0, KEY_BACKSPACE, SPITZ_KEY_EXOK, SPITZ_KEY_EXCANCEL, 0, 0, 0, 0, 0, /* 1-16 */
  48. 0, KEY_2, KEY_4, KEY_R, KEY_Y, KEY_8, KEY_I, KEY_O, KEY_P, SPITZ_KEY_EXJOGDOWN, SPITZ_KEY_EXJOGUP, 0, 0, 0, 0, 0, /* 17-32 */
  49. KEY_TAB, KEY_Q, KEY_E, KEY_T, KEY_G, KEY_U, KEY_J, KEY_K, 0, 0, 0, 0, 0, 0, 0, 0, /* 33-48 */
  50. SPITZ_KEY_ADDRESS, KEY_W, KEY_S, KEY_F, KEY_V, KEY_H, KEY_M, KEY_L, 0, KEY_RIGHTSHIFT, 0, 0, 0, 0, 0, 0, /* 49-64 */
  51. SPITZ_KEY_CALENDER, KEY_A, KEY_D, KEY_C, KEY_B, KEY_N, KEY_DOT, 0, KEY_ENTER, KEY_LEFTSHIFT, 0, 0, 0, 0, 0, 0, /* 65-80 */
  52. SPITZ_KEY_MAIL, KEY_Z, KEY_X, KEY_MINUS, KEY_SPACE, KEY_COMMA, 0, KEY_UP, 0, 0, SPITZ_KEY_FN, 0, 0, 0, 0, 0, /* 81-96 */
  53. KEY_SYSRQ, SPITZ_KEY_JAP1, SPITZ_KEY_JAP2, SPITZ_KEY_CANCEL, SPITZ_KEY_OK, SPITZ_KEY_MENU, KEY_LEFT, KEY_DOWN, KEY_RIGHT, 0, 0, 0, 0, 0, 0, 0 /* 97-112 */
  54. };
  55. static int spitz_strobes[] = {
  56. SPITZ_GPIO_KEY_STROBE0,
  57. SPITZ_GPIO_KEY_STROBE1,
  58. SPITZ_GPIO_KEY_STROBE2,
  59. SPITZ_GPIO_KEY_STROBE3,
  60. SPITZ_GPIO_KEY_STROBE4,
  61. SPITZ_GPIO_KEY_STROBE5,
  62. SPITZ_GPIO_KEY_STROBE6,
  63. SPITZ_GPIO_KEY_STROBE7,
  64. SPITZ_GPIO_KEY_STROBE8,
  65. SPITZ_GPIO_KEY_STROBE9,
  66. SPITZ_GPIO_KEY_STROBE10,
  67. };
  68. static int spitz_senses[] = {
  69. SPITZ_GPIO_KEY_SENSE0,
  70. SPITZ_GPIO_KEY_SENSE1,
  71. SPITZ_GPIO_KEY_SENSE2,
  72. SPITZ_GPIO_KEY_SENSE3,
  73. SPITZ_GPIO_KEY_SENSE4,
  74. SPITZ_GPIO_KEY_SENSE5,
  75. SPITZ_GPIO_KEY_SENSE6,
  76. };
  77. struct spitzkbd {
  78. unsigned char keycode[ARRAY_SIZE(spitzkbd_keycode)];
  79. struct input_dev *input;
  80. char phys[32];
  81. spinlock_t lock;
  82. struct timer_list timer;
  83. struct timer_list htimer;
  84. unsigned int suspended;
  85. unsigned long suspend_jiffies;
  86. };
  87. #define KB_DISCHARGE_DELAY 10
  88. #define KB_ACTIVATE_DELAY 10
  89. /* Helper functions for reading the keyboard matrix
  90. * Note: We should really be using pxa_gpio_mode to alter GPDR but it
  91. * requires a function call per GPIO bit which is excessive
  92. * when we need to access 11 bits at once, multiple times.
  93. * These functions must be called within local_irq_save()/local_irq_restore()
  94. * or similar.
  95. */
  96. static inline void spitzkbd_discharge_all(void)
  97. {
  98. /* STROBE All HiZ */
  99. GPCR0 = SPITZ_GPIO_G0_STROBE_BIT;
  100. GPDR0 &= ~SPITZ_GPIO_G0_STROBE_BIT;
  101. GPCR1 = SPITZ_GPIO_G1_STROBE_BIT;
  102. GPDR1 &= ~SPITZ_GPIO_G1_STROBE_BIT;
  103. GPCR2 = SPITZ_GPIO_G2_STROBE_BIT;
  104. GPDR2 &= ~SPITZ_GPIO_G2_STROBE_BIT;
  105. GPCR3 = SPITZ_GPIO_G3_STROBE_BIT;
  106. GPDR3 &= ~SPITZ_GPIO_G3_STROBE_BIT;
  107. }
  108. static inline void spitzkbd_activate_all(void)
  109. {
  110. /* STROBE ALL -> High */
  111. GPSR0 = SPITZ_GPIO_G0_STROBE_BIT;
  112. GPDR0 |= SPITZ_GPIO_G0_STROBE_BIT;
  113. GPSR1 = SPITZ_GPIO_G1_STROBE_BIT;
  114. GPDR1 |= SPITZ_GPIO_G1_STROBE_BIT;
  115. GPSR2 = SPITZ_GPIO_G2_STROBE_BIT;
  116. GPDR2 |= SPITZ_GPIO_G2_STROBE_BIT;
  117. GPSR3 = SPITZ_GPIO_G3_STROBE_BIT;
  118. GPDR3 |= SPITZ_GPIO_G3_STROBE_BIT;
  119. udelay(KB_DISCHARGE_DELAY);
  120. /* Clear any interrupts we may have triggered when altering the GPIO lines */
  121. GEDR0 = SPITZ_GPIO_G0_SENSE_BIT;
  122. GEDR1 = SPITZ_GPIO_G1_SENSE_BIT;
  123. GEDR2 = SPITZ_GPIO_G2_SENSE_BIT;
  124. GEDR3 = SPITZ_GPIO_G3_SENSE_BIT;
  125. }
  126. static inline void spitzkbd_activate_col(int col)
  127. {
  128. int gpio = spitz_strobes[col];
  129. GPDR0 &= ~SPITZ_GPIO_G0_STROBE_BIT;
  130. GPDR1 &= ~SPITZ_GPIO_G1_STROBE_BIT;
  131. GPDR2 &= ~SPITZ_GPIO_G2_STROBE_BIT;
  132. GPDR3 &= ~SPITZ_GPIO_G3_STROBE_BIT;
  133. GPSR(gpio) = GPIO_bit(gpio);
  134. GPDR(gpio) |= GPIO_bit(gpio);
  135. }
  136. static inline void spitzkbd_reset_col(int col)
  137. {
  138. int gpio = spitz_strobes[col];
  139. GPDR0 &= ~SPITZ_GPIO_G0_STROBE_BIT;
  140. GPDR1 &= ~SPITZ_GPIO_G1_STROBE_BIT;
  141. GPDR2 &= ~SPITZ_GPIO_G2_STROBE_BIT;
  142. GPDR3 &= ~SPITZ_GPIO_G3_STROBE_BIT;
  143. GPCR(gpio) = GPIO_bit(gpio);
  144. GPDR(gpio) |= GPIO_bit(gpio);
  145. }
  146. static inline int spitzkbd_get_row_status(int col)
  147. {
  148. return ((GPLR0 >> 12) & 0x01) | ((GPLR0 >> 16) & 0x02)
  149. | ((GPLR2 >> 25) & 0x04) | ((GPLR1 << 1) & 0x08)
  150. | ((GPLR1 >> 0) & 0x10) | ((GPLR1 >> 1) & 0x60);
  151. }
  152. /*
  153. * The spitz keyboard only generates interrupts when a key is pressed.
  154. * When a key is pressed, we enable a timer which then scans the
  155. * keyboard to detect when the key is released.
  156. */
  157. /* Scan the hardware keyboard and push any changes up through the input layer */
  158. static void spitzkbd_scankeyboard(struct spitzkbd *spitzkbd_data)
  159. {
  160. unsigned int row, col, rowd;
  161. unsigned long flags;
  162. unsigned int num_pressed, pwrkey = ((GPLR(SPITZ_GPIO_ON_KEY) & GPIO_bit(SPITZ_GPIO_ON_KEY)) != 0);
  163. if (spitzkbd_data->suspended)
  164. return;
  165. spin_lock_irqsave(&spitzkbd_data->lock, flags);
  166. num_pressed = 0;
  167. for (col = 0; col < KB_COLS; col++) {
  168. /*
  169. * Discharge the output driver capacitatance
  170. * in the keyboard matrix. (Yes it is significant..)
  171. */
  172. spitzkbd_discharge_all();
  173. udelay(KB_DISCHARGE_DELAY);
  174. spitzkbd_activate_col(col);
  175. udelay(KB_ACTIVATE_DELAY);
  176. rowd = spitzkbd_get_row_status(col);
  177. for (row = 0; row < KB_ROWS; row++) {
  178. unsigned int scancode, pressed;
  179. scancode = SCANCODE(row, col);
  180. pressed = rowd & KB_ROWMASK(row);
  181. input_report_key(spitzkbd_data->input, spitzkbd_data->keycode[scancode], pressed);
  182. if (pressed)
  183. num_pressed++;
  184. }
  185. spitzkbd_reset_col(col);
  186. }
  187. spitzkbd_activate_all();
  188. input_report_key(spitzkbd_data->input, SPITZ_KEY_SYNC, (GPLR(SPITZ_GPIO_SYNC) & GPIO_bit(SPITZ_GPIO_SYNC)) != 0 );
  189. input_report_key(spitzkbd_data->input, KEY_SUSPEND, pwrkey);
  190. if (pwrkey && time_after(jiffies, spitzkbd_data->suspend_jiffies + msecs_to_jiffies(1000))) {
  191. input_event(spitzkbd_data->input, EV_PWR, KEY_SUSPEND, 1);
  192. spitzkbd_data->suspend_jiffies = jiffies;
  193. }
  194. input_sync(spitzkbd_data->input);
  195. /* if any keys are pressed, enable the timer */
  196. if (num_pressed)
  197. mod_timer(&spitzkbd_data->timer, jiffies + msecs_to_jiffies(SCAN_INTERVAL));
  198. spin_unlock_irqrestore(&spitzkbd_data->lock, flags);
  199. }
  200. /*
  201. * spitz keyboard interrupt handler.
  202. */
  203. static irqreturn_t spitzkbd_interrupt(int irq, void *dev_id)
  204. {
  205. struct spitzkbd *spitzkbd_data = dev_id;
  206. if (!timer_pending(&spitzkbd_data->timer)) {
  207. /** wait chattering delay **/
  208. udelay(20);
  209. spitzkbd_scankeyboard(spitzkbd_data);
  210. }
  211. return IRQ_HANDLED;
  212. }
  213. /*
  214. * spitz timer checking for released keys
  215. */
  216. static void spitzkbd_timer_callback(unsigned long data)
  217. {
  218. struct spitzkbd *spitzkbd_data = (struct spitzkbd *) data;
  219. spitzkbd_scankeyboard(spitzkbd_data);
  220. }
  221. /*
  222. * The hinge switches generate an interrupt.
  223. * We debounce the switches and pass them to the input system.
  224. */
  225. static irqreturn_t spitzkbd_hinge_isr(int irq, void *dev_id)
  226. {
  227. struct spitzkbd *spitzkbd_data = dev_id;
  228. if (!timer_pending(&spitzkbd_data->htimer))
  229. mod_timer(&spitzkbd_data->htimer, jiffies + msecs_to_jiffies(HINGE_SCAN_INTERVAL));
  230. return IRQ_HANDLED;
  231. }
  232. #define HINGE_STABLE_COUNT 2
  233. static int sharpsl_hinge_state;
  234. static int hinge_count;
  235. static void spitzkbd_hinge_timer(unsigned long data)
  236. {
  237. struct spitzkbd *spitzkbd_data = (struct spitzkbd *) data;
  238. unsigned long state;
  239. unsigned long flags;
  240. state = GPLR(SPITZ_GPIO_SWA) & (GPIO_bit(SPITZ_GPIO_SWA)|GPIO_bit(SPITZ_GPIO_SWB));
  241. state |= (GPLR(SPITZ_GPIO_AK_INT) & GPIO_bit(SPITZ_GPIO_AK_INT));
  242. if (state != sharpsl_hinge_state) {
  243. hinge_count = 0;
  244. sharpsl_hinge_state = state;
  245. } else if (hinge_count < HINGE_STABLE_COUNT) {
  246. hinge_count++;
  247. }
  248. if (hinge_count >= HINGE_STABLE_COUNT) {
  249. spin_lock_irqsave(&spitzkbd_data->lock, flags);
  250. input_report_switch(spitzkbd_data->input, SW_LID, ((GPLR(SPITZ_GPIO_SWA) & GPIO_bit(SPITZ_GPIO_SWA)) != 0));
  251. input_report_switch(spitzkbd_data->input, SW_TABLET_MODE, ((GPLR(SPITZ_GPIO_SWB) & GPIO_bit(SPITZ_GPIO_SWB)) != 0));
  252. input_report_switch(spitzkbd_data->input, SW_HEADPHONE_INSERT, ((GPLR(SPITZ_GPIO_AK_INT) & GPIO_bit(SPITZ_GPIO_AK_INT)) != 0));
  253. input_sync(spitzkbd_data->input);
  254. spin_unlock_irqrestore(&spitzkbd_data->lock, flags);
  255. } else {
  256. mod_timer(&spitzkbd_data->htimer, jiffies + msecs_to_jiffies(HINGE_SCAN_INTERVAL));
  257. }
  258. }
  259. #ifdef CONFIG_PM
  260. static int spitzkbd_suspend(struct platform_device *dev, pm_message_t state)
  261. {
  262. int i;
  263. struct spitzkbd *spitzkbd = platform_get_drvdata(dev);
  264. spitzkbd->suspended = 1;
  265. /* Set Strobe lines as inputs - *except* strobe line 0 leave this
  266. enabled so we can detect a power button press for resume */
  267. for (i = 1; i < SPITZ_KEY_STROBE_NUM; i++)
  268. pxa_gpio_mode(spitz_strobes[i] | GPIO_IN);
  269. return 0;
  270. }
  271. static int spitzkbd_resume(struct platform_device *dev)
  272. {
  273. int i;
  274. struct spitzkbd *spitzkbd = platform_get_drvdata(dev);
  275. for (i = 0; i < SPITZ_KEY_STROBE_NUM; i++)
  276. pxa_gpio_mode(spitz_strobes[i] | GPIO_OUT | GPIO_DFLT_HIGH);
  277. /* Upon resume, ignore the suspend key for a short while */
  278. spitzkbd->suspend_jiffies = jiffies;
  279. spitzkbd->suspended = 0;
  280. return 0;
  281. }
  282. #else
  283. #define spitzkbd_suspend NULL
  284. #define spitzkbd_resume NULL
  285. #endif
  286. static int __init spitzkbd_probe(struct platform_device *dev)
  287. {
  288. struct spitzkbd *spitzkbd;
  289. struct input_dev *input_dev;
  290. int i, err = -ENOMEM;
  291. spitzkbd = kzalloc(sizeof(struct spitzkbd), GFP_KERNEL);
  292. input_dev = input_allocate_device();
  293. if (!spitzkbd || !input_dev)
  294. goto fail;
  295. platform_set_drvdata(dev, spitzkbd);
  296. strcpy(spitzkbd->phys, "spitzkbd/input0");
  297. spin_lock_init(&spitzkbd->lock);
  298. /* Init Keyboard rescan timer */
  299. init_timer(&spitzkbd->timer);
  300. spitzkbd->timer.function = spitzkbd_timer_callback;
  301. spitzkbd->timer.data = (unsigned long) spitzkbd;
  302. /* Init Hinge Timer */
  303. init_timer(&spitzkbd->htimer);
  304. spitzkbd->htimer.function = spitzkbd_hinge_timer;
  305. spitzkbd->htimer.data = (unsigned long) spitzkbd;
  306. spitzkbd->suspend_jiffies = jiffies;
  307. spitzkbd->input = input_dev;
  308. input_dev->private = spitzkbd;
  309. input_dev->name = "Spitz Keyboard";
  310. input_dev->phys = spitzkbd->phys;
  311. input_dev->cdev.dev = &dev->dev;
  312. input_dev->id.bustype = BUS_HOST;
  313. input_dev->id.vendor = 0x0001;
  314. input_dev->id.product = 0x0001;
  315. input_dev->id.version = 0x0100;
  316. input_dev->evbit[0] = BIT(EV_KEY) | BIT(EV_REP) | BIT(EV_PWR) | BIT(EV_SW);
  317. input_dev->keycode = spitzkbd->keycode;
  318. input_dev->keycodesize = sizeof(unsigned char);
  319. input_dev->keycodemax = ARRAY_SIZE(spitzkbd_keycode);
  320. memcpy(spitzkbd->keycode, spitzkbd_keycode, sizeof(spitzkbd->keycode));
  321. for (i = 0; i < ARRAY_SIZE(spitzkbd_keycode); i++)
  322. set_bit(spitzkbd->keycode[i], input_dev->keybit);
  323. clear_bit(0, input_dev->keybit);
  324. set_bit(SW_LID, input_dev->swbit);
  325. set_bit(SW_TABLET_MODE, input_dev->swbit);
  326. set_bit(SW_HEADPHONE_INSERT, input_dev->swbit);
  327. err = input_register_device(input_dev);
  328. if (err)
  329. goto fail;
  330. mod_timer(&spitzkbd->htimer, jiffies + msecs_to_jiffies(HINGE_SCAN_INTERVAL));
  331. /* Setup sense interrupts - RisingEdge Detect, sense lines as inputs */
  332. for (i = 0; i < SPITZ_KEY_SENSE_NUM; i++) {
  333. pxa_gpio_mode(spitz_senses[i] | GPIO_IN);
  334. if (request_irq(IRQ_GPIO(spitz_senses[i]), spitzkbd_interrupt,
  335. IRQF_DISABLED|IRQF_TRIGGER_RISING,
  336. "Spitzkbd Sense", spitzkbd))
  337. printk(KERN_WARNING "spitzkbd: Can't get Sense IRQ: %d!\n", i);
  338. }
  339. /* Set Strobe lines as outputs - set high */
  340. for (i = 0; i < SPITZ_KEY_STROBE_NUM; i++)
  341. pxa_gpio_mode(spitz_strobes[i] | GPIO_OUT | GPIO_DFLT_HIGH);
  342. pxa_gpio_mode(SPITZ_GPIO_SYNC | GPIO_IN);
  343. pxa_gpio_mode(SPITZ_GPIO_ON_KEY | GPIO_IN);
  344. pxa_gpio_mode(SPITZ_GPIO_SWA | GPIO_IN);
  345. pxa_gpio_mode(SPITZ_GPIO_SWB | GPIO_IN);
  346. request_irq(SPITZ_IRQ_GPIO_SYNC, spitzkbd_interrupt,
  347. IRQF_DISABLED | IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING,
  348. "Spitzkbd Sync", spitzkbd);
  349. request_irq(SPITZ_IRQ_GPIO_ON_KEY, spitzkbd_interrupt,
  350. IRQF_DISABLED | IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING,
  351. "Spitzkbd PwrOn", spitzkbd);
  352. request_irq(SPITZ_IRQ_GPIO_SWA, spitzkbd_hinge_isr,
  353. IRQF_DISABLED | IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING,
  354. "Spitzkbd SWA", spitzkbd);
  355. request_irq(SPITZ_IRQ_GPIO_SWB, spitzkbd_hinge_isr,
  356. IRQF_DISABLED | IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING,
  357. "Spitzkbd SWB", spitzkbd);
  358. request_irq(SPITZ_IRQ_GPIO_AK_INT, spitzkbd_hinge_isr,
  359. IRQF_DISABLED | IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING,
  360. "Spitzkbd HP", spitzkbd);
  361. return 0;
  362. fail: input_free_device(input_dev);
  363. kfree(spitzkbd);
  364. return err;
  365. }
  366. static int spitzkbd_remove(struct platform_device *dev)
  367. {
  368. int i;
  369. struct spitzkbd *spitzkbd = platform_get_drvdata(dev);
  370. for (i = 0; i < SPITZ_KEY_SENSE_NUM; i++)
  371. free_irq(IRQ_GPIO(spitz_senses[i]), spitzkbd);
  372. free_irq(SPITZ_IRQ_GPIO_SYNC, spitzkbd);
  373. free_irq(SPITZ_IRQ_GPIO_ON_KEY, spitzkbd);
  374. free_irq(SPITZ_IRQ_GPIO_SWA, spitzkbd);
  375. free_irq(SPITZ_IRQ_GPIO_SWB, spitzkbd);
  376. free_irq(SPITZ_IRQ_GPIO_AK_INT, spitzkbd);
  377. del_timer_sync(&spitzkbd->htimer);
  378. del_timer_sync(&spitzkbd->timer);
  379. input_unregister_device(spitzkbd->input);
  380. kfree(spitzkbd);
  381. return 0;
  382. }
  383. static struct platform_driver spitzkbd_driver = {
  384. .probe = spitzkbd_probe,
  385. .remove = spitzkbd_remove,
  386. .suspend = spitzkbd_suspend,
  387. .resume = spitzkbd_resume,
  388. .driver = {
  389. .name = "spitz-keyboard",
  390. .owner = THIS_MODULE,
  391. },
  392. };
  393. static int __devinit spitzkbd_init(void)
  394. {
  395. return platform_driver_register(&spitzkbd_driver);
  396. }
  397. static void __exit spitzkbd_exit(void)
  398. {
  399. platform_driver_unregister(&spitzkbd_driver);
  400. }
  401. module_init(spitzkbd_init);
  402. module_exit(spitzkbd_exit);
  403. MODULE_AUTHOR("Richard Purdie <rpurdie@rpsys.net>");
  404. MODULE_DESCRIPTION("Spitz Keyboard Driver");
  405. MODULE_LICENSE("GPLv2");