1 /* 2 * SPEAr Keyboard Driver 3 * Based on omap-keypad driver 4 * 5 * Copyright (C) 2010 ST Microelectronics 6 * Rajeev Kumar<rajeev-dlh.kumar@st.com> 7 * 8 * This file is licensed under the terms of the GNU General Public 9 * License version 2. This program is licensed "as is" without any 10 * warranty of any kind, whether express or implied. 11 */ 12 13 #include <linux/clk.h> 14 #include <linux/errno.h> 15 #include <linux/init.h> 16 #include <linux/interrupt.h> 17 #include <linux/input.h> 18 #include <linux/io.h> 19 #include <linux/irq.h> 20 #include <linux/kernel.h> 21 #include <linux/module.h> 22 #include <linux/of.h> 23 #include <linux/platform_device.h> 24 #include <linux/pm_wakeup.h> 25 #include <linux/slab.h> 26 #include <linux/types.h> 27 #include <linux/platform_data/keyboard-spear.h> 28 29 /* Keyboard Registers */ 30 #define MODE_CTL_REG 0x00 31 #define STATUS_REG 0x0C 32 #define DATA_REG 0x10 33 #define INTR_MASK 0x54 34 35 /* Register Values */ 36 #define NUM_ROWS 16 37 #define NUM_COLS 16 38 #define MODE_CTL_PCLK_FREQ_SHIFT 9 39 #define MODE_CTL_PCLK_FREQ_MSK 0x7F 40 41 #define MODE_CTL_KEYBOARD (0x2 << 0) 42 #define MODE_CTL_SCAN_RATE_10 (0x0 << 2) 43 #define MODE_CTL_SCAN_RATE_20 (0x1 << 2) 44 #define MODE_CTL_SCAN_RATE_40 (0x2 << 2) 45 #define MODE_CTL_SCAN_RATE_80 (0x3 << 2) 46 #define MODE_CTL_KEYNUM_SHIFT 6 47 #define MODE_CTL_START_SCAN (0x1 << 8) 48 49 #define STATUS_DATA_AVAIL (0x1 << 1) 50 51 #define DATA_ROW_MASK 0xF0 52 #define DATA_COLUMN_MASK 0x0F 53 54 #define ROW_SHIFT 4 55 56 struct spear_kbd { 57 struct input_dev *input; 58 void __iomem *io_base; 59 struct clk *clk; 60 unsigned int irq; 61 unsigned int mode; 62 unsigned int suspended_rate; 63 unsigned short last_key; 64 unsigned short keycodes[NUM_ROWS * NUM_COLS]; 65 bool rep; 66 bool irq_wake_enabled; 67 u32 mode_ctl_reg; 68 }; 69 70 static irqreturn_t spear_kbd_interrupt(int irq, void *dev_id) 71 { 72 struct spear_kbd *kbd = dev_id; 73 struct input_dev *input = kbd->input; 74 unsigned int key; 75 u32 sts, val; 76 77 sts = readl_relaxed(kbd->io_base + STATUS_REG); 78 if (!(sts & STATUS_DATA_AVAIL)) 79 return IRQ_NONE; 80 81 if (kbd->last_key != KEY_RESERVED) { 82 input_report_key(input, kbd->last_key, 0); 83 kbd->last_key = KEY_RESERVED; 84 } 85 86 /* following reads active (row, col) pair */ 87 val = readl_relaxed(kbd->io_base + DATA_REG) & 88 (DATA_ROW_MASK | DATA_COLUMN_MASK); 89 key = kbd->keycodes[val]; 90 91 input_event(input, EV_MSC, MSC_SCAN, val); 92 input_report_key(input, key, 1); 93 input_sync(input); 94 95 kbd->last_key = key; 96 97 /* clear interrupt */ 98 writel_relaxed(0, kbd->io_base + STATUS_REG); 99 100 return IRQ_HANDLED; 101 } 102 103 static int spear_kbd_open(struct input_dev *dev) 104 { 105 struct spear_kbd *kbd = input_get_drvdata(dev); 106 int error; 107 u32 val; 108 109 kbd->last_key = KEY_RESERVED; 110 111 error = clk_enable(kbd->clk); 112 if (error) 113 return error; 114 115 /* keyboard rate to be programmed is input clock (in MHz) - 1 */ 116 val = clk_get_rate(kbd->clk) / 1000000 - 1; 117 val = (val & MODE_CTL_PCLK_FREQ_MSK) << MODE_CTL_PCLK_FREQ_SHIFT; 118 119 /* program keyboard */ 120 val = MODE_CTL_SCAN_RATE_80 | MODE_CTL_KEYBOARD | val | 121 (kbd->mode << MODE_CTL_KEYNUM_SHIFT); 122 writel_relaxed(val, kbd->io_base + MODE_CTL_REG); 123 writel_relaxed(1, kbd->io_base + STATUS_REG); 124 125 /* start key scan */ 126 val = readl_relaxed(kbd->io_base + MODE_CTL_REG); 127 val |= MODE_CTL_START_SCAN; 128 writel_relaxed(val, kbd->io_base + MODE_CTL_REG); 129 130 return 0; 131 } 132 133 static void spear_kbd_close(struct input_dev *dev) 134 { 135 struct spear_kbd *kbd = input_get_drvdata(dev); 136 u32 val; 137 138 /* stop key scan */ 139 val = readl_relaxed(kbd->io_base + MODE_CTL_REG); 140 val &= ~MODE_CTL_START_SCAN; 141 writel_relaxed(val, kbd->io_base + MODE_CTL_REG); 142 143 clk_disable(kbd->clk); 144 145 kbd->last_key = KEY_RESERVED; 146 } 147 148 #ifdef CONFIG_OF 149 static int spear_kbd_parse_dt(struct platform_device *pdev, 150 struct spear_kbd *kbd) 151 { 152 struct device_node *np = pdev->dev.of_node; 153 int error; 154 u32 val, suspended_rate; 155 156 if (!np) { 157 dev_err(&pdev->dev, "Missing DT data\n"); 158 return -EINVAL; 159 } 160 161 if (of_property_read_bool(np, "autorepeat")) 162 kbd->rep = true; 163 164 if (of_property_read_u32(np, "suspended_rate", &suspended_rate)) 165 kbd->suspended_rate = suspended_rate; 166 167 error = of_property_read_u32(np, "st,mode", &val); 168 if (error) { 169 dev_err(&pdev->dev, "DT: Invalid or missing mode\n"); 170 return error; 171 } 172 173 kbd->mode = val; 174 return 0; 175 } 176 #else 177 static inline int spear_kbd_parse_dt(struct platform_device *pdev, 178 struct spear_kbd *kbd) 179 { 180 return -ENOSYS; 181 } 182 #endif 183 184 static int spear_kbd_probe(struct platform_device *pdev) 185 { 186 struct kbd_platform_data *pdata = dev_get_platdata(&pdev->dev); 187 const struct matrix_keymap_data *keymap = pdata ? pdata->keymap : NULL; 188 struct spear_kbd *kbd; 189 struct input_dev *input_dev; 190 struct resource *res; 191 int irq; 192 int error; 193 194 res = platform_get_resource(pdev, IORESOURCE_MEM, 0); 195 if (!res) { 196 dev_err(&pdev->dev, "no keyboard resource defined\n"); 197 return -EBUSY; 198 } 199 200 irq = platform_get_irq(pdev, 0); 201 if (irq < 0) { 202 dev_err(&pdev->dev, "not able to get irq for the device\n"); 203 return irq; 204 } 205 206 kbd = devm_kzalloc(&pdev->dev, sizeof(*kbd), GFP_KERNEL); 207 if (!kbd) { 208 dev_err(&pdev->dev, "not enough memory for driver data\n"); 209 return -ENOMEM; 210 } 211 212 input_dev = devm_input_allocate_device(&pdev->dev); 213 if (!input_dev) { 214 dev_err(&pdev->dev, "unable to allocate input device\n"); 215 return -ENOMEM; 216 } 217 218 kbd->input = input_dev; 219 kbd->irq = irq; 220 221 if (!pdata) { 222 error = spear_kbd_parse_dt(pdev, kbd); 223 if (error) 224 return error; 225 } else { 226 kbd->mode = pdata->mode; 227 kbd->rep = pdata->rep; 228 kbd->suspended_rate = pdata->suspended_rate; 229 } 230 231 kbd->io_base = devm_request_and_ioremap(&pdev->dev, res); 232 if (!kbd->io_base) { 233 dev_err(&pdev->dev, "request-ioremap failed for kbd_region\n"); 234 return -ENOMEM; 235 } 236 237 kbd->clk = devm_clk_get(&pdev->dev, NULL); 238 if (IS_ERR(kbd->clk)) 239 return PTR_ERR(kbd->clk); 240 241 input_dev->name = "Spear Keyboard"; 242 input_dev->phys = "keyboard/input0"; 243 input_dev->id.bustype = BUS_HOST; 244 input_dev->id.vendor = 0x0001; 245 input_dev->id.product = 0x0001; 246 input_dev->id.version = 0x0100; 247 input_dev->open = spear_kbd_open; 248 input_dev->close = spear_kbd_close; 249 250 error = matrix_keypad_build_keymap(keymap, NULL, NUM_ROWS, NUM_COLS, 251 kbd->keycodes, input_dev); 252 if (error) { 253 dev_err(&pdev->dev, "Failed to build keymap\n"); 254 return error; 255 } 256 257 if (kbd->rep) 258 __set_bit(EV_REP, input_dev->evbit); 259 input_set_capability(input_dev, EV_MSC, MSC_SCAN); 260 261 input_set_drvdata(input_dev, kbd); 262 263 error = devm_request_irq(&pdev->dev, irq, spear_kbd_interrupt, 0, 264 "keyboard", kbd); 265 if (error) { 266 dev_err(&pdev->dev, "request_irq failed\n"); 267 return error; 268 } 269 270 error = clk_prepare(kbd->clk); 271 if (error) 272 return error; 273 274 error = input_register_device(input_dev); 275 if (error) { 276 dev_err(&pdev->dev, "Unable to register keyboard device\n"); 277 clk_unprepare(kbd->clk); 278 return error; 279 } 280 281 device_init_wakeup(&pdev->dev, 1); 282 platform_set_drvdata(pdev, kbd); 283 284 return 0; 285 } 286 287 static int spear_kbd_remove(struct platform_device *pdev) 288 { 289 struct spear_kbd *kbd = platform_get_drvdata(pdev); 290 291 input_unregister_device(kbd->input); 292 clk_unprepare(kbd->clk); 293 294 device_init_wakeup(&pdev->dev, 0); 295 platform_set_drvdata(pdev, NULL); 296 297 return 0; 298 } 299 300 #ifdef CONFIG_PM 301 static int spear_kbd_suspend(struct device *dev) 302 { 303 struct platform_device *pdev = to_platform_device(dev); 304 struct spear_kbd *kbd = platform_get_drvdata(pdev); 305 struct input_dev *input_dev = kbd->input; 306 unsigned int rate = 0, mode_ctl_reg, val; 307 308 mutex_lock(&input_dev->mutex); 309 310 /* explicitly enable clock as we may program device */ 311 clk_enable(kbd->clk); 312 313 mode_ctl_reg = readl_relaxed(kbd->io_base + MODE_CTL_REG); 314 315 if (device_may_wakeup(&pdev->dev)) { 316 if (!enable_irq_wake(kbd->irq)) 317 kbd->irq_wake_enabled = true; 318 319 /* 320 * reprogram the keyboard operating frequency as on some 321 * platform it may change during system suspended 322 */ 323 if (kbd->suspended_rate) 324 rate = kbd->suspended_rate / 1000000 - 1; 325 else 326 rate = clk_get_rate(kbd->clk) / 1000000 - 1; 327 328 val = mode_ctl_reg & 329 ~(MODE_CTL_PCLK_FREQ_MSK << MODE_CTL_PCLK_FREQ_SHIFT); 330 val |= (rate & MODE_CTL_PCLK_FREQ_MSK) 331 << MODE_CTL_PCLK_FREQ_SHIFT; 332 writel_relaxed(val, kbd->io_base + MODE_CTL_REG); 333 334 } else { 335 if (input_dev->users) { 336 writel_relaxed(mode_ctl_reg & ~MODE_CTL_START_SCAN, 337 kbd->io_base + MODE_CTL_REG); 338 clk_disable(kbd->clk); 339 } 340 } 341 342 /* store current configuration */ 343 if (input_dev->users) 344 kbd->mode_ctl_reg = mode_ctl_reg; 345 346 /* restore previous clk state */ 347 clk_disable(kbd->clk); 348 349 mutex_unlock(&input_dev->mutex); 350 351 return 0; 352 } 353 354 static int spear_kbd_resume(struct device *dev) 355 { 356 struct platform_device *pdev = to_platform_device(dev); 357 struct spear_kbd *kbd = platform_get_drvdata(pdev); 358 struct input_dev *input_dev = kbd->input; 359 360 mutex_lock(&input_dev->mutex); 361 362 if (device_may_wakeup(&pdev->dev)) { 363 if (kbd->irq_wake_enabled) { 364 kbd->irq_wake_enabled = false; 365 disable_irq_wake(kbd->irq); 366 } 367 } else { 368 if (input_dev->users) 369 clk_enable(kbd->clk); 370 } 371 372 /* restore current configuration */ 373 if (input_dev->users) 374 writel_relaxed(kbd->mode_ctl_reg, kbd->io_base + MODE_CTL_REG); 375 376 mutex_unlock(&input_dev->mutex); 377 378 return 0; 379 } 380 #endif 381 382 static SIMPLE_DEV_PM_OPS(spear_kbd_pm_ops, spear_kbd_suspend, spear_kbd_resume); 383 384 #ifdef CONFIG_OF 385 static const struct of_device_id spear_kbd_id_table[] = { 386 { .compatible = "st,spear300-kbd" }, 387 {} 388 }; 389 MODULE_DEVICE_TABLE(of, spear_kbd_id_table); 390 #endif 391 392 static struct platform_driver spear_kbd_driver = { 393 .probe = spear_kbd_probe, 394 .remove = spear_kbd_remove, 395 .driver = { 396 .name = "keyboard", 397 .owner = THIS_MODULE, 398 .pm = &spear_kbd_pm_ops, 399 .of_match_table = of_match_ptr(spear_kbd_id_table), 400 }, 401 }; 402 module_platform_driver(spear_kbd_driver); 403 404 MODULE_AUTHOR("Rajeev Kumar"); 405 MODULE_DESCRIPTION("SPEAr Keyboard Driver"); 406 MODULE_LICENSE("GPL"); 407