PageRenderTime 86ms CodeModel.GetById 41ms RepoModel.GetById 0ms app.codeStats 1ms

/drivers/pcmcia/cs.c

https://bitbucket.org/evzijst/gittest
C | 1917 lines | 1383 code | 299 blank | 235 comment | 321 complexity | 5aa5a5c2978dd148a457c35a574ad6df MD5 | raw file
Possible License(s): CC-BY-SA-3.0, GPL-2.0, LGPL-2.0
  1. /*
  2. * cs.c -- Kernel Card Services - core services
  3. *
  4. * This program is free software; you can redistribute it and/or modify
  5. * it under the terms of the GNU General Public License version 2 as
  6. * published by the Free Software Foundation.
  7. *
  8. * The initial developer of the original code is David A. Hinds
  9. * <dahinds@users.sourceforge.net>. Portions created by David A. Hinds
  10. * are Copyright (C) 1999 David A. Hinds. All Rights Reserved.
  11. *
  12. * (C) 1999 David A. Hinds
  13. */
  14. #include <linux/module.h>
  15. #include <linux/moduleparam.h>
  16. #include <linux/init.h>
  17. #include <linux/kernel.h>
  18. #include <linux/config.h>
  19. #include <linux/string.h>
  20. #include <linux/major.h>
  21. #include <linux/errno.h>
  22. #include <linux/slab.h>
  23. #include <linux/mm.h>
  24. #include <linux/interrupt.h>
  25. #include <linux/timer.h>
  26. #include <linux/ioport.h>
  27. #include <linux/delay.h>
  28. #include <linux/pm.h>
  29. #include <linux/pci.h>
  30. #include <linux/device.h>
  31. #include <asm/system.h>
  32. #include <asm/irq.h>
  33. #define IN_CARD_SERVICES
  34. #include <pcmcia/version.h>
  35. #include <pcmcia/cs_types.h>
  36. #include <pcmcia/ss.h>
  37. #include <pcmcia/cs.h>
  38. #include <pcmcia/bulkmem.h>
  39. #include <pcmcia/cistpl.h>
  40. #include <pcmcia/cisreg.h>
  41. #include <pcmcia/ds.h>
  42. #include "cs_internal.h"
  43. #ifdef CONFIG_PCI
  44. #define PCI_OPT " [pci]"
  45. #else
  46. #define PCI_OPT ""
  47. #endif
  48. #ifdef CONFIG_CARDBUS
  49. #define CB_OPT " [cardbus]"
  50. #else
  51. #define CB_OPT ""
  52. #endif
  53. #ifdef CONFIG_PM
  54. #define PM_OPT " [pm]"
  55. #else
  56. #define PM_OPT ""
  57. #endif
  58. #if !defined(CONFIG_CARDBUS) && !defined(CONFIG_PCI) && !defined(CONFIG_PM)
  59. #define OPTIONS " none"
  60. #else
  61. #define OPTIONS PCI_OPT CB_OPT PM_OPT
  62. #endif
  63. static const char *release = "Linux Kernel Card Services";
  64. static const char *options = "options: " OPTIONS;
  65. /*====================================================================*/
  66. /* Module parameters */
  67. MODULE_AUTHOR("David Hinds <dahinds@users.sourceforge.net>");
  68. MODULE_DESCRIPTION("Linux Kernel Card Services\noptions:" OPTIONS);
  69. MODULE_LICENSE("GPL");
  70. #define INT_MODULE_PARM(n, v) static int n = v; module_param(n, int, 0444)
  71. INT_MODULE_PARM(setup_delay, 10); /* centiseconds */
  72. INT_MODULE_PARM(resume_delay, 20); /* centiseconds */
  73. INT_MODULE_PARM(shutdown_delay, 3); /* centiseconds */
  74. INT_MODULE_PARM(vcc_settle, 40); /* centiseconds */
  75. INT_MODULE_PARM(reset_time, 10); /* usecs */
  76. INT_MODULE_PARM(unreset_delay, 10); /* centiseconds */
  77. INT_MODULE_PARM(unreset_check, 10); /* centiseconds */
  78. INT_MODULE_PARM(unreset_limit, 30); /* unreset_check's */
  79. /* Access speed for attribute memory windows */
  80. INT_MODULE_PARM(cis_speed, 300); /* ns */
  81. /* Access speed for IO windows */
  82. INT_MODULE_PARM(io_speed, 0); /* ns */
  83. #ifdef DEBUG
  84. static int pc_debug;
  85. module_param(pc_debug, int, 0644);
  86. int cs_debug_level(int level)
  87. {
  88. return pc_debug > level;
  89. }
  90. #endif
  91. /*====================================================================*/
  92. socket_state_t dead_socket = {
  93. .csc_mask = SS_DETECT,
  94. };
  95. /* List of all sockets, protected by a rwsem */
  96. LIST_HEAD(pcmcia_socket_list);
  97. DECLARE_RWSEM(pcmcia_socket_list_rwsem);
  98. EXPORT_SYMBOL(pcmcia_socket_list);
  99. EXPORT_SYMBOL(pcmcia_socket_list_rwsem);
  100. #ifdef CONFIG_PCMCIA_PROBE
  101. /* mask ofIRQs already reserved by other cards, we should avoid using them */
  102. static u8 pcmcia_used_irq[NR_IRQS];
  103. #endif
  104. /*====================================================================
  105. Low-level PC Card interface drivers need to register with Card
  106. Services using these calls.
  107. ======================================================================*/
  108. /**
  109. * socket drivers are expected to use the following callbacks in their
  110. * .drv struct:
  111. * - pcmcia_socket_dev_suspend
  112. * - pcmcia_socket_dev_resume
  113. * These functions check for the appropriate struct pcmcia_soket arrays,
  114. * and pass them to the low-level functions pcmcia_{suspend,resume}_socket
  115. */
  116. static int socket_resume(struct pcmcia_socket *skt);
  117. static int socket_suspend(struct pcmcia_socket *skt);
  118. int pcmcia_socket_dev_suspend(struct device *dev, pm_message_t state)
  119. {
  120. struct pcmcia_socket *socket;
  121. down_read(&pcmcia_socket_list_rwsem);
  122. list_for_each_entry(socket, &pcmcia_socket_list, socket_list) {
  123. if (socket->dev.dev != dev)
  124. continue;
  125. down(&socket->skt_sem);
  126. socket_suspend(socket);
  127. up(&socket->skt_sem);
  128. }
  129. up_read(&pcmcia_socket_list_rwsem);
  130. return 0;
  131. }
  132. EXPORT_SYMBOL(pcmcia_socket_dev_suspend);
  133. int pcmcia_socket_dev_resume(struct device *dev)
  134. {
  135. struct pcmcia_socket *socket;
  136. down_read(&pcmcia_socket_list_rwsem);
  137. list_for_each_entry(socket, &pcmcia_socket_list, socket_list) {
  138. if (socket->dev.dev != dev)
  139. continue;
  140. down(&socket->skt_sem);
  141. socket_resume(socket);
  142. up(&socket->skt_sem);
  143. }
  144. up_read(&pcmcia_socket_list_rwsem);
  145. return 0;
  146. }
  147. EXPORT_SYMBOL(pcmcia_socket_dev_resume);
  148. struct pcmcia_socket * pcmcia_get_socket(struct pcmcia_socket *skt)
  149. {
  150. struct class_device *cl_dev = class_device_get(&skt->dev);
  151. if (!cl_dev)
  152. return NULL;
  153. skt = class_get_devdata(cl_dev);
  154. if (!try_module_get(skt->owner)) {
  155. class_device_put(&skt->dev);
  156. return NULL;
  157. }
  158. return (skt);
  159. }
  160. EXPORT_SYMBOL(pcmcia_get_socket);
  161. void pcmcia_put_socket(struct pcmcia_socket *skt)
  162. {
  163. module_put(skt->owner);
  164. class_device_put(&skt->dev);
  165. }
  166. EXPORT_SYMBOL(pcmcia_put_socket);
  167. static void pcmcia_release_socket(struct class_device *class_dev)
  168. {
  169. struct pcmcia_socket *socket = class_get_devdata(class_dev);
  170. complete(&socket->socket_released);
  171. }
  172. static int pccardd(void *__skt);
  173. /**
  174. * pcmcia_register_socket - add a new pcmcia socket device
  175. */
  176. int pcmcia_register_socket(struct pcmcia_socket *socket)
  177. {
  178. int ret;
  179. if (!socket || !socket->ops || !socket->dev.dev || !socket->resource_ops)
  180. return -EINVAL;
  181. cs_dbg(socket, 0, "pcmcia_register_socket(0x%p)\n", socket->ops);
  182. spin_lock_init(&socket->lock);
  183. if (socket->resource_ops->init) {
  184. ret = socket->resource_ops->init(socket);
  185. if (ret)
  186. return (ret);
  187. }
  188. /* try to obtain a socket number [yes, it gets ugly if we
  189. * register more than 2^sizeof(unsigned int) pcmcia
  190. * sockets... but the socket number is deprecated
  191. * anyways, so I don't care] */
  192. down_write(&pcmcia_socket_list_rwsem);
  193. if (list_empty(&pcmcia_socket_list))
  194. socket->sock = 0;
  195. else {
  196. unsigned int found, i = 1;
  197. struct pcmcia_socket *tmp;
  198. do {
  199. found = 1;
  200. list_for_each_entry(tmp, &pcmcia_socket_list, socket_list) {
  201. if (tmp->sock == i)
  202. found = 0;
  203. }
  204. i++;
  205. } while (!found);
  206. socket->sock = i - 1;
  207. }
  208. list_add_tail(&socket->socket_list, &pcmcia_socket_list);
  209. up_write(&pcmcia_socket_list_rwsem);
  210. /* set proper values in socket->dev */
  211. socket->dev.class_data = socket;
  212. socket->dev.class = &pcmcia_socket_class;
  213. snprintf(socket->dev.class_id, BUS_ID_SIZE, "pcmcia_socket%u", socket->sock);
  214. /* base address = 0, map = 0 */
  215. socket->cis_mem.flags = 0;
  216. socket->cis_mem.speed = cis_speed;
  217. INIT_LIST_HEAD(&socket->cis_cache);
  218. init_completion(&socket->socket_released);
  219. init_completion(&socket->thread_done);
  220. init_waitqueue_head(&socket->thread_wait);
  221. init_MUTEX(&socket->skt_sem);
  222. spin_lock_init(&socket->thread_lock);
  223. ret = kernel_thread(pccardd, socket, CLONE_KERNEL);
  224. if (ret < 0)
  225. goto err;
  226. wait_for_completion(&socket->thread_done);
  227. if(!socket->thread) {
  228. printk(KERN_WARNING "PCMCIA: warning: socket thread for socket %p did not start\n", socket);
  229. return -EIO;
  230. }
  231. pcmcia_parse_events(socket, SS_DETECT);
  232. return 0;
  233. err:
  234. down_write(&pcmcia_socket_list_rwsem);
  235. list_del(&socket->socket_list);
  236. up_write(&pcmcia_socket_list_rwsem);
  237. return ret;
  238. } /* pcmcia_register_socket */
  239. EXPORT_SYMBOL(pcmcia_register_socket);
  240. /**
  241. * pcmcia_unregister_socket - remove a pcmcia socket device
  242. */
  243. void pcmcia_unregister_socket(struct pcmcia_socket *socket)
  244. {
  245. if (!socket)
  246. return;
  247. cs_dbg(socket, 0, "pcmcia_unregister_socket(0x%p)\n", socket->ops);
  248. if (socket->thread) {
  249. init_completion(&socket->thread_done);
  250. socket->thread = NULL;
  251. wake_up(&socket->thread_wait);
  252. wait_for_completion(&socket->thread_done);
  253. }
  254. release_cis_mem(socket);
  255. /* remove from our own list */
  256. down_write(&pcmcia_socket_list_rwsem);
  257. list_del(&socket->socket_list);
  258. up_write(&pcmcia_socket_list_rwsem);
  259. /* wait for sysfs to drop all references */
  260. release_resource_db(socket);
  261. wait_for_completion(&socket->socket_released);
  262. } /* pcmcia_unregister_socket */
  263. EXPORT_SYMBOL(pcmcia_unregister_socket);
  264. struct pcmcia_socket * pcmcia_get_socket_by_nr(unsigned int nr)
  265. {
  266. struct pcmcia_socket *s;
  267. down_read(&pcmcia_socket_list_rwsem);
  268. list_for_each_entry(s, &pcmcia_socket_list, socket_list)
  269. if (s->sock == nr) {
  270. up_read(&pcmcia_socket_list_rwsem);
  271. return s;
  272. }
  273. up_read(&pcmcia_socket_list_rwsem);
  274. return NULL;
  275. }
  276. EXPORT_SYMBOL(pcmcia_get_socket_by_nr);
  277. /*======================================================================
  278. socket_setup() and shutdown_socket() are called by the main event
  279. handler when card insertion and removal events are received.
  280. socket_setup() turns on socket power and resets the socket, in two stages.
  281. shutdown_socket() unconfigures a socket and turns off socket power.
  282. ======================================================================*/
  283. static void shutdown_socket(struct pcmcia_socket *s)
  284. {
  285. cs_dbg(s, 1, "shutdown_socket\n");
  286. /* Blank out the socket state */
  287. s->socket = dead_socket;
  288. s->ops->init(s);
  289. s->ops->set_socket(s, &s->socket);
  290. s->irq.AssignedIRQ = s->irq.Config = 0;
  291. s->lock_count = 0;
  292. destroy_cis_cache(s);
  293. #ifdef CONFIG_CARDBUS
  294. cb_free(s);
  295. #endif
  296. s->functions = 0;
  297. if (s->config) {
  298. kfree(s->config);
  299. s->config = NULL;
  300. }
  301. {
  302. int status;
  303. s->ops->get_status(s, &status);
  304. if (status & SS_POWERON) {
  305. printk(KERN_ERR "PCMCIA: socket %p: *** DANGER *** unable to remove socket power\n", s);
  306. }
  307. }
  308. } /* shutdown_socket */
  309. /*======================================================================
  310. The central event handler. Send_event() sends an event to the
  311. 16-bit subsystem, which then calls the relevant device drivers.
  312. Parse_events() interprets the event bits from
  313. a card status change report. Do_shutdown() handles the high
  314. priority stuff associated with a card removal.
  315. ======================================================================*/
  316. /* NOTE: send_event needs to be called with skt->sem held. */
  317. static int send_event(struct pcmcia_socket *s, event_t event, int priority)
  318. {
  319. int ret;
  320. if (s->state & SOCKET_CARDBUS)
  321. return 0;
  322. cs_dbg(s, 1, "send_event(event %d, pri %d, callback 0x%p)\n",
  323. event, priority, s->callback);
  324. if (!s->callback)
  325. return 0;
  326. if (!try_module_get(s->callback->owner))
  327. return 0;
  328. ret = s->callback->event(s, event, priority);
  329. module_put(s->callback->owner);
  330. return ret;
  331. }
  332. static void socket_remove_drivers(struct pcmcia_socket *skt)
  333. {
  334. cs_dbg(skt, 4, "remove_drivers\n");
  335. send_event(skt, CS_EVENT_CARD_REMOVAL, CS_EVENT_PRI_HIGH);
  336. }
  337. static void socket_shutdown(struct pcmcia_socket *skt)
  338. {
  339. cs_dbg(skt, 4, "shutdown\n");
  340. socket_remove_drivers(skt);
  341. skt->state &= SOCKET_INUSE|SOCKET_PRESENT;
  342. msleep(shutdown_delay * 10);
  343. skt->state &= SOCKET_INUSE;
  344. shutdown_socket(skt);
  345. }
  346. static int socket_reset(struct pcmcia_socket *skt)
  347. {
  348. int status, i;
  349. cs_dbg(skt, 4, "reset\n");
  350. skt->socket.flags |= SS_OUTPUT_ENA | SS_RESET;
  351. skt->ops->set_socket(skt, &skt->socket);
  352. udelay((long)reset_time);
  353. skt->socket.flags &= ~SS_RESET;
  354. skt->ops->set_socket(skt, &skt->socket);
  355. msleep(unreset_delay * 10);
  356. for (i = 0; i < unreset_limit; i++) {
  357. skt->ops->get_status(skt, &status);
  358. if (!(status & SS_DETECT))
  359. return CS_NO_CARD;
  360. if (status & SS_READY)
  361. return CS_SUCCESS;
  362. msleep(unreset_check * 10);
  363. }
  364. cs_err(skt, "time out after reset.\n");
  365. return CS_GENERAL_FAILURE;
  366. }
  367. static int socket_setup(struct pcmcia_socket *skt, int initial_delay)
  368. {
  369. int status, i;
  370. cs_dbg(skt, 4, "setup\n");
  371. skt->ops->get_status(skt, &status);
  372. if (!(status & SS_DETECT))
  373. return CS_NO_CARD;
  374. msleep(initial_delay * 10);
  375. for (i = 0; i < 100; i++) {
  376. skt->ops->get_status(skt, &status);
  377. if (!(status & SS_DETECT))
  378. return CS_NO_CARD;
  379. if (!(status & SS_PENDING))
  380. break;
  381. msleep(100);
  382. }
  383. if (status & SS_PENDING) {
  384. cs_err(skt, "voltage interrogation timed out.\n");
  385. return CS_GENERAL_FAILURE;
  386. }
  387. if (status & SS_CARDBUS) {
  388. skt->state |= SOCKET_CARDBUS;
  389. #ifndef CONFIG_CARDBUS
  390. cs_err(skt, "cardbus cards are not supported.\n");
  391. return CS_BAD_TYPE;
  392. #endif
  393. }
  394. /*
  395. * Decode the card voltage requirements, and apply power to the card.
  396. */
  397. if (status & SS_3VCARD)
  398. skt->socket.Vcc = skt->socket.Vpp = 33;
  399. else if (!(status & SS_XVCARD))
  400. skt->socket.Vcc = skt->socket.Vpp = 50;
  401. else {
  402. cs_err(skt, "unsupported voltage key.\n");
  403. return CS_BAD_TYPE;
  404. }
  405. skt->socket.flags = 0;
  406. skt->ops->set_socket(skt, &skt->socket);
  407. /*
  408. * Wait "vcc_settle" for the supply to stabilise.
  409. */
  410. msleep(vcc_settle * 10);
  411. skt->ops->get_status(skt, &status);
  412. if (!(status & SS_POWERON)) {
  413. cs_err(skt, "unable to apply power.\n");
  414. return CS_BAD_TYPE;
  415. }
  416. return socket_reset(skt);
  417. }
  418. /*
  419. * Handle card insertion. Setup the socket, reset the card,
  420. * and then tell the rest of PCMCIA that a card is present.
  421. */
  422. static int socket_insert(struct pcmcia_socket *skt)
  423. {
  424. int ret;
  425. cs_dbg(skt, 4, "insert\n");
  426. if (!cs_socket_get(skt))
  427. return CS_NO_CARD;
  428. ret = socket_setup(skt, setup_delay);
  429. if (ret == CS_SUCCESS) {
  430. skt->state |= SOCKET_PRESENT;
  431. #ifdef CONFIG_CARDBUS
  432. if (skt->state & SOCKET_CARDBUS) {
  433. cb_alloc(skt);
  434. skt->state |= SOCKET_CARDBUS_CONFIG;
  435. }
  436. #endif
  437. cs_dbg(skt, 4, "insert done\n");
  438. send_event(skt, CS_EVENT_CARD_INSERTION, CS_EVENT_PRI_LOW);
  439. } else {
  440. socket_shutdown(skt);
  441. cs_socket_put(skt);
  442. }
  443. return ret;
  444. }
  445. static int socket_suspend(struct pcmcia_socket *skt)
  446. {
  447. if (skt->state & SOCKET_SUSPEND)
  448. return CS_IN_USE;
  449. send_event(skt, CS_EVENT_PM_SUSPEND, CS_EVENT_PRI_LOW);
  450. skt->socket = dead_socket;
  451. skt->ops->set_socket(skt, &skt->socket);
  452. if (skt->ops->suspend)
  453. skt->ops->suspend(skt);
  454. skt->state |= SOCKET_SUSPEND;
  455. return CS_SUCCESS;
  456. }
  457. /*
  458. * Resume a socket. If a card is present, verify its CIS against
  459. * our cached copy. If they are different, the card has been
  460. * replaced, and we need to tell the drivers.
  461. */
  462. static int socket_resume(struct pcmcia_socket *skt)
  463. {
  464. int ret;
  465. if (!(skt->state & SOCKET_SUSPEND))
  466. return CS_IN_USE;
  467. skt->socket = dead_socket;
  468. skt->ops->init(skt);
  469. skt->ops->set_socket(skt, &skt->socket);
  470. if (!(skt->state & SOCKET_PRESENT)) {
  471. skt->state &= ~SOCKET_SUSPEND;
  472. return socket_insert(skt);
  473. }
  474. ret = socket_setup(skt, resume_delay);
  475. if (ret == CS_SUCCESS) {
  476. /*
  477. * FIXME: need a better check here for cardbus cards.
  478. */
  479. if (verify_cis_cache(skt) != 0) {
  480. cs_dbg(skt, 4, "cis mismatch - different card\n");
  481. socket_remove_drivers(skt);
  482. destroy_cis_cache(skt);
  483. /*
  484. * Workaround: give DS time to schedule removal.
  485. * Remove me once the 100ms delay is eliminated
  486. * in ds.c
  487. */
  488. msleep(200);
  489. send_event(skt, CS_EVENT_CARD_INSERTION, CS_EVENT_PRI_LOW);
  490. } else {
  491. cs_dbg(skt, 4, "cis matches cache\n");
  492. send_event(skt, CS_EVENT_PM_RESUME, CS_EVENT_PRI_LOW);
  493. }
  494. } else {
  495. socket_shutdown(skt);
  496. cs_socket_put(skt);
  497. }
  498. skt->state &= ~SOCKET_SUSPEND;
  499. return CS_SUCCESS;
  500. }
  501. static void socket_remove(struct pcmcia_socket *skt)
  502. {
  503. socket_shutdown(skt);
  504. cs_socket_put(skt);
  505. }
  506. /*
  507. * Process a socket card detect status change.
  508. *
  509. * If we don't have a card already present, delay the detect event for
  510. * about 20ms (to be on the safe side) before reading the socket status.
  511. *
  512. * Some i82365-based systems send multiple SS_DETECT events during card
  513. * insertion, and the "card present" status bit seems to bounce. This
  514. * will probably be true with GPIO-based card detection systems after
  515. * the product has aged.
  516. */
  517. static void socket_detect_change(struct pcmcia_socket *skt)
  518. {
  519. if (!(skt->state & SOCKET_SUSPEND)) {
  520. int status;
  521. if (!(skt->state & SOCKET_PRESENT))
  522. msleep(20);
  523. skt->ops->get_status(skt, &status);
  524. if ((skt->state & SOCKET_PRESENT) &&
  525. !(status & SS_DETECT))
  526. socket_remove(skt);
  527. if (!(skt->state & SOCKET_PRESENT) &&
  528. (status & SS_DETECT))
  529. socket_insert(skt);
  530. }
  531. }
  532. static int pccardd(void *__skt)
  533. {
  534. struct pcmcia_socket *skt = __skt;
  535. DECLARE_WAITQUEUE(wait, current);
  536. int ret;
  537. daemonize("pccardd");
  538. skt->thread = current;
  539. skt->socket = dead_socket;
  540. skt->ops->init(skt);
  541. skt->ops->set_socket(skt, &skt->socket);
  542. /* register with the device core */
  543. ret = class_device_register(&skt->dev);
  544. if (ret) {
  545. printk(KERN_WARNING "PCMCIA: unable to register socket 0x%p\n",
  546. skt);
  547. skt->thread = NULL;
  548. complete_and_exit(&skt->thread_done, 0);
  549. }
  550. complete(&skt->thread_done);
  551. add_wait_queue(&skt->thread_wait, &wait);
  552. for (;;) {
  553. unsigned long flags;
  554. unsigned int events;
  555. set_current_state(TASK_INTERRUPTIBLE);
  556. spin_lock_irqsave(&skt->thread_lock, flags);
  557. events = skt->thread_events;
  558. skt->thread_events = 0;
  559. spin_unlock_irqrestore(&skt->thread_lock, flags);
  560. if (events) {
  561. down(&skt->skt_sem);
  562. if (events & SS_DETECT)
  563. socket_detect_change(skt);
  564. if (events & SS_BATDEAD)
  565. send_event(skt, CS_EVENT_BATTERY_DEAD, CS_EVENT_PRI_LOW);
  566. if (events & SS_BATWARN)
  567. send_event(skt, CS_EVENT_BATTERY_LOW, CS_EVENT_PRI_LOW);
  568. if (events & SS_READY)
  569. send_event(skt, CS_EVENT_READY_CHANGE, CS_EVENT_PRI_LOW);
  570. up(&skt->skt_sem);
  571. continue;
  572. }
  573. schedule();
  574. try_to_freeze(PF_FREEZE);
  575. if (!skt->thread)
  576. break;
  577. }
  578. remove_wait_queue(&skt->thread_wait, &wait);
  579. /* remove from the device core */
  580. class_device_unregister(&skt->dev);
  581. complete_and_exit(&skt->thread_done, 0);
  582. }
  583. /*
  584. * Yenta (at least) probes interrupts before registering the socket and
  585. * starting the handler thread.
  586. */
  587. void pcmcia_parse_events(struct pcmcia_socket *s, u_int events)
  588. {
  589. cs_dbg(s, 4, "parse_events: events %08x\n", events);
  590. if (s->thread) {
  591. spin_lock(&s->thread_lock);
  592. s->thread_events |= events;
  593. spin_unlock(&s->thread_lock);
  594. wake_up(&s->thread_wait);
  595. }
  596. } /* pcmcia_parse_events */
  597. /*======================================================================
  598. Special stuff for managing IO windows, because they are scarce.
  599. ======================================================================*/
  600. static int alloc_io_space(struct pcmcia_socket *s, u_int attr, ioaddr_t *base,
  601. ioaddr_t num, u_int lines)
  602. {
  603. int i;
  604. kio_addr_t try, align;
  605. align = (*base) ? (lines ? 1<<lines : 0) : 1;
  606. if (align && (align < num)) {
  607. if (*base) {
  608. cs_dbg(s, 0, "odd IO request: num %#x align %#lx\n",
  609. num, align);
  610. align = 0;
  611. } else
  612. while (align && (align < num)) align <<= 1;
  613. }
  614. if (*base & ~(align-1)) {
  615. cs_dbg(s, 0, "odd IO request: base %#x align %#lx\n",
  616. *base, align);
  617. align = 0;
  618. }
  619. if ((s->features & SS_CAP_STATIC_MAP) && s->io_offset) {
  620. *base = s->io_offset | (*base & 0x0fff);
  621. return 0;
  622. }
  623. /* Check for an already-allocated window that must conflict with
  624. what was asked for. It is a hack because it does not catch all
  625. potential conflicts, just the most obvious ones. */
  626. for (i = 0; i < MAX_IO_WIN; i++)
  627. if ((s->io[i].NumPorts != 0) &&
  628. ((s->io[i].BasePort & (align-1)) == *base))
  629. return 1;
  630. for (i = 0; i < MAX_IO_WIN; i++) {
  631. if (s->io[i].NumPorts == 0) {
  632. s->io[i].res = find_io_region(*base, num, align, s);
  633. if (s->io[i].res) {
  634. s->io[i].Attributes = attr;
  635. s->io[i].BasePort = *base = s->io[i].res->start;
  636. s->io[i].NumPorts = s->io[i].InUse = num;
  637. break;
  638. } else
  639. return 1;
  640. } else if (s->io[i].Attributes != attr)
  641. continue;
  642. /* Try to extend top of window */
  643. try = s->io[i].BasePort + s->io[i].NumPorts;
  644. if ((*base == 0) || (*base == try))
  645. if (adjust_io_region(s->io[i].res, s->io[i].res->start,
  646. s->io[i].res->end + num, s) == 0) {
  647. *base = try;
  648. s->io[i].NumPorts += num;
  649. s->io[i].InUse += num;
  650. break;
  651. }
  652. /* Try to extend bottom of window */
  653. try = s->io[i].BasePort - num;
  654. if ((*base == 0) || (*base == try))
  655. if (adjust_io_region(s->io[i].res, s->io[i].res->start - num,
  656. s->io[i].res->end, s) == 0) {
  657. s->io[i].BasePort = *base = try;
  658. s->io[i].NumPorts += num;
  659. s->io[i].InUse += num;
  660. break;
  661. }
  662. }
  663. return (i == MAX_IO_WIN);
  664. } /* alloc_io_space */
  665. static void release_io_space(struct pcmcia_socket *s, ioaddr_t base,
  666. ioaddr_t num)
  667. {
  668. int i;
  669. for (i = 0; i < MAX_IO_WIN; i++) {
  670. if ((s->io[i].BasePort <= base) &&
  671. (s->io[i].BasePort+s->io[i].NumPorts >= base+num)) {
  672. s->io[i].InUse -= num;
  673. /* Free the window if no one else is using it */
  674. if (s->io[i].InUse == 0) {
  675. s->io[i].NumPorts = 0;
  676. release_resource(s->io[i].res);
  677. kfree(s->io[i].res);
  678. s->io[i].res = NULL;
  679. }
  680. }
  681. }
  682. }
  683. /*======================================================================
  684. Access_configuration_register() reads and writes configuration
  685. registers in attribute memory. Memory window 0 is reserved for
  686. this and the tuple reading services.
  687. ======================================================================*/
  688. int pccard_access_configuration_register(struct pcmcia_socket *s,
  689. unsigned int function,
  690. conf_reg_t *reg)
  691. {
  692. config_t *c;
  693. int addr;
  694. u_char val;
  695. if (!s || !s->config)
  696. return CS_NO_CARD;
  697. c = &s->config[function];
  698. if (c == NULL)
  699. return CS_NO_CARD;
  700. if (!(c->state & CONFIG_LOCKED))
  701. return CS_CONFIGURATION_LOCKED;
  702. addr = (c->ConfigBase + reg->Offset) >> 1;
  703. switch (reg->Action) {
  704. case CS_READ:
  705. read_cis_mem(s, 1, addr, 1, &val);
  706. reg->Value = val;
  707. break;
  708. case CS_WRITE:
  709. val = reg->Value;
  710. write_cis_mem(s, 1, addr, 1, &val);
  711. break;
  712. default:
  713. return CS_BAD_ARGS;
  714. break;
  715. }
  716. return CS_SUCCESS;
  717. } /* access_configuration_register */
  718. EXPORT_SYMBOL(pccard_access_configuration_register);
  719. /*====================================================================*/
  720. int pccard_get_configuration_info(struct pcmcia_socket *s,
  721. unsigned int function,
  722. config_info_t *config)
  723. {
  724. config_t *c;
  725. if (!(s->state & SOCKET_PRESENT))
  726. return CS_NO_CARD;
  727. config->Function = function;
  728. #ifdef CONFIG_CARDBUS
  729. if (s->state & SOCKET_CARDBUS) {
  730. memset(config, 0, sizeof(config_info_t));
  731. config->Vcc = s->socket.Vcc;
  732. config->Vpp1 = config->Vpp2 = s->socket.Vpp;
  733. config->Option = s->cb_dev->subordinate->number;
  734. if (s->state & SOCKET_CARDBUS_CONFIG) {
  735. config->Attributes = CONF_VALID_CLIENT;
  736. config->IntType = INT_CARDBUS;
  737. config->AssignedIRQ = s->irq.AssignedIRQ;
  738. if (config->AssignedIRQ)
  739. config->Attributes |= CONF_ENABLE_IRQ;
  740. config->BasePort1 = s->io[0].BasePort;
  741. config->NumPorts1 = s->io[0].NumPorts;
  742. }
  743. return CS_SUCCESS;
  744. }
  745. #endif
  746. c = (s->config != NULL) ? &s->config[function] : NULL;
  747. if ((c == NULL) || !(c->state & CONFIG_LOCKED)) {
  748. config->Attributes = 0;
  749. config->Vcc = s->socket.Vcc;
  750. config->Vpp1 = config->Vpp2 = s->socket.Vpp;
  751. return CS_SUCCESS;
  752. }
  753. /* !!! This is a hack !!! */
  754. memcpy(&config->Attributes, &c->Attributes, sizeof(config_t));
  755. config->Attributes |= CONF_VALID_CLIENT;
  756. config->CardValues = c->CardValues;
  757. config->IRQAttributes = c->irq.Attributes;
  758. config->AssignedIRQ = s->irq.AssignedIRQ;
  759. config->BasePort1 = c->io.BasePort1;
  760. config->NumPorts1 = c->io.NumPorts1;
  761. config->Attributes1 = c->io.Attributes1;
  762. config->BasePort2 = c->io.BasePort2;
  763. config->NumPorts2 = c->io.NumPorts2;
  764. config->Attributes2 = c->io.Attributes2;
  765. config->IOAddrLines = c->io.IOAddrLines;
  766. return CS_SUCCESS;
  767. } /* get_configuration_info */
  768. EXPORT_SYMBOL(pccard_get_configuration_info);
  769. /*======================================================================
  770. Return information about this version of Card Services.
  771. ======================================================================*/
  772. int pcmcia_get_card_services_info(servinfo_t *info)
  773. {
  774. unsigned int socket_count = 0;
  775. struct list_head *tmp;
  776. info->Signature[0] = 'C';
  777. info->Signature[1] = 'S';
  778. down_read(&pcmcia_socket_list_rwsem);
  779. list_for_each(tmp, &pcmcia_socket_list)
  780. socket_count++;
  781. up_read(&pcmcia_socket_list_rwsem);
  782. info->Count = socket_count;
  783. info->Revision = CS_RELEASE_CODE;
  784. info->CSLevel = 0x0210;
  785. info->VendorString = (char *)release;
  786. return CS_SUCCESS;
  787. } /* get_card_services_info */
  788. /*====================================================================*/
  789. int pcmcia_get_window(struct pcmcia_socket *s, window_handle_t *handle, int idx, win_req_t *req)
  790. {
  791. window_t *win;
  792. int w;
  793. if (!s || !(s->state & SOCKET_PRESENT))
  794. return CS_NO_CARD;
  795. for (w = idx; w < MAX_WIN; w++)
  796. if (s->state & SOCKET_WIN_REQ(w)) break;
  797. if (w == MAX_WIN)
  798. return CS_NO_MORE_ITEMS;
  799. win = &s->win[w];
  800. req->Base = win->ctl.res->start;
  801. req->Size = win->ctl.res->end - win->ctl.res->start + 1;
  802. req->AccessSpeed = win->ctl.speed;
  803. req->Attributes = 0;
  804. if (win->ctl.flags & MAP_ATTRIB)
  805. req->Attributes |= WIN_MEMORY_TYPE_AM;
  806. if (win->ctl.flags & MAP_ACTIVE)
  807. req->Attributes |= WIN_ENABLE;
  808. if (win->ctl.flags & MAP_16BIT)
  809. req->Attributes |= WIN_DATA_WIDTH_16;
  810. if (win->ctl.flags & MAP_USE_WAIT)
  811. req->Attributes |= WIN_USE_WAIT;
  812. *handle = win;
  813. return CS_SUCCESS;
  814. } /* get_window */
  815. EXPORT_SYMBOL(pcmcia_get_window);
  816. /*=====================================================================
  817. Return the PCI device associated with a card..
  818. ======================================================================*/
  819. #ifdef CONFIG_CARDBUS
  820. struct pci_bus *pcmcia_lookup_bus(struct pcmcia_socket *s)
  821. {
  822. if (!s || !(s->state & SOCKET_CARDBUS))
  823. return NULL;
  824. return s->cb_dev->subordinate;
  825. }
  826. EXPORT_SYMBOL(pcmcia_lookup_bus);
  827. #endif
  828. /*======================================================================
  829. Get the current socket state bits. We don't support the latched
  830. SocketState yet: I haven't seen any point for it.
  831. ======================================================================*/
  832. int pccard_get_status(struct pcmcia_socket *s, unsigned int function, cs_status_t *status)
  833. {
  834. config_t *c;
  835. int val;
  836. s->ops->get_status(s, &val);
  837. status->CardState = status->SocketState = 0;
  838. status->CardState |= (val & SS_DETECT) ? CS_EVENT_CARD_DETECT : 0;
  839. status->CardState |= (val & SS_CARDBUS) ? CS_EVENT_CB_DETECT : 0;
  840. status->CardState |= (val & SS_3VCARD) ? CS_EVENT_3VCARD : 0;
  841. status->CardState |= (val & SS_XVCARD) ? CS_EVENT_XVCARD : 0;
  842. if (s->state & SOCKET_SUSPEND)
  843. status->CardState |= CS_EVENT_PM_SUSPEND;
  844. if (!(s->state & SOCKET_PRESENT))
  845. return CS_NO_CARD;
  846. c = (s->config != NULL) ? &s->config[function] : NULL;
  847. if ((c != NULL) && (c->state & CONFIG_LOCKED) &&
  848. (c->IntType & (INT_MEMORY_AND_IO | INT_ZOOMED_VIDEO))) {
  849. u_char reg;
  850. if (c->Present & PRESENT_PIN_REPLACE) {
  851. read_cis_mem(s, 1, (c->ConfigBase+CISREG_PRR)>>1, 1, &reg);
  852. status->CardState |=
  853. (reg & PRR_WP_STATUS) ? CS_EVENT_WRITE_PROTECT : 0;
  854. status->CardState |=
  855. (reg & PRR_READY_STATUS) ? CS_EVENT_READY_CHANGE : 0;
  856. status->CardState |=
  857. (reg & PRR_BVD2_STATUS) ? CS_EVENT_BATTERY_LOW : 0;
  858. status->CardState |=
  859. (reg & PRR_BVD1_STATUS) ? CS_EVENT_BATTERY_DEAD : 0;
  860. } else {
  861. /* No PRR? Then assume we're always ready */
  862. status->CardState |= CS_EVENT_READY_CHANGE;
  863. }
  864. if (c->Present & PRESENT_EXT_STATUS) {
  865. read_cis_mem(s, 1, (c->ConfigBase+CISREG_ESR)>>1, 1, &reg);
  866. status->CardState |=
  867. (reg & ESR_REQ_ATTN) ? CS_EVENT_REQUEST_ATTENTION : 0;
  868. }
  869. return CS_SUCCESS;
  870. }
  871. status->CardState |=
  872. (val & SS_WRPROT) ? CS_EVENT_WRITE_PROTECT : 0;
  873. status->CardState |=
  874. (val & SS_BATDEAD) ? CS_EVENT_BATTERY_DEAD : 0;
  875. status->CardState |=
  876. (val & SS_BATWARN) ? CS_EVENT_BATTERY_LOW : 0;
  877. status->CardState |=
  878. (val & SS_READY) ? CS_EVENT_READY_CHANGE : 0;
  879. return CS_SUCCESS;
  880. } /* get_status */
  881. EXPORT_SYMBOL(pccard_get_status);
  882. /*======================================================================
  883. Change the card address of an already open memory window.
  884. ======================================================================*/
  885. int pcmcia_get_mem_page(window_handle_t win, memreq_t *req)
  886. {
  887. if ((win == NULL) || (win->magic != WINDOW_MAGIC))
  888. return CS_BAD_HANDLE;
  889. req->Page = 0;
  890. req->CardOffset = win->ctl.card_start;
  891. return CS_SUCCESS;
  892. } /* get_mem_page */
  893. int pcmcia_map_mem_page(window_handle_t win, memreq_t *req)
  894. {
  895. struct pcmcia_socket *s;
  896. if ((win == NULL) || (win->magic != WINDOW_MAGIC))
  897. return CS_BAD_HANDLE;
  898. if (req->Page != 0)
  899. return CS_BAD_PAGE;
  900. s = win->sock;
  901. win->ctl.card_start = req->CardOffset;
  902. if (s->ops->set_mem_map(s, &win->ctl) != 0)
  903. return CS_BAD_OFFSET;
  904. return CS_SUCCESS;
  905. } /* map_mem_page */
  906. /*======================================================================
  907. Modify a locked socket configuration
  908. ======================================================================*/
  909. int pcmcia_modify_configuration(client_handle_t handle,
  910. modconf_t *mod)
  911. {
  912. struct pcmcia_socket *s;
  913. config_t *c;
  914. if (CHECK_HANDLE(handle))
  915. return CS_BAD_HANDLE;
  916. s = SOCKET(handle); c = CONFIG(handle);
  917. if (!(s->state & SOCKET_PRESENT))
  918. return CS_NO_CARD;
  919. if (!(c->state & CONFIG_LOCKED))
  920. return CS_CONFIGURATION_LOCKED;
  921. if (mod->Attributes & CONF_IRQ_CHANGE_VALID) {
  922. if (mod->Attributes & CONF_ENABLE_IRQ) {
  923. c->Attributes |= CONF_ENABLE_IRQ;
  924. s->socket.io_irq = s->irq.AssignedIRQ;
  925. } else {
  926. c->Attributes &= ~CONF_ENABLE_IRQ;
  927. s->socket.io_irq = 0;
  928. }
  929. s->ops->set_socket(s, &s->socket);
  930. }
  931. if (mod->Attributes & CONF_VCC_CHANGE_VALID)
  932. return CS_BAD_VCC;
  933. /* We only allow changing Vpp1 and Vpp2 to the same value */
  934. if ((mod->Attributes & CONF_VPP1_CHANGE_VALID) &&
  935. (mod->Attributes & CONF_VPP2_CHANGE_VALID)) {
  936. if (mod->Vpp1 != mod->Vpp2)
  937. return CS_BAD_VPP;
  938. c->Vpp1 = c->Vpp2 = s->socket.Vpp = mod->Vpp1;
  939. if (s->ops->set_socket(s, &s->socket))
  940. return CS_BAD_VPP;
  941. } else if ((mod->Attributes & CONF_VPP1_CHANGE_VALID) ||
  942. (mod->Attributes & CONF_VPP2_CHANGE_VALID))
  943. return CS_BAD_VPP;
  944. return CS_SUCCESS;
  945. } /* modify_configuration */
  946. /* register pcmcia_callback */
  947. int pccard_register_pcmcia(struct pcmcia_socket *s, struct pcmcia_callback *c)
  948. {
  949. int ret = 0;
  950. /* s->skt_sem also protects s->callback */
  951. down(&s->skt_sem);
  952. if (c) {
  953. /* registration */
  954. if (s->callback) {
  955. ret = -EBUSY;
  956. goto err;
  957. }
  958. s->callback = c;
  959. if ((s->state & (SOCKET_PRESENT|SOCKET_CARDBUS)) == SOCKET_PRESENT)
  960. send_event(s, CS_EVENT_CARD_INSERTION, CS_EVENT_PRI_LOW);
  961. } else
  962. s->callback = NULL;
  963. err:
  964. up(&s->skt_sem);
  965. return ret;
  966. }
  967. EXPORT_SYMBOL(pccard_register_pcmcia);
  968. /*====================================================================*/
  969. int pcmcia_release_configuration(client_handle_t handle)
  970. {
  971. pccard_io_map io = { 0, 0, 0, 0, 1 };
  972. struct pcmcia_socket *s;
  973. int i;
  974. if (CHECK_HANDLE(handle) ||
  975. !(handle->state & CLIENT_CONFIG_LOCKED))
  976. return CS_BAD_HANDLE;
  977. handle->state &= ~CLIENT_CONFIG_LOCKED;
  978. s = SOCKET(handle);
  979. #ifdef CONFIG_CARDBUS
  980. if (handle->state & CLIENT_CARDBUS)
  981. return CS_SUCCESS;
  982. #endif
  983. if (!(handle->state & CLIENT_STALE)) {
  984. config_t *c = CONFIG(handle);
  985. if (--(s->lock_count) == 0) {
  986. s->socket.flags = SS_OUTPUT_ENA; /* Is this correct? */
  987. s->socket.Vpp = 0;
  988. s->socket.io_irq = 0;
  989. s->ops->set_socket(s, &s->socket);
  990. }
  991. if (c->state & CONFIG_IO_REQ)
  992. for (i = 0; i < MAX_IO_WIN; i++) {
  993. if (s->io[i].NumPorts == 0)
  994. continue;
  995. s->io[i].Config--;
  996. if (s->io[i].Config != 0)
  997. continue;
  998. io.map = i;
  999. s->ops->set_io_map(s, &io);
  1000. }
  1001. c->state &= ~CONFIG_LOCKED;
  1002. }
  1003. return CS_SUCCESS;
  1004. } /* release_configuration */
  1005. /*======================================================================
  1006. Release_io() releases the I/O ranges allocated by a client. This
  1007. may be invoked some time after a card ejection has already dumped
  1008. the actual socket configuration, so if the client is "stale", we
  1009. don't bother checking the port ranges against the current socket
  1010. values.
  1011. ======================================================================*/
  1012. int pcmcia_release_io(client_handle_t handle, io_req_t *req)
  1013. {
  1014. struct pcmcia_socket *s;
  1015. if (CHECK_HANDLE(handle) || !(handle->state & CLIENT_IO_REQ))
  1016. return CS_BAD_HANDLE;
  1017. handle->state &= ~CLIENT_IO_REQ;
  1018. s = SOCKET(handle);
  1019. #ifdef CONFIG_CARDBUS
  1020. if (handle->state & CLIENT_CARDBUS)
  1021. return CS_SUCCESS;
  1022. #endif
  1023. if (!(handle->state & CLIENT_STALE)) {
  1024. config_t *c = CONFIG(handle);
  1025. if (c->state & CONFIG_LOCKED)
  1026. return CS_CONFIGURATION_LOCKED;
  1027. if ((c->io.BasePort1 != req->BasePort1) ||
  1028. (c->io.NumPorts1 != req->NumPorts1) ||
  1029. (c->io.BasePort2 != req->BasePort2) ||
  1030. (c->io.NumPorts2 != req->NumPorts2))
  1031. return CS_BAD_ARGS;
  1032. c->state &= ~CONFIG_IO_REQ;
  1033. }
  1034. release_io_space(s, req->BasePort1, req->NumPorts1);
  1035. if (req->NumPorts2)
  1036. release_io_space(s, req->BasePort2, req->NumPorts2);
  1037. return CS_SUCCESS;
  1038. } /* release_io */
  1039. /*====================================================================*/
  1040. int pcmcia_release_irq(client_handle_t handle, irq_req_t *req)
  1041. {
  1042. struct pcmcia_socket *s;
  1043. if (CHECK_HANDLE(handle) || !(handle->state & CLIENT_IRQ_REQ))
  1044. return CS_BAD_HANDLE;
  1045. handle->state &= ~CLIENT_IRQ_REQ;
  1046. s = SOCKET(handle);
  1047. if (!(handle->state & CLIENT_STALE)) {
  1048. config_t *c = CONFIG(handle);
  1049. if (c->state & CONFIG_LOCKED)
  1050. return CS_CONFIGURATION_LOCKED;
  1051. if (c->irq.Attributes != req->Attributes)
  1052. return CS_BAD_ATTRIBUTE;
  1053. if (s->irq.AssignedIRQ != req->AssignedIRQ)
  1054. return CS_BAD_IRQ;
  1055. if (--s->irq.Config == 0) {
  1056. c->state &= ~CONFIG_IRQ_REQ;
  1057. s->irq.AssignedIRQ = 0;
  1058. }
  1059. }
  1060. if (req->Attributes & IRQ_HANDLE_PRESENT) {
  1061. free_irq(req->AssignedIRQ, req->Instance);
  1062. }
  1063. #ifdef CONFIG_PCMCIA_PROBE
  1064. pcmcia_used_irq[req->AssignedIRQ]--;
  1065. #endif
  1066. return CS_SUCCESS;
  1067. } /* cs_release_irq */
  1068. /*====================================================================*/
  1069. int pcmcia_release_window(window_handle_t win)
  1070. {
  1071. struct pcmcia_socket *s;
  1072. if ((win == NULL) || (win->magic != WINDOW_MAGIC))
  1073. return CS_BAD_HANDLE;
  1074. s = win->sock;
  1075. if (!(win->handle->state & CLIENT_WIN_REQ(win->index)))
  1076. return CS_BAD_HANDLE;
  1077. /* Shut down memory window */
  1078. win->ctl.flags &= ~MAP_ACTIVE;
  1079. s->ops->set_mem_map(s, &win->ctl);
  1080. s->state &= ~SOCKET_WIN_REQ(win->index);
  1081. /* Release system memory */
  1082. if (win->ctl.res) {
  1083. release_resource(win->ctl.res);
  1084. kfree(win->ctl.res);
  1085. win->ctl.res = NULL;
  1086. }
  1087. win->handle->state &= ~CLIENT_WIN_REQ(win->index);
  1088. win->magic = 0;
  1089. return CS_SUCCESS;
  1090. } /* release_window */
  1091. /*====================================================================*/
  1092. int pcmcia_request_configuration(client_handle_t handle,
  1093. config_req_t *req)
  1094. {
  1095. int i;
  1096. u_int base;
  1097. struct pcmcia_socket *s;
  1098. config_t *c;
  1099. pccard_io_map iomap;
  1100. if (CHECK_HANDLE(handle))
  1101. return CS_BAD_HANDLE;
  1102. s = SOCKET(handle);
  1103. if (!(s->state & SOCKET_PRESENT))
  1104. return CS_NO_CARD;
  1105. #ifdef CONFIG_CARDBUS
  1106. if (handle->state & CLIENT_CARDBUS)
  1107. return CS_UNSUPPORTED_MODE;
  1108. #endif
  1109. if (req->IntType & INT_CARDBUS)
  1110. return CS_UNSUPPORTED_MODE;
  1111. c = CONFIG(handle);
  1112. if (c->state & CONFIG_LOCKED)
  1113. return CS_CONFIGURATION_LOCKED;
  1114. /* Do power control. We don't allow changes in Vcc. */
  1115. if (s->socket.Vcc != req->Vcc)
  1116. return CS_BAD_VCC;
  1117. if (req->Vpp1 != req->Vpp2)
  1118. return CS_BAD_VPP;
  1119. s->socket.Vpp = req->Vpp1;
  1120. if (s->ops->set_socket(s, &s->socket))
  1121. return CS_BAD_VPP;
  1122. c->Vcc = req->Vcc; c->Vpp1 = c->Vpp2 = req->Vpp1;
  1123. /* Pick memory or I/O card, DMA mode, interrupt */
  1124. c->IntType = req->IntType;
  1125. c->Attributes = req->Attributes;
  1126. if (req->IntType & INT_MEMORY_AND_IO)
  1127. s->socket.flags |= SS_IOCARD;
  1128. if (req->IntType & INT_ZOOMED_VIDEO)
  1129. s->socket.flags |= SS_ZVCARD | SS_IOCARD;
  1130. if (req->Attributes & CONF_ENABLE_DMA)
  1131. s->socket.flags |= SS_DMA_MODE;
  1132. if (req->Attributes & CONF_ENABLE_SPKR)
  1133. s->socket.flags |= SS_SPKR_ENA;
  1134. if (req->Attributes & CONF_ENABLE_IRQ)
  1135. s->socket.io_irq = s->irq.AssignedIRQ;
  1136. else
  1137. s->socket.io_irq = 0;
  1138. s->ops->set_socket(s, &s->socket);
  1139. s->lock_count++;
  1140. /* Set up CIS configuration registers */
  1141. base = c->ConfigBase = req->ConfigBase;
  1142. c->Present = c->CardValues = req->Present;
  1143. if (req->Present & PRESENT_COPY) {
  1144. c->Copy = req->Copy;
  1145. write_cis_mem(s, 1, (base + CISREG_SCR)>>1, 1, &c->Copy);
  1146. }
  1147. if (req->Present & PRESENT_OPTION) {
  1148. if (s->functions == 1) {
  1149. c->Option = req->ConfigIndex & COR_CONFIG_MASK;
  1150. } else {
  1151. c->Option = req->ConfigIndex & COR_MFC_CONFIG_MASK;
  1152. c->Option |= COR_FUNC_ENA|COR_IREQ_ENA;
  1153. if (req->Present & PRESENT_IOBASE_0)
  1154. c->Option |= COR_ADDR_DECODE;
  1155. }
  1156. if (c->state & CONFIG_IRQ_REQ)
  1157. if (!(c->irq.Attributes & IRQ_FORCED_PULSE))
  1158. c->Option |= COR_LEVEL_REQ;
  1159. write_cis_mem(s, 1, (base + CISREG_COR)>>1, 1, &c->Option);
  1160. mdelay(40);
  1161. }
  1162. if (req->Present & PRESENT_STATUS) {
  1163. c->Status = req->Status;
  1164. write_cis_mem(s, 1, (base + CISREG_CCSR)>>1, 1, &c->Status);
  1165. }
  1166. if (req->Present & PRESENT_PIN_REPLACE) {
  1167. c->Pin = req->Pin;
  1168. write_cis_mem(s, 1, (base + CISREG_PRR)>>1, 1, &c->Pin);
  1169. }
  1170. if (req->Present & PRESENT_EXT_STATUS) {
  1171. c->ExtStatus = req->ExtStatus;
  1172. write_cis_mem(s, 1, (base + CISREG_ESR)>>1, 1, &c->ExtStatus);
  1173. }
  1174. if (req->Present & PRESENT_IOBASE_0) {
  1175. u_char b = c->io.BasePort1 & 0xff;
  1176. write_cis_mem(s, 1, (base + CISREG_IOBASE_0)>>1, 1, &b);
  1177. b = (c->io.BasePort1 >> 8) & 0xff;
  1178. write_cis_mem(s, 1, (base + CISREG_IOBASE_1)>>1, 1, &b);
  1179. }
  1180. if (req->Present & PRESENT_IOSIZE) {
  1181. u_char b = c->io.NumPorts1 + c->io.NumPorts2 - 1;
  1182. write_cis_mem(s, 1, (base + CISREG_IOSIZE)>>1, 1, &b);
  1183. }
  1184. /* Configure I/O windows */
  1185. if (c->state & CONFIG_IO_REQ) {
  1186. iomap.speed = io_speed;
  1187. for (i = 0; i < MAX_IO_WIN; i++)
  1188. if (s->io[i].NumPorts != 0) {
  1189. iomap.map = i;
  1190. iomap.flags = MAP_ACTIVE;
  1191. switch (s->io[i].Attributes & IO_DATA_PATH_WIDTH) {
  1192. case IO_DATA_PATH_WIDTH_16:
  1193. iomap.flags |= MAP_16BIT; break;
  1194. case IO_DATA_PATH_WIDTH_AUTO:
  1195. iomap.flags |= MAP_AUTOSZ; break;
  1196. default:
  1197. break;
  1198. }
  1199. iomap.start = s->io[i].BasePort;
  1200. iomap.stop = iomap.start + s->io[i].NumPorts - 1;
  1201. s->ops->set_io_map(s, &iomap);
  1202. s->io[i].Config++;
  1203. }
  1204. }
  1205. c->state |= CONFIG_LOCKED;
  1206. handle->state |= CLIENT_CONFIG_LOCKED;
  1207. return CS_SUCCESS;
  1208. } /* request_configuration */
  1209. /*======================================================================
  1210. Request_io() reserves ranges of port addresses for a socket.
  1211. I have not implemented range sharing or alias addressing.
  1212. ======================================================================*/
  1213. int pcmcia_request_io(client_handle_t handle, io_req_t *req)
  1214. {
  1215. struct pcmcia_socket *s;
  1216. config_t *c;
  1217. if (CHECK_HANDLE(handle))
  1218. return CS_BAD_HANDLE;
  1219. s = SOCKET(handle);
  1220. if (!(s->state & SOCKET_PRESENT))
  1221. return CS_NO_CARD;
  1222. if (handle->state & CLIENT_CARDBUS) {
  1223. #ifdef CONFIG_CARDBUS
  1224. handle->state |= CLIENT_IO_REQ;
  1225. return CS_SUCCESS;
  1226. #else
  1227. return CS_UNSUPPORTED_FUNCTION;
  1228. #endif
  1229. }
  1230. if (!req)
  1231. return CS_UNSUPPORTED_MODE;
  1232. c = CONFIG(handle);
  1233. if (c->state & CONFIG_LOCKED)
  1234. return CS_CONFIGURATION_LOCKED;
  1235. if (c->state & CONFIG_IO_REQ)
  1236. return CS_IN_USE;
  1237. if (req->Attributes1 & (IO_SHARED | IO_FORCE_ALIAS_ACCESS))
  1238. return CS_BAD_ATTRIBUTE;
  1239. if ((req->NumPorts2 > 0) &&
  1240. (req->Attributes2 & (IO_SHARED | IO_FORCE_ALIAS_ACCESS)))
  1241. return CS_BAD_ATTRIBUTE;
  1242. if (alloc_io_space(s, req->Attributes1, &req->BasePort1,
  1243. req->NumPorts1, req->IOAddrLines))
  1244. return CS_IN_USE;
  1245. if (req->NumPorts2) {
  1246. if (alloc_io_space(s, req->Attributes2, &req->BasePort2,
  1247. req->NumPorts2, req->IOAddrLines)) {
  1248. release_io_space(s, req->BasePort1, req->NumPorts1);
  1249. return CS_IN_USE;
  1250. }
  1251. }
  1252. c->io = *req;
  1253. c->state |= CONFIG_IO_REQ;
  1254. handle->state |= CLIENT_IO_REQ;
  1255. return CS_SUCCESS;
  1256. } /* request_io */
  1257. /*======================================================================
  1258. Request_irq() reserves an irq for this client.
  1259. Also, since Linux only reserves irq's when they are actually
  1260. hooked, we don't guarantee that an irq will still be available
  1261. when the configuration is locked. Now that I think about it,
  1262. there might be a way to fix this using a dummy handler.
  1263. ======================================================================*/
  1264. #ifdef CONFIG_PCMCIA_PROBE
  1265. static irqreturn_t test_action(int cpl, void *dev_id, struct pt_regs *regs)
  1266. {
  1267. return IRQ_NONE;
  1268. }
  1269. #endif
  1270. int pcmcia_request_irq(client_handle_t handle, irq_req_t *req)
  1271. {
  1272. struct pcmcia_socket *s;
  1273. config_t *c;
  1274. int ret = CS_IN_USE, irq = 0;
  1275. struct pcmcia_device *p_dev = handle_to_pdev(handle);
  1276. if (CHECK_HANDLE(handle))
  1277. return CS_BAD_HANDLE;
  1278. s = SOCKET(handle);
  1279. if (!(s->state & SOCKET_PRESENT))
  1280. return CS_NO_CARD;
  1281. c = CONFIG(handle);
  1282. if (c->state & CONFIG_LOCKED)
  1283. return CS_CONFIGURATION_LOCKED;
  1284. if (c->state & CONFIG_IRQ_REQ)
  1285. return CS_IN_USE;
  1286. #ifdef CONFIG_PCMCIA_PROBE
  1287. if (s->irq.AssignedIRQ != 0) {
  1288. /* If the interrupt is already assigned, it must be the same */
  1289. irq = s->irq.AssignedIRQ;
  1290. } else {
  1291. int try;
  1292. u32 mask = s->irq_mask;
  1293. void *data = NULL;
  1294. for (try = 0; try < 64; try++) {
  1295. irq = try % 32;
  1296. /* marked as available by driver, and not blocked by userspace? */
  1297. if (!((mask >> irq) & 1))
  1298. continue;
  1299. /* avoid an IRQ which is already used by a PCMCIA card */
  1300. if ((try < 32) && pcmcia_used_irq[irq])
  1301. continue;
  1302. /* register the correct driver, if possible, of check whether
  1303. * registering a dummy handle works, i.e. if the IRQ isn't
  1304. * marked as used by the kernel resource management core */
  1305. ret = request_irq(irq,
  1306. (req->Attributes & IRQ_HANDLE_PRESENT) ? req->Handler : test_action,
  1307. ((req->Attributes & IRQ_TYPE_DYNAMIC_SHARING) ||
  1308. (s->functions > 1) ||
  1309. (irq == s->pci_irq)) ? SA_SHIRQ : 0,
  1310. p_dev->dev.bus_id,
  1311. (req->Attributes & IRQ_HANDLE_PRESENT) ? req->Instance : data);
  1312. if (!ret) {
  1313. if (!(req->Attributes & IRQ_HANDLE_PRESENT))
  1314. free_irq(irq, data);
  1315. break;
  1316. }
  1317. }
  1318. }
  1319. #endif
  1320. if (ret) {
  1321. if (!s->pci_irq)
  1322. return ret;
  1323. irq = s->pci_irq;
  1324. }
  1325. if (ret && req->Attributes & IRQ_HANDLE_PRESENT) {
  1326. if (request_irq(irq, req->Handler,
  1327. ((req->Attributes & IRQ_TYPE_DYNAMIC_SHARING) ||
  1328. (s->functions > 1) ||
  1329. (irq == s->pci_irq)) ? SA_SHIRQ : 0,
  1330. p_dev->dev.bus_id, req->Instance))
  1331. return CS_IN_USE;
  1332. }
  1333. c->irq.Attributes = req->Attributes;
  1334. s->irq.AssignedIRQ = req->AssignedIRQ = irq;
  1335. s->irq.Config++;
  1336. c->state |= CONFIG_IRQ_REQ;
  1337. handle->state |= CLIENT_IRQ_REQ;
  1338. #ifdef CONFIG_PCMCIA_PROBE
  1339. pcmcia_used_irq[irq]++;
  1340. #endif
  1341. return CS_SUCCESS;
  1342. } /* pcmcia_request_irq */
  1343. /*======================================================================
  1344. Request_window() establishes a mapping between card memory space
  1345. and system memory space.
  1346. ======================================================================*/
  1347. int pcmcia_request_window(client_handle_t *handle, win_req_t *req, window_handle_t *wh)
  1348. {
  1349. struct pcmcia_socket *s;
  1350. window_t *win;
  1351. u_long align;
  1352. int w;
  1353. if (CHECK_HANDLE(*handle))
  1354. return CS_BAD_HANDLE;
  1355. s = (*handle)->Socket;
  1356. if (!(s->state & SOCKET_PRESENT))
  1357. return CS_NO_CARD;
  1358. if (req->Attributes & (WIN_PAGED | WIN_SHARED))
  1359. return CS_BAD_ATTRIBUTE;
  1360. /* Window size defaults to smallest available */
  1361. if (req->Size == 0)
  1362. req->Size = s->map_size;
  1363. align = (((s->features & SS_CAP_MEM_ALIGN) ||
  1364. (req->Attributes & WIN_STRICT_ALIGN)) ?
  1365. req->Size : s->map_size);
  1366. if (req->Size & (s->map_size-1))
  1367. return CS_BAD_SIZE;
  1368. if ((req->Base && (s->features & SS_CAP_STATIC_MAP)) ||
  1369. (req->Base & (align-1)))
  1370. return CS_BAD_BASE;
  1371. if (req->Base)
  1372. align = 0;
  1373. /* Allocate system memory window */
  1374. for (w = 0; w < MAX_WIN; w++)
  1375. if (!(s->state & SOCKET_WIN_REQ(w))) break;
  1376. if (w == MAX_WIN)
  1377. return CS_OUT_OF_RESOURCE;
  1378. win = &s->win[w];
  1379. win->magic = WINDOW_MAGIC;
  1380. win->index = w;
  1381. win->handle = *handle;
  1382. win->sock = s;
  1383. if (!(s->features & SS_CAP_STATIC_MAP)) {
  1384. win->ctl.res = find_mem_region(req->Base, req->Size, align,
  1385. (req->Attributes & WIN_MAP_BELOW_1MB), s);
  1386. if (!win->ctl.res)
  1387. return CS_IN_USE;
  1388. }
  1389. (*handle)->state |= CLIENT_WIN_REQ(w);
  1390. /* Configure the socket controller */
  1391. win->ctl.map = w+1;
  1392. win->ctl.flags = 0;
  1393. win->ctl.speed = req->AccessSpeed;
  1394. if (req->Attributes & WIN_MEMORY_TYPE)
  1395. win->ctl.flags |= MAP_ATTRIB;
  1396. if (req->Attributes & WIN_ENABLE)
  1397. win->ctl.flags |= MAP_ACTIVE;
  1398. if (req->Attributes & WIN_DATA_WIDTH_16)
  1399. win->ctl.flags |= MAP_16BIT;
  1400. if (req->Attributes & WIN_USE_WAIT)
  1401. win->ctl.flags |= MAP_USE_WAIT;
  1402. win->ctl.card_start = 0;
  1403. if (s->ops->set_mem_map(s, &win->ctl) != 0)
  1404. return CS_BAD_ARGS;
  1405. s->state |= SOCKET_WIN_REQ(w);
  1406. /* Return window handle */
  1407. if (s->features & SS_CAP_STATIC_MAP) {
  1408. req->Base = win->ctl.static_start;
  1409. } else {
  1410. req->Base = win->ctl.res->start;
  1411. }
  1412. *wh = win;
  1413. return CS_SUCCESS;
  1414. } /* request_window */
  1415. /*======================================================================
  1416. I'm not sure which "reset" function this is supposed to use,
  1417. but for now, it uses the low-level interface's reset, not the
  1418. CIS register.
  1419. ======================================================================*/
  1420. int pccard_reset_card(struct pcmcia_socket *skt)
  1421. {
  1422. int ret;
  1423. cs_dbg(skt, 1, "resetting socket\n");
  1424. down(&skt->skt_sem);
  1425. do {
  1426. if (!(skt->state & SOCKET_PRESENT)) {
  1427. ret = CS_NO_CARD;
  1428. break;
  1429. }
  1430. if (skt->state & SOCKET_SUSPEND) {
  1431. ret = CS_IN_USE;
  1432. break;
  1433. }
  1434. if (skt->state & SOCKET_CARDBUS) {
  1435. ret = CS_UNSUPPORTED_FUNCTION;
  1436. break;
  1437. }
  1438. ret = send_event(skt, CS_EVENT_RESET_REQUEST, CS_EVENT_PRI_LOW);
  1439. if (ret == 0) {
  1440. send_event(skt, CS_EVENT_RESET_PHYSICAL, CS_EVENT_PRI_LOW);
  1441. if (socket_reset(skt) == CS_SUCCESS)
  1442. send_event(skt, CS_EVENT_CARD_RESET, CS_EVENT_PRI_LOW);
  1443. }
  1444. ret = CS_SUCCESS;
  1445. } while (0);
  1446. up(&skt->skt_sem);
  1447. return ret;
  1448. } /* reset_card */
  1449. EXPORT_SYMBOL(pccard_reset_card);
  1450. /*======================================================================
  1451. These shut down or wake up a socket. They are sort of user
  1452. initiated versions of the APM suspend and resume actions.
  1453. ======================================================================*/
  1454. int pcmcia_suspend_card(struct pcmcia_socket *skt)
  1455. {
  1456. int ret;
  1457. cs_dbg(skt, 1, "suspending socket\n");
  1458. down(&skt->skt_sem);
  1459. do {
  1460. if (!(skt->state & SOCKET_PRESENT)) {
  1461. ret = CS_NO_CARD;
  1462. break;
  1463. }
  1464. if (skt->state & SOCKET_CARDBUS) {
  1465. ret = CS_UNSUPPORTED_FUNCTION;
  1466. break;
  1467. }
  1468. ret = socket_suspend(skt);
  1469. } while (0);
  1470. up(&skt->skt_sem);
  1471. return ret;
  1472. } /* suspend_card */
  1473. int pcmcia_resume_card(struct pcmcia_socket *skt)
  1474. {
  1475. int ret;
  1476. cs_dbg(skt, 1, "waking up socket\n");
  1477. down(&skt->skt_sem);
  1478. do {
  1479. if (!(skt->state & SOCKET_PRESENT)) {
  1480. ret = CS_NO_CARD;
  1481. break;
  1482. }
  1483. if (skt->state & SOCKET_CARDBUS) {
  1484. ret = CS_UNSUPPORTED_FUNCTION;
  1485. break;
  1486. }
  1487. ret = socket_resume(skt);
  1488. } while (0);
  1489. up(&skt->skt_sem);
  1490. return ret;
  1491. } /* resume_card */
  1492. /*======================================================================
  1493. These handle user requests to eject or insert a card.
  1494. ======================================================================*/
  1495. int pcmcia_eject_card(struct pcmcia_socket *skt)
  1496. {
  1497. int ret;
  1498. cs_dbg(skt, 1, "user eject request\n");
  1499. down(&skt->skt_sem);
  1500. do {
  1501. if (!(skt->state & SOCKET_PRESENT)) {
  1502. ret = -ENODEV;
  1503. break;
  1504. }
  1505. ret = send_event(skt, CS_EVENT_EJECTION_REQUEST, CS_EVENT_PRI_LOW);
  1506. if (ret != 0) {
  1507. ret = -EINVAL;
  1508. break;
  1509. }
  1510. socket_remove(skt);
  1511. ret = 0;
  1512. } while (0);
  1513. up(&skt->skt_sem);
  1514. return ret;
  1515. } /* eject_card */
  1516. int pcmcia_insert_card(struct pcmcia_socket *skt)
  1517. {
  1518. int ret;
  1519. cs_dbg(skt, 1, "user insert request\n");
  1520. down(&skt->skt_sem);
  1521. do {
  1522. if (skt->state & SOCKET_PRESENT) {
  1523. ret = -EBUSY;
  1524. break;
  1525. }
  1526. if (socket_insert(skt) == CS_NO_CARD) {
  1527. ret = -ENODEV;
  1528. break;
  1529. }
  1530. ret = 0;
  1531. } while (0);
  1532. up(&skt->skt_sem);
  1533. return ret;
  1534. } /* insert_card */
  1535. /*======================================================================
  1536. OS-specific module glue goes here
  1537. ======================================================================*/
  1538. /* in alpha order */
  1539. EXPORT_SYMBOL(pcmcia_eject_card);
  1540. EXPORT_SYMBOL(pcmcia_get_card_services_info);
  1541. EXPORT_SYMBOL(pcmcia_get_mem_page);
  1542. EXPORT_SYMBOL(pcmcia_insert_card);
  1543. EXPORT_SYMBOL(pcmcia_map_mem_page);
  1544. EXPORT_SYMBOL(pcmcia_modify_configuration);
  1545. EXPORT_SYMBOL(pcmcia_release_configuration);
  1546. EXPORT_SYMBOL(pcmcia_release_io);
  1547. EXPORT_SYMBOL(pcmcia_release_irq);
  1548. EXPORT_SYMBOL(pcmcia_release_window);
  1549. EXPORT_SYMBOL(pcmcia_replace_cis);
  1550. EXPORT_SYMBOL(pcmcia_request_configuration);
  1551. EXPORT_SYMBOL(pcmcia_request_io);
  1552. EXPORT_SYMBOL(pcmcia_request_irq);
  1553. EXPORT_SYMBOL(pcmcia_request_window);
  1554. EXPORT_SYMBOL(pcmcia_resume_card);
  1555. EXPORT_SYMBOL(pcmcia_suspend_card);
  1556. EXPORT_SYMBOL(dead_socket);
  1557. EXPORT_SYMBOL(pcmcia_parse_events);
  1558. struct class pcmcia_socket_class = {
  1559. .name = "pcmcia_socket",
  1560. .release = pcmcia_release_socket,
  1561. };
  1562. EXPORT_SYMBOL(pcmcia_socket_class);
  1563. static int __init init_pcmcia_cs(void)
  1564. {
  1565. int ret;
  1566. printk(KERN_INFO "%s\n", release);
  1567. printk(KERN_INFO " %s\n", options);
  1568. ret = class_register(&pcmcia_socket_class);
  1569. if (ret)
  1570. return (ret);
  1571. return class_interface_register(&pccard_sysfs_interface);
  1572. }
  1573. static void __exit exit_pcmcia_cs(void)
  1574. {
  1575. printk(KERN_INFO "unloading Kernel Card Services\n");
  1576. class_interface_unregister(&pccard_sysfs_interface);
  1577. class_unregister(&pcmcia_socket_class);
  1578. }
  1579. subsys_initcall(init_pcmcia_cs);
  1580. module_exit(exit_pcmcia_cs);
  1581. /*====================================================================*/