daisy.c 13 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507
  1. /*
  2. * IEEE 1284.3 Parallel port daisy chain and multiplexor code
  3. *
  4. * Copyright (C) 1999, 2000 Tim Waugh <tim@cyberelk.demon.co.uk>
  5. *
  6. * This program is free software; you can redistribute it and/or
  7. * modify it under the terms of the GNU General Public License
  8. * as published by the Free Software Foundation; either version
  9. * 2 of the License, or (at your option) any later version.
  10. *
  11. * ??-12-1998: Initial implementation.
  12. * 31-01-1999: Make port-cloning transparent.
  13. * 13-02-1999: Move DeviceID technique from parport_probe.
  14. * 13-03-1999: Get DeviceID from non-IEEE 1284.3 devices too.
  15. * 22-02-2000: Count devices that are actually detected.
  16. *
  17. * Any part of this program may be used in documents licensed under
  18. * the GNU Free Documentation License, Version 1.1 or any later version
  19. * published by the Free Software Foundation.
  20. */
  21. #include <linux/module.h>
  22. #include <linux/parport.h>
  23. #include <linux/delay.h>
  24. #include <linux/slab.h>
  25. #include <linux/sched/signal.h>
  26. #include <asm/current.h>
  27. #include <linux/uaccess.h>
  28. #undef DEBUG
  29. static struct daisydev {
  30. struct daisydev *next;
  31. struct parport *port;
  32. int daisy;
  33. int devnum;
  34. } *topology = NULL;
  35. static DEFINE_SPINLOCK(topology_lock);
  36. static int numdevs;
  37. static bool daisy_init_done;
  38. /* Forward-declaration of lower-level functions. */
  39. static int mux_present(struct parport *port);
  40. static int num_mux_ports(struct parport *port);
  41. static int select_port(struct parport *port);
  42. static int assign_addrs(struct parport *port);
  43. /* Add a device to the discovered topology. */
  44. static void add_dev(int devnum, struct parport *port, int daisy)
  45. {
  46. struct daisydev *newdev, **p;
  47. newdev = kmalloc(sizeof(struct daisydev), GFP_KERNEL);
  48. if (newdev) {
  49. newdev->port = port;
  50. newdev->daisy = daisy;
  51. newdev->devnum = devnum;
  52. spin_lock(&topology_lock);
  53. for (p = &topology; *p && (*p)->devnum<devnum; p = &(*p)->next)
  54. ;
  55. newdev->next = *p;
  56. *p = newdev;
  57. spin_unlock(&topology_lock);
  58. }
  59. }
  60. /* Clone a parport (actually, make an alias). */
  61. static struct parport *clone_parport(struct parport *real, int muxport)
  62. {
  63. struct parport *extra = parport_register_port(real->base,
  64. real->irq,
  65. real->dma,
  66. real->ops);
  67. if (extra) {
  68. extra->portnum = real->portnum;
  69. extra->physport = real;
  70. extra->muxport = muxport;
  71. real->slaves[muxport-1] = extra;
  72. }
  73. return extra;
  74. }
  75. static int daisy_drv_probe(struct pardevice *par_dev)
  76. {
  77. struct device_driver *drv = par_dev->dev.driver;
  78. if (strcmp(drv->name, "daisy_drv"))
  79. return -ENODEV;
  80. if (strcmp(par_dev->name, daisy_dev_name))
  81. return -ENODEV;
  82. return 0;
  83. }
  84. static struct parport_driver daisy_driver = {
  85. .name = "daisy_drv",
  86. .probe = daisy_drv_probe,
  87. .devmodel = true,
  88. };
  89. /* Discover the IEEE1284.3 topology on a port -- muxes and daisy chains.
  90. * Return value is number of devices actually detected. */
  91. int parport_daisy_init(struct parport *port)
  92. {
  93. int detected = 0;
  94. char *deviceid;
  95. static const char *th[] = { /*0*/"th", "st", "nd", "rd", "th" };
  96. int num_ports;
  97. int i;
  98. int last_try = 0;
  99. if (!daisy_init_done) {
  100. /*
  101. * flag should be marked true first as
  102. * parport_register_driver() might try to load the low
  103. * level driver which will lead to announcing new ports
  104. * and which will again come back here at
  105. * parport_daisy_init()
  106. */
  107. daisy_init_done = true;
  108. i = parport_register_driver(&daisy_driver);
  109. if (i) {
  110. pr_err("daisy registration failed\n");
  111. daisy_init_done = false;
  112. return i;
  113. }
  114. }
  115. again:
  116. /* Because this is called before any other devices exist,
  117. * we don't have to claim exclusive access. */
  118. /* If mux present on normal port, need to create new
  119. * parports for each extra port. */
  120. if (port->muxport < 0 && mux_present(port) &&
  121. /* don't be fooled: a mux must have 2 or 4 ports. */
  122. ((num_ports = num_mux_ports(port)) == 2 || num_ports == 4)) {
  123. /* Leave original as port zero. */
  124. port->muxport = 0;
  125. pr_info("%s: 1st (default) port of %d-way multiplexor\n",
  126. port->name, num_ports);
  127. for (i = 1; i < num_ports; i++) {
  128. /* Clone the port. */
  129. struct parport *extra = clone_parport(port, i);
  130. if (!extra) {
  131. if (signal_pending(current))
  132. break;
  133. schedule();
  134. continue;
  135. }
  136. pr_info("%s: %d%s port of %d-way multiplexor on %s\n",
  137. extra->name, i + 1, th[i + 1], num_ports,
  138. port->name);
  139. /* Analyse that port too. We won't recurse
  140. forever because of the 'port->muxport < 0'
  141. test above. */
  142. parport_daisy_init(extra);
  143. }
  144. }
  145. if (port->muxport >= 0)
  146. select_port(port);
  147. parport_daisy_deselect_all(port);
  148. detected += assign_addrs(port);
  149. /* Count the potential legacy device at the end. */
  150. add_dev(numdevs++, port, -1);
  151. /* Find out the legacy device's IEEE 1284 device ID. */
  152. deviceid = kmalloc(1024, GFP_KERNEL);
  153. if (deviceid) {
  154. if (parport_device_id(numdevs - 1, deviceid, 1024) > 2)
  155. detected++;
  156. kfree(deviceid);
  157. }
  158. if (!detected && !last_try) {
  159. /* No devices were detected. Perhaps they are in some
  160. funny state; let's try to reset them and see if
  161. they wake up. */
  162. parport_daisy_fini(port);
  163. parport_write_control(port, PARPORT_CONTROL_SELECT);
  164. udelay(50);
  165. parport_write_control(port,
  166. PARPORT_CONTROL_SELECT |
  167. PARPORT_CONTROL_INIT);
  168. udelay(50);
  169. last_try = 1;
  170. goto again;
  171. }
  172. return detected;
  173. }
  174. /* Forget about devices on a physical port. */
  175. void parport_daisy_fini(struct parport *port)
  176. {
  177. struct daisydev **p;
  178. spin_lock(&topology_lock);
  179. p = &topology;
  180. while (*p) {
  181. struct daisydev *dev = *p;
  182. if (dev->port != port) {
  183. p = &dev->next;
  184. continue;
  185. }
  186. *p = dev->next;
  187. kfree(dev);
  188. }
  189. /* Gaps in the numbering could be handled better. How should
  190. someone enumerate through all IEEE1284.3 devices in the
  191. topology?. */
  192. if (!topology) numdevs = 0;
  193. spin_unlock(&topology_lock);
  194. return;
  195. }
  196. /**
  197. * parport_open - find a device by canonical device number
  198. * @devnum: canonical device number
  199. * @name: name to associate with the device
  200. *
  201. * This function is similar to parport_register_device(), except
  202. * that it locates a device by its number rather than by the port
  203. * it is attached to.
  204. *
  205. * All parameters except for @devnum are the same as for
  206. * parport_register_device(). The return value is the same as
  207. * for parport_register_device().
  208. **/
  209. struct pardevice *parport_open(int devnum, const char *name)
  210. {
  211. struct daisydev *p = topology;
  212. struct pardev_cb par_cb;
  213. struct parport *port;
  214. struct pardevice *dev;
  215. int daisy;
  216. memset(&par_cb, 0, sizeof(par_cb));
  217. spin_lock(&topology_lock);
  218. while (p && p->devnum != devnum)
  219. p = p->next;
  220. if (!p) {
  221. spin_unlock(&topology_lock);
  222. return NULL;
  223. }
  224. daisy = p->daisy;
  225. port = parport_get_port(p->port);
  226. spin_unlock(&topology_lock);
  227. dev = parport_register_dev_model(port, name, &par_cb, devnum);
  228. parport_put_port(port);
  229. if (!dev)
  230. return NULL;
  231. dev->daisy = daisy;
  232. /* Check that there really is a device to select. */
  233. if (daisy >= 0) {
  234. int selected;
  235. parport_claim_or_block(dev);
  236. selected = port->daisy;
  237. parport_release(dev);
  238. if (selected != daisy) {
  239. /* No corresponding device. */
  240. parport_unregister_device(dev);
  241. return NULL;
  242. }
  243. }
  244. return dev;
  245. }
  246. /**
  247. * parport_close - close a device opened with parport_open()
  248. * @dev: device to close
  249. *
  250. * This is to parport_open() as parport_unregister_device() is to
  251. * parport_register_device().
  252. **/
  253. void parport_close(struct pardevice *dev)
  254. {
  255. parport_unregister_device(dev);
  256. }
  257. /* Send a daisy-chain-style CPP command packet. */
  258. static int cpp_daisy(struct parport *port, int cmd)
  259. {
  260. unsigned char s;
  261. parport_data_forward(port);
  262. parport_write_data(port, 0xaa); udelay(2);
  263. parport_write_data(port, 0x55); udelay(2);
  264. parport_write_data(port, 0x00); udelay(2);
  265. parport_write_data(port, 0xff); udelay(2);
  266. s = parport_read_status(port) & (PARPORT_STATUS_BUSY
  267. | PARPORT_STATUS_PAPEROUT
  268. | PARPORT_STATUS_SELECT
  269. | PARPORT_STATUS_ERROR);
  270. if (s != (PARPORT_STATUS_BUSY
  271. | PARPORT_STATUS_PAPEROUT
  272. | PARPORT_STATUS_SELECT
  273. | PARPORT_STATUS_ERROR)) {
  274. pr_debug("%s: cpp_daisy: aa5500ff(%02x)\n", port->name, s);
  275. return -ENXIO;
  276. }
  277. parport_write_data(port, 0x87); udelay(2);
  278. s = parport_read_status(port) & (PARPORT_STATUS_BUSY
  279. | PARPORT_STATUS_PAPEROUT
  280. | PARPORT_STATUS_SELECT
  281. | PARPORT_STATUS_ERROR);
  282. if (s != (PARPORT_STATUS_SELECT | PARPORT_STATUS_ERROR)) {
  283. pr_debug("%s: cpp_daisy: aa5500ff87(%02x)\n", port->name, s);
  284. return -ENXIO;
  285. }
  286. parport_write_data(port, 0x78); udelay(2);
  287. parport_write_data(port, cmd); udelay(2);
  288. parport_frob_control(port,
  289. PARPORT_CONTROL_STROBE,
  290. PARPORT_CONTROL_STROBE);
  291. udelay(1);
  292. s = parport_read_status(port);
  293. parport_frob_control(port, PARPORT_CONTROL_STROBE, 0);
  294. udelay(1);
  295. parport_write_data(port, 0xff); udelay(2);
  296. return s;
  297. }
  298. /* Send a mux-style CPP command packet. */
  299. static int cpp_mux(struct parport *port, int cmd)
  300. {
  301. unsigned char s;
  302. int rc;
  303. parport_data_forward(port);
  304. parport_write_data(port, 0xaa); udelay(2);
  305. parport_write_data(port, 0x55); udelay(2);
  306. parport_write_data(port, 0xf0); udelay(2);
  307. parport_write_data(port, 0x0f); udelay(2);
  308. parport_write_data(port, 0x52); udelay(2);
  309. parport_write_data(port, 0xad); udelay(2);
  310. parport_write_data(port, cmd); udelay(2);
  311. s = parport_read_status(port);
  312. if (!(s & PARPORT_STATUS_ACK)) {
  313. pr_debug("%s: cpp_mux: aa55f00f52ad%02x(%02x)\n",
  314. port->name, cmd, s);
  315. return -EIO;
  316. }
  317. rc = (((s & PARPORT_STATUS_SELECT ? 1 : 0) << 0) |
  318. ((s & PARPORT_STATUS_PAPEROUT ? 1 : 0) << 1) |
  319. ((s & PARPORT_STATUS_BUSY ? 0 : 1) << 2) |
  320. ((s & PARPORT_STATUS_ERROR ? 0 : 1) << 3));
  321. return rc;
  322. }
  323. void parport_daisy_deselect_all(struct parport *port)
  324. {
  325. cpp_daisy(port, 0x30);
  326. }
  327. int parport_daisy_select(struct parport *port, int daisy, int mode)
  328. {
  329. switch (mode)
  330. {
  331. // For these modes we should switch to EPP mode:
  332. case IEEE1284_MODE_EPP:
  333. case IEEE1284_MODE_EPPSL:
  334. case IEEE1284_MODE_EPPSWE:
  335. return !(cpp_daisy(port, 0x20 + daisy) &
  336. PARPORT_STATUS_ERROR);
  337. // For these modes we should switch to ECP mode:
  338. case IEEE1284_MODE_ECP:
  339. case IEEE1284_MODE_ECPRLE:
  340. case IEEE1284_MODE_ECPSWE:
  341. return !(cpp_daisy(port, 0xd0 + daisy) &
  342. PARPORT_STATUS_ERROR);
  343. // Nothing was told for BECP in Daisy chain specification.
  344. // May be it's wise to use ECP?
  345. case IEEE1284_MODE_BECP:
  346. // Others use compat mode
  347. case IEEE1284_MODE_NIBBLE:
  348. case IEEE1284_MODE_BYTE:
  349. case IEEE1284_MODE_COMPAT:
  350. default:
  351. return !(cpp_daisy(port, 0xe0 + daisy) &
  352. PARPORT_STATUS_ERROR);
  353. }
  354. }
  355. static int mux_present(struct parport *port)
  356. {
  357. return cpp_mux(port, 0x51) == 3;
  358. }
  359. static int num_mux_ports(struct parport *port)
  360. {
  361. return cpp_mux(port, 0x58);
  362. }
  363. static int select_port(struct parport *port)
  364. {
  365. int muxport = port->muxport;
  366. return cpp_mux(port, 0x60 + muxport) == muxport;
  367. }
  368. static int assign_addrs(struct parport *port)
  369. {
  370. unsigned char s;
  371. unsigned char daisy;
  372. int thisdev = numdevs;
  373. int detected;
  374. char *deviceid;
  375. parport_data_forward(port);
  376. parport_write_data(port, 0xaa); udelay(2);
  377. parport_write_data(port, 0x55); udelay(2);
  378. parport_write_data(port, 0x00); udelay(2);
  379. parport_write_data(port, 0xff); udelay(2);
  380. s = parport_read_status(port) & (PARPORT_STATUS_BUSY
  381. | PARPORT_STATUS_PAPEROUT
  382. | PARPORT_STATUS_SELECT
  383. | PARPORT_STATUS_ERROR);
  384. if (s != (PARPORT_STATUS_BUSY
  385. | PARPORT_STATUS_PAPEROUT
  386. | PARPORT_STATUS_SELECT
  387. | PARPORT_STATUS_ERROR)) {
  388. pr_debug("%s: assign_addrs: aa5500ff(%02x)\n", port->name, s);
  389. return 0;
  390. }
  391. parport_write_data(port, 0x87); udelay(2);
  392. s = parport_read_status(port) & (PARPORT_STATUS_BUSY
  393. | PARPORT_STATUS_PAPEROUT
  394. | PARPORT_STATUS_SELECT
  395. | PARPORT_STATUS_ERROR);
  396. if (s != (PARPORT_STATUS_SELECT | PARPORT_STATUS_ERROR)) {
  397. pr_debug("%s: assign_addrs: aa5500ff87(%02x)\n", port->name, s);
  398. return 0;
  399. }
  400. parport_write_data(port, 0x78); udelay(2);
  401. s = parport_read_status(port);
  402. for (daisy = 0;
  403. (s & (PARPORT_STATUS_PAPEROUT|PARPORT_STATUS_SELECT))
  404. == (PARPORT_STATUS_PAPEROUT|PARPORT_STATUS_SELECT)
  405. && daisy < 4;
  406. ++daisy) {
  407. parport_write_data(port, daisy);
  408. udelay(2);
  409. parport_frob_control(port,
  410. PARPORT_CONTROL_STROBE,
  411. PARPORT_CONTROL_STROBE);
  412. udelay(1);
  413. parport_frob_control(port, PARPORT_CONTROL_STROBE, 0);
  414. udelay(1);
  415. add_dev(numdevs++, port, daisy);
  416. /* See if this device thought it was the last in the
  417. * chain. */
  418. if (!(s & PARPORT_STATUS_BUSY))
  419. break;
  420. /* We are seeing pass through status now. We see
  421. last_dev from next device or if last_dev does not
  422. work status lines from some non-daisy chain
  423. device. */
  424. s = parport_read_status(port);
  425. }
  426. parport_write_data(port, 0xff); udelay(2);
  427. detected = numdevs - thisdev;
  428. pr_debug("%s: Found %d daisy-chained devices\n", port->name, detected);
  429. /* Ask the new devices to introduce themselves. */
  430. deviceid = kmalloc(1024, GFP_KERNEL);
  431. if (!deviceid) return 0;
  432. for (daisy = 0; thisdev < numdevs; thisdev++, daisy++)
  433. parport_device_id(thisdev, deviceid, 1024);
  434. kfree(deviceid);
  435. return detected;
  436. }