]>
Commit | Line | Data |
---|---|---|
c5e8848f LP |
1 | /* |
2 | * Copyright (C) 2015-2016 Red Hat | |
3 | * Copyright (C) 2015 Lyude Paul <thatslyude@gmail.com> | |
4 | * | |
5 | * This program is free software; you can redistribute it and/or modify it | |
6 | * under the terms of the GNU General Public License version 2 as published by | |
7 | * the Free Software Foundation. | |
8 | */ | |
9 | ||
10 | #include <linux/kernel.h> | |
11 | #include <linux/slab.h> | |
12 | #include <linux/serio.h> | |
13 | #include <linux/notifier.h> | |
14 | #include "rmi_driver.h" | |
15 | ||
16 | #define RMI_F03_RX_DATA_OFB 0x01 | |
17 | #define RMI_F03_OB_SIZE 2 | |
18 | ||
19 | #define RMI_F03_OB_OFFSET 2 | |
20 | #define RMI_F03_OB_DATA_OFFSET 1 | |
21 | #define RMI_F03_OB_FLAG_TIMEOUT BIT(6) | |
22 | #define RMI_F03_OB_FLAG_PARITY BIT(7) | |
23 | ||
24 | #define RMI_F03_DEVICE_COUNT 0x07 | |
25 | #define RMI_F03_BYTES_PER_DEVICE 0x07 | |
26 | #define RMI_F03_BYTES_PER_DEVICE_SHIFT 4 | |
27 | #define RMI_F03_QUEUE_LENGTH 0x0F | |
28 | ||
81dec809 BT |
29 | #define PSMOUSE_OOB_EXTRA_BTNS 0x01 |
30 | ||
c5e8848f LP |
31 | struct f03_data { |
32 | struct rmi_function *fn; | |
33 | ||
34 | struct serio *serio; | |
35 | ||
81dec809 BT |
36 | unsigned int overwrite_buttons; |
37 | ||
c5e8848f LP |
38 | u8 device_count; |
39 | u8 rx_queue_length; | |
40 | }; | |
41 | ||
81dec809 BT |
42 | int rmi_f03_overwrite_button(struct rmi_function *fn, unsigned int button, |
43 | int value) | |
44 | { | |
45 | struct f03_data *f03 = dev_get_drvdata(&fn->dev); | |
46 | unsigned int bit; | |
47 | ||
48 | if (button < BTN_LEFT || button > BTN_MIDDLE) | |
49 | return -EINVAL; | |
50 | ||
51 | bit = BIT(button - BTN_LEFT); | |
52 | ||
53 | if (value) | |
54 | f03->overwrite_buttons |= bit; | |
55 | else | |
56 | f03->overwrite_buttons &= ~bit; | |
57 | ||
58 | return 0; | |
59 | } | |
60 | ||
61 | void rmi_f03_commit_buttons(struct rmi_function *fn) | |
62 | { | |
63 | struct f03_data *f03 = dev_get_drvdata(&fn->dev); | |
64 | struct serio *serio = f03->serio; | |
65 | ||
66 | serio_pause_rx(serio); | |
67 | if (serio->drv) { | |
68 | serio->drv->interrupt(serio, PSMOUSE_OOB_EXTRA_BTNS, | |
69 | SERIO_OOB_DATA); | |
70 | serio->drv->interrupt(serio, f03->overwrite_buttons, | |
71 | SERIO_OOB_DATA); | |
72 | } | |
73 | serio_continue_rx(serio); | |
74 | } | |
75 | ||
c5e8848f LP |
76 | static int rmi_f03_pt_write(struct serio *id, unsigned char val) |
77 | { | |
78 | struct f03_data *f03 = id->port_data; | |
79 | int error; | |
80 | ||
81 | rmi_dbg(RMI_DEBUG_FN, &f03->fn->dev, | |
82 | "%s: Wrote %.2hhx to PS/2 passthrough address", | |
83 | __func__, val); | |
84 | ||
85 | error = rmi_write(f03->fn->rmi_dev, f03->fn->fd.data_base_addr, val); | |
86 | if (error) { | |
87 | dev_err(&f03->fn->dev, | |
88 | "%s: Failed to write to F03 TX register (%d).\n", | |
89 | __func__, error); | |
90 | return error; | |
91 | } | |
92 | ||
93 | return 0; | |
94 | } | |
95 | ||
96 | static int rmi_f03_initialize(struct f03_data *f03) | |
97 | { | |
98 | struct rmi_function *fn = f03->fn; | |
99 | struct device *dev = &fn->dev; | |
100 | int error; | |
101 | u8 bytes_per_device; | |
102 | u8 query1; | |
103 | u8 query2[RMI_F03_DEVICE_COUNT * RMI_F03_BYTES_PER_DEVICE]; | |
104 | size_t query2_len; | |
105 | ||
106 | error = rmi_read(fn->rmi_dev, fn->fd.query_base_addr, &query1); | |
107 | if (error) { | |
108 | dev_err(dev, "Failed to read query register (%d).\n", error); | |
109 | return error; | |
110 | } | |
111 | ||
112 | f03->device_count = query1 & RMI_F03_DEVICE_COUNT; | |
113 | bytes_per_device = (query1 >> RMI_F03_BYTES_PER_DEVICE_SHIFT) & | |
114 | RMI_F03_BYTES_PER_DEVICE; | |
115 | ||
116 | query2_len = f03->device_count * bytes_per_device; | |
117 | ||
118 | /* | |
119 | * The first generation of image sensors don't have a second part to | |
120 | * their f03 query, as such we have to set some of these values manually | |
121 | */ | |
122 | if (query2_len < 1) { | |
123 | f03->device_count = 1; | |
124 | f03->rx_queue_length = 7; | |
125 | } else { | |
126 | error = rmi_read_block(fn->rmi_dev, fn->fd.query_base_addr + 1, | |
127 | query2, query2_len); | |
128 | if (error) { | |
129 | dev_err(dev, | |
130 | "Failed to read second set of query registers (%d).\n", | |
131 | error); | |
132 | return error; | |
133 | } | |
134 | ||
135 | f03->rx_queue_length = query2[0] & RMI_F03_QUEUE_LENGTH; | |
136 | } | |
137 | ||
138 | return 0; | |
139 | } | |
140 | ||
141 | static int rmi_f03_register_pt(struct f03_data *f03) | |
142 | { | |
143 | struct serio *serio; | |
144 | ||
145 | serio = kzalloc(sizeof(struct serio), GFP_KERNEL); | |
146 | if (!serio) | |
147 | return -ENOMEM; | |
148 | ||
149 | serio->id.type = SERIO_8042; | |
150 | serio->write = rmi_f03_pt_write; | |
151 | serio->port_data = f03; | |
152 | ||
153 | strlcpy(serio->name, "Synaptics RMI4 PS/2 pass-through", | |
154 | sizeof(serio->name)); | |
155 | strlcpy(serio->phys, "synaptics-rmi4-pt/serio1", | |
156 | sizeof(serio->phys)); | |
157 | serio->dev.parent = &f03->fn->dev; | |
158 | ||
159 | f03->serio = serio; | |
160 | ||
161 | serio_register_port(serio); | |
162 | ||
163 | return 0; | |
164 | } | |
165 | ||
166 | static int rmi_f03_probe(struct rmi_function *fn) | |
167 | { | |
168 | struct device *dev = &fn->dev; | |
169 | struct f03_data *f03; | |
170 | int error; | |
171 | ||
172 | f03 = devm_kzalloc(dev, sizeof(struct f03_data), GFP_KERNEL); | |
173 | if (!f03) | |
174 | return -ENOMEM; | |
175 | ||
176 | f03->fn = fn; | |
177 | ||
178 | error = rmi_f03_initialize(f03); | |
179 | if (error < 0) | |
180 | return error; | |
181 | ||
182 | if (f03->device_count != 1) | |
183 | dev_warn(dev, "found %d devices on PS/2 passthrough", | |
184 | f03->device_count); | |
185 | ||
186 | dev_set_drvdata(dev, f03); | |
187 | ||
188 | error = rmi_f03_register_pt(f03); | |
189 | if (error) | |
190 | return error; | |
191 | ||
192 | return 0; | |
193 | } | |
194 | ||
195 | static int rmi_f03_config(struct rmi_function *fn) | |
196 | { | |
197 | fn->rmi_dev->driver->set_irq_bits(fn->rmi_dev, fn->irq_mask); | |
198 | ||
199 | return 0; | |
200 | } | |
201 | ||
202 | static int rmi_f03_attention(struct rmi_function *fn, unsigned long *irq_bits) | |
203 | { | |
e621132f | 204 | struct rmi_device *rmi_dev = fn->rmi_dev; |
ae9979c3 | 205 | struct rmi_driver_data *drvdata = dev_get_drvdata(&rmi_dev->dev); |
c5e8848f LP |
206 | struct f03_data *f03 = dev_get_drvdata(&fn->dev); |
207 | u16 data_addr = fn->fd.data_base_addr; | |
208 | const u8 ob_len = f03->rx_queue_length * RMI_F03_OB_SIZE; | |
209 | u8 obs[RMI_F03_QUEUE_LENGTH * RMI_F03_OB_SIZE]; | |
210 | u8 ob_status; | |
211 | u8 ob_data; | |
212 | unsigned int serio_flags; | |
213 | int i; | |
214 | int error; | |
215 | ||
ae9979c3 | 216 | if (drvdata->attn_data.data) { |
e621132f | 217 | /* First grab the data passed by the transport device */ |
ae9979c3 | 218 | if (drvdata->attn_data.size < ob_len) { |
e621132f DW |
219 | dev_warn(&fn->dev, "F03 interrupted, but data is missing!\n"); |
220 | return 0; | |
221 | } | |
222 | ||
ae9979c3 | 223 | memcpy(obs, drvdata->attn_data.data, ob_len); |
e621132f | 224 | |
ae9979c3 BT |
225 | drvdata->attn_data.data += ob_len; |
226 | drvdata->attn_data.size -= ob_len; | |
e621132f DW |
227 | } else { |
228 | /* Grab all of the data registers, and check them for data */ | |
229 | error = rmi_read_block(fn->rmi_dev, data_addr + RMI_F03_OB_OFFSET, | |
230 | &obs, ob_len); | |
231 | if (error) { | |
232 | dev_err(&fn->dev, | |
233 | "%s: Failed to read F03 output buffers: %d\n", | |
234 | __func__, error); | |
235 | serio_interrupt(f03->serio, 0, SERIO_TIMEOUT); | |
236 | return error; | |
237 | } | |
c5e8848f LP |
238 | } |
239 | ||
240 | for (i = 0; i < ob_len; i += RMI_F03_OB_SIZE) { | |
241 | ob_status = obs[i]; | |
242 | ob_data = obs[i + RMI_F03_OB_DATA_OFFSET]; | |
243 | serio_flags = 0; | |
244 | ||
245 | if (!(ob_status & RMI_F03_RX_DATA_OFB)) | |
246 | continue; | |
247 | ||
248 | if (ob_status & RMI_F03_OB_FLAG_TIMEOUT) | |
249 | serio_flags |= SERIO_TIMEOUT; | |
250 | if (ob_status & RMI_F03_OB_FLAG_PARITY) | |
251 | serio_flags |= SERIO_PARITY; | |
252 | ||
253 | rmi_dbg(RMI_DEBUG_FN, &fn->dev, | |
254 | "%s: Received %.2hhx from PS2 guest T: %c P: %c\n", | |
255 | __func__, ob_data, | |
256 | serio_flags & SERIO_TIMEOUT ? 'Y' : 'N', | |
257 | serio_flags & SERIO_PARITY ? 'Y' : 'N'); | |
258 | ||
259 | serio_interrupt(f03->serio, ob_data, serio_flags); | |
260 | } | |
261 | ||
262 | return 0; | |
263 | } | |
264 | ||
265 | static void rmi_f03_remove(struct rmi_function *fn) | |
266 | { | |
267 | struct f03_data *f03 = dev_get_drvdata(&fn->dev); | |
268 | ||
269 | serio_unregister_port(f03->serio); | |
270 | } | |
271 | ||
272 | struct rmi_function_handler rmi_f03_handler = { | |
273 | .driver = { | |
274 | .name = "rmi4_f03", | |
275 | }, | |
276 | .func = 0x03, | |
277 | .probe = rmi_f03_probe, | |
278 | .config = rmi_f03_config, | |
279 | .attention = rmi_f03_attention, | |
280 | .remove = rmi_f03_remove, | |
281 | }; | |
282 | ||
283 | MODULE_AUTHOR("Lyude Paul <thatslyude@gmail.com>"); | |
284 | MODULE_DESCRIPTION("RMI F03 module"); | |
285 | MODULE_LICENSE("GPL"); |