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(priv->reg_base); 112 113 barrier(); 114 n64joy_write_reg(priv->reg_base, SI_DRAM_REG, virt_to_phys(in)); 115 barrier(); 116 n64joy_write_reg(priv->reg_base, SI_WRITE_REG, PIF_RAM); 117 barrier(); 118 119 n64joy_wait_si_dma(priv->reg_base); 120 121 barrier(); 122 n64joy_write_reg(priv->reg_base, SI_DRAM_REG, virt_to_phys(priv->si_buf)); 123 barrier(); 124 n64joy_write_reg(priv->reg_base, SI_READ_REG, PIF_RAM); 125 barrier(); 126 127 n64joy_wait_si_dma(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, 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, data[i].up); 162 input_report_key(dev, BTN_DPAD_DOWN, data[i].down); 163 input_report_key(dev, BTN_DPAD_LEFT, data[i].left); 164 input_report_key(dev, BTN_DPAD_RIGHT, data[i].right); 165 166 /* c buttons */ 167 input_report_key(dev, BTN_FORWARD, data[i].c_up); 168 input_report_key(dev, BTN_BACK, data[i].c_down); 169 input_report_key(dev, BTN_LEFT, data[i].c_left); 170 input_report_key(dev, BTN_RIGHT, data[i].c_right); 171 172 /* matching buttons */ 173 input_report_key(dev, BTN_START, data[i].start); 174 input_report_key(dev, BTN_Z, data[i].z); 175 176 /* remaining ones: a, b, l, r */ 177 input_report_key(dev, BTN_0, data[i].a); 178 input_report_key(dev, BTN_1, data[i].b); 179 input_report_key(dev, BTN_2, data[i].l); 180 input_report_key(dev, BTN_3, data[i].r); 181 182 input_report_abs(dev, ABS_X, data[i].x); 183 input_report_abs(dev, ABS_Y, data[i].y); 184 185 input_sync(dev); 186 } 187 188 mod_timer(&priv->timer, jiffies + msecs_to_jiffies(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(&priv->timer, jiffies + msecs_to_jiffies(16)); 207 } 208 209 priv->n64joy_opened++; 210 211 mutex_unlock(&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(&priv->timer); 222 mutex_unlock(&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(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, 0); 255 if (IS_ERR(priv->reg_base)) { 256 err = PTR_ERR(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, 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, 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, 0, 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