cs.c 21 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918
  1. // SPDX-License-Identifier: GPL-2.0-only
  2. /*
  3. * cs.c -- Kernel Card Services - core services
  4. *
  5. * The initial developer of the original code is David A. Hinds
  6. * <dahinds@users.sourceforge.net>. Portions created by David A. Hinds
  7. * are Copyright (C) 1999 David A. Hinds. All Rights Reserved.
  8. *
  9. * (C) 1999 David A. Hinds
  10. */
  11. #include <linux/module.h>
  12. #include <linux/moduleparam.h>
  13. #include <linux/init.h>
  14. #include <linux/kernel.h>
  15. #include <linux/string.h>
  16. #include <linux/major.h>
  17. #include <linux/errno.h>
  18. #include <linux/slab.h>
  19. #include <linux/mm.h>
  20. #include <linux/interrupt.h>
  21. #include <linux/timer.h>
  22. #include <linux/ioport.h>
  23. #include <linux/delay.h>
  24. #include <linux/pm.h>
  25. #include <linux/device.h>
  26. #include <linux/kthread.h>
  27. #include <linux/freezer.h>
  28. #include <asm/irq.h>
  29. #include <pcmcia/ss.h>
  30. #include <pcmcia/cistpl.h>
  31. #include <pcmcia/cisreg.h>
  32. #include <pcmcia/ds.h>
  33. #include "cs_internal.h"
  34. /* Module parameters */
  35. MODULE_AUTHOR("David Hinds <dahinds@users.sourceforge.net>");
  36. MODULE_DESCRIPTION("Linux Kernel Card Services");
  37. MODULE_LICENSE("GPL");
  38. #define INT_MODULE_PARM(n, v) static int n = v; module_param(n, int, 0444)
  39. INT_MODULE_PARM(setup_delay, 10); /* centiseconds */
  40. INT_MODULE_PARM(resume_delay, 20); /* centiseconds */
  41. INT_MODULE_PARM(shutdown_delay, 3); /* centiseconds */
  42. INT_MODULE_PARM(vcc_settle, 40); /* centiseconds */
  43. INT_MODULE_PARM(reset_time, 10); /* usecs */
  44. INT_MODULE_PARM(unreset_delay, 10); /* centiseconds */
  45. INT_MODULE_PARM(unreset_check, 10); /* centiseconds */
  46. INT_MODULE_PARM(unreset_limit, 30); /* unreset_check's */
  47. /* Access speed for attribute memory windows */
  48. INT_MODULE_PARM(cis_speed, 300); /* ns */
  49. socket_state_t dead_socket = {
  50. .csc_mask = SS_DETECT,
  51. };
  52. EXPORT_SYMBOL(dead_socket);
  53. /* List of all sockets, protected by a rwsem */
  54. LIST_HEAD(pcmcia_socket_list);
  55. EXPORT_SYMBOL(pcmcia_socket_list);
  56. DECLARE_RWSEM(pcmcia_socket_list_rwsem);
  57. EXPORT_SYMBOL(pcmcia_socket_list_rwsem);
  58. struct pcmcia_socket *pcmcia_get_socket(struct pcmcia_socket *skt)
  59. {
  60. struct device *dev = get_device(&skt->dev);
  61. if (!dev)
  62. return NULL;
  63. return dev_get_drvdata(dev);
  64. }
  65. EXPORT_SYMBOL(pcmcia_get_socket);
  66. void pcmcia_put_socket(struct pcmcia_socket *skt)
  67. {
  68. put_device(&skt->dev);
  69. }
  70. EXPORT_SYMBOL(pcmcia_put_socket);
  71. static void pcmcia_release_socket(struct device *dev)
  72. {
  73. struct pcmcia_socket *socket = dev_get_drvdata(dev);
  74. complete(&socket->socket_released);
  75. }
  76. static int pccardd(void *__skt);
  77. /**
  78. * pcmcia_register_socket - add a new pcmcia socket device
  79. * @socket: the &socket to register
  80. */
  81. int pcmcia_register_socket(struct pcmcia_socket *socket)
  82. {
  83. struct task_struct *tsk;
  84. int ret;
  85. if (!socket || !socket->ops || !socket->dev.parent || !socket->resource_ops)
  86. return -EINVAL;
  87. dev_dbg(&socket->dev, "pcmcia_register_socket(0x%p)\n", socket->ops);
  88. /* try to obtain a socket number [yes, it gets ugly if we
  89. * register more than 2^sizeof(unsigned int) pcmcia
  90. * sockets... but the socket number is deprecated
  91. * anyways, so I don't care] */
  92. down_write(&pcmcia_socket_list_rwsem);
  93. if (list_empty(&pcmcia_socket_list))
  94. socket->sock = 0;
  95. else {
  96. unsigned int found, i = 1;
  97. struct pcmcia_socket *tmp;
  98. do {
  99. found = 1;
  100. list_for_each_entry(tmp, &pcmcia_socket_list, socket_list) {
  101. if (tmp->sock == i)
  102. found = 0;
  103. }
  104. i++;
  105. } while (!found);
  106. socket->sock = i - 1;
  107. }
  108. list_add_tail(&socket->socket_list, &pcmcia_socket_list);
  109. up_write(&pcmcia_socket_list_rwsem);
  110. #ifndef CONFIG_CARDBUS
  111. /*
  112. * If we do not support Cardbus, ensure that
  113. * the Cardbus socket capability is disabled.
  114. */
  115. socket->features &= ~SS_CAP_CARDBUS;
  116. #endif
  117. /* set proper values in socket->dev */
  118. dev_set_drvdata(&socket->dev, socket);
  119. socket->dev.class = &pcmcia_socket_class;
  120. dev_set_name(&socket->dev, "pcmcia_socket%u", socket->sock);
  121. /* base address = 0, map = 0 */
  122. socket->cis_mem.flags = 0;
  123. socket->cis_mem.speed = cis_speed;
  124. INIT_LIST_HEAD(&socket->cis_cache);
  125. init_completion(&socket->socket_released);
  126. init_completion(&socket->thread_done);
  127. mutex_init(&socket->skt_mutex);
  128. mutex_init(&socket->ops_mutex);
  129. spin_lock_init(&socket->thread_lock);
  130. if (socket->resource_ops->init) {
  131. mutex_lock(&socket->ops_mutex);
  132. ret = socket->resource_ops->init(socket);
  133. mutex_unlock(&socket->ops_mutex);
  134. if (ret)
  135. goto err;
  136. }
  137. tsk = kthread_run(pccardd, socket, "pccardd");
  138. if (IS_ERR(tsk)) {
  139. ret = PTR_ERR(tsk);
  140. goto err;
  141. }
  142. wait_for_completion(&socket->thread_done);
  143. if (!socket->thread) {
  144. dev_warn(&socket->dev,
  145. "PCMCIA: warning: socket thread did not start\n");
  146. return -EIO;
  147. }
  148. pcmcia_parse_events(socket, SS_DETECT);
  149. /*
  150. * Let's try to get the PCMCIA module for 16-bit PCMCIA support.
  151. * If it fails, it doesn't matter -- we still have 32-bit CardBus
  152. * support to offer, so this is not a failure mode.
  153. */
  154. request_module_nowait("pcmcia");
  155. return 0;
  156. err:
  157. down_write(&pcmcia_socket_list_rwsem);
  158. list_del(&socket->socket_list);
  159. up_write(&pcmcia_socket_list_rwsem);
  160. return ret;
  161. } /* pcmcia_register_socket */
  162. EXPORT_SYMBOL(pcmcia_register_socket);
  163. /**
  164. * pcmcia_unregister_socket - remove a pcmcia socket device
  165. * @socket: the &socket to unregister
  166. */
  167. void pcmcia_unregister_socket(struct pcmcia_socket *socket)
  168. {
  169. if (!socket)
  170. return;
  171. dev_dbg(&socket->dev, "pcmcia_unregister_socket(0x%p)\n", socket->ops);
  172. if (socket->thread)
  173. kthread_stop(socket->thread);
  174. /* remove from our own list */
  175. down_write(&pcmcia_socket_list_rwsem);
  176. list_del(&socket->socket_list);
  177. up_write(&pcmcia_socket_list_rwsem);
  178. /* wait for sysfs to drop all references */
  179. if (socket->resource_ops->exit) {
  180. mutex_lock(&socket->ops_mutex);
  181. socket->resource_ops->exit(socket);
  182. mutex_unlock(&socket->ops_mutex);
  183. }
  184. wait_for_completion(&socket->socket_released);
  185. } /* pcmcia_unregister_socket */
  186. EXPORT_SYMBOL(pcmcia_unregister_socket);
  187. struct pcmcia_socket *pcmcia_get_socket_by_nr(unsigned int nr)
  188. {
  189. struct pcmcia_socket *s;
  190. down_read(&pcmcia_socket_list_rwsem);
  191. list_for_each_entry(s, &pcmcia_socket_list, socket_list)
  192. if (s->sock == nr) {
  193. up_read(&pcmcia_socket_list_rwsem);
  194. return s;
  195. }
  196. up_read(&pcmcia_socket_list_rwsem);
  197. return NULL;
  198. }
  199. EXPORT_SYMBOL(pcmcia_get_socket_by_nr);
  200. static int socket_reset(struct pcmcia_socket *skt)
  201. {
  202. int status, i;
  203. dev_dbg(&skt->dev, "reset\n");
  204. skt->socket.flags |= SS_OUTPUT_ENA | SS_RESET;
  205. skt->ops->set_socket(skt, &skt->socket);
  206. udelay((long)reset_time);
  207. skt->socket.flags &= ~SS_RESET;
  208. skt->ops->set_socket(skt, &skt->socket);
  209. msleep(unreset_delay * 10);
  210. for (i = 0; i < unreset_limit; i++) {
  211. skt->ops->get_status(skt, &status);
  212. if (!(status & SS_DETECT))
  213. return -ENODEV;
  214. if (status & SS_READY)
  215. return 0;
  216. msleep(unreset_check * 10);
  217. }
  218. dev_err(&skt->dev, "time out after reset\n");
  219. return -ETIMEDOUT;
  220. }
  221. /*
  222. * socket_setup() and socket_shutdown() are called by the main event handler
  223. * when card insertion and removal events are received.
  224. * socket_setup() turns on socket power and resets the socket, in two stages.
  225. * socket_shutdown() unconfigures a socket and turns off socket power.
  226. */
  227. static void socket_shutdown(struct pcmcia_socket *s)
  228. {
  229. int status;
  230. dev_dbg(&s->dev, "shutdown\n");
  231. if (s->callback)
  232. s->callback->remove(s);
  233. mutex_lock(&s->ops_mutex);
  234. s->state &= SOCKET_INUSE | SOCKET_PRESENT;
  235. msleep(shutdown_delay * 10);
  236. s->state &= SOCKET_INUSE;
  237. /* Blank out the socket state */
  238. s->socket = dead_socket;
  239. s->ops->init(s);
  240. s->ops->set_socket(s, &s->socket);
  241. s->lock_count = 0;
  242. kfree(s->fake_cis);
  243. s->fake_cis = NULL;
  244. s->functions = 0;
  245. /* From here on we can be sure that only we (that is, the
  246. * pccardd thread) accesses this socket, and all (16-bit)
  247. * PCMCIA interactions are gone. Therefore, release
  248. * ops_mutex so that we don't get a sysfs-related lockdep
  249. * warning.
  250. */
  251. mutex_unlock(&s->ops_mutex);
  252. #ifdef CONFIG_CARDBUS
  253. cb_free(s);
  254. #endif
  255. /* give socket some time to power down */
  256. msleep(100);
  257. s->ops->get_status(s, &status);
  258. if (status & SS_POWERON) {
  259. dev_err(&s->dev,
  260. "*** DANGER *** unable to remove socket power\n");
  261. }
  262. s->state &= ~SOCKET_INUSE;
  263. }
  264. static int socket_setup(struct pcmcia_socket *skt, int initial_delay)
  265. {
  266. int status, i;
  267. dev_dbg(&skt->dev, "setup\n");
  268. skt->ops->get_status(skt, &status);
  269. if (!(status & SS_DETECT))
  270. return -ENODEV;
  271. msleep(initial_delay * 10);
  272. for (i = 0; i < 100; i++) {
  273. skt->ops->get_status(skt, &status);
  274. if (!(status & SS_DETECT))
  275. return -ENODEV;
  276. if (!(status & SS_PENDING))
  277. break;
  278. msleep(100);
  279. }
  280. if (status & SS_PENDING) {
  281. dev_err(&skt->dev, "voltage interrogation timed out\n");
  282. return -ETIMEDOUT;
  283. }
  284. if (status & SS_CARDBUS) {
  285. if (!(skt->features & SS_CAP_CARDBUS)) {
  286. dev_err(&skt->dev, "cardbus cards are not supported\n");
  287. return -EINVAL;
  288. }
  289. skt->state |= SOCKET_CARDBUS;
  290. } else
  291. skt->state &= ~SOCKET_CARDBUS;
  292. /*
  293. * Decode the card voltage requirements, and apply power to the card.
  294. */
  295. if (status & SS_3VCARD)
  296. skt->socket.Vcc = skt->socket.Vpp = 33;
  297. else if (!(status & SS_XVCARD))
  298. skt->socket.Vcc = skt->socket.Vpp = 50;
  299. else {
  300. dev_err(&skt->dev, "unsupported voltage key\n");
  301. return -EIO;
  302. }
  303. if (skt->power_hook)
  304. skt->power_hook(skt, HOOK_POWER_PRE);
  305. skt->socket.flags = 0;
  306. skt->ops->set_socket(skt, &skt->socket);
  307. /*
  308. * Wait "vcc_settle" for the supply to stabilise.
  309. */
  310. msleep(vcc_settle * 10);
  311. skt->ops->get_status(skt, &status);
  312. if (!(status & SS_POWERON)) {
  313. dev_err(&skt->dev, "unable to apply power\n");
  314. return -EIO;
  315. }
  316. status = socket_reset(skt);
  317. if (skt->power_hook)
  318. skt->power_hook(skt, HOOK_POWER_POST);
  319. return status;
  320. }
  321. /*
  322. * Handle card insertion. Setup the socket, reset the card,
  323. * and then tell the rest of PCMCIA that a card is present.
  324. */
  325. static int socket_insert(struct pcmcia_socket *skt)
  326. {
  327. int ret;
  328. dev_dbg(&skt->dev, "insert\n");
  329. mutex_lock(&skt->ops_mutex);
  330. if (skt->state & SOCKET_INUSE) {
  331. mutex_unlock(&skt->ops_mutex);
  332. return -EINVAL;
  333. }
  334. skt->state |= SOCKET_INUSE;
  335. ret = socket_setup(skt, setup_delay);
  336. if (ret == 0) {
  337. skt->state |= SOCKET_PRESENT;
  338. dev_notice(&skt->dev, "pccard: %s card inserted into slot %d\n",
  339. (skt->state & SOCKET_CARDBUS) ? "CardBus" : "PCMCIA",
  340. skt->sock);
  341. #ifdef CONFIG_CARDBUS
  342. if (skt->state & SOCKET_CARDBUS) {
  343. cb_alloc(skt);
  344. skt->state |= SOCKET_CARDBUS_CONFIG;
  345. }
  346. #endif
  347. dev_dbg(&skt->dev, "insert done\n");
  348. mutex_unlock(&skt->ops_mutex);
  349. if (!(skt->state & SOCKET_CARDBUS) && (skt->callback))
  350. skt->callback->add(skt);
  351. } else {
  352. mutex_unlock(&skt->ops_mutex);
  353. socket_shutdown(skt);
  354. }
  355. return ret;
  356. }
  357. static int socket_suspend(struct pcmcia_socket *skt)
  358. {
  359. if ((skt->state & SOCKET_SUSPEND) && !(skt->state & SOCKET_IN_RESUME))
  360. return -EBUSY;
  361. mutex_lock(&skt->ops_mutex);
  362. /* store state on first suspend, but not after spurious wakeups */
  363. if (!(skt->state & SOCKET_IN_RESUME))
  364. skt->suspended_state = skt->state;
  365. skt->socket = dead_socket;
  366. skt->ops->set_socket(skt, &skt->socket);
  367. if (skt->ops->suspend)
  368. skt->ops->suspend(skt);
  369. skt->state |= SOCKET_SUSPEND;
  370. skt->state &= ~SOCKET_IN_RESUME;
  371. mutex_unlock(&skt->ops_mutex);
  372. return 0;
  373. }
  374. static int socket_early_resume(struct pcmcia_socket *skt)
  375. {
  376. mutex_lock(&skt->ops_mutex);
  377. skt->socket = dead_socket;
  378. skt->ops->init(skt);
  379. skt->ops->set_socket(skt, &skt->socket);
  380. if (skt->state & SOCKET_PRESENT)
  381. skt->resume_status = socket_setup(skt, resume_delay);
  382. skt->state |= SOCKET_IN_RESUME;
  383. mutex_unlock(&skt->ops_mutex);
  384. return 0;
  385. }
  386. static int socket_late_resume(struct pcmcia_socket *skt)
  387. {
  388. int ret = 0;
  389. mutex_lock(&skt->ops_mutex);
  390. skt->state &= ~(SOCKET_SUSPEND | SOCKET_IN_RESUME);
  391. mutex_unlock(&skt->ops_mutex);
  392. if (!(skt->state & SOCKET_PRESENT)) {
  393. ret = socket_insert(skt);
  394. if (ret == -ENODEV)
  395. ret = 0;
  396. return ret;
  397. }
  398. if (skt->resume_status) {
  399. socket_shutdown(skt);
  400. return 0;
  401. }
  402. if (skt->suspended_state != skt->state) {
  403. dev_dbg(&skt->dev,
  404. "suspend state 0x%x != resume state 0x%x\n",
  405. skt->suspended_state, skt->state);
  406. socket_shutdown(skt);
  407. return socket_insert(skt);
  408. }
  409. if (!(skt->state & SOCKET_CARDBUS) && (skt->callback))
  410. ret = skt->callback->early_resume(skt);
  411. return ret;
  412. }
  413. /*
  414. * Finalize the resume. In case of a cardbus socket, we have
  415. * to rebind the devices as we can't be certain that it has been
  416. * replaced, or not.
  417. */
  418. static int socket_complete_resume(struct pcmcia_socket *skt)
  419. {
  420. int ret = 0;
  421. #ifdef CONFIG_CARDBUS
  422. if (skt->state & SOCKET_CARDBUS) {
  423. /* We can't be sure the CardBus card is the same
  424. * as the one previously inserted. Therefore, remove
  425. * and re-add... */
  426. cb_free(skt);
  427. ret = cb_alloc(skt);
  428. if (ret)
  429. cb_free(skt);
  430. }
  431. #endif
  432. return ret;
  433. }
  434. /*
  435. * Resume a socket. If a card is present, verify its CIS against
  436. * our cached copy. If they are different, the card has been
  437. * replaced, and we need to tell the drivers.
  438. */
  439. static int socket_resume(struct pcmcia_socket *skt)
  440. {
  441. int err;
  442. if (!(skt->state & SOCKET_SUSPEND))
  443. return -EBUSY;
  444. socket_early_resume(skt);
  445. err = socket_late_resume(skt);
  446. if (!err)
  447. err = socket_complete_resume(skt);
  448. return err;
  449. }
  450. static void socket_remove(struct pcmcia_socket *skt)
  451. {
  452. dev_notice(&skt->dev, "pccard: card ejected from slot %d\n", skt->sock);
  453. socket_shutdown(skt);
  454. }
  455. /*
  456. * Process a socket card detect status change.
  457. *
  458. * If we don't have a card already present, delay the detect event for
  459. * about 20ms (to be on the safe side) before reading the socket status.
  460. *
  461. * Some i82365-based systems send multiple SS_DETECT events during card
  462. * insertion, and the "card present" status bit seems to bounce. This
  463. * will probably be true with GPIO-based card detection systems after
  464. * the product has aged.
  465. */
  466. static void socket_detect_change(struct pcmcia_socket *skt)
  467. {
  468. if (!(skt->state & SOCKET_SUSPEND)) {
  469. int status;
  470. if (!(skt->state & SOCKET_PRESENT))
  471. msleep(20);
  472. skt->ops->get_status(skt, &status);
  473. if ((skt->state & SOCKET_PRESENT) &&
  474. !(status & SS_DETECT))
  475. socket_remove(skt);
  476. if (!(skt->state & SOCKET_PRESENT) &&
  477. (status & SS_DETECT))
  478. socket_insert(skt);
  479. }
  480. }
  481. static int pccardd(void *__skt)
  482. {
  483. struct pcmcia_socket *skt = __skt;
  484. int ret;
  485. skt->thread = current;
  486. skt->socket = dead_socket;
  487. skt->ops->init(skt);
  488. skt->ops->set_socket(skt, &skt->socket);
  489. /* register with the device core */
  490. ret = device_register(&skt->dev);
  491. if (ret) {
  492. dev_warn(&skt->dev, "PCMCIA: unable to register socket\n");
  493. skt->thread = NULL;
  494. complete(&skt->thread_done);
  495. return 0;
  496. }
  497. ret = pccard_sysfs_add_socket(&skt->dev);
  498. if (ret)
  499. dev_warn(&skt->dev, "err %d adding socket attributes\n", ret);
  500. complete(&skt->thread_done);
  501. /* wait for userspace to catch up */
  502. msleep(250);
  503. set_freezable();
  504. for (;;) {
  505. unsigned long flags;
  506. unsigned int events;
  507. unsigned int sysfs_events;
  508. spin_lock_irqsave(&skt->thread_lock, flags);
  509. events = skt->thread_events;
  510. skt->thread_events = 0;
  511. sysfs_events = skt->sysfs_events;
  512. skt->sysfs_events = 0;
  513. spin_unlock_irqrestore(&skt->thread_lock, flags);
  514. mutex_lock(&skt->skt_mutex);
  515. if (events & SS_DETECT)
  516. socket_detect_change(skt);
  517. if (sysfs_events) {
  518. if (sysfs_events & PCMCIA_UEVENT_EJECT)
  519. socket_remove(skt);
  520. if (sysfs_events & PCMCIA_UEVENT_INSERT)
  521. socket_insert(skt);
  522. if ((sysfs_events & PCMCIA_UEVENT_SUSPEND) &&
  523. !(skt->state & SOCKET_CARDBUS)) {
  524. if (skt->callback)
  525. ret = skt->callback->suspend(skt);
  526. else
  527. ret = 0;
  528. if (!ret) {
  529. socket_suspend(skt);
  530. msleep(100);
  531. }
  532. }
  533. if ((sysfs_events & PCMCIA_UEVENT_RESUME) &&
  534. !(skt->state & SOCKET_CARDBUS)) {
  535. ret = socket_resume(skt);
  536. if (!ret && skt->callback)
  537. skt->callback->resume(skt);
  538. }
  539. if ((sysfs_events & PCMCIA_UEVENT_REQUERY) &&
  540. !(skt->state & SOCKET_CARDBUS)) {
  541. if (!ret && skt->callback)
  542. skt->callback->requery(skt);
  543. }
  544. }
  545. mutex_unlock(&skt->skt_mutex);
  546. if (events || sysfs_events)
  547. continue;
  548. set_current_state(TASK_INTERRUPTIBLE);
  549. if (kthread_should_stop())
  550. break;
  551. schedule();
  552. try_to_freeze();
  553. }
  554. /* make sure we are running before we exit */
  555. __set_current_state(TASK_RUNNING);
  556. /* shut down socket, if a device is still present */
  557. if (skt->state & SOCKET_PRESENT) {
  558. mutex_lock(&skt->skt_mutex);
  559. socket_remove(skt);
  560. mutex_unlock(&skt->skt_mutex);
  561. }
  562. /* remove from the device core */
  563. pccard_sysfs_remove_socket(&skt->dev);
  564. device_unregister(&skt->dev);
  565. return 0;
  566. }
  567. /*
  568. * Yenta (at least) probes interrupts before registering the socket and
  569. * starting the handler thread.
  570. */
  571. void pcmcia_parse_events(struct pcmcia_socket *s, u_int events)
  572. {
  573. unsigned long flags;
  574. dev_dbg(&s->dev, "parse_events: events %08x\n", events);
  575. if (s->thread) {
  576. spin_lock_irqsave(&s->thread_lock, flags);
  577. s->thread_events |= events;
  578. spin_unlock_irqrestore(&s->thread_lock, flags);
  579. wake_up_process(s->thread);
  580. }
  581. } /* pcmcia_parse_events */
  582. EXPORT_SYMBOL(pcmcia_parse_events);
  583. /**
  584. * pcmcia_parse_uevents() - tell pccardd to issue manual commands
  585. * @s: the PCMCIA socket we wan't to command
  586. * @events: events to pass to pccardd
  587. *
  588. * userspace-issued insert, eject, suspend and resume commands must be
  589. * handled by pccardd to avoid any sysfs-related deadlocks. Valid events
  590. * are PCMCIA_UEVENT_EJECT (for eject), PCMCIA_UEVENT__INSERT (for insert),
  591. * PCMCIA_UEVENT_RESUME (for resume), PCMCIA_UEVENT_SUSPEND (for suspend)
  592. * and PCMCIA_UEVENT_REQUERY (for re-querying the PCMCIA card).
  593. */
  594. void pcmcia_parse_uevents(struct pcmcia_socket *s, u_int events)
  595. {
  596. unsigned long flags;
  597. dev_dbg(&s->dev, "parse_uevents: events %08x\n", events);
  598. if (s->thread) {
  599. spin_lock_irqsave(&s->thread_lock, flags);
  600. s->sysfs_events |= events;
  601. spin_unlock_irqrestore(&s->thread_lock, flags);
  602. wake_up_process(s->thread);
  603. }
  604. }
  605. EXPORT_SYMBOL(pcmcia_parse_uevents);
  606. /* register pcmcia_callback */
  607. int pccard_register_pcmcia(struct pcmcia_socket *s, struct pcmcia_callback *c)
  608. {
  609. int ret = 0;
  610. /* s->skt_mutex also protects s->callback */
  611. mutex_lock(&s->skt_mutex);
  612. if (c) {
  613. /* registration */
  614. if (s->callback) {
  615. ret = -EBUSY;
  616. goto err;
  617. }
  618. s->callback = c;
  619. if ((s->state & (SOCKET_PRESENT|SOCKET_CARDBUS)) == SOCKET_PRESENT)
  620. s->callback->add(s);
  621. } else
  622. s->callback = NULL;
  623. err:
  624. mutex_unlock(&s->skt_mutex);
  625. return ret;
  626. }
  627. EXPORT_SYMBOL(pccard_register_pcmcia);
  628. /* I'm not sure which "reset" function this is supposed to use,
  629. * but for now, it uses the low-level interface's reset, not the
  630. * CIS register.
  631. */
  632. int pcmcia_reset_card(struct pcmcia_socket *skt)
  633. {
  634. int ret;
  635. dev_dbg(&skt->dev, "resetting socket\n");
  636. mutex_lock(&skt->skt_mutex);
  637. do {
  638. if (!(skt->state & SOCKET_PRESENT)) {
  639. dev_dbg(&skt->dev, "can't reset, not present\n");
  640. ret = -ENODEV;
  641. break;
  642. }
  643. if (skt->state & SOCKET_SUSPEND) {
  644. dev_dbg(&skt->dev, "can't reset, suspended\n");
  645. ret = -EBUSY;
  646. break;
  647. }
  648. if (skt->state & SOCKET_CARDBUS) {
  649. dev_dbg(&skt->dev, "can't reset, is cardbus\n");
  650. ret = -EPERM;
  651. break;
  652. }
  653. if (skt->callback)
  654. skt->callback->suspend(skt);
  655. mutex_lock(&skt->ops_mutex);
  656. ret = socket_reset(skt);
  657. mutex_unlock(&skt->ops_mutex);
  658. if ((ret == 0) && (skt->callback))
  659. skt->callback->resume(skt);
  660. ret = 0;
  661. } while (0);
  662. mutex_unlock(&skt->skt_mutex);
  663. return ret;
  664. } /* reset_card */
  665. EXPORT_SYMBOL(pcmcia_reset_card);
  666. static int pcmcia_socket_uevent(struct device *dev,
  667. struct kobj_uevent_env *env)
  668. {
  669. struct pcmcia_socket *s = container_of(dev, struct pcmcia_socket, dev);
  670. if (add_uevent_var(env, "SOCKET_NO=%u", s->sock))
  671. return -ENOMEM;
  672. return 0;
  673. }
  674. static struct completion pcmcia_unload;
  675. static void pcmcia_release_socket_class(struct class *data)
  676. {
  677. complete(&pcmcia_unload);
  678. }
  679. #ifdef CONFIG_PM
  680. static int __pcmcia_pm_op(struct device *dev,
  681. int (*callback) (struct pcmcia_socket *skt))
  682. {
  683. struct pcmcia_socket *s = container_of(dev, struct pcmcia_socket, dev);
  684. int ret;
  685. mutex_lock(&s->skt_mutex);
  686. ret = callback(s);
  687. mutex_unlock(&s->skt_mutex);
  688. return ret;
  689. }
  690. static int pcmcia_socket_dev_suspend_noirq(struct device *dev)
  691. {
  692. return __pcmcia_pm_op(dev, socket_suspend);
  693. }
  694. static int pcmcia_socket_dev_resume_noirq(struct device *dev)
  695. {
  696. return __pcmcia_pm_op(dev, socket_early_resume);
  697. }
  698. static int __used pcmcia_socket_dev_resume(struct device *dev)
  699. {
  700. return __pcmcia_pm_op(dev, socket_late_resume);
  701. }
  702. static void __used pcmcia_socket_dev_complete(struct device *dev)
  703. {
  704. WARN(__pcmcia_pm_op(dev, socket_complete_resume),
  705. "failed to complete resume");
  706. }
  707. static const struct dev_pm_ops pcmcia_socket_pm_ops = {
  708. /* dev_resume may be called with IRQs enabled */
  709. SET_SYSTEM_SLEEP_PM_OPS(NULL,
  710. pcmcia_socket_dev_resume)
  711. /* late suspend must be called with IRQs disabled */
  712. .suspend_noirq = pcmcia_socket_dev_suspend_noirq,
  713. .freeze_noirq = pcmcia_socket_dev_suspend_noirq,
  714. .poweroff_noirq = pcmcia_socket_dev_suspend_noirq,
  715. /* early resume must be called with IRQs disabled */
  716. .resume_noirq = pcmcia_socket_dev_resume_noirq,
  717. .thaw_noirq = pcmcia_socket_dev_resume_noirq,
  718. .restore_noirq = pcmcia_socket_dev_resume_noirq,
  719. .complete = pcmcia_socket_dev_complete,
  720. };
  721. #define PCMCIA_SOCKET_CLASS_PM_OPS (&pcmcia_socket_pm_ops)
  722. #else /* CONFIG_PM */
  723. #define PCMCIA_SOCKET_CLASS_PM_OPS NULL
  724. #endif /* CONFIG_PM */
  725. struct class pcmcia_socket_class = {
  726. .name = "pcmcia_socket",
  727. .dev_uevent = pcmcia_socket_uevent,
  728. .dev_release = pcmcia_release_socket,
  729. .class_release = pcmcia_release_socket_class,
  730. .pm = PCMCIA_SOCKET_CLASS_PM_OPS,
  731. };
  732. EXPORT_SYMBOL(pcmcia_socket_class);
  733. static int __init init_pcmcia_cs(void)
  734. {
  735. init_completion(&pcmcia_unload);
  736. return class_register(&pcmcia_socket_class);
  737. }
  738. static void __exit exit_pcmcia_cs(void)
  739. {
  740. class_unregister(&pcmcia_socket_class);
  741. wait_for_completion(&pcmcia_unload);
  742. }
  743. subsys_initcall(init_pcmcia_cs);
  744. module_exit(exit_pcmcia_cs);