API tools faq
paste
Advertisement
Guest User

Untitled

a guest
Dec 14th, 2019
109
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 14.55 KB | None | 0 0
raw download clone embed print report
  1. /*
  2. * Arcade Joystick Driver for Pandora Box 4
  3. *
  4. * Copyright (c) 2018 Vanni Brutto
  5. *
  6. * based on the mk_arcade_joystick_rpi by Matthieu Proucelle
  7. * and on the gamecon driver by Vojtech Pavlik, and Markus Hiienkari
  8. */
  9.  
  10.  
  11. /*
  12. * This program is free software; you can redistribute it and/or modify
  13. * it under the terms of the GNU General Public License as published by
  14. * the Free Software Foundation; either version 2 of the License, or
  15. * (at your option) any later version.
  16. *
  17. * This program is distributed in the hope that it will be useful,
  18. * but WITHOUT ANY WARRANTY; without even the implied warranty of
  19. * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  20. * GNU General Public License for more details.
  21. *
  22. * You should have received a copy of the GNU General Public License
  23. * along with this program; if not, write to the Free Software
  24. * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
  25. * MA 02110-1301, USA.
  26. */
  27.  
  28. #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  29.  
  30. #include <linux/kernel.h>
  31. #include <linux/delay.h>
  32. #include <linux/module.h>
  33. #include <linux/init.h>
  34. #include <linux/input.h>
  35. #include <linux/mutex.h>
  36. #include <linux/slab.h>
  37. #include <linux/jiffies.h>
  38.  
  39. #include <linux/ioport.h>
  40. #include <asm/io.h>
  41.  
  42.  
  43. MODULE_AUTHOR("Matthieu Proucelle");
  44. MODULE_DESCRIPTION("Gb2000s Arcade Joystick Driver");
  45. MODULE_LICENSE("GPL");
  46.  
  47. #define MK_DEVICES 2
  48.  
  49. #define GPIO_BASE 0x01c20800 /* GPIO controller */
  50.  
  51. static volatile unsigned int gpio = 0xffffffff;
  52. static volatile unsigned int reg = GPIO_BASE;
  53. static volatile unsigned int dev_base = 0x0;
  54. static volatile unsigned long long int mk_jiffies = 0x0;
  55.  
  56.  
  57. struct mk_config {
  58. int args[MK_DEVICES];
  59. unsigned int nargs;
  60. };
  61.  
  62. static struct mk_config mk_cfg __initdata;
  63.  
  64. module_param_array_named(map, mk_cfg.args, int, &(mk_cfg.nargs), 0);
  65. MODULE_PARM_DESC(map, "Enable or disable GPIO Arcade Joystick");
  66.  
  67. struct gpio_config {
  68. int mk_arcade_gpio_maps_custom[11];
  69. unsigned int nargs;
  70. };
  71.  
  72. static struct gpio_config gpio_cfg __initdata;
  73.  
  74. module_param_array_named(gpio, gpio_cfg.mk_arcade_gpio_maps_custom, int, &(gpio_cfg.nargs), 0);
  75. MODULE_PARM_DESC(gpio, "Numbers of custom GPIO for Arcade Joystick");
  76.  
  77. #define MK_REFRESH_TIME HZ/100
  78.  
  79. struct mk_pad {
  80. struct input_dev *dev;
  81. char phys[32];
  82. };
  83.  
  84. struct mk_nin_gpio {
  85. unsigned pad_id;
  86. unsigned cmd_setinputs;
  87. unsigned cmd_setoutputs;
  88. unsigned valid_bits;
  89. unsigned request;
  90. unsigned request_len;
  91. unsigned response_len;
  92. unsigned response_bufsize;
  93. };
  94.  
  95. struct mk {
  96. struct mk_pad pads[MK_DEVICES];
  97. struct timer_list timer;
  98. int used;
  99. struct mutex mutex;
  100. };
  101.  
  102. struct mk_subdev {
  103. unsigned int idx;
  104. };
  105.  
  106. static struct mk *mk_base;
  107.  
  108. static const int mk_data_size = 24;
  109.  
  110. static const int mk_max_arcade_buttons = 12;
  111.  
  112. static const int mk_arcade_gpio_maps[] = {
  113. 0x20*4+0x08,
  114. 0x20*4+0x09,
  115. 0x20*4+0x0a,
  116. 0x20*4+0x0b,
  117.  
  118. 0x20*4+0x00,
  119. 0x20*4+0x01,
  120. 0x20*4+0x02,
  121. 0x20*4+0x03,
  122. 0x20*4+0x04,
  123. 0x20*4+0x05,
  124. 0x20*4+0x06,
  125. 0x20*4+0x07,
  126. 0x20*4+0x08,
  127.  
  128. };
  129.  
  130.  
  131.  
  132.  
  133.  
  134. static const short mk_arcade_gpio_btn[] = {
  135. BTN_START, BTN_SELECT, BTN_A, BTN_B, BTN_TR, BTN_Y, BTN_X, BTN_TL
  136. };
  137.  
  138. static const char *mk_names[] = {
  139. "Gb2000s v2.26 JAMMA Controller0" ,
  140. "Gb2000s v2.26 JAMMA Controller1" ,
  141. };
  142.  
  143.  
  144. static int readGpio(unsigned int gpio_reg, int pio, int index)
  145. {
  146. int port = (pio>>5) & 0xf;
  147. int bit = (pio>>0) & 0x1f;
  148. unsigned int regData = *((volatile unsigned int *) (gpio_reg+0x10+0x24*port));
  149. int a = (regData>>bit)&0x1;
  150.  
  151. if (index) {
  152. printk("readGpio, %d %d\n", index, a);
  153. }
  154.  
  155. return a;
  156. }
  157.  
  158. static void writeGpio(unsigned int gpio_reg, int pio, int d)
  159. {
  160. int port = (pio>>5) & 0xf;
  161. int bit = (pio>>0) & 0x1f;
  162. int regOff = 0x10+0x24*port;
  163. unsigned int regData = *((volatile unsigned int *) (gpio_reg+regOff));
  164. if (d)
  165. regData |= (1<<bit);
  166. else
  167. regData &= ~(1<<bit);
  168. *((volatile unsigned int *) (gpio_reg+regOff)) = regData;
  169. return ;
  170. }
  171.  
  172. static void writeGpioCfg(unsigned int gpio_reg, int pio, bool out)
  173. {
  174. int port = (pio>>5) & 0x1f;
  175. int bit = (pio>>3) & 0x3;
  176. int bit0 = (pio>>0) & 0x7;
  177. int regOff = 0x00+0x24*port+0x04*bit;
  178. unsigned int regData = *((volatile unsigned int *) (gpio_reg+regOff));
  179.  
  180. int offset = bit0*4;
  181.  
  182. regData &= ~(0xf<<(offset));
  183. if(out)
  184. regData |= (0x01<<(offset));
  185. else
  186. regData |= (0x00<<(offset));
  187.  
  188. *((volatile unsigned int *) (gpio_reg+regOff)) = regData;
  189. return ;
  190. }
  191.  
  192.  
  193. enum{
  194.  
  195. VK_AXI_UP,
  196. VK_AXI_DOWN,
  197. VK_AXI_LEFT,
  198. VK_AXI_RIGHT,
  199. VK_BTN_START,
  200. VK_BTN_SELECT,
  201. VK_BTN_A,
  202. VK_BTN_B,
  203. VK_BTN_TR,
  204. VK_BTN_Y,
  205. VK_BTN_X,
  206. VK_BTN_TL,
  207.  
  208. NUM_VKS
  209.  
  210. };
  211.  
  212. static void mk_gpio_read_packet( unsigned char *data) {
  213. int i;
  214. unsigned long long int tmp_jiffies;
  215. tmp_jiffies = jiffies_to_msecs(jiffies - mk_jiffies);
  216.  
  217.  
  218. // PIO mapping
  219. // SETTING -- BTN_SELECT 1
  220. // COIN -- BTN_SELECT 0
  221. // 1P_START -- BTN_START 0
  222. // 1P_UP -- BTN_UP 0
  223. // 1P_DOWN -- BTN_DOWN 0
  224. // 1P_LEFT -- BTN_LEFT 0
  225. // 1P_RIGHT -- BTN_RIGHT 0
  226. // 1P_A -- BTN_A 0
  227. // 1P_B -- BTN_B 0
  228. // 1P_C -- BTN_TR 0
  229. // 1P_D -- BTN_Y 0
  230. // 1P_E -- BTN_X 0
  231. // 1P_F -- BTN_TL 0
  232. // 2P_START -- BTN_START 1
  233. // 2P_UP -- BTN_UP 1
  234. // 2P_DOWN -- BTN_DOWN 1
  235. // 2P_LEFT -- BTN_LEFT 1
  236. // 2P_RIGHT -- BTN_RIGHT 1
  237. // 2P_A -- BTN_A 1
  238. // 2P_B -- BTN_B 1
  239. // 2P_C -- BTN_TR 1
  240. // 2P_D -- BTN_Y 1
  241. // 2P_E -- BTN_X 1
  242. // 2P_F -- BTN_TL 1
  243.  
  244. unsigned int d;
  245. int idx;
  246.  
  247. // 0
  248. writeGpio(gpio, mk_arcade_gpio_maps[0], 0x00);
  249. writeGpio(gpio, mk_arcade_gpio_maps[1], 0x01);
  250. writeGpio(gpio, mk_arcade_gpio_maps[2], 0x01);
  251. writeGpio(gpio, mk_arcade_gpio_maps[3], 0x01);
  252. idx = VK_BTN_SELECT +NUM_VKS* 0; d=readGpio(gpio, mk_arcade_gpio_maps[4 ], 0);if(d==0)data[idx]=1; else data[idx]=0;
  253. idx = VK_BTN_SELECT +NUM_VKS* 1; d=readGpio(gpio, mk_arcade_gpio_maps[5 ], 0);if(d==0)data[idx]=1; else data[idx]=0;
  254. idx = VK_BTN_START +NUM_VKS* 0; d=readGpio(gpio, mk_arcade_gpio_maps[6 ], 0);if(d==0)data[idx]=1; else data[idx]=0;
  255. idx = VK_AXI_UP +NUM_VKS* 0; d=readGpio(gpio, mk_arcade_gpio_maps[7 ], 0);if(d==0)data[idx]=1; else data[idx]=0;
  256. idx = VK_AXI_DOWN +NUM_VKS* 0; d=readGpio(gpio, mk_arcade_gpio_maps[8 ], 0);if(d==0)data[idx]=1; else data[idx]=0;
  257. idx = VK_AXI_LEFT +NUM_VKS* 0; d=readGpio(gpio, mk_arcade_gpio_maps[9 ], 0);if(d==0)data[idx]=1; else data[idx]=0;
  258. idx = VK_AXI_RIGHT +NUM_VKS* 0; d=readGpio(gpio, mk_arcade_gpio_maps[10], 0);if(d==0)data[idx]=1; else data[idx]=0;
  259. idx = VK_BTN_A +NUM_VKS* 0; d=readGpio(gpio, mk_arcade_gpio_maps[11], 0);if(d==0)data[idx]=1; else data[idx]=0;
  260.  
  261. // 1
  262. writeGpio(gpio, mk_arcade_gpio_maps[0], 0x01);
  263. writeGpio(gpio, mk_arcade_gpio_maps[1], 0x00);
  264. writeGpio(gpio, mk_arcade_gpio_maps[2], 0x01);
  265. writeGpio(gpio, mk_arcade_gpio_maps[3], 0x01);
  266. idx = VK_BTN_B +NUM_VKS* 0; d=readGpio(gpio, mk_arcade_gpio_maps[4 ], 0);if(d==0)data[idx]=1; else data[idx]=0;
  267. idx = VK_BTN_TR +NUM_VKS* 0; d=readGpio(gpio, mk_arcade_gpio_maps[5 ], 0);if(d==0)data[idx]=1; else data[idx]=0;
  268. idx = VK_BTN_Y +NUM_VKS* 0; d=readGpio(gpio, mk_arcade_gpio_maps[6 ], 0);if(d==0)data[idx]=1; else data[idx]=0;
  269. idx = VK_BTN_X +NUM_VKS* 0; d=readGpio(gpio, mk_arcade_gpio_maps[7 ], 0);if(d==0)data[idx]=1; else data[idx]=0;
  270. idx = VK_BTN_TL +NUM_VKS* 0; d=readGpio(gpio, mk_arcade_gpio_maps[8 ], 0);if(d==0)data[idx]=1; else data[idx]=0;
  271. idx = VK_BTN_START +NUM_VKS* 1; d=readGpio(gpio, mk_arcade_gpio_maps[9 ], 0);if(d==0)data[idx]=1; else data[idx]=0;
  272. idx = VK_AXI_UP +NUM_VKS* 1; d=readGpio(gpio, mk_arcade_gpio_maps[10], 0);if(d==0)data[idx]=1; else data[idx]=0;
  273. idx = VK_AXI_DOWN +NUM_VKS* 1; d=readGpio(gpio, mk_arcade_gpio_maps[11], 0);if(d==0)data[idx]=1; else data[idx]=0;
  274.  
  275. // 2
  276. writeGpio(gpio, mk_arcade_gpio_maps[0], 0x01);
  277. writeGpio(gpio, mk_arcade_gpio_maps[1], 0x01);
  278. writeGpio(gpio, mk_arcade_gpio_maps[2], 0x00);
  279. writeGpio(gpio, mk_arcade_gpio_maps[3], 0x01);
  280. idx = VK_AXI_LEFT +NUM_VKS* 1; d=readGpio(gpio, mk_arcade_gpio_maps[4 ], 0);if(d==0)data[idx]=1; else data[idx]=0;
  281. idx = VK_AXI_RIGHT +NUM_VKS* 1; d=readGpio(gpio, mk_arcade_gpio_maps[5 ], 0);if(d==0)data[idx]=1; else data[idx]=0;
  282. idx = VK_BTN_A +NUM_VKS* 1; d=readGpio(gpio, mk_arcade_gpio_maps[6 ], 0);if(d==0)data[idx]=1; else data[idx]=0;
  283. idx = VK_BTN_B +NUM_VKS* 1; d=readGpio(gpio, mk_arcade_gpio_maps[7 ], 0);if(d==0)data[idx]=1; else data[idx]=0;
  284. idx = VK_BTN_TR +NUM_VKS* 1; d=readGpio(gpio, mk_arcade_gpio_maps[8 ], 0);if(d==0)data[idx]=1; else data[idx]=0;
  285. idx = VK_BTN_Y +NUM_VKS* 1; d=readGpio(gpio, mk_arcade_gpio_maps[9 ], 0);if(d==0)data[idx]=1; else data[idx]=0;
  286. idx = VK_BTN_X +NUM_VKS* 1; d=readGpio(gpio, mk_arcade_gpio_maps[10], 0);if(d==0)data[idx]=1; else data[idx]=0;
  287. idx = VK_BTN_TL +NUM_VKS* 1; d=readGpio(gpio, mk_arcade_gpio_maps[11], 0);if(d==0)data[idx]=1; else data[idx]=0;
  288.  
  289. mk_jiffies = jiffies;
  290.  
  291. }
  292.  
  293. static void mk_input_report(struct mk_pad * pad, unsigned char * data) {
  294. struct input_dev * dev = pad->dev;
  295. int j;
  296. input_report_abs(dev, ABS_Y, !data[0]-!data[1]);
  297. input_report_abs(dev, ABS_X, !data[2]-!data[3]);
  298. for (j = 4; j < mk_max_arcade_buttons; j++) {
  299. input_report_key(dev, mk_arcade_gpio_btn[j - 4], data[j]);
  300. }
  301. input_sync(dev);
  302. }
  303.  
  304. static void mk_process_packet(struct mk *mk) {
  305.  
  306. unsigned char data[mk_data_size];
  307.  
  308. mk_gpio_read_packet(data);
  309. mk_input_report(&mk->pads[0], &data[NUM_VKS*0]);
  310. mk_input_report(&mk->pads[1], &data[NUM_VKS*1]);
  311.  
  312. }
  313.  
  314. /*
  315. * mk_timer() initiates reads of console pads data.
  316. */
  317.  
  318. static void mk_timer(unsigned long private) {
  319. struct mk *mk = (void *) private;
  320. mk_process_packet(mk);
  321. mod_timer(&mk->timer, jiffies + MK_REFRESH_TIME);
  322. }
  323.  
  324. static int mk_open(struct input_dev *dev) {
  325. struct mk *mk = input_get_drvdata(dev);
  326. int err;
  327.  
  328. err = mutex_lock_interruptible(&mk->mutex);
  329. if (err)
  330. return err;
  331.  
  332. if (!mk->used++)
  333. mod_timer(&mk->timer, jiffies + MK_REFRESH_TIME);
  334.  
  335. mutex_unlock(&mk->mutex);
  336. return 0;
  337. }
  338.  
  339. static void mk_close(struct input_dev *dev) {
  340. struct mk *mk = input_get_drvdata(dev);
  341.  
  342. mutex_lock(&mk->mutex);
  343. if (!--mk->used) {
  344. del_timer_sync(&mk->timer);
  345. }
  346. mutex_unlock(&mk->mutex);
  347. }
  348.  
  349.  
  350. int readKey(int key_code) {
  351. int port = (key_code>>5) & 0xf;
  352. int bit = (key_code>>0) & 0x1f;
  353. printk("mk_port:%08x, bit:%08x\n", port, bit); //000007ff
  354. printk("mk_addr:%08x\n", (gpio+0x10+0x24*port)); //000007ff
  355. unsigned int regData = *((volatile unsigned int *) (gpio+0x10+0x24*port));
  356. printk("mk_regData:%08x\n", regData);
  357. printk("mk_regData (shift):%08x\n", (regData >> bit));
  358.  
  359. return (regData>>bit)&0x1;
  360. }
  361.  
  362. static int __init mk_setup_pad(struct mk *mk, int idx) {
  363. struct mk_pad *pad = &mk->pads[idx];
  364. struct input_dev *input_dev;
  365. int i;
  366. int err;
  367.  
  368. pad->dev = input_dev = input_allocate_device();
  369. if (!input_dev) {
  370. pr_err("Not enough memory for input device\n");
  371. return -ENOMEM;
  372. }
  373.  
  374. snprintf(pad->phys, sizeof (pad->phys),
  375. "input%d", idx);
  376.  
  377. input_dev->name = mk_names[idx];
  378. input_dev->phys = pad->phys;
  379. input_dev->id.bustype = BUS_PARPORT;
  380. input_dev->id.vendor = 0x0001;
  381. input_dev->id.product = idx;
  382. input_dev->id.version = 0x0100;
  383.  
  384. input_set_drvdata(input_dev, mk);
  385.  
  386. input_dev->open = mk_open;
  387. input_dev->close = mk_close;
  388.  
  389. input_dev->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS);
  390.  
  391. for (i = 0; i < 2; i++)
  392. input_set_abs_params(input_dev, ABS_X + i, -1, 1, 0, 0);
  393.  
  394. for (i = 0; i < (mk_max_arcade_buttons - 4); i++)
  395. __set_bit(mk_arcade_gpio_btn[i], input_dev->keybit);
  396.  
  397. printk("GPIO configured for pad%d\n", idx);
  398.  
  399.  
  400. err = input_register_device(pad->dev);
  401. if (err)
  402. goto err_free_dev;
  403.  
  404. return 0;
  405.  
  406. err_free_dev:
  407. input_free_device(pad->dev);
  408. pad->dev = NULL;
  409. return err;
  410. }
  411.  
  412. static struct mk __init *mk_probe() {
  413. struct mk *mk;
  414. int i;
  415. int count = 0;
  416. int err;
  417.  
  418. mk = kzalloc(sizeof (struct mk), GFP_KERNEL);
  419. if (!mk) {
  420. pr_err("Not enough memory\n");
  421. err = -ENOMEM;
  422. goto err_out;
  423. }
  424.  
  425. mutex_init(&mk->mutex);
  426. setup_timer(&mk->timer, mk_timer, (long) mk);
  427.  
  428. for (i = 0; i < MK_DEVICES; i++) {
  429.  
  430. err = mk_setup_pad(mk, i);
  431. if (err)
  432. goto err_unreg_devs;
  433.  
  434. count++;
  435. }
  436.  
  437. // initial gpio direction
  438. writeGpioCfg(gpio, mk_arcade_gpio_maps[0 ], true);
  439. writeGpioCfg(gpio, mk_arcade_gpio_maps[1 ], true);
  440. writeGpioCfg(gpio, mk_arcade_gpio_maps[2 ], true);
  441. writeGpioCfg(gpio, mk_arcade_gpio_maps[3 ], true);
  442.  
  443. writeGpioCfg(gpio, mk_arcade_gpio_maps[4 ], false);
  444. writeGpioCfg(gpio, mk_arcade_gpio_maps[5 ], false);
  445. writeGpioCfg(gpio, mk_arcade_gpio_maps[6 ], false);
  446. writeGpioCfg(gpio, mk_arcade_gpio_maps[7 ], false);
  447. writeGpioCfg(gpio, mk_arcade_gpio_maps[8 ], false);
  448. writeGpioCfg(gpio, mk_arcade_gpio_maps[9 ], false);
  449. writeGpioCfg(gpio, mk_arcade_gpio_maps[10], false);
  450. writeGpioCfg(gpio, mk_arcade_gpio_maps[11], false);
  451.  
  452.  
  453. if (count == 0) {
  454. pr_err("No valid devices specified\n");
  455. err = -EINVAL;
  456. goto err_free_mk;
  457. }
  458.  
  459.  
  460.  
  461. return mk;
  462.  
  463. err_unreg_devs:
  464. while (--i >= 0)
  465. if (mk->pads[i].dev)
  466. input_unregister_device(mk->pads[i].dev);
  467. err_free_mk:
  468. kfree(mk);
  469. err_out:
  470. return ERR_PTR(err);
  471. }
  472.  
  473. static void mk_remove(struct mk *mk) {
  474. int i;
  475.  
  476. for (i = 0; i < MK_DEVICES; i++)
  477. if (mk->pads[i].dev)
  478. input_unregister_device(mk->pads[i].dev);
  479. kfree(mk);
  480. }
  481.  
  482. static int __init mk_init(void) {
  483. /* Set up gpio pointer for direct register access */
  484. void* mem = NULL;
  485. unsigned int offset;
  486. printk("GPIO_BASE%08x\n", GPIO_BASE);
  487. dev_base = reg & (~(0x1000-1));
  488. printk("mk_dev_base:%08x\n", dev_base);
  489. if ((mem = ioremap(dev_base, 0x1000)) == NULL) {
  490. pr_err("io remap failed\n");
  491. return -EBUSY;
  492. }
  493. offset = reg & ( (0x1000-1));
  494. gpio = ((unsigned int)mem)+offset;
  495.  
  496. printk("mk_gpio_reg:%08x\n", gpio);
  497. mk_base = mk_probe();
  498. return 0;
  499. }
  500.  
  501. static void __exit mk_exit(void) {
  502. if (mk_base)
  503. mk_remove(mk_base);
  504.  
  505. iounmap(gpio);
  506. }
  507.  
  508. module_init(mk_init);
  509. module_exit(mk_exit);
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!