linux/drivers/input/keyboard/pxa27x_keypad.c
<<
>>
Prefs
   1/*
   2 * linux/drivers/input/keyboard/pxa27x_keypad.c
   3 *
   4 * Driver for the pxa27x matrix keyboard controller.
   5 *
   6 * Created:     Feb 22, 2007
   7 * Author:      Rodolfo Giometti <giometti@linux.it>
   8 *
   9 * Based on a previous implementations by Kevin O'Connor
  10 * <kevin_at_koconnor.net> and Alex Osborne <bobofdoom@gmail.com> and
  11 * on some suggestions by Nicolas Pitre <nico@fluxnic.net>.
  12 *
  13 * This program is free software; you can redistribute it and/or modify
  14 * it under the terms of the GNU General Public License version 2 as
  15 * published by the Free Software Foundation.
  16 */
  17
  18
  19#include <linux/kernel.h>
  20#include <linux/module.h>
  21#include <linux/interrupt.h>
  22#include <linux/input.h>
  23#include <linux/io.h>
  24#include <linux/device.h>
  25#include <linux/platform_device.h>
  26#include <linux/clk.h>
  27#include <linux/err.h>
  28#include <linux/input/matrix_keypad.h>
  29#include <linux/slab.h>
  30#include <linux/of.h>
  31
  32#include <linux/platform_data/keypad-pxa27x.h>
  33/*
  34 * Keypad Controller registers
  35 */
  36#define KPC             0x0000 /* Keypad Control register */
  37#define KPDK            0x0008 /* Keypad Direct Key register */
  38#define KPREC           0x0010 /* Keypad Rotary Encoder register */
  39#define KPMK            0x0018 /* Keypad Matrix Key register */
  40#define KPAS            0x0020 /* Keypad Automatic Scan register */
  41
  42/* Keypad Automatic Scan Multiple Key Presser register 0-3 */
  43#define KPASMKP0        0x0028
  44#define KPASMKP1        0x0030
  45#define KPASMKP2        0x0038
  46#define KPASMKP3        0x0040
  47#define KPKDI           0x0048
  48
  49/* bit definitions */
  50#define KPC_MKRN(n)     ((((n) - 1) & 0x7) << 26) /* matrix key row number */
  51#define KPC_MKCN(n)     ((((n) - 1) & 0x7) << 23) /* matrix key column number */
  52#define KPC_DKN(n)      ((((n) - 1) & 0x7) << 6)  /* direct key number */
  53
  54#define KPC_AS          (0x1 << 30)  /* Automatic Scan bit */
  55#define KPC_ASACT       (0x1 << 29)  /* Automatic Scan on Activity */
  56#define KPC_MI          (0x1 << 22)  /* Matrix interrupt bit */
  57#define KPC_IMKP        (0x1 << 21)  /* Ignore Multiple Key Press */
  58
  59#define KPC_MS(n)       (0x1 << (13 + (n)))     /* Matrix scan line 'n' */
  60#define KPC_MS_ALL      (0xff << 13)
  61
  62#define KPC_ME          (0x1 << 12)  /* Matrix Keypad Enable */
  63#define KPC_MIE         (0x1 << 11)  /* Matrix Interrupt Enable */
  64#define KPC_DK_DEB_SEL  (0x1 <<  9)  /* Direct Keypad Debounce Select */
  65#define KPC_DI          (0x1 <<  5)  /* Direct key interrupt bit */
  66#define KPC_RE_ZERO_DEB (0x1 <<  4)  /* Rotary Encoder Zero Debounce */
  67#define KPC_REE1        (0x1 <<  3)  /* Rotary Encoder1 Enable */
  68#define KPC_REE0        (0x1 <<  2)  /* Rotary Encoder0 Enable */
  69#define KPC_DE          (0x1 <<  1)  /* Direct Keypad Enable */
  70#define KPC_DIE         (0x1 <<  0)  /* Direct Keypad interrupt Enable */
  71
  72#define KPDK_DKP        (0x1 << 31)
  73#define KPDK_DK(n)      ((n) & 0xff)
  74
  75#define KPREC_OF1       (0x1 << 31)
  76#define kPREC_UF1       (0x1 << 30)
  77#define KPREC_OF0       (0x1 << 15)
  78#define KPREC_UF0       (0x1 << 14)
  79
  80#define KPREC_RECOUNT0(n)       ((n) & 0xff)
  81#define KPREC_RECOUNT1(n)       (((n) >> 16) & 0xff)
  82
  83#define KPMK_MKP        (0x1 << 31)
  84#define KPAS_SO         (0x1 << 31)
  85#define KPASMKPx_SO     (0x1 << 31)
  86
  87#define KPAS_MUKP(n)    (((n) >> 26) & 0x1f)
  88#define KPAS_RP(n)      (((n) >> 4) & 0xf)
  89#define KPAS_CP(n)      ((n) & 0xf)
  90
  91#define KPASMKP_MKC_MASK        (0xff)
  92
  93#define keypad_readl(off)       __raw_readl(keypad->mmio_base + (off))
  94#define keypad_writel(off, v)   __raw_writel((v), keypad->mmio_base + (off))
  95
  96#define MAX_MATRIX_KEY_NUM      (MAX_MATRIX_KEY_ROWS * MAX_MATRIX_KEY_COLS)
  97#define MAX_KEYPAD_KEYS         (MAX_MATRIX_KEY_NUM + MAX_DIRECT_KEY_NUM)
  98
  99struct pxa27x_keypad {
 100        const struct pxa27x_keypad_platform_data *pdata;
 101
 102        struct clk *clk;
 103        struct input_dev *input_dev;
 104        void __iomem *mmio_base;
 105
 106        int irq;
 107
 108        unsigned short keycodes[MAX_KEYPAD_KEYS];
 109        int rotary_rel_code[2];
 110
 111        unsigned int row_shift;
 112
 113        /* state row bits of each column scan */
 114        uint32_t matrix_key_state[MAX_MATRIX_KEY_COLS];
 115        uint32_t direct_key_state;
 116
 117        unsigned int direct_key_mask;
 118};
 119
 120#ifdef CONFIG_OF
 121static int pxa27x_keypad_matrix_key_parse_dt(struct pxa27x_keypad *keypad,
 122                                struct pxa27x_keypad_platform_data *pdata)
 123{
 124        struct input_dev *input_dev = keypad->input_dev;
 125        struct device *dev = input_dev->dev.parent;
 126        u32 rows, cols;
 127        int error;
 128
 129        error = matrix_keypad_parse_properties(dev, &rows, &cols);
 130        if (error)
 131                return error;
 132
 133        if (rows > MAX_MATRIX_KEY_ROWS || cols > MAX_MATRIX_KEY_COLS) {
 134                dev_err(dev, "rows or cols exceeds maximum value\n");
 135                return -EINVAL;
 136        }
 137
 138        pdata->matrix_key_rows = rows;
 139        pdata->matrix_key_cols = cols;
 140
 141        error = matrix_keypad_build_keymap(NULL, NULL,
 142                                           pdata->matrix_key_rows,
 143                                           pdata->matrix_key_cols,
 144                                           keypad->keycodes, input_dev);
 145        if (error)
 146                return error;
 147
 148        return 0;
 149}
 150
 151static int pxa27x_keypad_direct_key_parse_dt(struct pxa27x_keypad *keypad,
 152                                struct pxa27x_keypad_platform_data *pdata)
 153{
 154        struct input_dev *input_dev = keypad->input_dev;
 155        struct device *dev = input_dev->dev.parent;
 156        struct device_node *np = dev->of_node;
 157        const __be16 *prop;
 158        unsigned short code;
 159        unsigned int proplen, size;
 160        int i;
 161        int error;
 162
 163        error = of_property_read_u32(np, "marvell,direct-key-count",
 164                                     &pdata->direct_key_num);
 165        if (error) {
 166                /*
 167                 * If do not have marvel,direct-key-count defined,
 168                 * it means direct key is not supported.
 169                 */
 170                return error == -EINVAL ? 0 : error;
 171        }
 172
 173        error = of_property_read_u32(np, "marvell,direct-key-mask",
 174                                     &pdata->direct_key_mask);
 175        if (error) {
 176                if (error != -EINVAL)
 177                        return error;
 178
 179                /*
 180                 * If marvell,direct-key-mask is not defined, driver will use
 181                 * default value. Default value is set when configure the keypad.
 182                 */
 183                pdata->direct_key_mask = 0;
 184        }
 185
 186        pdata->direct_key_low_active = of_property_read_bool(np,
 187                                        "marvell,direct-key-low-active");
 188
 189        prop = of_get_property(np, "marvell,direct-key-map", &proplen);
 190        if (!prop)
 191                return -EINVAL;
 192
 193        if (proplen % sizeof(u16))
 194                return -EINVAL;
 195
 196        size = proplen / sizeof(u16);
 197
 198        /* Only MAX_DIRECT_KEY_NUM is accepted.*/
 199        if (size > MAX_DIRECT_KEY_NUM)
 200                return -EINVAL;
 201
 202        for (i = 0; i < size; i++) {
 203                code = be16_to_cpup(prop + i);
 204                keypad->keycodes[MAX_MATRIX_KEY_NUM + i] = code;
 205                __set_bit(code, input_dev->keybit);
 206        }
 207
 208        return 0;
 209}
 210
 211static int pxa27x_keypad_rotary_parse_dt(struct pxa27x_keypad *keypad,
 212                                struct pxa27x_keypad_platform_data *pdata)
 213{
 214        const __be32 *prop;
 215        int i, relkey_ret;
 216        unsigned int code, proplen;
 217        const char *rotaryname[2] = {
 218                        "marvell,rotary0", "marvell,rotary1"};
 219        const char relkeyname[] = {"marvell,rotary-rel-key"};
 220        struct input_dev *input_dev = keypad->input_dev;
 221        struct device *dev = input_dev->dev.parent;
 222        struct device_node *np = dev->of_node;
 223
 224        relkey_ret = of_property_read_u32(np, relkeyname, &code);
 225        /* if can read correct rotary key-code, we do not need this. */
 226        if (relkey_ret == 0) {
 227                unsigned short relcode;
 228
 229                /* rotary0 taks lower half, rotary1 taks upper half. */
 230                relcode = code & 0xffff;
 231                pdata->rotary0_rel_code = (code & 0xffff);
 232                __set_bit(relcode, input_dev->relbit);
 233
 234                relcode = code >> 16;
 235                pdata->rotary1_rel_code = relcode;
 236                __set_bit(relcode, input_dev->relbit);
 237        }
 238
 239        for (i = 0; i < 2; i++) {
 240                prop = of_get_property(np, rotaryname[i], &proplen);
 241                /*
 242                 * If the prop is not set, it means keypad does not need
 243                 * initialize the rotaryX.
 244                 */
 245                if (!prop)
 246                        continue;
 247
 248                code = be32_to_cpup(prop);
 249                /*
 250                 * Not all up/down key code are valid.
 251                 * Now we depends on direct-rel-code.
 252                 */
 253                if ((!(code & 0xffff) || !(code >> 16)) && relkey_ret) {
 254                        return relkey_ret;
 255                } else {
 256                        unsigned int n = MAX_MATRIX_KEY_NUM + (i << 1);
 257                        unsigned short keycode;
 258
 259                        keycode = code & 0xffff;
 260                        keypad->keycodes[n] = keycode;
 261                        __set_bit(keycode, input_dev->keybit);
 262
 263                        keycode = code >> 16;
 264                        keypad->keycodes[n + 1] = keycode;
 265                        __set_bit(keycode, input_dev->keybit);
 266
 267                        if (i == 0)
 268                                pdata->rotary0_rel_code = -1;
 269                        else
 270                                pdata->rotary1_rel_code = -1;
 271                }
 272                if (i == 0)
 273                        pdata->enable_rotary0 = 1;
 274                else
 275                        pdata->enable_rotary1 = 1;
 276        }
 277
 278        keypad->rotary_rel_code[0] = pdata->rotary0_rel_code;
 279        keypad->rotary_rel_code[1] = pdata->rotary1_rel_code;
 280
 281        return 0;
 282}
 283
 284static int pxa27x_keypad_build_keycode_from_dt(struct pxa27x_keypad *keypad)
 285{
 286        struct input_dev *input_dev = keypad->input_dev;
 287        struct device *dev = input_dev->dev.parent;
 288        struct device_node *np = dev->of_node;
 289        struct pxa27x_keypad_platform_data *pdata;
 290        int error;
 291
 292        pdata = devm_kzalloc(dev, sizeof(*pdata), GFP_KERNEL);
 293        if (!pdata) {
 294                dev_err(dev, "failed to allocate memory for pdata\n");
 295                return -ENOMEM;
 296        }
 297
 298        error = pxa27x_keypad_matrix_key_parse_dt(keypad, pdata);
 299        if (error) {
 300                dev_err(dev, "failed to parse matrix key\n");
 301                return error;
 302        }
 303
 304        error = pxa27x_keypad_direct_key_parse_dt(keypad, pdata);
 305        if (error) {
 306                dev_err(dev, "failed to parse direct key\n");
 307                return error;
 308        }
 309
 310        error = pxa27x_keypad_rotary_parse_dt(keypad, pdata);
 311        if (error) {
 312                dev_err(dev, "failed to parse rotary key\n");
 313                return error;
 314        }
 315
 316        error = of_property_read_u32(np, "marvell,debounce-interval",
 317                                     &pdata->debounce_interval);
 318        if (error) {
 319                dev_err(dev, "failed to parse debounce-interval\n");
 320                return error;
 321        }
 322
 323        /*
 324         * The keycodes may not only includes matrix key but also the direct
 325         * key or rotary key.
 326         */
 327        input_dev->keycodemax = ARRAY_SIZE(keypad->keycodes);
 328
 329        keypad->pdata = pdata;
 330        return 0;
 331}
 332
 333#else
 334
 335static int pxa27x_keypad_build_keycode_from_dt(struct pxa27x_keypad *keypad)
 336{
 337        dev_info(keypad->input_dev->dev.parent, "missing platform data\n");
 338
 339        return -EINVAL;
 340}
 341
 342#endif
 343
 344static int pxa27x_keypad_build_keycode(struct pxa27x_keypad *keypad)
 345{
 346        const struct pxa27x_keypad_platform_data *pdata = keypad->pdata;
 347        struct input_dev *input_dev = keypad->input_dev;
 348        unsigned short keycode;
 349        int i;
 350        int error;
 351
 352        error = matrix_keypad_build_keymap(pdata->matrix_keymap_data, NULL,
 353                                           pdata->matrix_key_rows,
 354                                           pdata->matrix_key_cols,
 355                                           keypad->keycodes, input_dev);
 356        if (error)
 357                return error;
 358
 359        /*
 360         * The keycodes may not only include matrix keys but also the direct
 361         * or rotary keys.
 362         */
 363        input_dev->keycodemax = ARRAY_SIZE(keypad->keycodes);
 364
 365        /* For direct keys. */
 366        for (i = 0; i < pdata->direct_key_num; i++) {
 367                keycode = pdata->direct_key_map[i];
 368                keypad->keycodes[MAX_MATRIX_KEY_NUM + i] = keycode;
 369                __set_bit(keycode, input_dev->keybit);
 370        }
 371
 372        if (pdata->enable_rotary0) {
 373                if (pdata->rotary0_up_key && pdata->rotary0_down_key) {
 374                        keycode = pdata->rotary0_up_key;
 375                        keypad->keycodes[MAX_MATRIX_KEY_NUM + 0] = keycode;
 376                        __set_bit(keycode, input_dev->keybit);
 377
 378                        keycode = pdata->rotary0_down_key;
 379                        keypad->keycodes[MAX_MATRIX_KEY_NUM + 1] = keycode;
 380                        __set_bit(keycode, input_dev->keybit);
 381
 382                        keypad->rotary_rel_code[0] = -1;
 383                } else {
 384                        keypad->rotary_rel_code[0] = pdata->rotary0_rel_code;
 385                        __set_bit(pdata->rotary0_rel_code, input_dev->relbit);
 386                }
 387        }
 388
 389        if (pdata->enable_rotary1) {
 390                if (pdata->rotary1_up_key && pdata->rotary1_down_key) {
 391                        keycode = pdata->rotary1_up_key;
 392                        keypad->keycodes[MAX_MATRIX_KEY_NUM + 2] = keycode;
 393                        __set_bit(keycode, input_dev->keybit);
 394
 395                        keycode = pdata->rotary1_down_key;
 396                        keypad->keycodes[MAX_MATRIX_KEY_NUM + 3] = keycode;
 397                        __set_bit(keycode, input_dev->keybit);
 398
 399                        keypad->rotary_rel_code[1] = -1;
 400                } else {
 401                        keypad->rotary_rel_code[1] = pdata->rotary1_rel_code;
 402                        __set_bit(pdata->rotary1_rel_code, input_dev->relbit);
 403                }
 404        }
 405
 406        __clear_bit(KEY_RESERVED, input_dev->keybit);
 407
 408        return 0;
 409}
 410
 411static void pxa27x_keypad_scan_matrix(struct pxa27x_keypad *keypad)
 412{
 413        const struct pxa27x_keypad_platform_data *pdata = keypad->pdata;
 414        struct input_dev *input_dev = keypad->input_dev;
 415        int row, col, num_keys_pressed = 0;
 416        uint32_t new_state[MAX_MATRIX_KEY_COLS];
 417        uint32_t kpas = keypad_readl(KPAS);
 418
 419        num_keys_pressed = KPAS_MUKP(kpas);
 420
 421        memset(new_state, 0, sizeof(new_state));
 422
 423        if (num_keys_pressed == 0)
 424                goto scan;
 425
 426        if (num_keys_pressed == 1) {
 427                col = KPAS_CP(kpas);
 428                row = KPAS_RP(kpas);
 429
 430                /* if invalid row/col, treat as no key pressed */
 431                if (col >= pdata->matrix_key_cols ||
 432                    row >= pdata->matrix_key_rows)
 433                        goto scan;
 434
 435                new_state[col] = (1 << row);
 436                goto scan;
 437        }
 438
 439        if (num_keys_pressed > 1) {
 440                uint32_t kpasmkp0 = keypad_readl(KPASMKP0);
 441                uint32_t kpasmkp1 = keypad_readl(KPASMKP1);
 442                uint32_t kpasmkp2 = keypad_readl(KPASMKP2);
 443                uint32_t kpasmkp3 = keypad_readl(KPASMKP3);
 444
 445                new_state[0] = kpasmkp0 & KPASMKP_MKC_MASK;
 446                new_state[1] = (kpasmkp0 >> 16) & KPASMKP_MKC_MASK;
 447                new_state[2] = kpasmkp1 & KPASMKP_MKC_MASK;
 448                new_state[3] = (kpasmkp1 >> 16) & KPASMKP_MKC_MASK;
 449                new_state[4] = kpasmkp2 & KPASMKP_MKC_MASK;
 450                new_state[5] = (kpasmkp2 >> 16) & KPASMKP_MKC_MASK;
 451                new_state[6] = kpasmkp3 & KPASMKP_MKC_MASK;
 452                new_state[7] = (kpasmkp3 >> 16) & KPASMKP_MKC_MASK;
 453        }
 454scan:
 455        for (col = 0; col < pdata->matrix_key_cols; col++) {
 456                uint32_t bits_changed;
 457                int code;
 458
 459                bits_changed = keypad->matrix_key_state[col] ^ new_state[col];
 460                if (bits_changed == 0)
 461                        continue;
 462
 463                for (row = 0; row < pdata->matrix_key_rows; row++) {
 464                        if ((bits_changed & (1 << row)) == 0)
 465                                continue;
 466
 467                        code = MATRIX_SCAN_CODE(row, col, keypad->row_shift);
 468
 469                        input_event(input_dev, EV_MSC, MSC_SCAN, code);
 470                        input_report_key(input_dev, keypad->keycodes[code],
 471                                         new_state[col] & (1 << row));
 472                }
 473        }
 474        input_sync(input_dev);
 475        memcpy(keypad->matrix_key_state, new_state, sizeof(new_state));
 476}
 477
 478#define DEFAULT_KPREC   (0x007f007f)
 479
 480static inline int rotary_delta(uint32_t kprec)
 481{
 482        if (kprec & KPREC_OF0)
 483                return (kprec & 0xff) + 0x7f;
 484        else if (kprec & KPREC_UF0)
 485                return (kprec & 0xff) - 0x7f - 0xff;
 486        else
 487                return (kprec & 0xff) - 0x7f;
 488}
 489
 490static void report_rotary_event(struct pxa27x_keypad *keypad, int r, int delta)
 491{
 492        struct input_dev *dev = keypad->input_dev;
 493
 494        if (delta == 0)
 495                return;
 496
 497        if (keypad->rotary_rel_code[r] == -1) {
 498                int code = MAX_MATRIX_KEY_NUM + 2 * r + (delta > 0 ? 0 : 1);
 499                unsigned char keycode = keypad->keycodes[code];
 500
 501                /* simulate a press-n-release */
 502                input_event(dev, EV_MSC, MSC_SCAN, code);
 503                input_report_key(dev, keycode, 1);
 504                input_sync(dev);
 505                input_event(dev, EV_MSC, MSC_SCAN, code);
 506                input_report_key(dev, keycode, 0);
 507                input_sync(dev);
 508        } else {
 509                input_report_rel(dev, keypad->rotary_rel_code[r], delta);
 510                input_sync(dev);
 511        }
 512}
 513
 514static void pxa27x_keypad_scan_rotary(struct pxa27x_keypad *keypad)
 515{
 516        const struct pxa27x_keypad_platform_data *pdata = keypad->pdata;
 517        uint32_t kprec;
 518
 519        /* read and reset to default count value */
 520        kprec = keypad_readl(KPREC);
 521        keypad_writel(KPREC, DEFAULT_KPREC);
 522
 523        if (pdata->enable_rotary0)
 524                report_rotary_event(keypad, 0, rotary_delta(kprec));
 525
 526        if (pdata->enable_rotary1)
 527                report_rotary_event(keypad, 1, rotary_delta(kprec >> 16));
 528}
 529
 530static void pxa27x_keypad_scan_direct(struct pxa27x_keypad *keypad)
 531{
 532        const struct pxa27x_keypad_platform_data *pdata = keypad->pdata;
 533        struct input_dev *input_dev = keypad->input_dev;
 534        unsigned int new_state;
 535        uint32_t kpdk, bits_changed;
 536        int i;
 537
 538        kpdk = keypad_readl(KPDK);
 539
 540        if (pdata->enable_rotary0 || pdata->enable_rotary1)
 541                pxa27x_keypad_scan_rotary(keypad);
 542
 543        /*
 544         * The KPDR_DK only output the key pin level, so it relates to board,
 545         * and low level may be active.
 546         */
 547        if (pdata->direct_key_low_active)
 548                new_state = ~KPDK_DK(kpdk) & keypad->direct_key_mask;
 549        else
 550                new_state = KPDK_DK(kpdk) & keypad->direct_key_mask;
 551
 552        bits_changed = keypad->direct_key_state ^ new_state;
 553
 554        if (bits_changed == 0)
 555                return;
 556
 557        for (i = 0; i < pdata->direct_key_num; i++) {
 558                if (bits_changed & (1 << i)) {
 559                        int code = MAX_MATRIX_KEY_NUM + i;
 560
 561                        input_event(input_dev, EV_MSC, MSC_SCAN, code);
 562                        input_report_key(input_dev, keypad->keycodes[code],
 563                                         new_state & (1 << i));
 564                }
 565        }
 566        input_sync(input_dev);
 567        keypad->direct_key_state = new_state;
 568}
 569
 570static void clear_wakeup_event(struct pxa27x_keypad *keypad)
 571{
 572        const struct pxa27x_keypad_platform_data *pdata = keypad->pdata;
 573
 574        if (pdata->clear_wakeup_event)
 575                (pdata->clear_wakeup_event)();
 576}
 577
 578static irqreturn_t pxa27x_keypad_irq_handler(int irq, void *dev_id)
 579{
 580        struct pxa27x_keypad *keypad = dev_id;
 581        unsigned long kpc = keypad_readl(KPC);
 582
 583        clear_wakeup_event(keypad);
 584
 585        if (kpc & KPC_DI)
 586                pxa27x_keypad_scan_direct(keypad);
 587
 588        if (kpc & KPC_MI)
 589                pxa27x_keypad_scan_matrix(keypad);
 590
 591        return IRQ_HANDLED;
 592}
 593
 594static void pxa27x_keypad_config(struct pxa27x_keypad *keypad)
 595{
 596        const struct pxa27x_keypad_platform_data *pdata = keypad->pdata;
 597        unsigned int mask = 0, direct_key_num = 0;
 598        unsigned long kpc = 0;
 599
 600        /* clear pending interrupt bit */
 601        keypad_readl(KPC);
 602
 603        /* enable matrix keys with automatic scan */
 604        if (pdata->matrix_key_rows && pdata->matrix_key_cols) {
 605                kpc |= KPC_ASACT | KPC_MIE | KPC_ME | KPC_MS_ALL;
 606                kpc |= KPC_MKRN(pdata->matrix_key_rows) |
 607                       KPC_MKCN(pdata->matrix_key_cols);
 608        }
 609
 610        /* enable rotary key, debounce interval same as direct keys */
 611        if (pdata->enable_rotary0) {
 612                mask |= 0x03;
 613                direct_key_num = 2;
 614                kpc |= KPC_REE0;
 615        }
 616
 617        if (pdata->enable_rotary1) {
 618                mask |= 0x0c;
 619                direct_key_num = 4;
 620                kpc |= KPC_REE1;
 621        }
 622
 623        if (pdata->direct_key_num > direct_key_num)
 624                direct_key_num = pdata->direct_key_num;
 625
 626        /*
 627         * Direct keys usage may not start from KP_DKIN0, check the platfrom
 628         * mask data to config the specific.
 629         */
 630        if (pdata->direct_key_mask)
 631                keypad->direct_key_mask = pdata->direct_key_mask;
 632        else
 633                keypad->direct_key_mask = ((1 << direct_key_num) - 1) & ~mask;
 634
 635        /* enable direct key */
 636        if (direct_key_num)
 637                kpc |= KPC_DE | KPC_DIE | KPC_DKN(direct_key_num);
 638
 639        keypad_writel(KPC, kpc | KPC_RE_ZERO_DEB);
 640        keypad_writel(KPREC, DEFAULT_KPREC);
 641        keypad_writel(KPKDI, pdata->debounce_interval);
 642}
 643
 644static int pxa27x_keypad_open(struct input_dev *dev)
 645{
 646        struct pxa27x_keypad *keypad = input_get_drvdata(dev);
 647
 648        /* Enable unit clock */
 649        clk_prepare_enable(keypad->clk);
 650        pxa27x_keypad_config(keypad);
 651
 652        return 0;
 653}
 654
 655static void pxa27x_keypad_close(struct input_dev *dev)
 656{
 657        struct pxa27x_keypad *keypad = input_get_drvdata(dev);
 658
 659        /* Disable clock unit */
 660        clk_disable_unprepare(keypad->clk);
 661}
 662
 663#ifdef CONFIG_PM_SLEEP
 664static int pxa27x_keypad_suspend(struct device *dev)
 665{
 666        struct platform_device *pdev = to_platform_device(dev);
 667        struct pxa27x_keypad *keypad = platform_get_drvdata(pdev);
 668
 669        /*
 670         * If the keypad is used a wake up source, clock can not be disabled.
 671         * Or it can not detect the key pressing.
 672         */
 673        if (device_may_wakeup(&pdev->dev))
 674                enable_irq_wake(keypad->irq);
 675        else
 676                clk_disable_unprepare(keypad->clk);
 677
 678        return 0;
 679}
 680
 681static int pxa27x_keypad_resume(struct device *dev)
 682{
 683        struct platform_device *pdev = to_platform_device(dev);
 684        struct pxa27x_keypad *keypad = platform_get_drvdata(pdev);
 685        struct input_dev *input_dev = keypad->input_dev;
 686
 687        /*
 688         * If the keypad is used as wake up source, the clock is not turned
 689         * off. So do not need configure it again.
 690         */
 691        if (device_may_wakeup(&pdev->dev)) {
 692                disable_irq_wake(keypad->irq);
 693        } else {
 694                mutex_lock(&input_dev->mutex);
 695
 696                if (input_dev->users) {
 697                        /* Enable unit clock */
 698                        clk_prepare_enable(keypad->clk);
 699                        pxa27x_keypad_config(keypad);
 700                }
 701
 702                mutex_unlock(&input_dev->mutex);
 703        }
 704
 705        return 0;
 706}
 707#endif
 708
 709static SIMPLE_DEV_PM_OPS(pxa27x_keypad_pm_ops,
 710                         pxa27x_keypad_suspend, pxa27x_keypad_resume);
 711
 712
 713static int pxa27x_keypad_probe(struct platform_device *pdev)
 714{
 715        const struct pxa27x_keypad_platform_data *pdata =
 716                                        dev_get_platdata(&pdev->dev);
 717        struct device_node *np = pdev->dev.of_node;
 718        struct pxa27x_keypad *keypad;
 719        struct input_dev *input_dev;
 720        struct resource *res;
 721        int irq, error;
 722
 723        /* Driver need build keycode from device tree or pdata */
 724        if (!np && !pdata)
 725                return -EINVAL;
 726
 727        irq = platform_get_irq(pdev, 0);
 728        if (irq < 0) {
 729                dev_err(&pdev->dev, "failed to get keypad irq\n");
 730                return -ENXIO;
 731        }
 732
 733        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
 734        if (res == NULL) {
 735                dev_err(&pdev->dev, "failed to get I/O memory\n");
 736                return -ENXIO;
 737        }
 738
 739        keypad = devm_kzalloc(&pdev->dev, sizeof(*keypad),
 740                              GFP_KERNEL);
 741        if (!keypad)
 742                return -ENOMEM;
 743
 744        input_dev = devm_input_allocate_device(&pdev->dev);
 745        if (!input_dev)
 746                return -ENOMEM;
 747
 748        keypad->pdata = pdata;
 749        keypad->input_dev = input_dev;
 750        keypad->irq = irq;
 751
 752        keypad->mmio_base = devm_ioremap_resource(&pdev->dev, res);
 753        if (IS_ERR(keypad->mmio_base))
 754                return PTR_ERR(keypad->mmio_base);
 755
 756        keypad->clk = devm_clk_get(&pdev->dev, NULL);
 757        if (IS_ERR(keypad->clk)) {
 758                dev_err(&pdev->dev, "failed to get keypad clock\n");
 759                return PTR_ERR(keypad->clk);
 760        }
 761
 762        input_dev->name = pdev->name;
 763        input_dev->id.bustype = BUS_HOST;
 764        input_dev->open = pxa27x_keypad_open;
 765        input_dev->close = pxa27x_keypad_close;
 766        input_dev->dev.parent = &pdev->dev;
 767
 768        input_dev->keycode = keypad->keycodes;
 769        input_dev->keycodesize = sizeof(keypad->keycodes[0]);
 770        input_dev->keycodemax = ARRAY_SIZE(keypad->keycodes);
 771
 772        input_set_drvdata(input_dev, keypad);
 773
 774        input_dev->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_REP);
 775        input_set_capability(input_dev, EV_MSC, MSC_SCAN);
 776
 777        if (pdata) {
 778                error = pxa27x_keypad_build_keycode(keypad);
 779        } else {
 780                error = pxa27x_keypad_build_keycode_from_dt(keypad);
 781                /*
 782                 * Data that we get from DT resides in dynamically
 783                 * allocated memory so we need to update our pdata
 784                 * pointer.
 785                 */
 786                pdata = keypad->pdata;
 787        }
 788        if (error) {
 789                dev_err(&pdev->dev, "failed to build keycode\n");
 790                return error;
 791        }
 792
 793        keypad->row_shift = get_count_order(pdata->matrix_key_cols);
 794
 795        if ((pdata->enable_rotary0 && keypad->rotary_rel_code[0] != -1) ||
 796            (pdata->enable_rotary1 && keypad->rotary_rel_code[1] != -1)) {
 797                input_dev->evbit[0] |= BIT_MASK(EV_REL);
 798        }
 799
 800        error = devm_request_irq(&pdev->dev, irq, pxa27x_keypad_irq_handler,
 801                                 0, pdev->name, keypad);
 802        if (error) {
 803                dev_err(&pdev->dev, "failed to request IRQ\n");
 804                return error;
 805        }
 806
 807        /* Register the input device */
 808        error = input_register_device(input_dev);
 809        if (error) {
 810                dev_err(&pdev->dev, "failed to register input device\n");
 811                return error;
 812        }
 813
 814        platform_set_drvdata(pdev, keypad);
 815        device_init_wakeup(&pdev->dev, 1);
 816
 817        return 0;
 818}
 819
 820#ifdef CONFIG_OF
 821static const struct of_device_id pxa27x_keypad_dt_match[] = {
 822        { .compatible = "marvell,pxa27x-keypad" },
 823        {},
 824};
 825MODULE_DEVICE_TABLE(of, pxa27x_keypad_dt_match);
 826#endif
 827
 828static struct platform_driver pxa27x_keypad_driver = {
 829        .probe          = pxa27x_keypad_probe,
 830        .driver         = {
 831                .name   = "pxa27x-keypad",
 832                .of_match_table = of_match_ptr(pxa27x_keypad_dt_match),
 833                .pm     = &pxa27x_keypad_pm_ops,
 834        },
 835};
 836module_platform_driver(pxa27x_keypad_driver);
 837
 838MODULE_DESCRIPTION("PXA27x Keypad Controller Driver");
 839MODULE_LICENSE("GPL");
 840/* work with hotplug and coldplug */
 841MODULE_ALIAS("platform:pxa27x-keypad");
 842