electra_cf.c 7.6 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352
  1. // SPDX-License-Identifier: GPL-2.0-or-later
  2. /*
  3. * Copyright (C) 2007 PA Semi, Inc
  4. *
  5. * Maintained by: Olof Johansson <olof@lixom.net>
  6. *
  7. * Based on drivers/pcmcia/omap_cf.c
  8. */
  9. #include <linux/module.h>
  10. #include <linux/kernel.h>
  11. #include <linux/sched.h>
  12. #include <linux/platform_device.h>
  13. #include <linux/errno.h>
  14. #include <linux/init.h>
  15. #include <linux/delay.h>
  16. #include <linux/interrupt.h>
  17. #include <linux/mm.h>
  18. #include <linux/vmalloc.h>
  19. #include <linux/of_address.h>
  20. #include <linux/of_irq.h>
  21. #include <linux/of_platform.h>
  22. #include <linux/slab.h>
  23. #include <pcmcia/ss.h>
  24. static const char driver_name[] = "electra-cf";
  25. struct electra_cf_socket {
  26. struct pcmcia_socket socket;
  27. struct timer_list timer;
  28. unsigned present:1;
  29. unsigned active:1;
  30. struct platform_device *ofdev;
  31. unsigned long mem_phys;
  32. void __iomem *mem_base;
  33. unsigned long mem_size;
  34. void __iomem *io_virt;
  35. unsigned int io_base;
  36. unsigned int io_size;
  37. u_int irq;
  38. struct resource iomem;
  39. void __iomem *gpio_base;
  40. int gpio_detect;
  41. int gpio_vsense;
  42. int gpio_3v;
  43. int gpio_5v;
  44. };
  45. #define POLL_INTERVAL (2 * HZ)
  46. static int electra_cf_present(struct electra_cf_socket *cf)
  47. {
  48. unsigned int gpio;
  49. gpio = in_le32(cf->gpio_base+0x40);
  50. return !(gpio & (1 << cf->gpio_detect));
  51. }
  52. static int electra_cf_ss_init(struct pcmcia_socket *s)
  53. {
  54. return 0;
  55. }
  56. /* the timer is primarily to kick this socket's pccardd */
  57. static void electra_cf_timer(struct timer_list *t)
  58. {
  59. struct electra_cf_socket *cf = from_timer(cf, t, timer);
  60. int present = electra_cf_present(cf);
  61. if (present != cf->present) {
  62. cf->present = present;
  63. pcmcia_parse_events(&cf->socket, SS_DETECT);
  64. }
  65. if (cf->active)
  66. mod_timer(&cf->timer, jiffies + POLL_INTERVAL);
  67. }
  68. static irqreturn_t electra_cf_irq(int irq, void *_cf)
  69. {
  70. struct electra_cf_socket *cf = _cf;
  71. electra_cf_timer(&cf->timer);
  72. return IRQ_HANDLED;
  73. }
  74. static int electra_cf_get_status(struct pcmcia_socket *s, u_int *sp)
  75. {
  76. struct electra_cf_socket *cf;
  77. if (!sp)
  78. return -EINVAL;
  79. cf = container_of(s, struct electra_cf_socket, socket);
  80. /* NOTE CF is always 3VCARD */
  81. if (electra_cf_present(cf)) {
  82. *sp = SS_READY | SS_DETECT | SS_POWERON | SS_3VCARD;
  83. s->pci_irq = cf->irq;
  84. } else
  85. *sp = 0;
  86. return 0;
  87. }
  88. static int electra_cf_set_socket(struct pcmcia_socket *sock,
  89. struct socket_state_t *s)
  90. {
  91. unsigned int gpio;
  92. unsigned int vcc;
  93. struct electra_cf_socket *cf;
  94. cf = container_of(sock, struct electra_cf_socket, socket);
  95. /* "reset" means no power in our case */
  96. vcc = (s->flags & SS_RESET) ? 0 : s->Vcc;
  97. switch (vcc) {
  98. case 0:
  99. gpio = 0;
  100. break;
  101. case 33:
  102. gpio = (1 << cf->gpio_3v);
  103. break;
  104. case 5:
  105. gpio = (1 << cf->gpio_5v);
  106. break;
  107. default:
  108. return -EINVAL;
  109. }
  110. gpio |= 1 << (cf->gpio_3v + 16); /* enwr */
  111. gpio |= 1 << (cf->gpio_5v + 16); /* enwr */
  112. out_le32(cf->gpio_base+0x90, gpio);
  113. pr_debug("%s: Vcc %d, io_irq %d, flags %04x csc %04x\n",
  114. driver_name, s->Vcc, s->io_irq, s->flags, s->csc_mask);
  115. return 0;
  116. }
  117. static int electra_cf_set_io_map(struct pcmcia_socket *s,
  118. struct pccard_io_map *io)
  119. {
  120. return 0;
  121. }
  122. static int electra_cf_set_mem_map(struct pcmcia_socket *s,
  123. struct pccard_mem_map *map)
  124. {
  125. struct electra_cf_socket *cf;
  126. if (map->card_start)
  127. return -EINVAL;
  128. cf = container_of(s, struct electra_cf_socket, socket);
  129. map->static_start = cf->mem_phys;
  130. map->flags &= MAP_ACTIVE|MAP_ATTRIB;
  131. if (!(map->flags & MAP_ATTRIB))
  132. map->static_start += 0x800;
  133. return 0;
  134. }
  135. static struct pccard_operations electra_cf_ops = {
  136. .init = electra_cf_ss_init,
  137. .get_status = electra_cf_get_status,
  138. .set_socket = electra_cf_set_socket,
  139. .set_io_map = electra_cf_set_io_map,
  140. .set_mem_map = electra_cf_set_mem_map,
  141. };
  142. static int electra_cf_probe(struct platform_device *ofdev)
  143. {
  144. struct device *device = &ofdev->dev;
  145. struct device_node *np = ofdev->dev.of_node;
  146. struct electra_cf_socket *cf;
  147. struct resource mem, io;
  148. int status = -ENOMEM;
  149. const unsigned int *prop;
  150. int err;
  151. err = of_address_to_resource(np, 0, &mem);
  152. if (err)
  153. return -EINVAL;
  154. err = of_address_to_resource(np, 1, &io);
  155. if (err)
  156. return -EINVAL;
  157. cf = kzalloc(sizeof(*cf), GFP_KERNEL);
  158. if (!cf)
  159. return -ENOMEM;
  160. timer_setup(&cf->timer, electra_cf_timer, 0);
  161. cf->irq = 0;
  162. cf->ofdev = ofdev;
  163. cf->mem_phys = mem.start;
  164. cf->mem_size = PAGE_ALIGN(resource_size(&mem));
  165. cf->mem_base = ioremap(cf->mem_phys, cf->mem_size);
  166. if (!cf->mem_base)
  167. goto out_free_cf;
  168. cf->io_size = PAGE_ALIGN(resource_size(&io));
  169. cf->io_virt = ioremap_phb(io.start, cf->io_size);
  170. if (!cf->io_virt)
  171. goto out_unmap_mem;
  172. cf->gpio_base = ioremap(0xfc103000, 0x1000);
  173. if (!cf->gpio_base)
  174. goto out_unmap_virt;
  175. dev_set_drvdata(device, cf);
  176. cf->io_base = (unsigned long)cf->io_virt - VMALLOC_END;
  177. cf->iomem.start = (unsigned long)cf->mem_base;
  178. cf->iomem.end = (unsigned long)cf->mem_base + (mem.end - mem.start);
  179. cf->iomem.flags = IORESOURCE_MEM;
  180. cf->irq = irq_of_parse_and_map(np, 0);
  181. status = request_irq(cf->irq, electra_cf_irq, IRQF_SHARED,
  182. driver_name, cf);
  183. if (status < 0) {
  184. dev_err(device, "request_irq failed\n");
  185. goto fail1;
  186. }
  187. cf->socket.pci_irq = cf->irq;
  188. prop = of_get_property(np, "card-detect-gpio", NULL);
  189. if (!prop)
  190. goto fail1;
  191. cf->gpio_detect = *prop;
  192. prop = of_get_property(np, "card-vsense-gpio", NULL);
  193. if (!prop)
  194. goto fail1;
  195. cf->gpio_vsense = *prop;
  196. prop = of_get_property(np, "card-3v-gpio", NULL);
  197. if (!prop)
  198. goto fail1;
  199. cf->gpio_3v = *prop;
  200. prop = of_get_property(np, "card-5v-gpio", NULL);
  201. if (!prop)
  202. goto fail1;
  203. cf->gpio_5v = *prop;
  204. cf->socket.io_offset = cf->io_base;
  205. /* reserve chip-select regions */
  206. if (!request_mem_region(cf->mem_phys, cf->mem_size, driver_name)) {
  207. status = -ENXIO;
  208. dev_err(device, "Can't claim memory region\n");
  209. goto fail1;
  210. }
  211. if (!request_region(cf->io_base, cf->io_size, driver_name)) {
  212. status = -ENXIO;
  213. dev_err(device, "Can't claim I/O region\n");
  214. goto fail2;
  215. }
  216. cf->socket.owner = THIS_MODULE;
  217. cf->socket.dev.parent = &ofdev->dev;
  218. cf->socket.ops = &electra_cf_ops;
  219. cf->socket.resource_ops = &pccard_static_ops;
  220. cf->socket.features = SS_CAP_PCCARD | SS_CAP_STATIC_MAP |
  221. SS_CAP_MEM_ALIGN;
  222. cf->socket.map_size = 0x800;
  223. status = pcmcia_register_socket(&cf->socket);
  224. if (status < 0) {
  225. dev_err(device, "pcmcia_register_socket failed\n");
  226. goto fail3;
  227. }
  228. dev_info(device, "at mem 0x%lx io 0x%llx irq %d\n",
  229. cf->mem_phys, io.start, cf->irq);
  230. cf->active = 1;
  231. electra_cf_timer(&cf->timer);
  232. return 0;
  233. fail3:
  234. release_region(cf->io_base, cf->io_size);
  235. fail2:
  236. release_mem_region(cf->mem_phys, cf->mem_size);
  237. fail1:
  238. if (cf->irq)
  239. free_irq(cf->irq, cf);
  240. iounmap(cf->gpio_base);
  241. out_unmap_virt:
  242. device_init_wakeup(&ofdev->dev, 0);
  243. iounmap(cf->io_virt);
  244. out_unmap_mem:
  245. iounmap(cf->mem_base);
  246. out_free_cf:
  247. kfree(cf);
  248. return status;
  249. }
  250. static int electra_cf_remove(struct platform_device *ofdev)
  251. {
  252. struct device *device = &ofdev->dev;
  253. struct electra_cf_socket *cf;
  254. cf = dev_get_drvdata(device);
  255. cf->active = 0;
  256. pcmcia_unregister_socket(&cf->socket);
  257. free_irq(cf->irq, cf);
  258. del_timer_sync(&cf->timer);
  259. iounmap(cf->io_virt);
  260. iounmap(cf->mem_base);
  261. iounmap(cf->gpio_base);
  262. release_mem_region(cf->mem_phys, cf->mem_size);
  263. release_region(cf->io_base, cf->io_size);
  264. kfree(cf);
  265. return 0;
  266. }
  267. static const struct of_device_id electra_cf_match[] = {
  268. {
  269. .compatible = "electra-cf",
  270. },
  271. {},
  272. };
  273. MODULE_DEVICE_TABLE(of, electra_cf_match);
  274. static struct platform_driver electra_cf_driver = {
  275. .driver = {
  276. .name = driver_name,
  277. .of_match_table = electra_cf_match,
  278. },
  279. .probe = electra_cf_probe,
  280. .remove = electra_cf_remove,
  281. };
  282. module_platform_driver(electra_cf_driver);
  283. MODULE_LICENSE("GPL");
  284. MODULE_AUTHOR("Olof Johansson <olof@lixom.net>");
  285. MODULE_DESCRIPTION("PA Semi Electra CF driver");