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/pm_runtime.h> 24 #include <linux/io.h> 25 #include <linux/slab.h> 26 27 static const struct { 28 unsigned char kymd, keyout, keyin; 29 } sh_keysc_mode[] = { 30 [SH_KEYSC_MODE_1] = { 0, 6, 5 }, 31 [SH_KEYSC_MODE_2] = { 1, 5, 6 }, 32 [SH_KEYSC_MODE_3] = { 2, 4, 7 }, 33 [SH_KEYSC_MODE_4] = { 3, 6, 6 }, 34 [SH_KEYSC_MODE_5] = { 4, 6, 7 }, 35 [SH_KEYSC_MODE_6] = { 5, 8, 8 }, 36 }; 37 38 struct sh_keysc_priv { 39 void __iomem *iomem_base; 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 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 int i; 172 int irq, error; 173 174 if (!pdev->dev.platform_data) { 175 dev_err(&pdev->dev, "no platform data defined\n"); 176 error = -EINVAL; 177 goto err0; 178 } 179 180 error = -ENXIO; 181 res = platform_get_resource(pdev, IORESOURCE_MEM, 0); 182 if (res == NULL) { 183 dev_err(&pdev->dev, "failed to get I/O memory\n"); 184 goto err0; 185 } 186 187 irq = platform_get_irq(pdev, 0); 188 if (irq < 0) { 189 dev_err(&pdev->dev, "failed to get irq\n"); 190 goto err0; 191 } 192 193 priv = kzalloc(sizeof(*priv), GFP_KERNEL); 194 if (priv == NULL) { 195 dev_err(&pdev->dev, "failed to allocate driver data\n"); 196 error = -ENOMEM; 197 goto err0; 198 } 199 200 platform_set_drvdata(pdev, priv); 201 memcpy(&priv->pdata, pdev->dev.platform_data, sizeof(priv->pdata)); 202 pdata = &priv->pdata; 203 204 priv->iomem_base = ioremap_nocache(res->start, resource_size(res)); 205 if (priv->iomem_base == NULL) { 206 dev_err(&pdev->dev, "failed to remap I/O memory\n"); 207 error = -ENXIO; 208 goto err1; 209 } 210 211 priv->input = input_allocate_device(); 212 if (!priv->input) { 213 dev_err(&pdev->dev, "failed to allocate input device\n"); 214 error = -ENOMEM; 215 goto err2; 216 } 217 218 input = priv->input; 219 input->evbit[0] = BIT_MASK(EV_KEY); 220 221 input->name = pdev->name; 222 input->phys = "sh-keysc-keys/input0"; 223 input->dev.parent = &pdev->dev; 224 225 input->id.bustype = BUS_HOST; 226 input->id.vendor = 0x0001; 227 input->id.product = 0x0001; 228 input->id.version = 0x0100; 229 230 input->keycode = pdata->keycodes; 231 input->keycodesize = sizeof(pdata->keycodes[0]); 232 input->keycodemax = ARRAY_SIZE(pdata->keycodes); 233 234 error = request_threaded_irq(irq, NULL, sh_keysc_isr, IRQF_ONESHOT, 235 dev_name(&pdev->dev), pdev); 236 if (error) { 237 dev_err(&pdev->dev, "failed to request IRQ\n"); 238 goto err3; 239 } 240 241 for (i = 0; i < SH_KEYSC_MAXKEYS; i++) 242 __set_bit(pdata->keycodes[i], input->keybit); 243 __clear_bit(KEY_RESERVED, input->keybit); 244 245 error = input_register_device(input); 246 if (error) { 247 dev_err(&pdev->dev, "failed to register input device\n"); 248 goto err4; 249 } 250 251 pm_runtime_enable(&pdev->dev); 252 pm_runtime_get_sync(&pdev->dev); 253 254 sh_keysc_write(priv, KYCR1, (sh_keysc_mode[pdata->mode].kymd << 8) | 255 pdata->scan_timing); 256 sh_keysc_level_mode(priv, 0); 257 258 device_init_wakeup(&pdev->dev, 1); 259 260 return 0; 261 262 err4: 263 free_irq(irq, pdev); 264 err3: 265 input_free_device(input); 266 err2: 267 iounmap(priv->iomem_base); 268 err1: 269 kfree(priv); 270 err0: 271 return error; 272 } 273 274 static int sh_keysc_remove(struct platform_device *pdev) 275 { 276 struct sh_keysc_priv *priv = platform_get_drvdata(pdev); 277 278 sh_keysc_write(priv, KYCR2, KYCR2_IRQ_DISABLED); 279 280 input_unregister_device(priv->input); 281 free_irq(platform_get_irq(pdev, 0), pdev); 282 iounmap(priv->iomem_base); 283 284 pm_runtime_put_sync(&pdev->dev); 285 pm_runtime_disable(&pdev->dev); 286 287 kfree(priv); 288 289 return 0; 290 } 291 292 #ifdef CONFIG_PM_SLEEP 293 static int sh_keysc_suspend(struct device *dev) 294 { 295 struct platform_device *pdev = to_platform_device(dev); 296 struct sh_keysc_priv *priv = platform_get_drvdata(pdev); 297 int irq = platform_get_irq(pdev, 0); 298 unsigned short value; 299 300 value = sh_keysc_read(priv, KYCR1); 301 302 if (device_may_wakeup(dev)) { 303 sh_keysc_write(priv, KYCR1, value | 0x80); 304 enable_irq_wake(irq); 305 } else { 306 sh_keysc_write(priv, KYCR1, value & ~0x80); 307 pm_runtime_put_sync(dev); 308 } 309 310 return 0; 311 } 312 313 static int sh_keysc_resume(struct device *dev) 314 { 315 struct platform_device *pdev = to_platform_device(dev); 316 int irq = platform_get_irq(pdev, 0); 317 318 if (device_may_wakeup(dev)) 319 disable_irq_wake(irq); 320 else 321 pm_runtime_get_sync(dev); 322 323 return 0; 324 } 325 #endif 326 327 static SIMPLE_DEV_PM_OPS(sh_keysc_dev_pm_ops, 328 sh_keysc_suspend, sh_keysc_resume); 329 330 static struct platform_driver sh_keysc_device_driver = { 331 .probe = sh_keysc_probe, 332 .remove = sh_keysc_remove, 333 .driver = { 334 .name = "sh_keysc", 335 .pm = &sh_keysc_dev_pm_ops, 336 } 337 }; 338 module_platform_driver(sh_keysc_device_driver); 339 340 MODULE_AUTHOR("Magnus Damm"); 341 MODULE_DESCRIPTION("SuperH KEYSC Keypad Driver"); 342 MODULE_LICENSE("GPL"); 343