1 /* 2 * SuperH KEYSC Keypad Driver 3 * 4 * Copyright (C) 2008 Magnus Damm 5 * 6 * Based on gpio_keys.c, Copyright 2005 Phil Blundell 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/kernel.h> 14 #include <linux/module.h> 15 #include <linux/init.h> 16 #include <linux/interrupt.h> 17 #include <linux/irq.h> 18 #include <linux/delay.h> 19 #include <linux/platform_device.h> 20 #include <linux/input.h> 21 #include <linux/input/sh_keysc.h> 22 #include <linux/bitmap.h> 23 #include <linux/clk.h> 24 #include <linux/io.h> 25 26 static const struct { 27 unsigned char kymd, keyout, keyin; 28 } sh_keysc_mode[] = { 29 [SH_KEYSC_MODE_1] = { 0, 6, 5 }, 30 [SH_KEYSC_MODE_2] = { 1, 5, 6 }, 31 [SH_KEYSC_MODE_3] = { 2, 4, 7 }, 32 [SH_KEYSC_MODE_4] = { 3, 6, 6 }, 33 [SH_KEYSC_MODE_5] = { 4, 6, 7 }, 34 [SH_KEYSC_MODE_6] = { 5, 7, 7 }, 35 }; 36 37 struct sh_keysc_priv { 38 void __iomem *iomem_base; 39 struct clk *clk; 40 DECLARE_BITMAP(last_keys, SH_KEYSC_MAXKEYS); 41 struct input_dev *input; 42 struct sh_keysc_info pdata; 43 }; 44 45 #define KYCR1 0 46 #define KYCR2 1 47 #define KYINDR 2 48 #define KYOUTDR 3 49 50 #define KYCR2_IRQ_LEVEL 0x10 51 #define KYCR2_IRQ_DISABLED 0x00 52 53 static unsigned long sh_keysc_read(struct sh_keysc_priv *p, int reg_nr) 54 { 55 return ioread16(p->iomem_base + (reg_nr << 2)); 56 } 57 58 static void sh_keysc_write(struct sh_keysc_priv *p, int reg_nr, 59 unsigned long value) 60 { 61 iowrite16(value, p->iomem_base + (reg_nr << 2)); 62 } 63 64 static void sh_keysc_level_mode(struct sh_keysc_priv *p, 65 unsigned long keys_set) 66 { 67 struct sh_keysc_info *pdata = &p->pdata; 68 69 sh_keysc_write(p, KYOUTDR, 0); 70 sh_keysc_write(p, KYCR2, KYCR2_IRQ_LEVEL | (keys_set << 8)); 71 72 if (pdata->kycr2_delay) 73 udelay(pdata->kycr2_delay); 74 } 75 76 static void sh_keysc_map_dbg(struct device *dev, unsigned long *map, 77 const char *str) 78 { 79 int k; 80 81 for (k = 0; k < BITS_TO_LONGS(SH_KEYSC_MAXKEYS); k++) 82 dev_dbg(dev, "%s[%d] 0x%lx\n", str, k, map[k]); 83 } 84 85 static irqreturn_t sh_keysc_isr(int irq, void *dev_id) 86 { 87 struct platform_device *pdev = dev_id; 88 struct sh_keysc_priv *priv = platform_get_drvdata(pdev); 89 struct sh_keysc_info *pdata = &priv->pdata; 90 int keyout_nr = sh_keysc_mode[pdata->mode].keyout; 91 int keyin_nr = sh_keysc_mode[pdata->mode].keyin; 92 DECLARE_BITMAP(keys, SH_KEYSC_MAXKEYS); 93 DECLARE_BITMAP(keys0, SH_KEYSC_MAXKEYS); 94 DECLARE_BITMAP(keys1, SH_KEYSC_MAXKEYS); 95 unsigned char keyin_set, tmp; 96 int i, k, n; 97 98 dev_dbg(&pdev->dev, "isr!\n"); 99 100 bitmap_fill(keys1, SH_KEYSC_MAXKEYS); 101 bitmap_zero(keys0, SH_KEYSC_MAXKEYS); 102 103 do { 104 bitmap_zero(keys, SH_KEYSC_MAXKEYS); 105 keyin_set = 0; 106 107 sh_keysc_write(priv, KYCR2, KYCR2_IRQ_DISABLED); 108 109 for (i = 0; i < keyout_nr; i++) { 110 n = keyin_nr * i; 111 112 /* drive one KEYOUT pin low, read KEYIN pins */ 113 sh_keysc_write(priv, KYOUTDR, 0xffff ^ (3 << (i * 2))); 114 udelay(pdata->delay); 115 tmp = sh_keysc_read(priv, KYINDR); 116 117 /* set bit if key press has been detected */ 118 for (k = 0; k < keyin_nr; k++) { 119 if (tmp & (1 << k)) 120 __set_bit(n + k, keys); 121 } 122 123 /* keep track of which KEYIN bits that have been set */ 124 keyin_set |= tmp ^ ((1 << keyin_nr) - 1); 125 } 126 127 sh_keysc_level_mode(priv, keyin_set); 128 129 bitmap_complement(keys, keys, SH_KEYSC_MAXKEYS); 130 bitmap_and(keys1, keys1, keys, SH_KEYSC_MAXKEYS); 131 bitmap_or(keys0, keys0, keys, SH_KEYSC_MAXKEYS); 132 133 sh_keysc_map_dbg(&pdev->dev, keys, "keys"); 134 135 } while (sh_keysc_read(priv, KYCR2) & 0x01); 136 137 sh_keysc_map_dbg(&pdev->dev, priv->last_keys, "last_keys"); 138 sh_keysc_map_dbg(&pdev->dev, keys0, "keys0"); 139 sh_keysc_map_dbg(&pdev->dev, keys1, "keys1"); 140 141 for (i = 0; i < SH_KEYSC_MAXKEYS; i++) { 142 k = pdata->keycodes[i]; 143 if (!k) 144 continue; 145 146 if (test_bit(i, keys0) == test_bit(i, priv->last_keys)) 147 continue; 148 149 if (test_bit(i, keys1) || test_bit(i, keys0)) { 150 input_event(priv->input, EV_KEY, k, 1); 151 __set_bit(i, priv->last_keys); 152 } 153 154 if (!test_bit(i, keys1)) { 155 input_event(priv->input, EV_KEY, k, 0); 156 __clear_bit(i, priv->last_keys); 157 } 158 159 } 160 input_sync(priv->input); 161 162 return IRQ_HANDLED; 163 } 164 165 static int __devinit sh_keysc_probe(struct platform_device *pdev) 166 { 167 struct sh_keysc_priv *priv; 168 struct sh_keysc_info *pdata; 169 struct resource *res; 170 struct input_dev *input; 171 char clk_name[8]; 172 int i; 173 int irq, error; 174 175 if (!pdev->dev.platform_data) { 176 dev_err(&pdev->dev, "no platform data defined\n"); 177 error = -EINVAL; 178 goto err0; 179 } 180 181 error = -ENXIO; 182 res = platform_get_resource(pdev, IORESOURCE_MEM, 0); 183 if (res == NULL) { 184 dev_err(&pdev->dev, "failed to get I/O memory\n"); 185 goto err0; 186 } 187 188 irq = platform_get_irq(pdev, 0); 189 if (irq < 0) { 190 dev_err(&pdev->dev, "failed to get irq\n"); 191 goto err0; 192 } 193 194 priv = kzalloc(sizeof(*priv), GFP_KERNEL); 195 if (priv == NULL) { 196 dev_err(&pdev->dev, "failed to allocate driver data\n"); 197 error = -ENOMEM; 198 goto err0; 199 } 200 201 platform_set_drvdata(pdev, priv); 202 memcpy(&priv->pdata, pdev->dev.platform_data, sizeof(priv->pdata)); 203 pdata = &priv->pdata; 204 205 priv->iomem_base = ioremap_nocache(res->start, resource_size(res)); 206 if (priv->iomem_base == NULL) { 207 dev_err(&pdev->dev, "failed to remap I/O memory\n"); 208 error = -ENXIO; 209 goto err1; 210 } 211 212 snprintf(clk_name, sizeof(clk_name), "keysc%d", pdev->id); 213 priv->clk = clk_get(&pdev->dev, clk_name); 214 if (IS_ERR(priv->clk)) { 215 dev_err(&pdev->dev, "cannot get clock \"%s\"\n", clk_name); 216 error = PTR_ERR(priv->clk); 217 goto err2; 218 } 219 220 priv->input = input_allocate_device(); 221 if (!priv->input) { 222 dev_err(&pdev->dev, "failed to allocate input device\n"); 223 error = -ENOMEM; 224 goto err3; 225 } 226 227 input = priv->input; 228 input->evbit[0] = BIT_MASK(EV_KEY); 229 230 input->name = pdev->name; 231 input->phys = "sh-keysc-keys/input0"; 232 input->dev.parent = &pdev->dev; 233 234 input->id.bustype = BUS_HOST; 235 input->id.vendor = 0x0001; 236 input->id.product = 0x0001; 237 input->id.version = 0x0100; 238 239 input->keycode = pdata->keycodes; 240 input->keycodesize = sizeof(pdata->keycodes[0]); 241 input->keycodemax = ARRAY_SIZE(pdata->keycodes); 242 243 error = request_irq(irq, sh_keysc_isr, 0, pdev->name, pdev); 244 if (error) { 245 dev_err(&pdev->dev, "failed to request IRQ\n"); 246 goto err4; 247 } 248 249 for (i = 0; i < SH_KEYSC_MAXKEYS; i++) 250 __set_bit(pdata->keycodes[i], input->keybit); 251 __clear_bit(KEY_RESERVED, input->keybit); 252 253 error = input_register_device(input); 254 if (error) { 255 dev_err(&pdev->dev, "failed to register input device\n"); 256 goto err5; 257 } 258 259 clk_enable(priv->clk); 260 261 sh_keysc_write(priv, KYCR1, (sh_keysc_mode[pdata->mode].kymd << 8) | 262 pdata->scan_timing); 263 sh_keysc_level_mode(priv, 0); 264 265 device_init_wakeup(&pdev->dev, 1); 266 267 return 0; 268 269 err5: 270 free_irq(irq, pdev); 271 err4: 272 input_free_device(input); 273 err3: 274 clk_put(priv->clk); 275 err2: 276 iounmap(priv->iomem_base); 277 err1: 278 platform_set_drvdata(pdev, NULL); 279 kfree(priv); 280 err0: 281 return error; 282 } 283 284 static int __devexit sh_keysc_remove(struct platform_device *pdev) 285 { 286 struct sh_keysc_priv *priv = platform_get_drvdata(pdev); 287 288 sh_keysc_write(priv, KYCR2, KYCR2_IRQ_DISABLED); 289 290 input_unregister_device(priv->input); 291 free_irq(platform_get_irq(pdev, 0), pdev); 292 iounmap(priv->iomem_base); 293 294 clk_disable(priv->clk); 295 clk_put(priv->clk); 296 297 platform_set_drvdata(pdev, NULL); 298 kfree(priv); 299 300 return 0; 301 } 302 303 static int sh_keysc_suspend(struct device *dev) 304 { 305 struct platform_device *pdev = to_platform_device(dev); 306 struct sh_keysc_priv *priv = platform_get_drvdata(pdev); 307 int irq = platform_get_irq(pdev, 0); 308 unsigned short value; 309 310 value = sh_keysc_read(priv, KYCR1); 311 312 if (device_may_wakeup(dev)) { 313 value |= 0x80; 314 enable_irq_wake(irq); 315 } else { 316 value &= ~0x80; 317 } 318 319 sh_keysc_write(priv, KYCR1, value); 320 321 return 0; 322 } 323 324 static int sh_keysc_resume(struct device *dev) 325 { 326 struct platform_device *pdev = to_platform_device(dev); 327 int irq = platform_get_irq(pdev, 0); 328 329 if (device_may_wakeup(dev)) 330 disable_irq_wake(irq); 331 332 return 0; 333 } 334 335 static const struct dev_pm_ops sh_keysc_dev_pm_ops = { 336 .suspend = sh_keysc_suspend, 337 .resume = sh_keysc_resume, 338 }; 339 340 struct platform_driver sh_keysc_device_driver = { 341 .probe = sh_keysc_probe, 342 .remove = __devexit_p(sh_keysc_remove), 343 .driver = { 344 .name = "sh_keysc", 345 .pm = &sh_keysc_dev_pm_ops, 346 } 347 }; 348 349 static int __init sh_keysc_init(void) 350 { 351 return platform_driver_register(&sh_keysc_device_driver); 352 } 353 354 static void __exit sh_keysc_exit(void) 355 { 356 platform_driver_unregister(&sh_keysc_device_driver); 357 } 358 359 module_init(sh_keysc_init); 360 module_exit(sh_keysc_exit); 361 362 MODULE_AUTHOR("Magnus Damm"); 363 MODULE_DESCRIPTION("SuperH KEYSC Keypad Driver"); 364 MODULE_LICENSE("GPL"); 365