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