1 /* 2 * Driver for a keypad w/16 buttons connected to a PCF8574 I2C I/O expander 3 * 4 * Copyright 2005-2008 Analog Devices Inc. 5 * 6 * Licensed under the GPL-2 or later. 7 */ 8 9 #include <linux/module.h> 10 #include <linux/init.h> 11 #include <linux/input.h> 12 #include <linux/interrupt.h> 13 #include <linux/i2c.h> 14 #include <linux/slab.h> 15 #include <linux/workqueue.h> 16 17 #define DRV_NAME "pcf8574_keypad" 18 19 static const unsigned char pcf8574_kp_btncode[] = { 20 [0] = KEY_RESERVED, 21 [1] = KEY_ENTER, 22 [2] = KEY_BACKSLASH, 23 [3] = KEY_0, 24 [4] = KEY_RIGHTBRACE, 25 [5] = KEY_C, 26 [6] = KEY_9, 27 [7] = KEY_8, 28 [8] = KEY_7, 29 [9] = KEY_B, 30 [10] = KEY_6, 31 [11] = KEY_5, 32 [12] = KEY_4, 33 [13] = KEY_A, 34 [14] = KEY_3, 35 [15] = KEY_2, 36 [16] = KEY_1 37 }; 38 39 struct kp_data { 40 unsigned short btncode[ARRAY_SIZE(pcf8574_kp_btncode)]; 41 struct input_dev *idev; 42 struct i2c_client *client; 43 char name[64]; 44 char phys[32]; 45 unsigned char laststate; 46 }; 47 48 static short read_state(struct kp_data *lp) 49 { 50 unsigned char x, y, a, b; 51 52 i2c_smbus_write_byte(lp->client, 240); 53 x = 0xF & (~(i2c_smbus_read_byte(lp->client) >> 4)); 54 55 i2c_smbus_write_byte(lp->client, 15); 56 y = 0xF & (~i2c_smbus_read_byte(lp->client)); 57 58 for (a = 0; x > 0; a++) 59 x = x >> 1; 60 for (b = 0; y > 0; b++) 61 y = y >> 1; 62 63 return ((a - 1) * 4) + b; 64 } 65 66 static irqreturn_t pcf8574_kp_irq_handler(int irq, void *dev_id) 67 { 68 struct kp_data *lp = dev_id; 69 unsigned char nextstate = read_state(lp); 70 71 if (lp->laststate != nextstate) { 72 int key_down = nextstate < ARRAY_SIZE(lp->btncode); 73 unsigned short keycode = key_down ? 74 lp->btncode[nextstate] : lp->btncode[lp->laststate]; 75 76 input_report_key(lp->idev, keycode, key_down); 77 input_sync(lp->idev); 78 79 lp->laststate = nextstate; 80 } 81 82 return IRQ_HANDLED; 83 } 84 85 static int pcf8574_kp_probe(struct i2c_client *client, const struct i2c_device_id *id) 86 { 87 int i, ret; 88 struct input_dev *idev; 89 struct kp_data *lp; 90 91 if (i2c_smbus_write_byte(client, 240) < 0) { 92 dev_err(&client->dev, "probe: write fail\n"); 93 return -ENODEV; 94 } 95 96 lp = kzalloc(sizeof(*lp), GFP_KERNEL); 97 if (!lp) 98 return -ENOMEM; 99 100 idev = input_allocate_device(); 101 if (!idev) { 102 dev_err(&client->dev, "Can't allocate input device\n"); 103 ret = -ENOMEM; 104 goto fail_allocate; 105 } 106 107 lp->idev = idev; 108 lp->client = client; 109 110 idev->evbit[0] = BIT_MASK(EV_KEY); 111 idev->keycode = lp->btncode; 112 idev->keycodesize = sizeof(lp->btncode[0]); 113 idev->keycodemax = ARRAY_SIZE(lp->btncode); 114 115 for (i = 0; i < ARRAY_SIZE(pcf8574_kp_btncode); i++) { 116 if (lp->btncode[i] <= KEY_MAX) { 117 lp->btncode[i] = pcf8574_kp_btncode[i]; 118 __set_bit(lp->btncode[i], idev->keybit); 119 } 120 } 121 __clear_bit(KEY_RESERVED, idev->keybit); 122 123 sprintf(lp->name, DRV_NAME); 124 sprintf(lp->phys, "kp_data/input0"); 125 126 idev->name = lp->name; 127 idev->phys = lp->phys; 128 idev->id.bustype = BUS_I2C; 129 idev->id.vendor = 0x0001; 130 idev->id.product = 0x0001; 131 idev->id.version = 0x0100; 132 133 lp->laststate = read_state(lp); 134 135 ret = request_threaded_irq(client->irq, NULL, pcf8574_kp_irq_handler, 136 IRQF_TRIGGER_LOW | IRQF_ONESHOT, 137 DRV_NAME, lp); 138 if (ret) { 139 dev_err(&client->dev, "IRQ %d is not free\n", client->irq); 140 goto fail_free_device; 141 } 142 143 ret = input_register_device(idev); 144 if (ret) { 145 dev_err(&client->dev, "input_register_device() failed\n"); 146 goto fail_free_irq; 147 } 148 149 i2c_set_clientdata(client, lp); 150 return 0; 151 152 fail_free_irq: 153 free_irq(client->irq, lp); 154 fail_free_device: 155 input_free_device(idev); 156 fail_allocate: 157 kfree(lp); 158 159 return ret; 160 } 161 162 static int pcf8574_kp_remove(struct i2c_client *client) 163 { 164 struct kp_data *lp = i2c_get_clientdata(client); 165 166 free_irq(client->irq, lp); 167 168 input_unregister_device(lp->idev); 169 kfree(lp); 170 171 return 0; 172 } 173 174 #ifdef CONFIG_PM 175 static int pcf8574_kp_resume(struct device *dev) 176 { 177 struct i2c_client *client = to_i2c_client(dev); 178 179 enable_irq(client->irq); 180 181 return 0; 182 } 183 184 static int pcf8574_kp_suspend(struct device *dev) 185 { 186 struct i2c_client *client = to_i2c_client(dev); 187 188 disable_irq(client->irq); 189 190 return 0; 191 } 192 193 static const struct dev_pm_ops pcf8574_kp_pm_ops = { 194 .suspend = pcf8574_kp_suspend, 195 .resume = pcf8574_kp_resume, 196 }; 197 198 #else 199 # define pcf8574_kp_resume NULL 200 # define pcf8574_kp_suspend NULL 201 #endif 202 203 static const struct i2c_device_id pcf8574_kp_id[] = { 204 { DRV_NAME, 0 }, 205 { } 206 }; 207 MODULE_DEVICE_TABLE(i2c, pcf8574_kp_id); 208 209 static struct i2c_driver pcf8574_kp_driver = { 210 .driver = { 211 .name = DRV_NAME, 212 .owner = THIS_MODULE, 213 #ifdef CONFIG_PM 214 .pm = &pcf8574_kp_pm_ops, 215 #endif 216 }, 217 .probe = pcf8574_kp_probe, 218 .remove = pcf8574_kp_remove, 219 .id_table = pcf8574_kp_id, 220 }; 221 222 module_i2c_driver(pcf8574_kp_driver); 223 224 MODULE_AUTHOR("Michael Hennerich"); 225 MODULE_DESCRIPTION("Keypad input driver for 16 keys connected to PCF8574"); 226 MODULE_LICENSE("GPL"); 227