db1xxx_ss.c 15 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603
  1. // SPDX-License-Identifier: GPL-2.0-only
  2. /*
  3. * PCMCIA socket code for the Alchemy Db1xxx/Pb1xxx boards.
  4. *
  5. * Copyright (c) 2009 Manuel Lauss <manuel.lauss@gmail.com>
  6. *
  7. */
  8. /* This is a fairly generic PCMCIA socket driver suitable for the
  9. * following Alchemy Development boards:
  10. * Db1000, Db/Pb1500, Db/Pb1100, Db/Pb1550, Db/Pb1200, Db1300
  11. *
  12. * The Db1000 is used as a reference: Per-socket card-, carddetect- and
  13. * statuschange IRQs connected to SoC GPIOs, control and status register
  14. * bits arranged in per-socket groups in an external PLD. All boards
  15. * listed here use this layout, including bit positions and meanings.
  16. * Of course there are exceptions in later boards:
  17. *
  18. * - Pb1100/Pb1500: single socket only; voltage key bits VS are
  19. * at STATUS[5:4] (instead of STATUS[1:0]).
  20. * - Au1200-based: additional card-eject irqs, irqs not gpios!
  21. * - Db1300: Db1200-like, no pwr ctrl, single socket (#1).
  22. */
  23. #include <linux/delay.h>
  24. #include <linux/gpio.h>
  25. #include <linux/interrupt.h>
  26. #include <linux/pm.h>
  27. #include <linux/module.h>
  28. #include <linux/platform_device.h>
  29. #include <linux/resource.h>
  30. #include <linux/slab.h>
  31. #include <linux/spinlock.h>
  32. #include <pcmcia/ss.h>
  33. #include <asm/mach-au1x00/au1000.h>
  34. #include <asm/mach-db1x00/bcsr.h>
  35. #define MEM_MAP_SIZE 0x400000
  36. #define IO_MAP_SIZE 0x1000
  37. struct db1x_pcmcia_sock {
  38. struct pcmcia_socket socket;
  39. int nr; /* socket number */
  40. void *virt_io;
  41. phys_addr_t phys_io;
  42. phys_addr_t phys_attr;
  43. phys_addr_t phys_mem;
  44. /* previous flags for set_socket() */
  45. unsigned int old_flags;
  46. /* interrupt sources: linux irq numbers! */
  47. int insert_irq; /* default carddetect irq */
  48. int stschg_irq; /* card-status-change irq */
  49. int card_irq; /* card irq */
  50. int eject_irq; /* db1200/pb1200 have these */
  51. int insert_gpio; /* db1000 carddetect gpio */
  52. #define BOARD_TYPE_DEFAULT 0 /* most boards */
  53. #define BOARD_TYPE_DB1200 1 /* IRQs aren't gpios */
  54. #define BOARD_TYPE_PB1100 2 /* VS bits slightly different */
  55. #define BOARD_TYPE_DB1300 3 /* no power control */
  56. int board_type;
  57. };
  58. #define to_db1x_socket(x) container_of(x, struct db1x_pcmcia_sock, socket)
  59. static int db1300_card_inserted(struct db1x_pcmcia_sock *sock)
  60. {
  61. return bcsr_read(BCSR_SIGSTAT) & (1 << 8);
  62. }
  63. /* DB/PB1200: check CPLD SIGSTATUS register bit 10/12 */
  64. static int db1200_card_inserted(struct db1x_pcmcia_sock *sock)
  65. {
  66. unsigned short sigstat;
  67. sigstat = bcsr_read(BCSR_SIGSTAT);
  68. return sigstat & 1 << (8 + 2 * sock->nr);
  69. }
  70. /* carddetect gpio: low-active */
  71. static int db1000_card_inserted(struct db1x_pcmcia_sock *sock)
  72. {
  73. return !gpio_get_value(sock->insert_gpio);
  74. }
  75. static int db1x_card_inserted(struct db1x_pcmcia_sock *sock)
  76. {
  77. switch (sock->board_type) {
  78. case BOARD_TYPE_DB1200:
  79. return db1200_card_inserted(sock);
  80. case BOARD_TYPE_DB1300:
  81. return db1300_card_inserted(sock);
  82. default:
  83. return db1000_card_inserted(sock);
  84. }
  85. }
  86. /* STSCHG tends to bounce heavily when cards are inserted/ejected.
  87. * To avoid this, the interrupt is normally disabled and only enabled
  88. * after reset to a card has been de-asserted.
  89. */
  90. static inline void set_stschg(struct db1x_pcmcia_sock *sock, int en)
  91. {
  92. if (sock->stschg_irq != -1) {
  93. if (en)
  94. enable_irq(sock->stschg_irq);
  95. else
  96. disable_irq(sock->stschg_irq);
  97. }
  98. }
  99. static irqreturn_t db1000_pcmcia_cdirq(int irq, void *data)
  100. {
  101. struct db1x_pcmcia_sock *sock = data;
  102. pcmcia_parse_events(&sock->socket, SS_DETECT);
  103. return IRQ_HANDLED;
  104. }
  105. static irqreturn_t db1000_pcmcia_stschgirq(int irq, void *data)
  106. {
  107. struct db1x_pcmcia_sock *sock = data;
  108. pcmcia_parse_events(&sock->socket, SS_STSCHG);
  109. return IRQ_HANDLED;
  110. }
  111. /* Db/Pb1200 have separate per-socket insertion and ejection
  112. * interrupts which stay asserted as long as the card is
  113. * inserted/missing. The one which caused us to be called
  114. * needs to be disabled and the other one enabled.
  115. */
  116. static irqreturn_t db1200_pcmcia_cdirq(int irq, void *data)
  117. {
  118. disable_irq_nosync(irq);
  119. return IRQ_WAKE_THREAD;
  120. }
  121. static irqreturn_t db1200_pcmcia_cdirq_fn(int irq, void *data)
  122. {
  123. struct db1x_pcmcia_sock *sock = data;
  124. /* Wait a bit for the signals to stop bouncing. */
  125. msleep(100);
  126. if (irq == sock->insert_irq)
  127. enable_irq(sock->eject_irq);
  128. else
  129. enable_irq(sock->insert_irq);
  130. pcmcia_parse_events(&sock->socket, SS_DETECT);
  131. return IRQ_HANDLED;
  132. }
  133. static int db1x_pcmcia_setup_irqs(struct db1x_pcmcia_sock *sock)
  134. {
  135. int ret;
  136. if (sock->stschg_irq != -1) {
  137. ret = request_irq(sock->stschg_irq, db1000_pcmcia_stschgirq,
  138. 0, "pcmcia_stschg", sock);
  139. if (ret)
  140. return ret;
  141. }
  142. /* Db/Pb1200 have separate per-socket insertion and ejection
  143. * interrupts, which should show edge behaviour but don't.
  144. * So interrupts are disabled until both insertion and
  145. * ejection handler have been registered and the currently
  146. * active one disabled.
  147. */
  148. if ((sock->board_type == BOARD_TYPE_DB1200) ||
  149. (sock->board_type == BOARD_TYPE_DB1300)) {
  150. ret = request_threaded_irq(sock->insert_irq, db1200_pcmcia_cdirq,
  151. db1200_pcmcia_cdirq_fn, 0, "pcmcia_insert", sock);
  152. if (ret)
  153. goto out1;
  154. ret = request_threaded_irq(sock->eject_irq, db1200_pcmcia_cdirq,
  155. db1200_pcmcia_cdirq_fn, 0, "pcmcia_eject", sock);
  156. if (ret) {
  157. free_irq(sock->insert_irq, sock);
  158. goto out1;
  159. }
  160. /* enable the currently silent one */
  161. if (db1x_card_inserted(sock))
  162. enable_irq(sock->eject_irq);
  163. else
  164. enable_irq(sock->insert_irq);
  165. } else {
  166. /* all other (older) Db1x00 boards use a GPIO to show
  167. * card detection status: use both-edge triggers.
  168. */
  169. irq_set_irq_type(sock->insert_irq, IRQ_TYPE_EDGE_BOTH);
  170. ret = request_irq(sock->insert_irq, db1000_pcmcia_cdirq,
  171. 0, "pcmcia_carddetect", sock);
  172. if (ret)
  173. goto out1;
  174. }
  175. return 0; /* all done */
  176. out1:
  177. if (sock->stschg_irq != -1)
  178. free_irq(sock->stschg_irq, sock);
  179. return ret;
  180. }
  181. static void db1x_pcmcia_free_irqs(struct db1x_pcmcia_sock *sock)
  182. {
  183. if (sock->stschg_irq != -1)
  184. free_irq(sock->stschg_irq, sock);
  185. free_irq(sock->insert_irq, sock);
  186. if (sock->eject_irq != -1)
  187. free_irq(sock->eject_irq, sock);
  188. }
  189. /*
  190. * configure a PCMCIA socket on the Db1x00 series of boards (and
  191. * compatibles).
  192. *
  193. * 2 external registers are involved:
  194. * pcmcia_status (offset 0x04): bits [0:1/2:3]: read card voltage id
  195. * pcmcia_control(offset 0x10):
  196. * bits[0:1] set vcc for card
  197. * bits[2:3] set vpp for card
  198. * bit 4: enable data buffers
  199. * bit 7: reset# for card
  200. * add 8 for second socket.
  201. */
  202. static int db1x_pcmcia_configure(struct pcmcia_socket *skt,
  203. struct socket_state_t *state)
  204. {
  205. struct db1x_pcmcia_sock *sock = to_db1x_socket(skt);
  206. unsigned short cr_clr, cr_set;
  207. unsigned int changed;
  208. int v, p, ret;
  209. /* card voltage setup */
  210. cr_clr = (0xf << (sock->nr * 8)); /* clear voltage settings */
  211. cr_set = 0;
  212. v = p = ret = 0;
  213. switch (state->Vcc) {
  214. case 50:
  215. ++v;
  216. fallthrough;
  217. case 33:
  218. ++v;
  219. fallthrough;
  220. case 0:
  221. break;
  222. default:
  223. printk(KERN_INFO "pcmcia%d unsupported Vcc %d\n",
  224. sock->nr, state->Vcc);
  225. }
  226. switch (state->Vpp) {
  227. case 12:
  228. ++p;
  229. fallthrough;
  230. case 33:
  231. case 50:
  232. ++p;
  233. fallthrough;
  234. case 0:
  235. break;
  236. default:
  237. printk(KERN_INFO "pcmcia%d unsupported Vpp %d\n",
  238. sock->nr, state->Vpp);
  239. }
  240. /* sanity check: Vpp must be 0, 12, or Vcc */
  241. if (((state->Vcc == 33) && (state->Vpp == 50)) ||
  242. ((state->Vcc == 50) && (state->Vpp == 33))) {
  243. printk(KERN_INFO "pcmcia%d bad Vcc/Vpp combo (%d %d)\n",
  244. sock->nr, state->Vcc, state->Vpp);
  245. v = p = 0;
  246. ret = -EINVAL;
  247. }
  248. /* create new voltage code */
  249. if (sock->board_type != BOARD_TYPE_DB1300)
  250. cr_set |= ((v << 2) | p) << (sock->nr * 8);
  251. changed = state->flags ^ sock->old_flags;
  252. if (changed & SS_RESET) {
  253. if (state->flags & SS_RESET) {
  254. set_stschg(sock, 0);
  255. /* assert reset, disable io buffers */
  256. cr_clr |= (1 << (7 + (sock->nr * 8)));
  257. cr_clr |= (1 << (4 + (sock->nr * 8)));
  258. } else {
  259. /* de-assert reset, enable io buffers */
  260. cr_set |= 1 << (7 + (sock->nr * 8));
  261. cr_set |= 1 << (4 + (sock->nr * 8));
  262. }
  263. }
  264. /* update PCMCIA configuration */
  265. bcsr_mod(BCSR_PCMCIA, cr_clr, cr_set);
  266. sock->old_flags = state->flags;
  267. /* reset was taken away: give card time to initialize properly */
  268. if ((changed & SS_RESET) && !(state->flags & SS_RESET)) {
  269. msleep(500);
  270. set_stschg(sock, 1);
  271. }
  272. return ret;
  273. }
  274. /* VCC bits at [3:2]/[11:10] */
  275. #define GET_VCC(cr, socknr) \
  276. ((((cr) >> 2) >> ((socknr) * 8)) & 3)
  277. /* VS bits at [0:1]/[3:2] */
  278. #define GET_VS(sr, socknr) \
  279. (((sr) >> (2 * (socknr))) & 3)
  280. /* reset bits at [7]/[15] */
  281. #define GET_RESET(cr, socknr) \
  282. ((cr) & (1 << (7 + (8 * (socknr)))))
  283. static int db1x_pcmcia_get_status(struct pcmcia_socket *skt,
  284. unsigned int *value)
  285. {
  286. struct db1x_pcmcia_sock *sock = to_db1x_socket(skt);
  287. unsigned short cr, sr;
  288. unsigned int status;
  289. status = db1x_card_inserted(sock) ? SS_DETECT : 0;
  290. cr = bcsr_read(BCSR_PCMCIA);
  291. sr = bcsr_read(BCSR_STATUS);
  292. /* PB1100/PB1500: voltage key bits are at [5:4] */
  293. if (sock->board_type == BOARD_TYPE_PB1100)
  294. sr >>= 4;
  295. /* determine card type */
  296. switch (GET_VS(sr, sock->nr)) {
  297. case 0:
  298. case 2:
  299. status |= SS_3VCARD; /* 3V card */
  300. case 3:
  301. break; /* 5V card: set nothing */
  302. default:
  303. status |= SS_XVCARD; /* treated as unsupported in core */
  304. }
  305. /* if Vcc is not zero, we have applied power to a card */
  306. status |= GET_VCC(cr, sock->nr) ? SS_POWERON : 0;
  307. /* DB1300: power always on, but don't tell when no card present */
  308. if ((sock->board_type == BOARD_TYPE_DB1300) && (status & SS_DETECT))
  309. status = SS_POWERON | SS_3VCARD | SS_DETECT;
  310. /* reset de-asserted? then we're ready */
  311. status |= (GET_RESET(cr, sock->nr)) ? SS_READY : SS_RESET;
  312. *value = status;
  313. return 0;
  314. }
  315. static int db1x_pcmcia_sock_init(struct pcmcia_socket *skt)
  316. {
  317. return 0;
  318. }
  319. static int db1x_pcmcia_sock_suspend(struct pcmcia_socket *skt)
  320. {
  321. return 0;
  322. }
  323. static int au1x00_pcmcia_set_io_map(struct pcmcia_socket *skt,
  324. struct pccard_io_map *map)
  325. {
  326. struct db1x_pcmcia_sock *sock = to_db1x_socket(skt);
  327. map->start = (u32)sock->virt_io;
  328. map->stop = map->start + IO_MAP_SIZE;
  329. return 0;
  330. }
  331. static int au1x00_pcmcia_set_mem_map(struct pcmcia_socket *skt,
  332. struct pccard_mem_map *map)
  333. {
  334. struct db1x_pcmcia_sock *sock = to_db1x_socket(skt);
  335. if (map->flags & MAP_ATTRIB)
  336. map->static_start = sock->phys_attr + map->card_start;
  337. else
  338. map->static_start = sock->phys_mem + map->card_start;
  339. return 0;
  340. }
  341. static struct pccard_operations db1x_pcmcia_operations = {
  342. .init = db1x_pcmcia_sock_init,
  343. .suspend = db1x_pcmcia_sock_suspend,
  344. .get_status = db1x_pcmcia_get_status,
  345. .set_socket = db1x_pcmcia_configure,
  346. .set_io_map = au1x00_pcmcia_set_io_map,
  347. .set_mem_map = au1x00_pcmcia_set_mem_map,
  348. };
  349. static int db1x_pcmcia_socket_probe(struct platform_device *pdev)
  350. {
  351. struct db1x_pcmcia_sock *sock;
  352. struct resource *r;
  353. int ret, bid;
  354. sock = kzalloc(sizeof(struct db1x_pcmcia_sock), GFP_KERNEL);
  355. if (!sock)
  356. return -ENOMEM;
  357. sock->nr = pdev->id;
  358. bid = BCSR_WHOAMI_BOARD(bcsr_read(BCSR_WHOAMI));
  359. switch (bid) {
  360. case BCSR_WHOAMI_PB1500:
  361. case BCSR_WHOAMI_PB1500R2:
  362. case BCSR_WHOAMI_PB1100:
  363. sock->board_type = BOARD_TYPE_PB1100;
  364. break;
  365. case BCSR_WHOAMI_DB1000 ... BCSR_WHOAMI_PB1550_SDR:
  366. sock->board_type = BOARD_TYPE_DEFAULT;
  367. break;
  368. case BCSR_WHOAMI_PB1200 ... BCSR_WHOAMI_DB1200:
  369. sock->board_type = BOARD_TYPE_DB1200;
  370. break;
  371. case BCSR_WHOAMI_DB1300:
  372. sock->board_type = BOARD_TYPE_DB1300;
  373. break;
  374. default:
  375. printk(KERN_INFO "db1xxx-ss: unknown board %d!\n", bid);
  376. ret = -ENODEV;
  377. goto out0;
  378. };
  379. /*
  380. * gather resources necessary and optional nice-to-haves to
  381. * operate a socket:
  382. * This includes IRQs for Carddetection/ejection, the card
  383. * itself and optional status change detection.
  384. * Also, the memory areas covered by a socket. For these
  385. * we require the real 36bit addresses (see the au1000.h
  386. * header for more information).
  387. */
  388. /* card: irq assigned to the card itself. */
  389. r = platform_get_resource_byname(pdev, IORESOURCE_IRQ, "card");
  390. sock->card_irq = r ? r->start : 0;
  391. /* insert: irq which triggers on card insertion/ejection
  392. * BIG FAT NOTE: on DB1000/1100/1500/1550 we pass a GPIO here!
  393. */
  394. r = platform_get_resource_byname(pdev, IORESOURCE_IRQ, "insert");
  395. sock->insert_irq = r ? r->start : -1;
  396. if (sock->board_type == BOARD_TYPE_DEFAULT) {
  397. sock->insert_gpio = r ? r->start : -1;
  398. sock->insert_irq = r ? gpio_to_irq(r->start) : -1;
  399. }
  400. /* stschg: irq which trigger on card status change (optional) */
  401. r = platform_get_resource_byname(pdev, IORESOURCE_IRQ, "stschg");
  402. sock->stschg_irq = r ? r->start : -1;
  403. /* eject: irq which triggers on ejection (DB1200/PB1200 only) */
  404. r = platform_get_resource_byname(pdev, IORESOURCE_IRQ, "eject");
  405. sock->eject_irq = r ? r->start : -1;
  406. ret = -ENODEV;
  407. /* 36bit PCMCIA Attribute area address */
  408. r = platform_get_resource_byname(pdev, IORESOURCE_MEM, "pcmcia-attr");
  409. if (!r) {
  410. printk(KERN_ERR "pcmcia%d has no 'pseudo-attr' resource!\n",
  411. sock->nr);
  412. goto out0;
  413. }
  414. sock->phys_attr = r->start;
  415. /* 36bit PCMCIA Memory area address */
  416. r = platform_get_resource_byname(pdev, IORESOURCE_MEM, "pcmcia-mem");
  417. if (!r) {
  418. printk(KERN_ERR "pcmcia%d has no 'pseudo-mem' resource!\n",
  419. sock->nr);
  420. goto out0;
  421. }
  422. sock->phys_mem = r->start;
  423. /* 36bit PCMCIA IO area address */
  424. r = platform_get_resource_byname(pdev, IORESOURCE_MEM, "pcmcia-io");
  425. if (!r) {
  426. printk(KERN_ERR "pcmcia%d has no 'pseudo-io' resource!\n",
  427. sock->nr);
  428. goto out0;
  429. }
  430. sock->phys_io = r->start;
  431. /*
  432. * PCMCIA client drivers use the inb/outb macros to access
  433. * the IO registers. Since mips_io_port_base is added
  434. * to the access address of the mips implementation of
  435. * inb/outb, we need to subtract it here because we want
  436. * to access the I/O or MEM address directly, without
  437. * going through this "mips_io_port_base" mechanism.
  438. */
  439. sock->virt_io = (void *)(ioremap(sock->phys_io, IO_MAP_SIZE) -
  440. mips_io_port_base);
  441. if (!sock->virt_io) {
  442. printk(KERN_ERR "pcmcia%d: cannot remap IO area\n",
  443. sock->nr);
  444. ret = -ENOMEM;
  445. goto out0;
  446. }
  447. sock->socket.ops = &db1x_pcmcia_operations;
  448. sock->socket.owner = THIS_MODULE;
  449. sock->socket.pci_irq = sock->card_irq;
  450. sock->socket.features = SS_CAP_STATIC_MAP | SS_CAP_PCCARD;
  451. sock->socket.map_size = MEM_MAP_SIZE;
  452. sock->socket.io_offset = (unsigned long)sock->virt_io;
  453. sock->socket.dev.parent = &pdev->dev;
  454. sock->socket.resource_ops = &pccard_static_ops;
  455. platform_set_drvdata(pdev, sock);
  456. ret = db1x_pcmcia_setup_irqs(sock);
  457. if (ret) {
  458. printk(KERN_ERR "pcmcia%d cannot setup interrupts\n",
  459. sock->nr);
  460. goto out1;
  461. }
  462. set_stschg(sock, 0);
  463. ret = pcmcia_register_socket(&sock->socket);
  464. if (ret) {
  465. printk(KERN_ERR "pcmcia%d failed to register\n", sock->nr);
  466. goto out2;
  467. }
  468. printk(KERN_INFO "Alchemy Db/Pb1xxx pcmcia%d @ io/attr/mem %09llx"
  469. "(%p) %09llx %09llx card/insert/stschg/eject irqs @ %d "
  470. "%d %d %d\n", sock->nr, sock->phys_io, sock->virt_io,
  471. sock->phys_attr, sock->phys_mem, sock->card_irq,
  472. sock->insert_irq, sock->stschg_irq, sock->eject_irq);
  473. return 0;
  474. out2:
  475. db1x_pcmcia_free_irqs(sock);
  476. out1:
  477. iounmap((void *)(sock->virt_io + (u32)mips_io_port_base));
  478. out0:
  479. kfree(sock);
  480. return ret;
  481. }
  482. static int db1x_pcmcia_socket_remove(struct platform_device *pdev)
  483. {
  484. struct db1x_pcmcia_sock *sock = platform_get_drvdata(pdev);
  485. db1x_pcmcia_free_irqs(sock);
  486. pcmcia_unregister_socket(&sock->socket);
  487. iounmap((void *)(sock->virt_io + (u32)mips_io_port_base));
  488. kfree(sock);
  489. return 0;
  490. }
  491. static struct platform_driver db1x_pcmcia_socket_driver = {
  492. .driver = {
  493. .name = "db1xxx_pcmcia",
  494. },
  495. .probe = db1x_pcmcia_socket_probe,
  496. .remove = db1x_pcmcia_socket_remove,
  497. };
  498. module_platform_driver(db1x_pcmcia_socket_driver);
  499. MODULE_LICENSE("GPL");
  500. MODULE_DESCRIPTION("PCMCIA Socket Services for Alchemy Db/Pb1x00 boards");
  501. MODULE_AUTHOR("Manuel Lauss");