This source file includes following definitions.
- rpi_ts_poll
- rpi_ts_dma_cleanup
- rpi_ts_probe
1
2
3
4
5
6
7
8
9 #include <linux/io.h>
10 #include <linux/of.h>
11 #include <linux/slab.h>
12 #include <linux/device.h>
13 #include <linux/module.h>
14 #include <linux/bitops.h>
15 #include <linux/dma-mapping.h>
16 #include <linux/platform_device.h>
17 #include <linux/input.h>
18 #include <linux/input/mt.h>
19 #include <linux/input-polldev.h>
20 #include <linux/input/touchscreen.h>
21 #include <soc/bcm2835/raspberrypi-firmware.h>
22
23 #define RPI_TS_DEFAULT_WIDTH 800
24 #define RPI_TS_DEFAULT_HEIGHT 480
25
26 #define RPI_TS_MAX_SUPPORTED_POINTS 10
27
28 #define RPI_TS_FTS_TOUCH_DOWN 0
29 #define RPI_TS_FTS_TOUCH_CONTACT 2
30
31 #define RPI_TS_POLL_INTERVAL 17
32
33 #define RPI_TS_NPOINTS_REG_INVALIDATE 99
34
35 struct rpi_ts {
36 struct platform_device *pdev;
37 struct input_polled_dev *poll_dev;
38 struct touchscreen_properties prop;
39
40 void __iomem *fw_regs_va;
41 dma_addr_t fw_regs_phys;
42
43 int known_ids;
44 };
45
46 struct rpi_ts_regs {
47 u8 device_mode;
48 u8 gesture_id;
49 u8 num_points;
50 struct rpi_ts_touch {
51 u8 xh;
52 u8 xl;
53 u8 yh;
54 u8 yl;
55 u8 pressure;
56 u8 area;
57 } point[RPI_TS_MAX_SUPPORTED_POINTS];
58 };
59
60 static void rpi_ts_poll(struct input_polled_dev *dev)
61 {
62 struct input_dev *input = dev->input;
63 struct rpi_ts *ts = dev->private;
64 struct rpi_ts_regs regs;
65 int modified_ids = 0;
66 long released_ids;
67 int event_type;
68 int touchid;
69 int x, y;
70 int i;
71
72 memcpy_fromio(®s, ts->fw_regs_va, sizeof(regs));
73
74
75
76
77
78
79 iowrite8(RPI_TS_NPOINTS_REG_INVALIDATE,
80 ts->fw_regs_va + offsetof(struct rpi_ts_regs, num_points));
81
82 if (regs.num_points == RPI_TS_NPOINTS_REG_INVALIDATE ||
83 (regs.num_points == 0 && ts->known_ids == 0))
84 return;
85
86 for (i = 0; i < regs.num_points; i++) {
87 x = (((int)regs.point[i].xh & 0xf) << 8) + regs.point[i].xl;
88 y = (((int)regs.point[i].yh & 0xf) << 8) + regs.point[i].yl;
89 touchid = (regs.point[i].yh >> 4) & 0xf;
90 event_type = (regs.point[i].xh >> 6) & 0x03;
91
92 modified_ids |= BIT(touchid);
93
94 if (event_type == RPI_TS_FTS_TOUCH_DOWN ||
95 event_type == RPI_TS_FTS_TOUCH_CONTACT) {
96 input_mt_slot(input, touchid);
97 input_mt_report_slot_state(input, MT_TOOL_FINGER, 1);
98 touchscreen_report_pos(input, &ts->prop, x, y, true);
99 }
100 }
101
102 released_ids = ts->known_ids & ~modified_ids;
103 for_each_set_bit(i, &released_ids, RPI_TS_MAX_SUPPORTED_POINTS) {
104 input_mt_slot(input, i);
105 input_mt_report_slot_state(input, MT_TOOL_FINGER, 0);
106 modified_ids &= ~(BIT(i));
107 }
108 ts->known_ids = modified_ids;
109
110 input_mt_sync_frame(input);
111 input_sync(input);
112 }
113
114 static void rpi_ts_dma_cleanup(void *data)
115 {
116 struct rpi_ts *ts = data;
117 struct device *dev = &ts->pdev->dev;
118
119 dma_free_coherent(dev, PAGE_SIZE, ts->fw_regs_va, ts->fw_regs_phys);
120 }
121
122 static int rpi_ts_probe(struct platform_device *pdev)
123 {
124 struct device *dev = &pdev->dev;
125 struct device_node *np = dev->of_node;
126 struct input_polled_dev *poll_dev;
127 struct device_node *fw_node;
128 struct rpi_firmware *fw;
129 struct input_dev *input;
130 struct rpi_ts *ts;
131 u32 touchbuf;
132 int error;
133
134 fw_node = of_get_parent(np);
135 if (!fw_node) {
136 dev_err(dev, "Missing firmware node\n");
137 return -ENOENT;
138 }
139
140 fw = rpi_firmware_get(fw_node);
141 of_node_put(fw_node);
142 if (!fw)
143 return -EPROBE_DEFER;
144
145 ts = devm_kzalloc(dev, sizeof(*ts), GFP_KERNEL);
146 if (!ts)
147 return -ENOMEM;
148 ts->pdev = pdev;
149
150 ts->fw_regs_va = dma_alloc_coherent(dev, PAGE_SIZE, &ts->fw_regs_phys,
151 GFP_KERNEL);
152 if (!ts->fw_regs_va) {
153 dev_err(dev, "failed to dma_alloc_coherent\n");
154 return -ENOMEM;
155 }
156
157 error = devm_add_action_or_reset(dev, rpi_ts_dma_cleanup, ts);
158 if (error) {
159 dev_err(dev, "failed to devm_add_action_or_reset, %d\n", error);
160 return error;
161 }
162
163
164 touchbuf = (u32)ts->fw_regs_phys;
165 error = rpi_firmware_property(fw, RPI_FIRMWARE_FRAMEBUFFER_SET_TOUCHBUF,
166 &touchbuf, sizeof(touchbuf));
167
168 if (error || touchbuf != 0) {
169 dev_warn(dev, "Failed to set touchbuf, %d\n", error);
170 return error;
171 }
172
173 poll_dev = devm_input_allocate_polled_device(dev);
174 if (!poll_dev) {
175 dev_err(dev, "Failed to allocate input device\n");
176 return -ENOMEM;
177 }
178 ts->poll_dev = poll_dev;
179 input = poll_dev->input;
180
181 input->name = "raspberrypi-ts";
182 input->id.bustype = BUS_HOST;
183 poll_dev->poll_interval = RPI_TS_POLL_INTERVAL;
184 poll_dev->poll = rpi_ts_poll;
185 poll_dev->private = ts;
186
187 input_set_abs_params(input, ABS_MT_POSITION_X, 0,
188 RPI_TS_DEFAULT_WIDTH, 0, 0);
189 input_set_abs_params(input, ABS_MT_POSITION_Y, 0,
190 RPI_TS_DEFAULT_HEIGHT, 0, 0);
191 touchscreen_parse_properties(input, true, &ts->prop);
192
193 error = input_mt_init_slots(input, RPI_TS_MAX_SUPPORTED_POINTS,
194 INPUT_MT_DIRECT);
195 if (error) {
196 dev_err(dev, "could not init mt slots, %d\n", error);
197 return error;
198 }
199
200 error = input_register_polled_device(poll_dev);
201 if (error) {
202 dev_err(dev, "could not register input device, %d\n", error);
203 return error;
204 }
205
206 return 0;
207 }
208
209 static const struct of_device_id rpi_ts_match[] = {
210 { .compatible = "raspberrypi,firmware-ts", },
211 {},
212 };
213 MODULE_DEVICE_TABLE(of, rpi_ts_match);
214
215 static struct platform_driver rpi_ts_driver = {
216 .driver = {
217 .name = "raspberrypi-ts",
218 .of_match_table = rpi_ts_match,
219 },
220 .probe = rpi_ts_probe,
221 };
222 module_platform_driver(rpi_ts_driver);
223
224 MODULE_AUTHOR("Gordon Hollingworth");
225 MODULE_AUTHOR("Nicolas Saenz Julienne <nsaenzjulienne@suse.de>");
226 MODULE_DESCRIPTION("Raspberry Pi firmware based touchscreen driver");
227 MODULE_LICENSE("GPL v2");