soc_common.c 21 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827
  1. /*======================================================================
  2. Common support code for the PCMCIA control functionality of
  3. integrated SOCs like the SA-11x0 and PXA2xx microprocessors.
  4. The contents of this file are subject to the Mozilla Public
  5. License Version 1.1 (the "License"); you may not use this file
  6. except in compliance with the License. You may obtain a copy of
  7. the License at http://www.mozilla.org/MPL/
  8. Software distributed under the License is distributed on an "AS
  9. IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
  10. implied. See the License for the specific language governing
  11. rights and limitations under the License.
  12. The initial developer of the original code is John G. Dorsey
  13. <john+@cs.cmu.edu>. Portions created by John G. Dorsey are
  14. Copyright (C) 1999 John G. Dorsey. All Rights Reserved.
  15. Alternatively, the contents of this file may be used under the
  16. terms of the GNU Public License version 2 (the "GPL"), in which
  17. case the provisions of the GPL are applicable instead of the
  18. above. If you wish to allow the use of your version of this file
  19. only under the terms of the GPL and not to allow others to use
  20. your version of this file under the MPL, indicate your decision
  21. by deleting the provisions above and replace them with the notice
  22. and other provisions required by the GPL. If you do not delete
  23. the provisions above, a recipient may use your version of this
  24. file under either the MPL or the GPL.
  25. ======================================================================*/
  26. #include <linux/module.h>
  27. #include <linux/moduleparam.h>
  28. #include <linux/init.h>
  29. #include <linux/kernel.h>
  30. #include <linux/timer.h>
  31. #include <linux/mm.h>
  32. #include <linux/interrupt.h>
  33. #include <linux/irq.h>
  34. #include <linux/spinlock.h>
  35. #include <linux/cpufreq.h>
  36. #include <asm/hardware.h>
  37. #include <asm/io.h>
  38. #include <asm/system.h>
  39. #include "soc_common.h"
  40. /* FIXME: platform dependent resource declaration has to move out of this file */
  41. #ifdef CONFIG_ARCH_PXA
  42. #include <asm/arch/pxa-regs.h>
  43. #endif
  44. #ifdef DEBUG
  45. static int pc_debug;
  46. module_param(pc_debug, int, 0644);
  47. void soc_pcmcia_debug(struct soc_pcmcia_socket *skt, const char *func,
  48. int lvl, const char *fmt, ...)
  49. {
  50. va_list args;
  51. if (pc_debug > lvl) {
  52. printk(KERN_DEBUG "skt%u: %s: ", skt->nr, func);
  53. va_start(args, fmt);
  54. vprintk(fmt, args);
  55. va_end(args);
  56. }
  57. }
  58. #endif
  59. #define to_soc_pcmcia_socket(x) container_of(x, struct soc_pcmcia_socket, socket)
  60. static unsigned short
  61. calc_speed(unsigned short *spds, int num, unsigned short dflt)
  62. {
  63. unsigned short speed = 0;
  64. int i;
  65. for (i = 0; i < num; i++)
  66. if (speed < spds[i])
  67. speed = spds[i];
  68. if (speed == 0)
  69. speed = dflt;
  70. return speed;
  71. }
  72. void soc_common_pcmcia_get_timing(struct soc_pcmcia_socket *skt, struct soc_pcmcia_timing *timing)
  73. {
  74. timing->io = calc_speed(skt->spd_io, MAX_IO_WIN, SOC_PCMCIA_IO_ACCESS);
  75. timing->mem = calc_speed(skt->spd_mem, MAX_WIN, SOC_PCMCIA_3V_MEM_ACCESS);
  76. timing->attr = calc_speed(skt->spd_attr, MAX_WIN, SOC_PCMCIA_3V_MEM_ACCESS);
  77. }
  78. EXPORT_SYMBOL(soc_common_pcmcia_get_timing);
  79. static unsigned int soc_common_pcmcia_skt_state(struct soc_pcmcia_socket *skt)
  80. {
  81. struct pcmcia_state state;
  82. unsigned int stat;
  83. memset(&state, 0, sizeof(struct pcmcia_state));
  84. skt->ops->socket_state(skt, &state);
  85. stat = state.detect ? SS_DETECT : 0;
  86. stat |= state.ready ? SS_READY : 0;
  87. stat |= state.wrprot ? SS_WRPROT : 0;
  88. stat |= state.vs_3v ? SS_3VCARD : 0;
  89. stat |= state.vs_Xv ? SS_XVCARD : 0;
  90. /* The power status of individual sockets is not available
  91. * explicitly from the hardware, so we just remember the state
  92. * and regurgitate it upon request:
  93. */
  94. stat |= skt->cs_state.Vcc ? SS_POWERON : 0;
  95. if (skt->cs_state.flags & SS_IOCARD)
  96. stat |= state.bvd1 ? SS_STSCHG : 0;
  97. else {
  98. if (state.bvd1 == 0)
  99. stat |= SS_BATDEAD;
  100. else if (state.bvd2 == 0)
  101. stat |= SS_BATWARN;
  102. }
  103. return stat;
  104. }
  105. /*
  106. * soc_common_pcmcia_config_skt
  107. * ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
  108. *
  109. * Convert PCMCIA socket state to our socket configure structure.
  110. */
  111. static int
  112. soc_common_pcmcia_config_skt(struct soc_pcmcia_socket *skt, socket_state_t *state)
  113. {
  114. int ret;
  115. ret = skt->ops->configure_socket(skt, state);
  116. if (ret == 0) {
  117. /*
  118. * This really needs a better solution. The IRQ
  119. * may or may not be claimed by the driver.
  120. */
  121. if (skt->irq_state != 1 && state->io_irq) {
  122. skt->irq_state = 1;
  123. set_irq_type(skt->irq, IRQT_FALLING);
  124. } else if (skt->irq_state == 1 && state->io_irq == 0) {
  125. skt->irq_state = 0;
  126. set_irq_type(skt->irq, IRQT_NOEDGE);
  127. }
  128. skt->cs_state = *state;
  129. }
  130. if (ret < 0)
  131. printk(KERN_ERR "soc_common_pcmcia: unable to configure "
  132. "socket %d\n", skt->nr);
  133. return ret;
  134. }
  135. /* soc_common_pcmcia_sock_init()
  136. * ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
  137. *
  138. * (Re-)Initialise the socket, turning on status interrupts
  139. * and PCMCIA bus. This must wait for power to stabilise
  140. * so that the card status signals report correctly.
  141. *
  142. * Returns: 0
  143. */
  144. static int soc_common_pcmcia_sock_init(struct pcmcia_socket *sock)
  145. {
  146. struct soc_pcmcia_socket *skt = to_soc_pcmcia_socket(sock);
  147. debug(skt, 2, "initializing socket\n");
  148. skt->ops->socket_init(skt);
  149. return 0;
  150. }
  151. /*
  152. * soc_common_pcmcia_suspend()
  153. * ^^^^^^^^^^^^^^^^^^^^^^^^^^^
  154. *
  155. * Remove power on the socket, disable IRQs from the card.
  156. * Turn off status interrupts, and disable the PCMCIA bus.
  157. *
  158. * Returns: 0
  159. */
  160. static int soc_common_pcmcia_suspend(struct pcmcia_socket *sock)
  161. {
  162. struct soc_pcmcia_socket *skt = to_soc_pcmcia_socket(sock);
  163. debug(skt, 2, "suspending socket\n");
  164. skt->ops->socket_suspend(skt);
  165. return 0;
  166. }
  167. static DEFINE_SPINLOCK(status_lock);
  168. static void soc_common_check_status(struct soc_pcmcia_socket *skt)
  169. {
  170. unsigned int events;
  171. debug(skt, 4, "entering PCMCIA monitoring thread\n");
  172. do {
  173. unsigned int status;
  174. unsigned long flags;
  175. status = soc_common_pcmcia_skt_state(skt);
  176. spin_lock_irqsave(&status_lock, flags);
  177. events = (status ^ skt->status) & skt->cs_state.csc_mask;
  178. skt->status = status;
  179. spin_unlock_irqrestore(&status_lock, flags);
  180. debug(skt, 4, "events: %s%s%s%s%s%s\n",
  181. events == 0 ? "<NONE>" : "",
  182. events & SS_DETECT ? "DETECT " : "",
  183. events & SS_READY ? "READY " : "",
  184. events & SS_BATDEAD ? "BATDEAD " : "",
  185. events & SS_BATWARN ? "BATWARN " : "",
  186. events & SS_STSCHG ? "STSCHG " : "");
  187. if (events)
  188. pcmcia_parse_events(&skt->socket, events);
  189. } while (events);
  190. }
  191. /* Let's poll for events in addition to IRQs since IRQ only is unreliable... */
  192. static void soc_common_pcmcia_poll_event(unsigned long dummy)
  193. {
  194. struct soc_pcmcia_socket *skt = (struct soc_pcmcia_socket *)dummy;
  195. debug(skt, 4, "polling for events\n");
  196. mod_timer(&skt->poll_timer, jiffies + SOC_PCMCIA_POLL_PERIOD);
  197. soc_common_check_status(skt);
  198. }
  199. /*
  200. * Service routine for socket driver interrupts (requested by the
  201. * low-level PCMCIA init() operation via soc_common_pcmcia_thread()).
  202. * The actual interrupt-servicing work is performed by
  203. * soc_common_pcmcia_thread(), largely because the Card Services event-
  204. * handling code performs scheduling operations which cannot be
  205. * executed from within an interrupt context.
  206. */
  207. static irqreturn_t soc_common_pcmcia_interrupt(int irq, void *dev)
  208. {
  209. struct soc_pcmcia_socket *skt = dev;
  210. debug(skt, 3, "servicing IRQ %d\n", irq);
  211. soc_common_check_status(skt);
  212. return IRQ_HANDLED;
  213. }
  214. /*
  215. * Implements the get_status() operation for the in-kernel PCMCIA
  216. * service (formerly SS_GetStatus in Card Services). Essentially just
  217. * fills in bits in `status' according to internal driver state or
  218. * the value of the voltage detect chipselect register.
  219. *
  220. * As a debugging note, during card startup, the PCMCIA core issues
  221. * three set_socket() commands in a row the first with RESET deasserted,
  222. * the second with RESET asserted, and the last with RESET deasserted
  223. * again. Following the third set_socket(), a get_status() command will
  224. * be issued. The kernel is looking for the SS_READY flag (see
  225. * setup_socket(), reset_socket(), and unreset_socket() in cs.c).
  226. *
  227. * Returns: 0
  228. */
  229. static int
  230. soc_common_pcmcia_get_status(struct pcmcia_socket *sock, unsigned int *status)
  231. {
  232. struct soc_pcmcia_socket *skt = to_soc_pcmcia_socket(sock);
  233. skt->status = soc_common_pcmcia_skt_state(skt);
  234. *status = skt->status;
  235. return 0;
  236. }
  237. /*
  238. * Implements the set_socket() operation for the in-kernel PCMCIA
  239. * service (formerly SS_SetSocket in Card Services). We more or
  240. * less punt all of this work and let the kernel handle the details
  241. * of power configuration, reset, &c. We also record the value of
  242. * `state' in order to regurgitate it to the PCMCIA core later.
  243. */
  244. static int
  245. soc_common_pcmcia_set_socket(struct pcmcia_socket *sock, socket_state_t *state)
  246. {
  247. struct soc_pcmcia_socket *skt = to_soc_pcmcia_socket(sock);
  248. debug(skt, 2, "mask: %s%s%s%s%s%sflags: %s%s%s%s%s%sVcc %d Vpp %d irq %d\n",
  249. (state->csc_mask==0)?"<NONE> ":"",
  250. (state->csc_mask&SS_DETECT)?"DETECT ":"",
  251. (state->csc_mask&SS_READY)?"READY ":"",
  252. (state->csc_mask&SS_BATDEAD)?"BATDEAD ":"",
  253. (state->csc_mask&SS_BATWARN)?"BATWARN ":"",
  254. (state->csc_mask&SS_STSCHG)?"STSCHG ":"",
  255. (state->flags==0)?"<NONE> ":"",
  256. (state->flags&SS_PWR_AUTO)?"PWR_AUTO ":"",
  257. (state->flags&SS_IOCARD)?"IOCARD ":"",
  258. (state->flags&SS_RESET)?"RESET ":"",
  259. (state->flags&SS_SPKR_ENA)?"SPKR_ENA ":"",
  260. (state->flags&SS_OUTPUT_ENA)?"OUTPUT_ENA ":"",
  261. state->Vcc, state->Vpp, state->io_irq);
  262. return soc_common_pcmcia_config_skt(skt, state);
  263. }
  264. /*
  265. * Implements the set_io_map() operation for the in-kernel PCMCIA
  266. * service (formerly SS_SetIOMap in Card Services). We configure
  267. * the map speed as requested, but override the address ranges
  268. * supplied by Card Services.
  269. *
  270. * Returns: 0 on success, -1 on error
  271. */
  272. static int
  273. soc_common_pcmcia_set_io_map(struct pcmcia_socket *sock, struct pccard_io_map *map)
  274. {
  275. struct soc_pcmcia_socket *skt = to_soc_pcmcia_socket(sock);
  276. unsigned short speed = map->speed;
  277. debug(skt, 2, "map %u speed %u start 0x%08x stop 0x%08x\n",
  278. map->map, map->speed, map->start, map->stop);
  279. debug(skt, 2, "flags: %s%s%s%s%s%s%s%s\n",
  280. (map->flags==0)?"<NONE>":"",
  281. (map->flags&MAP_ACTIVE)?"ACTIVE ":"",
  282. (map->flags&MAP_16BIT)?"16BIT ":"",
  283. (map->flags&MAP_AUTOSZ)?"AUTOSZ ":"",
  284. (map->flags&MAP_0WS)?"0WS ":"",
  285. (map->flags&MAP_WRPROT)?"WRPROT ":"",
  286. (map->flags&MAP_USE_WAIT)?"USE_WAIT ":"",
  287. (map->flags&MAP_PREFETCH)?"PREFETCH ":"");
  288. if (map->map >= MAX_IO_WIN) {
  289. printk(KERN_ERR "%s(): map (%d) out of range\n", __FUNCTION__,
  290. map->map);
  291. return -1;
  292. }
  293. if (map->flags & MAP_ACTIVE) {
  294. if (speed == 0)
  295. speed = SOC_PCMCIA_IO_ACCESS;
  296. } else {
  297. speed = 0;
  298. }
  299. skt->spd_io[map->map] = speed;
  300. skt->ops->set_timing(skt);
  301. if (map->stop == 1)
  302. map->stop = PAGE_SIZE-1;
  303. map->stop -= map->start;
  304. map->stop += skt->socket.io_offset;
  305. map->start = skt->socket.io_offset;
  306. return 0;
  307. }
  308. /*
  309. * Implements the set_mem_map() operation for the in-kernel PCMCIA
  310. * service (formerly SS_SetMemMap in Card Services). We configure
  311. * the map speed as requested, but override the address ranges
  312. * supplied by Card Services.
  313. *
  314. * Returns: 0 on success, -ERRNO on error
  315. */
  316. static int
  317. soc_common_pcmcia_set_mem_map(struct pcmcia_socket *sock, struct pccard_mem_map *map)
  318. {
  319. struct soc_pcmcia_socket *skt = to_soc_pcmcia_socket(sock);
  320. struct resource *res;
  321. unsigned short speed = map->speed;
  322. debug(skt, 2, "map %u speed %u card_start %08x\n",
  323. map->map, map->speed, map->card_start);
  324. debug(skt, 2, "flags: %s%s%s%s%s%s%s%s\n",
  325. (map->flags==0)?"<NONE>":"",
  326. (map->flags&MAP_ACTIVE)?"ACTIVE ":"",
  327. (map->flags&MAP_16BIT)?"16BIT ":"",
  328. (map->flags&MAP_AUTOSZ)?"AUTOSZ ":"",
  329. (map->flags&MAP_0WS)?"0WS ":"",
  330. (map->flags&MAP_WRPROT)?"WRPROT ":"",
  331. (map->flags&MAP_ATTRIB)?"ATTRIB ":"",
  332. (map->flags&MAP_USE_WAIT)?"USE_WAIT ":"");
  333. if (map->map >= MAX_WIN)
  334. return -EINVAL;
  335. if (map->flags & MAP_ACTIVE) {
  336. if (speed == 0)
  337. speed = 300;
  338. } else {
  339. speed = 0;
  340. }
  341. if (map->flags & MAP_ATTRIB) {
  342. res = &skt->res_attr;
  343. skt->spd_attr[map->map] = speed;
  344. skt->spd_mem[map->map] = 0;
  345. } else {
  346. res = &skt->res_mem;
  347. skt->spd_attr[map->map] = 0;
  348. skt->spd_mem[map->map] = speed;
  349. }
  350. skt->ops->set_timing(skt);
  351. map->static_start = res->start + map->card_start;
  352. return 0;
  353. }
  354. struct bittbl {
  355. unsigned int mask;
  356. const char *name;
  357. };
  358. static struct bittbl status_bits[] = {
  359. { SS_WRPROT, "SS_WRPROT" },
  360. { SS_BATDEAD, "SS_BATDEAD" },
  361. { SS_BATWARN, "SS_BATWARN" },
  362. { SS_READY, "SS_READY" },
  363. { SS_DETECT, "SS_DETECT" },
  364. { SS_POWERON, "SS_POWERON" },
  365. { SS_STSCHG, "SS_STSCHG" },
  366. { SS_3VCARD, "SS_3VCARD" },
  367. { SS_XVCARD, "SS_XVCARD" },
  368. };
  369. static struct bittbl conf_bits[] = {
  370. { SS_PWR_AUTO, "SS_PWR_AUTO" },
  371. { SS_IOCARD, "SS_IOCARD" },
  372. { SS_RESET, "SS_RESET" },
  373. { SS_DMA_MODE, "SS_DMA_MODE" },
  374. { SS_SPKR_ENA, "SS_SPKR_ENA" },
  375. { SS_OUTPUT_ENA, "SS_OUTPUT_ENA" },
  376. };
  377. static void
  378. dump_bits(char **p, const char *prefix, unsigned int val, struct bittbl *bits, int sz)
  379. {
  380. char *b = *p;
  381. int i;
  382. b += sprintf(b, "%-9s:", prefix);
  383. for (i = 0; i < sz; i++)
  384. if (val & bits[i].mask)
  385. b += sprintf(b, " %s", bits[i].name);
  386. *b++ = '\n';
  387. *p = b;
  388. }
  389. /*
  390. * Implements the /sys/class/pcmcia_socket/??/status file.
  391. *
  392. * Returns: the number of characters added to the buffer
  393. */
  394. static ssize_t show_status(struct device *dev, struct device_attribute *attr, char *buf)
  395. {
  396. struct soc_pcmcia_socket *skt =
  397. container_of(dev, struct soc_pcmcia_socket, socket.dev);
  398. char *p = buf;
  399. p+=sprintf(p, "slot : %d\n", skt->nr);
  400. dump_bits(&p, "status", skt->status,
  401. status_bits, ARRAY_SIZE(status_bits));
  402. dump_bits(&p, "csc_mask", skt->cs_state.csc_mask,
  403. status_bits, ARRAY_SIZE(status_bits));
  404. dump_bits(&p, "cs_flags", skt->cs_state.flags,
  405. conf_bits, ARRAY_SIZE(conf_bits));
  406. p+=sprintf(p, "Vcc : %d\n", skt->cs_state.Vcc);
  407. p+=sprintf(p, "Vpp : %d\n", skt->cs_state.Vpp);
  408. p+=sprintf(p, "IRQ : %d (%d)\n", skt->cs_state.io_irq, skt->irq);
  409. if (skt->ops->show_timing)
  410. p+=skt->ops->show_timing(skt, p);
  411. return p-buf;
  412. }
  413. static DEVICE_ATTR(status, S_IRUGO, show_status, NULL);
  414. static struct pccard_operations soc_common_pcmcia_operations = {
  415. .init = soc_common_pcmcia_sock_init,
  416. .suspend = soc_common_pcmcia_suspend,
  417. .get_status = soc_common_pcmcia_get_status,
  418. .set_socket = soc_common_pcmcia_set_socket,
  419. .set_io_map = soc_common_pcmcia_set_io_map,
  420. .set_mem_map = soc_common_pcmcia_set_mem_map,
  421. };
  422. int soc_pcmcia_request_irqs(struct soc_pcmcia_socket *skt,
  423. struct pcmcia_irqs *irqs, int nr)
  424. {
  425. int i, res = 0;
  426. for (i = 0; i < nr; i++) {
  427. if (irqs[i].sock != skt->nr)
  428. continue;
  429. res = request_irq(irqs[i].irq, soc_common_pcmcia_interrupt,
  430. IRQF_DISABLED, irqs[i].str, skt);
  431. if (res)
  432. break;
  433. set_irq_type(irqs[i].irq, IRQT_NOEDGE);
  434. }
  435. if (res) {
  436. printk(KERN_ERR "PCMCIA: request for IRQ%d failed (%d)\n",
  437. irqs[i].irq, res);
  438. while (i--)
  439. if (irqs[i].sock == skt->nr)
  440. free_irq(irqs[i].irq, skt);
  441. }
  442. return res;
  443. }
  444. EXPORT_SYMBOL(soc_pcmcia_request_irqs);
  445. void soc_pcmcia_free_irqs(struct soc_pcmcia_socket *skt,
  446. struct pcmcia_irqs *irqs, int nr)
  447. {
  448. int i;
  449. for (i = 0; i < nr; i++)
  450. if (irqs[i].sock == skt->nr)
  451. free_irq(irqs[i].irq, skt);
  452. }
  453. EXPORT_SYMBOL(soc_pcmcia_free_irqs);
  454. void soc_pcmcia_disable_irqs(struct soc_pcmcia_socket *skt,
  455. struct pcmcia_irqs *irqs, int nr)
  456. {
  457. int i;
  458. for (i = 0; i < nr; i++)
  459. if (irqs[i].sock == skt->nr)
  460. set_irq_type(irqs[i].irq, IRQT_NOEDGE);
  461. }
  462. EXPORT_SYMBOL(soc_pcmcia_disable_irqs);
  463. void soc_pcmcia_enable_irqs(struct soc_pcmcia_socket *skt,
  464. struct pcmcia_irqs *irqs, int nr)
  465. {
  466. int i;
  467. for (i = 0; i < nr; i++)
  468. if (irqs[i].sock == skt->nr) {
  469. set_irq_type(irqs[i].irq, IRQT_RISING);
  470. set_irq_type(irqs[i].irq, IRQT_BOTHEDGE);
  471. }
  472. }
  473. EXPORT_SYMBOL(soc_pcmcia_enable_irqs);
  474. LIST_HEAD(soc_pcmcia_sockets);
  475. DECLARE_MUTEX(soc_pcmcia_sockets_lock);
  476. static const char *skt_names[] = {
  477. "PCMCIA socket 0",
  478. "PCMCIA socket 1",
  479. };
  480. struct skt_dev_info {
  481. int nskt;
  482. struct soc_pcmcia_socket skt[0];
  483. };
  484. #define SKT_DEV_INFO_SIZE(n) \
  485. (sizeof(struct skt_dev_info) + (n)*sizeof(struct soc_pcmcia_socket))
  486. #ifdef CONFIG_CPU_FREQ
  487. static int
  488. soc_pcmcia_notifier(struct notifier_block *nb, unsigned long val, void *data)
  489. {
  490. struct soc_pcmcia_socket *skt;
  491. struct cpufreq_freqs *freqs = data;
  492. int ret = 0;
  493. down(&soc_pcmcia_sockets_lock);
  494. list_for_each_entry(skt, &soc_pcmcia_sockets, node)
  495. if ( skt->ops->frequency_change )
  496. ret += skt->ops->frequency_change(skt, val, freqs);
  497. up(&soc_pcmcia_sockets_lock);
  498. return ret;
  499. }
  500. static struct notifier_block soc_pcmcia_notifier_block = {
  501. .notifier_call = soc_pcmcia_notifier
  502. };
  503. static int soc_pcmcia_cpufreq_register(void)
  504. {
  505. int ret;
  506. ret = cpufreq_register_notifier(&soc_pcmcia_notifier_block,
  507. CPUFREQ_TRANSITION_NOTIFIER);
  508. if (ret < 0)
  509. printk(KERN_ERR "Unable to register CPU frequency change "
  510. "notifier for PCMCIA (%d)\n", ret);
  511. return ret;
  512. }
  513. static void soc_pcmcia_cpufreq_unregister(void)
  514. {
  515. cpufreq_unregister_notifier(&soc_pcmcia_notifier_block, CPUFREQ_TRANSITION_NOTIFIER);
  516. }
  517. #else
  518. static int soc_pcmcia_cpufreq_register(void) { return 0; }
  519. static void soc_pcmcia_cpufreq_unregister(void) {}
  520. #endif
  521. int soc_common_drv_pcmcia_probe(struct device *dev, struct pcmcia_low_level *ops, int first, int nr)
  522. {
  523. struct skt_dev_info *sinfo;
  524. struct soc_pcmcia_socket *skt;
  525. int ret, i;
  526. down(&soc_pcmcia_sockets_lock);
  527. sinfo = kzalloc(SKT_DEV_INFO_SIZE(nr), GFP_KERNEL);
  528. if (!sinfo) {
  529. ret = -ENOMEM;
  530. goto out;
  531. }
  532. sinfo->nskt = nr;
  533. /*
  534. * Initialise the per-socket structure.
  535. */
  536. for (i = 0; i < nr; i++) {
  537. skt = &sinfo->skt[i];
  538. skt->socket.ops = &soc_common_pcmcia_operations;
  539. skt->socket.owner = ops->owner;
  540. skt->socket.dev.parent = dev;
  541. init_timer(&skt->poll_timer);
  542. skt->poll_timer.function = soc_common_pcmcia_poll_event;
  543. skt->poll_timer.data = (unsigned long)skt;
  544. skt->poll_timer.expires = jiffies + SOC_PCMCIA_POLL_PERIOD;
  545. skt->nr = first + i;
  546. skt->irq = NO_IRQ;
  547. skt->dev = dev;
  548. skt->ops = ops;
  549. skt->res_skt.start = _PCMCIA(skt->nr);
  550. skt->res_skt.end = _PCMCIA(skt->nr) + PCMCIASp - 1;
  551. skt->res_skt.name = skt_names[skt->nr];
  552. skt->res_skt.flags = IORESOURCE_MEM;
  553. ret = request_resource(&iomem_resource, &skt->res_skt);
  554. if (ret)
  555. goto out_err_1;
  556. skt->res_io.start = _PCMCIAIO(skt->nr);
  557. skt->res_io.end = _PCMCIAIO(skt->nr) + PCMCIAIOSp - 1;
  558. skt->res_io.name = "io";
  559. skt->res_io.flags = IORESOURCE_MEM | IORESOURCE_BUSY;
  560. ret = request_resource(&skt->res_skt, &skt->res_io);
  561. if (ret)
  562. goto out_err_2;
  563. skt->res_mem.start = _PCMCIAMem(skt->nr);
  564. skt->res_mem.end = _PCMCIAMem(skt->nr) + PCMCIAMemSp - 1;
  565. skt->res_mem.name = "memory";
  566. skt->res_mem.flags = IORESOURCE_MEM;
  567. ret = request_resource(&skt->res_skt, &skt->res_mem);
  568. if (ret)
  569. goto out_err_3;
  570. skt->res_attr.start = _PCMCIAAttr(skt->nr);
  571. skt->res_attr.end = _PCMCIAAttr(skt->nr) + PCMCIAAttrSp - 1;
  572. skt->res_attr.name = "attribute";
  573. skt->res_attr.flags = IORESOURCE_MEM;
  574. ret = request_resource(&skt->res_skt, &skt->res_attr);
  575. if (ret)
  576. goto out_err_4;
  577. skt->virt_io = ioremap(skt->res_io.start, 0x10000);
  578. if (skt->virt_io == NULL) {
  579. ret = -ENOMEM;
  580. goto out_err_5;
  581. }
  582. if (list_empty(&soc_pcmcia_sockets))
  583. soc_pcmcia_cpufreq_register();
  584. list_add(&skt->node, &soc_pcmcia_sockets);
  585. /*
  586. * We initialize default socket timing here, because
  587. * we are not guaranteed to see a SetIOMap operation at
  588. * runtime.
  589. */
  590. ops->set_timing(skt);
  591. ret = ops->hw_init(skt);
  592. if (ret)
  593. goto out_err_6;
  594. skt->socket.features = SS_CAP_STATIC_MAP|SS_CAP_PCCARD;
  595. skt->socket.resource_ops = &pccard_static_ops;
  596. skt->socket.irq_mask = 0;
  597. skt->socket.map_size = PAGE_SIZE;
  598. skt->socket.pci_irq = skt->irq;
  599. skt->socket.io_offset = (unsigned long)skt->virt_io;
  600. skt->status = soc_common_pcmcia_skt_state(skt);
  601. ret = pcmcia_register_socket(&skt->socket);
  602. if (ret)
  603. goto out_err_7;
  604. WARN_ON(skt->socket.sock != i);
  605. add_timer(&skt->poll_timer);
  606. device_create_file(&skt->socket.dev, &dev_attr_status);
  607. }
  608. dev_set_drvdata(dev, sinfo);
  609. ret = 0;
  610. goto out;
  611. do {
  612. skt = &sinfo->skt[i];
  613. del_timer_sync(&skt->poll_timer);
  614. pcmcia_unregister_socket(&skt->socket);
  615. out_err_7:
  616. flush_scheduled_work();
  617. ops->hw_shutdown(skt);
  618. out_err_6:
  619. list_del(&skt->node);
  620. iounmap(skt->virt_io);
  621. out_err_5:
  622. release_resource(&skt->res_attr);
  623. out_err_4:
  624. release_resource(&skt->res_mem);
  625. out_err_3:
  626. release_resource(&skt->res_io);
  627. out_err_2:
  628. release_resource(&skt->res_skt);
  629. out_err_1:
  630. i--;
  631. } while (i > 0);
  632. kfree(sinfo);
  633. out:
  634. up(&soc_pcmcia_sockets_lock);
  635. return ret;
  636. }
  637. int soc_common_drv_pcmcia_remove(struct device *dev)
  638. {
  639. struct skt_dev_info *sinfo = dev_get_drvdata(dev);
  640. int i;
  641. dev_set_drvdata(dev, NULL);
  642. down(&soc_pcmcia_sockets_lock);
  643. for (i = 0; i < sinfo->nskt; i++) {
  644. struct soc_pcmcia_socket *skt = &sinfo->skt[i];
  645. del_timer_sync(&skt->poll_timer);
  646. pcmcia_unregister_socket(&skt->socket);
  647. flush_scheduled_work();
  648. skt->ops->hw_shutdown(skt);
  649. soc_common_pcmcia_config_skt(skt, &dead_socket);
  650. list_del(&skt->node);
  651. iounmap(skt->virt_io);
  652. skt->virt_io = NULL;
  653. release_resource(&skt->res_attr);
  654. release_resource(&skt->res_mem);
  655. release_resource(&skt->res_io);
  656. release_resource(&skt->res_skt);
  657. }
  658. if (list_empty(&soc_pcmcia_sockets))
  659. soc_pcmcia_cpufreq_unregister();
  660. up(&soc_pcmcia_sockets_lock);
  661. kfree(sinfo);
  662. return 0;
  663. }
  664. EXPORT_SYMBOL(soc_common_drv_pcmcia_remove);