hid-wiimote-debug.c 4.7 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222
  1. // SPDX-License-Identifier: GPL-2.0-or-later
  2. /*
  3. * Debug support for HID Nintendo Wii / Wii U peripherals
  4. * Copyright (c) 2011-2013 David Herrmann <dh.herrmann@gmail.com>
  5. */
  6. /*
  7. */
  8. #include <linux/debugfs.h>
  9. #include <linux/module.h>
  10. #include <linux/seq_file.h>
  11. #include <linux/spinlock.h>
  12. #include <linux/uaccess.h>
  13. #include "hid-wiimote.h"
  14. struct wiimote_debug {
  15. struct wiimote_data *wdata;
  16. struct dentry *eeprom;
  17. struct dentry *drm;
  18. };
  19. static ssize_t wiidebug_eeprom_read(struct file *f, char __user *u, size_t s,
  20. loff_t *off)
  21. {
  22. struct wiimote_debug *dbg = f->private_data;
  23. struct wiimote_data *wdata = dbg->wdata;
  24. unsigned long flags;
  25. ssize_t ret;
  26. char buf[16];
  27. __u16 size = 0;
  28. if (s == 0)
  29. return -EINVAL;
  30. if (*off > 0xffffff)
  31. return 0;
  32. if (s > 16)
  33. s = 16;
  34. ret = wiimote_cmd_acquire(wdata);
  35. if (ret)
  36. return ret;
  37. spin_lock_irqsave(&wdata->state.lock, flags);
  38. wdata->state.cmd_read_size = s;
  39. wdata->state.cmd_read_buf = buf;
  40. wiimote_cmd_set(wdata, WIIPROTO_REQ_RMEM, *off & 0xffff);
  41. wiiproto_req_reeprom(wdata, *off, s);
  42. spin_unlock_irqrestore(&wdata->state.lock, flags);
  43. ret = wiimote_cmd_wait(wdata);
  44. if (!ret)
  45. size = wdata->state.cmd_read_size;
  46. spin_lock_irqsave(&wdata->state.lock, flags);
  47. wdata->state.cmd_read_buf = NULL;
  48. spin_unlock_irqrestore(&wdata->state.lock, flags);
  49. wiimote_cmd_release(wdata);
  50. if (ret)
  51. return ret;
  52. else if (size == 0)
  53. return -EIO;
  54. if (copy_to_user(u, buf, size))
  55. return -EFAULT;
  56. *off += size;
  57. ret = size;
  58. return ret;
  59. }
  60. static const struct file_operations wiidebug_eeprom_fops = {
  61. .owner = THIS_MODULE,
  62. .open = simple_open,
  63. .read = wiidebug_eeprom_read,
  64. .llseek = generic_file_llseek,
  65. };
  66. static const char *wiidebug_drmmap[] = {
  67. [WIIPROTO_REQ_NULL] = "NULL",
  68. [WIIPROTO_REQ_DRM_K] = "K",
  69. [WIIPROTO_REQ_DRM_KA] = "KA",
  70. [WIIPROTO_REQ_DRM_KE] = "KE",
  71. [WIIPROTO_REQ_DRM_KAI] = "KAI",
  72. [WIIPROTO_REQ_DRM_KEE] = "KEE",
  73. [WIIPROTO_REQ_DRM_KAE] = "KAE",
  74. [WIIPROTO_REQ_DRM_KIE] = "KIE",
  75. [WIIPROTO_REQ_DRM_KAIE] = "KAIE",
  76. [WIIPROTO_REQ_DRM_E] = "E",
  77. [WIIPROTO_REQ_DRM_SKAI1] = "SKAI1",
  78. [WIIPROTO_REQ_DRM_SKAI2] = "SKAI2",
  79. [WIIPROTO_REQ_MAX] = NULL
  80. };
  81. static int wiidebug_drm_show(struct seq_file *f, void *p)
  82. {
  83. struct wiimote_debug *dbg = f->private;
  84. const char *str = NULL;
  85. unsigned long flags;
  86. __u8 drm;
  87. spin_lock_irqsave(&dbg->wdata->state.lock, flags);
  88. drm = dbg->wdata->state.drm;
  89. spin_unlock_irqrestore(&dbg->wdata->state.lock, flags);
  90. if (drm < WIIPROTO_REQ_MAX)
  91. str = wiidebug_drmmap[drm];
  92. if (!str)
  93. str = "unknown";
  94. seq_printf(f, "%s\n", str);
  95. return 0;
  96. }
  97. static int wiidebug_drm_open(struct inode *i, struct file *f)
  98. {
  99. return single_open(f, wiidebug_drm_show, i->i_private);
  100. }
  101. static ssize_t wiidebug_drm_write(struct file *f, const char __user *u,
  102. size_t s, loff_t *off)
  103. {
  104. struct seq_file *sf = f->private_data;
  105. struct wiimote_debug *dbg = sf->private;
  106. unsigned long flags;
  107. char buf[16];
  108. ssize_t len;
  109. int i;
  110. if (s == 0)
  111. return -EINVAL;
  112. len = min((size_t) 15, s);
  113. if (copy_from_user(buf, u, len))
  114. return -EFAULT;
  115. buf[len] = 0;
  116. for (i = 0; i < WIIPROTO_REQ_MAX; ++i) {
  117. if (!wiidebug_drmmap[i])
  118. continue;
  119. if (!strcasecmp(buf, wiidebug_drmmap[i]))
  120. break;
  121. }
  122. if (i == WIIPROTO_REQ_MAX)
  123. i = simple_strtoul(buf, NULL, 16);
  124. spin_lock_irqsave(&dbg->wdata->state.lock, flags);
  125. dbg->wdata->state.flags &= ~WIIPROTO_FLAG_DRM_LOCKED;
  126. wiiproto_req_drm(dbg->wdata, (__u8) i);
  127. if (i != WIIPROTO_REQ_NULL)
  128. dbg->wdata->state.flags |= WIIPROTO_FLAG_DRM_LOCKED;
  129. spin_unlock_irqrestore(&dbg->wdata->state.lock, flags);
  130. return len;
  131. }
  132. static const struct file_operations wiidebug_drm_fops = {
  133. .owner = THIS_MODULE,
  134. .open = wiidebug_drm_open,
  135. .read = seq_read,
  136. .llseek = seq_lseek,
  137. .write = wiidebug_drm_write,
  138. .release = single_release,
  139. };
  140. int wiidebug_init(struct wiimote_data *wdata)
  141. {
  142. struct wiimote_debug *dbg;
  143. unsigned long flags;
  144. int ret = -ENOMEM;
  145. dbg = kzalloc(sizeof(*dbg), GFP_KERNEL);
  146. if (!dbg)
  147. return -ENOMEM;
  148. dbg->wdata = wdata;
  149. dbg->eeprom = debugfs_create_file("eeprom", S_IRUSR,
  150. dbg->wdata->hdev->debug_dir, dbg, &wiidebug_eeprom_fops);
  151. if (!dbg->eeprom)
  152. goto err;
  153. dbg->drm = debugfs_create_file("drm", S_IRUSR,
  154. dbg->wdata->hdev->debug_dir, dbg, &wiidebug_drm_fops);
  155. if (!dbg->drm)
  156. goto err_drm;
  157. spin_lock_irqsave(&wdata->state.lock, flags);
  158. wdata->debug = dbg;
  159. spin_unlock_irqrestore(&wdata->state.lock, flags);
  160. return 0;
  161. err_drm:
  162. debugfs_remove(dbg->eeprom);
  163. err:
  164. kfree(dbg);
  165. return ret;
  166. }
  167. void wiidebug_deinit(struct wiimote_data *wdata)
  168. {
  169. struct wiimote_debug *dbg = wdata->debug;
  170. unsigned long flags;
  171. if (!dbg)
  172. return;
  173. spin_lock_irqsave(&wdata->state.lock, flags);
  174. wdata->debug = NULL;
  175. spin_unlock_irqrestore(&wdata->state.lock, flags);
  176. debugfs_remove(dbg->drm);
  177. debugfs_remove(dbg->eeprom);
  178. kfree(dbg);
  179. }