1 | // SPDX-License-Identifier: GPL-2.0 |
2 | /* |
3 | * Support for the four N64 controllers. |
4 | * |
5 | * Copyright (c) 2021 Lauri Kasanen |
6 | */ |
7 | |
8 | #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt |
9 | |
10 | #include <linux/errno.h> |
11 | #include <linux/init.h> |
12 | #include <linux/input.h> |
13 | #include <linux/limits.h> |
14 | #include <linux/kernel.h> |
15 | #include <linux/module.h> |
16 | #include <linux/mutex.h> |
17 | #include <linux/platform_device.h> |
18 | #include <linux/slab.h> |
19 | #include <linux/timer.h> |
20 | |
21 | MODULE_AUTHOR("Lauri Kasanen <cand@gmx.com>" ); |
22 | MODULE_DESCRIPTION("Driver for N64 controllers" ); |
23 | MODULE_LICENSE("GPL" ); |
24 | |
25 | #define PIF_RAM 0x1fc007c0 |
26 | |
27 | #define SI_DRAM_REG 0 |
28 | #define SI_READ_REG 1 |
29 | #define SI_WRITE_REG 4 |
30 | #define SI_STATUS_REG 6 |
31 | |
32 | #define SI_STATUS_DMA_BUSY BIT(0) |
33 | #define SI_STATUS_IO_BUSY BIT(1) |
34 | |
35 | #define N64_CONTROLLER_ID 0x0500 |
36 | |
37 | #define MAX_CONTROLLERS 4 |
38 | |
39 | static const char *n64joy_phys[MAX_CONTROLLERS] = { |
40 | "n64joy/port0" , |
41 | "n64joy/port1" , |
42 | "n64joy/port2" , |
43 | "n64joy/port3" , |
44 | }; |
45 | |
46 | struct n64joy_priv { |
47 | u64 si_buf[8] ____cacheline_aligned; |
48 | struct timer_list timer; |
49 | struct mutex n64joy_mutex; |
50 | struct input_dev *n64joy_dev[MAX_CONTROLLERS]; |
51 | u32 __iomem *reg_base; |
52 | u8 n64joy_opened; |
53 | }; |
54 | |
55 | struct joydata { |
56 | unsigned int: 16; /* unused */ |
57 | unsigned int err: 2; |
58 | unsigned int: 14; /* unused */ |
59 | |
60 | union { |
61 | u32 data; |
62 | |
63 | struct { |
64 | unsigned int a: 1; |
65 | unsigned int b: 1; |
66 | unsigned int z: 1; |
67 | unsigned int start: 1; |
68 | unsigned int up: 1; |
69 | unsigned int down: 1; |
70 | unsigned int left: 1; |
71 | unsigned int right: 1; |
72 | unsigned int: 2; /* unused */ |
73 | unsigned int l: 1; |
74 | unsigned int r: 1; |
75 | unsigned int c_up: 1; |
76 | unsigned int c_down: 1; |
77 | unsigned int c_left: 1; |
78 | unsigned int c_right: 1; |
79 | signed int x: 8; |
80 | signed int y: 8; |
81 | }; |
82 | }; |
83 | }; |
84 | |
85 | static void n64joy_write_reg(u32 __iomem *reg_base, const u8 reg, const u32 value) |
86 | { |
87 | writel(value, reg_base + reg); |
88 | } |
89 | |
90 | static u32 n64joy_read_reg(u32 __iomem *reg_base, const u8 reg) |
91 | { |
92 | return readl(reg_base + reg); |
93 | } |
94 | |
95 | static void n64joy_wait_si_dma(u32 __iomem *reg_base) |
96 | { |
97 | while (n64joy_read_reg(reg_base, SI_STATUS_REG) & |
98 | (SI_STATUS_DMA_BUSY | SI_STATUS_IO_BUSY)) |
99 | cpu_relax(); |
100 | } |
101 | |
102 | static void n64joy_exec_pif(struct n64joy_priv *priv, const u64 in[8]) |
103 | { |
104 | unsigned long flags; |
105 | |
106 | dma_cache_wback_inv((unsigned long) in, 8 * 8); |
107 | dma_cache_inv((unsigned long) priv->si_buf, 8 * 8); |
108 | |
109 | local_irq_save(flags); |
110 | |
111 | n64joy_wait_si_dma(reg_base: priv->reg_base); |
112 | |
113 | barrier(); |
114 | n64joy_write_reg(reg_base: priv->reg_base, SI_DRAM_REG, value: virt_to_phys(in)); |
115 | barrier(); |
116 | n64joy_write_reg(reg_base: priv->reg_base, SI_WRITE_REG, PIF_RAM); |
117 | barrier(); |
118 | |
119 | n64joy_wait_si_dma(reg_base: priv->reg_base); |
120 | |
121 | barrier(); |
122 | n64joy_write_reg(reg_base: priv->reg_base, SI_DRAM_REG, value: virt_to_phys(priv->si_buf)); |
123 | barrier(); |
124 | n64joy_write_reg(reg_base: priv->reg_base, SI_READ_REG, PIF_RAM); |
125 | barrier(); |
126 | |
127 | n64joy_wait_si_dma(reg_base: priv->reg_base); |
128 | |
129 | local_irq_restore(flags); |
130 | } |
131 | |
132 | static const u64 polldata[] ____cacheline_aligned = { |
133 | 0xff010401ffffffff, |
134 | 0xff010401ffffffff, |
135 | 0xff010401ffffffff, |
136 | 0xff010401ffffffff, |
137 | 0xfe00000000000000, |
138 | 0, |
139 | 0, |
140 | 1 |
141 | }; |
142 | |
143 | static void n64joy_poll(struct timer_list *t) |
144 | { |
145 | const struct joydata *data; |
146 | struct n64joy_priv *priv = container_of(t, struct n64joy_priv, timer); |
147 | struct input_dev *dev; |
148 | u32 i; |
149 | |
150 | n64joy_exec_pif(priv, in: polldata); |
151 | |
152 | data = (struct joydata *) priv->si_buf; |
153 | |
154 | for (i = 0; i < MAX_CONTROLLERS; i++) { |
155 | if (!priv->n64joy_dev[i]) |
156 | continue; |
157 | |
158 | dev = priv->n64joy_dev[i]; |
159 | |
160 | /* d-pad */ |
161 | input_report_key(dev, BTN_DPAD_UP, value: data[i].up); |
162 | input_report_key(dev, BTN_DPAD_DOWN, value: data[i].down); |
163 | input_report_key(dev, BTN_DPAD_LEFT, value: data[i].left); |
164 | input_report_key(dev, BTN_DPAD_RIGHT, value: data[i].right); |
165 | |
166 | /* c buttons */ |
167 | input_report_key(dev, BTN_FORWARD, value: data[i].c_up); |
168 | input_report_key(dev, BTN_BACK, value: data[i].c_down); |
169 | input_report_key(dev, BTN_LEFT, value: data[i].c_left); |
170 | input_report_key(dev, BTN_RIGHT, value: data[i].c_right); |
171 | |
172 | /* matching buttons */ |
173 | input_report_key(dev, BTN_START, value: data[i].start); |
174 | input_report_key(dev, BTN_Z, value: data[i].z); |
175 | |
176 | /* remaining ones: a, b, l, r */ |
177 | input_report_key(dev, BTN_0, value: data[i].a); |
178 | input_report_key(dev, BTN_1, value: data[i].b); |
179 | input_report_key(dev, BTN_2, value: data[i].l); |
180 | input_report_key(dev, BTN_3, value: data[i].r); |
181 | |
182 | input_report_abs(dev, ABS_X, value: data[i].x); |
183 | input_report_abs(dev, ABS_Y, value: data[i].y); |
184 | |
185 | input_sync(dev); |
186 | } |
187 | |
188 | mod_timer(timer: &priv->timer, expires: jiffies + msecs_to_jiffies(m: 16)); |
189 | } |
190 | |
191 | static int n64joy_open(struct input_dev *dev) |
192 | { |
193 | struct n64joy_priv *priv = input_get_drvdata(dev); |
194 | int err; |
195 | |
196 | err = mutex_lock_interruptible(&priv->n64joy_mutex); |
197 | if (err) |
198 | return err; |
199 | |
200 | if (!priv->n64joy_opened) { |
201 | /* |
202 | * We could use the vblank irq, but it's not important if |
203 | * the poll point slightly changes. |
204 | */ |
205 | timer_setup(&priv->timer, n64joy_poll, 0); |
206 | mod_timer(timer: &priv->timer, expires: jiffies + msecs_to_jiffies(m: 16)); |
207 | } |
208 | |
209 | priv->n64joy_opened++; |
210 | |
211 | mutex_unlock(lock: &priv->n64joy_mutex); |
212 | return err; |
213 | } |
214 | |
215 | static void n64joy_close(struct input_dev *dev) |
216 | { |
217 | struct n64joy_priv *priv = input_get_drvdata(dev); |
218 | |
219 | mutex_lock(&priv->n64joy_mutex); |
220 | if (!--priv->n64joy_opened) |
221 | del_timer_sync(timer: &priv->timer); |
222 | mutex_unlock(lock: &priv->n64joy_mutex); |
223 | } |
224 | |
225 | static const u64 __initconst scandata[] ____cacheline_aligned = { |
226 | 0xff010300ffffffff, |
227 | 0xff010300ffffffff, |
228 | 0xff010300ffffffff, |
229 | 0xff010300ffffffff, |
230 | 0xfe00000000000000, |
231 | 0, |
232 | 0, |
233 | 1 |
234 | }; |
235 | |
236 | /* |
237 | * The target device is embedded and RAM-constrained. We save RAM |
238 | * by initializing in __init code that gets dropped late in boot. |
239 | * For the same reason there is no module or unloading support. |
240 | */ |
241 | static int __init n64joy_probe(struct platform_device *pdev) |
242 | { |
243 | const struct joydata *data; |
244 | struct n64joy_priv *priv; |
245 | struct input_dev *dev; |
246 | int err = 0; |
247 | u32 i, j, found = 0; |
248 | |
249 | priv = kzalloc(size: sizeof(struct n64joy_priv), GFP_KERNEL); |
250 | if (!priv) |
251 | return -ENOMEM; |
252 | mutex_init(&priv->n64joy_mutex); |
253 | |
254 | priv->reg_base = devm_platform_ioremap_resource(pdev, index: 0); |
255 | if (IS_ERR(ptr: priv->reg_base)) { |
256 | err = PTR_ERR(ptr: priv->reg_base); |
257 | goto fail; |
258 | } |
259 | |
260 | /* The controllers are not hotpluggable, so we can scan in init */ |
261 | n64joy_exec_pif(priv, in: scandata); |
262 | |
263 | data = (struct joydata *) priv->si_buf; |
264 | |
265 | for (i = 0; i < MAX_CONTROLLERS; i++) { |
266 | if (!data[i].err && data[i].data >> 16 == N64_CONTROLLER_ID) { |
267 | found++; |
268 | |
269 | dev = priv->n64joy_dev[i] = input_allocate_device(); |
270 | if (!priv->n64joy_dev[i]) { |
271 | err = -ENOMEM; |
272 | goto fail; |
273 | } |
274 | |
275 | input_set_drvdata(dev, data: priv); |
276 | |
277 | dev->name = "N64 controller" ; |
278 | dev->phys = n64joy_phys[i]; |
279 | dev->id.bustype = BUS_HOST; |
280 | dev->id.vendor = 0; |
281 | dev->id.product = data[i].data >> 16; |
282 | dev->id.version = 0; |
283 | dev->dev.parent = &pdev->dev; |
284 | |
285 | dev->open = n64joy_open; |
286 | dev->close = n64joy_close; |
287 | |
288 | /* d-pad */ |
289 | input_set_capability(dev, EV_KEY, BTN_DPAD_UP); |
290 | input_set_capability(dev, EV_KEY, BTN_DPAD_DOWN); |
291 | input_set_capability(dev, EV_KEY, BTN_DPAD_LEFT); |
292 | input_set_capability(dev, EV_KEY, BTN_DPAD_RIGHT); |
293 | /* c buttons */ |
294 | input_set_capability(dev, EV_KEY, BTN_LEFT); |
295 | input_set_capability(dev, EV_KEY, BTN_RIGHT); |
296 | input_set_capability(dev, EV_KEY, BTN_FORWARD); |
297 | input_set_capability(dev, EV_KEY, BTN_BACK); |
298 | /* matching buttons */ |
299 | input_set_capability(dev, EV_KEY, BTN_START); |
300 | input_set_capability(dev, EV_KEY, BTN_Z); |
301 | /* remaining ones: a, b, l, r */ |
302 | input_set_capability(dev, EV_KEY, BTN_0); |
303 | input_set_capability(dev, EV_KEY, BTN_1); |
304 | input_set_capability(dev, EV_KEY, BTN_2); |
305 | input_set_capability(dev, EV_KEY, BTN_3); |
306 | |
307 | for (j = 0; j < 2; j++) |
308 | input_set_abs_params(dev, ABS_X + j, |
309 | S8_MIN, S8_MAX, fuzz: 0, flat: 0); |
310 | |
311 | err = input_register_device(dev); |
312 | if (err) { |
313 | input_free_device(dev); |
314 | goto fail; |
315 | } |
316 | } |
317 | } |
318 | |
319 | pr_info("%u controller(s) connected\n" , found); |
320 | |
321 | if (!found) |
322 | return -ENODEV; |
323 | |
324 | return 0; |
325 | fail: |
326 | for (i = 0; i < MAX_CONTROLLERS; i++) { |
327 | if (!priv->n64joy_dev[i]) |
328 | continue; |
329 | input_unregister_device(priv->n64joy_dev[i]); |
330 | } |
331 | return err; |
332 | } |
333 | |
334 | static struct platform_driver n64joy_driver = { |
335 | .driver = { |
336 | .name = "n64joy" , |
337 | }, |
338 | }; |
339 | |
340 | static int __init n64joy_init(void) |
341 | { |
342 | return platform_driver_probe(&n64joy_driver, n64joy_probe); |
343 | } |
344 | |
345 | module_init(n64joy_init); |
346 | |