tb0219.c 7.1 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359
  1. // SPDX-License-Identifier: GPL-2.0-or-later
  2. /*
  3. * Driver for TANBAC TB0219 base board.
  4. *
  5. * Copyright (C) 2005 Yoichi Yuasa <yuasa@linux-mips.org>
  6. */
  7. #include <linux/platform_device.h>
  8. #include <linux/fs.h>
  9. #include <linux/init.h>
  10. #include <linux/module.h>
  11. #include <linux/uaccess.h>
  12. #include <asm/io.h>
  13. #include <asm/reboot.h>
  14. #include <asm/vr41xx/giu.h>
  15. #include <asm/vr41xx/tb0219.h>
  16. MODULE_AUTHOR("Yoichi Yuasa <yuasa@linux-mips.org>");
  17. MODULE_DESCRIPTION("TANBAC TB0219 base board driver");
  18. MODULE_LICENSE("GPL");
  19. static int major; /* default is dynamic major device number */
  20. module_param(major, int, 0);
  21. MODULE_PARM_DESC(major, "Major device number");
  22. static void (*old_machine_restart)(char *command);
  23. static void __iomem *tb0219_base;
  24. static DEFINE_SPINLOCK(tb0219_lock);
  25. #define tb0219_read(offset) readw(tb0219_base + (offset))
  26. #define tb0219_write(offset, value) writew((value), tb0219_base + (offset))
  27. #define TB0219_START 0x0a000000UL
  28. #define TB0219_SIZE 0x20UL
  29. #define TB0219_LED 0x00
  30. #define TB0219_GPIO_INPUT 0x02
  31. #define TB0219_GPIO_OUTPUT 0x04
  32. #define TB0219_DIP_SWITCH 0x06
  33. #define TB0219_MISC 0x08
  34. #define TB0219_RESET 0x0e
  35. #define TB0219_PCI_SLOT1_IRQ_STATUS 0x10
  36. #define TB0219_PCI_SLOT2_IRQ_STATUS 0x12
  37. #define TB0219_PCI_SLOT3_IRQ_STATUS 0x14
  38. typedef enum {
  39. TYPE_LED,
  40. TYPE_GPIO_OUTPUT,
  41. } tb0219_type_t;
  42. /*
  43. * Minor device number
  44. * 0 = 7 segment LED
  45. *
  46. * 16 = GPIO IN 0
  47. * 17 = GPIO IN 1
  48. * 18 = GPIO IN 2
  49. * 19 = GPIO IN 3
  50. * 20 = GPIO IN 4
  51. * 21 = GPIO IN 5
  52. * 22 = GPIO IN 6
  53. * 23 = GPIO IN 7
  54. *
  55. * 32 = GPIO OUT 0
  56. * 33 = GPIO OUT 1
  57. * 34 = GPIO OUT 2
  58. * 35 = GPIO OUT 3
  59. * 36 = GPIO OUT 4
  60. * 37 = GPIO OUT 5
  61. * 38 = GPIO OUT 6
  62. * 39 = GPIO OUT 7
  63. *
  64. * 48 = DIP switch 1
  65. * 49 = DIP switch 2
  66. * 50 = DIP switch 3
  67. * 51 = DIP switch 4
  68. * 52 = DIP switch 5
  69. * 53 = DIP switch 6
  70. * 54 = DIP switch 7
  71. * 55 = DIP switch 8
  72. */
  73. static inline char get_led(void)
  74. {
  75. return (char)tb0219_read(TB0219_LED);
  76. }
  77. static inline char get_gpio_input_pin(unsigned int pin)
  78. {
  79. uint16_t values;
  80. values = tb0219_read(TB0219_GPIO_INPUT);
  81. if (values & (1 << pin))
  82. return '1';
  83. return '0';
  84. }
  85. static inline char get_gpio_output_pin(unsigned int pin)
  86. {
  87. uint16_t values;
  88. values = tb0219_read(TB0219_GPIO_OUTPUT);
  89. if (values & (1 << pin))
  90. return '1';
  91. return '0';
  92. }
  93. static inline char get_dip_switch(unsigned int pin)
  94. {
  95. uint16_t values;
  96. values = tb0219_read(TB0219_DIP_SWITCH);
  97. if (values & (1 << pin))
  98. return '1';
  99. return '0';
  100. }
  101. static inline int set_led(char command)
  102. {
  103. tb0219_write(TB0219_LED, command);
  104. return 0;
  105. }
  106. static inline int set_gpio_output_pin(unsigned int pin, char command)
  107. {
  108. unsigned long flags;
  109. uint16_t value;
  110. if (command != '0' && command != '1')
  111. return -EINVAL;
  112. spin_lock_irqsave(&tb0219_lock, flags);
  113. value = tb0219_read(TB0219_GPIO_OUTPUT);
  114. if (command == '0')
  115. value &= ~(1 << pin);
  116. else
  117. value |= 1 << pin;
  118. tb0219_write(TB0219_GPIO_OUTPUT, value);
  119. spin_unlock_irqrestore(&tb0219_lock, flags);
  120. return 0;
  121. }
  122. static ssize_t tanbac_tb0219_read(struct file *file, char __user *buf, size_t len,
  123. loff_t *ppos)
  124. {
  125. unsigned int minor;
  126. char value;
  127. minor = iminor(file_inode(file));
  128. switch (minor) {
  129. case 0:
  130. value = get_led();
  131. break;
  132. case 16 ... 23:
  133. value = get_gpio_input_pin(minor - 16);
  134. break;
  135. case 32 ... 39:
  136. value = get_gpio_output_pin(minor - 32);
  137. break;
  138. case 48 ... 55:
  139. value = get_dip_switch(minor - 48);
  140. break;
  141. default:
  142. return -EBADF;
  143. }
  144. if (len <= 0)
  145. return -EFAULT;
  146. if (put_user(value, buf))
  147. return -EFAULT;
  148. return 1;
  149. }
  150. static ssize_t tanbac_tb0219_write(struct file *file, const char __user *data,
  151. size_t len, loff_t *ppos)
  152. {
  153. unsigned int minor;
  154. tb0219_type_t type;
  155. size_t i;
  156. int retval = 0;
  157. char c;
  158. minor = iminor(file_inode(file));
  159. switch (minor) {
  160. case 0:
  161. type = TYPE_LED;
  162. break;
  163. case 32 ... 39:
  164. type = TYPE_GPIO_OUTPUT;
  165. break;
  166. default:
  167. return -EBADF;
  168. }
  169. for (i = 0; i < len; i++) {
  170. if (get_user(c, data + i))
  171. return -EFAULT;
  172. switch (type) {
  173. case TYPE_LED:
  174. retval = set_led(c);
  175. break;
  176. case TYPE_GPIO_OUTPUT:
  177. retval = set_gpio_output_pin(minor - 32, c);
  178. break;
  179. }
  180. if (retval < 0)
  181. break;
  182. }
  183. return i;
  184. }
  185. static int tanbac_tb0219_open(struct inode *inode, struct file *file)
  186. {
  187. unsigned int minor;
  188. minor = iminor(inode);
  189. switch (minor) {
  190. case 0:
  191. case 16 ... 23:
  192. case 32 ... 39:
  193. case 48 ... 55:
  194. return stream_open(inode, file);
  195. default:
  196. break;
  197. }
  198. return -EBADF;
  199. }
  200. static int tanbac_tb0219_release(struct inode *inode, struct file *file)
  201. {
  202. return 0;
  203. }
  204. static const struct file_operations tb0219_fops = {
  205. .owner = THIS_MODULE,
  206. .read = tanbac_tb0219_read,
  207. .write = tanbac_tb0219_write,
  208. .open = tanbac_tb0219_open,
  209. .release = tanbac_tb0219_release,
  210. .llseek = no_llseek,
  211. };
  212. static void tb0219_restart(char *command)
  213. {
  214. tb0219_write(TB0219_RESET, 0);
  215. }
  216. static void tb0219_pci_irq_init(void)
  217. {
  218. /* PCI Slot 1 */
  219. vr41xx_set_irq_trigger(TB0219_PCI_SLOT1_PIN, IRQ_TRIGGER_LEVEL, IRQ_SIGNAL_THROUGH);
  220. vr41xx_set_irq_level(TB0219_PCI_SLOT1_PIN, IRQ_LEVEL_LOW);
  221. /* PCI Slot 2 */
  222. vr41xx_set_irq_trigger(TB0219_PCI_SLOT2_PIN, IRQ_TRIGGER_LEVEL, IRQ_SIGNAL_THROUGH);
  223. vr41xx_set_irq_level(TB0219_PCI_SLOT2_PIN, IRQ_LEVEL_LOW);
  224. /* PCI Slot 3 */
  225. vr41xx_set_irq_trigger(TB0219_PCI_SLOT3_PIN, IRQ_TRIGGER_LEVEL, IRQ_SIGNAL_THROUGH);
  226. vr41xx_set_irq_level(TB0219_PCI_SLOT3_PIN, IRQ_LEVEL_LOW);
  227. }
  228. static int tb0219_probe(struct platform_device *dev)
  229. {
  230. int retval;
  231. if (request_mem_region(TB0219_START, TB0219_SIZE, "TB0219") == NULL)
  232. return -EBUSY;
  233. tb0219_base = ioremap(TB0219_START, TB0219_SIZE);
  234. if (tb0219_base == NULL) {
  235. release_mem_region(TB0219_START, TB0219_SIZE);
  236. return -ENOMEM;
  237. }
  238. retval = register_chrdev(major, "TB0219", &tb0219_fops);
  239. if (retval < 0) {
  240. iounmap(tb0219_base);
  241. tb0219_base = NULL;
  242. release_mem_region(TB0219_START, TB0219_SIZE);
  243. return retval;
  244. }
  245. old_machine_restart = _machine_restart;
  246. _machine_restart = tb0219_restart;
  247. tb0219_pci_irq_init();
  248. if (major == 0) {
  249. major = retval;
  250. printk(KERN_INFO "TB0219: major number %d\n", major);
  251. }
  252. return 0;
  253. }
  254. static int tb0219_remove(struct platform_device *dev)
  255. {
  256. _machine_restart = old_machine_restart;
  257. iounmap(tb0219_base);
  258. tb0219_base = NULL;
  259. release_mem_region(TB0219_START, TB0219_SIZE);
  260. return 0;
  261. }
  262. static struct platform_device *tb0219_platform_device;
  263. static struct platform_driver tb0219_device_driver = {
  264. .probe = tb0219_probe,
  265. .remove = tb0219_remove,
  266. .driver = {
  267. .name = "TB0219",
  268. },
  269. };
  270. static int __init tanbac_tb0219_init(void)
  271. {
  272. int retval;
  273. tb0219_platform_device = platform_device_alloc("TB0219", -1);
  274. if (!tb0219_platform_device)
  275. return -ENOMEM;
  276. retval = platform_device_add(tb0219_platform_device);
  277. if (retval < 0) {
  278. platform_device_put(tb0219_platform_device);
  279. return retval;
  280. }
  281. retval = platform_driver_register(&tb0219_device_driver);
  282. if (retval < 0)
  283. platform_device_unregister(tb0219_platform_device);
  284. return retval;
  285. }
  286. static void __exit tanbac_tb0219_exit(void)
  287. {
  288. platform_driver_unregister(&tb0219_device_driver);
  289. platform_device_unregister(tb0219_platform_device);
  290. }
  291. module_init(tanbac_tb0219_init);
  292. module_exit(tanbac_tb0219_exit);