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