开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > 嵌入式Linux > 查看源码
parport_pc.c
资源名称：SBC-2410X_kernel.tar.gz　[点击查看]
上传用户：lgb322
上传日期：2013-02-24
资源大小：30529k
文件大小：84k
源码类别：

嵌入式Linux

开发平台：

Unix_Linux

parport_pc.c：源码内容
  1. /* Low-level parallel-port routines for 8255-based PC-style hardware.
  2.  * 
  3.  * Authors: Phil Blundell <Philip.Blundell@pobox.com>
  4.  *          Tim Waugh <tim@cyberelk.demon.co.uk>
  5.  *     Jose Renau <renau@acm.org>
  6.  *          David Campbell <campbell@torque.net>
  7.  *          Andrea Arcangeli
  8.  *
  9.  * based on work by Grant Guenther <grant@torque.net> and Phil Blundell.
  10.  *
  11.  * Cleaned up include files - Russell King <linux@arm.uk.linux.org>
  12.  * DMA support - Bert De Jonghe <bert@sophis.be>
  13.  * Many ECP bugs fixed.  Fred Barnes & Jamie Lokier, 1999
  14.  * More PCI support now conditional on CONFIG_PCI, 03/2001, Paul G. 
  15.  * Various hacks, Fred Barnes, 04/2001
  16.  */
  18. /* This driver should work with any hardware that is broadly compatible
  19.  * with that in the IBM PC.  This applies to the majority of integrated
  20.  * I/O chipsets that are commonly available.  The expected register
  21.  * layout is:
  22.  *
  23.  * base+0 data
  24.  * base+1 status
  25.  * base+2 control
  26.  *
  27.  * In addition, there are some optional registers:
  28.  *
  29.  * base+3 EPP address
  30.  * base+4 EPP data
  31.  * base+0x400 ECP config A
  32.  * base+0x401 ECP config B
  33.  * base+0x402 ECP control
  34.  *
  35.  * All registers are 8 bits wide and read/write.  If your hardware differs
  36.  * only in register addresses (eg because your registers are on 32-bit
  37.  * word boundaries) then you can alter the constants in parport_pc.h to
  38.  * accomodate this.
  39.  *
  40.  * Note that the ECP registers may not start at offset 0x400 for PCI cards,
  41.  * but rather will start at port->base_hi.
  42.  */
  44. #include <linux/config.h>
  45. #include <linux/module.h>
  46. #include <linux/init.h>
  47. #include <linux/sched.h>
  48. #include <linux/delay.h>
  49. #include <linux/errno.h>
  50. #include <linux/interrupt.h>
  51. #include <linux/ioport.h>
  52. #include <linux/kernel.h>
  53. #include <linux/slab.h>
  54. #include <linux/pci.h>
  55. #include <linux/sysctl.h>
  57. #include <asm/io.h>
  58. #include <asm/dma.h>
  59. #include <asm/uaccess.h>
  61. #include <linux/parport.h>
  62. #include <linux/parport_pc.h>
  63. #include <asm/parport.h>
  65. #define PARPORT_PC_MAX_PORTS PARPORT_MAX
  67. /* ECR modes */
  68. #define ECR_SPP 00
  69. #define ECR_PS2 01
  70. #define ECR_PPF 02
  71. #define ECR_ECP 03
  72. #define ECR_EPP 04
  73. #define ECR_VND 05
  74. #define ECR_TST 06
  75. #define ECR_CNF 07
  76. #define ECR_MODE_MASK 0xe0
  77. #define ECR_WRITE(p,v) frob_econtrol((p),0xff,(v))
  79. #undef DEBUG
  81. #ifdef DEBUG
  82. #define DPRINTK  printk
  83. #else
  84. #define DPRINTK(stuff...)
  85. #endif
  88. #define NR_SUPERIOS 3
  89. static struct superio_struct { /* For Super-IO chips autodetection */
  90. int io;
  91. int irq;
  92. int dma;
  93. } superios[NR_SUPERIOS] __devinitdata = { {0,},};
  95. static int user_specified __devinitdata = 0;
  96. #if defined(CONFIG_PARPORT_PC_FIFO) || defined(CONFIG_PARPORT_PC_SUPERIO)
  97. static int verbose_probing;
  98. #endif
  99. static int registered_parport;
  101. /* frob_control, but for ECR */
  102. static void frob_econtrol (struct parport *pb, unsigned char m,
  103.    unsigned char v)
  104. {
  105. unsigned char ectr = 0;
  107. if (m != 0xff)
  108. ectr = inb (ECONTROL (pb));
  110. DPRINTK (KERN_DEBUG "frob_econtrol(%02x,%02x): %02x -> %02xn",
  111. m, v, ectr, (ectr & ~m) ^ v);
  113. outb ((ectr & ~m) ^ v, ECONTROL (pb));
  114. }
  116. static void __inline__ frob_set_mode (struct parport *p, int mode)
  117. {
  118. frob_econtrol (p, ECR_MODE_MASK, mode << 5);
  119. }
  121. #ifdef CONFIG_PARPORT_PC_FIFO
  122. /* Safely change the mode bits in the ECR 
  123.    Returns:
  124.     0    : Success
  125.    -EBUSY: Could not drain FIFO in some finite amount of time,
  126.    mode not changed!
  127.  */
  128. static int change_mode(struct parport *p, int m)
  129. {
  130. const struct parport_pc_private *priv = p->physport->private_data;
  131. unsigned char oecr;
  132. int mode;
  134. DPRINTK(KERN_INFO "parport change_mode ECP-ISA to mode 0x%02xn",m);
  136. if (!priv->ecr) {
  137. printk (KERN_DEBUG "change_mode: but there's no ECR!n");
  138. return 0;
  139. }
  141. /* Bits <7:5> contain the mode. */
  142. oecr = inb (ECONTROL (p));
  143. mode = (oecr >> 5) & 0x7;
  144. if (mode == m) return 0;
  146. if (mode >= 2 && !(priv->ctr & 0x20)) {
  147. /* This mode resets the FIFO, so we may
  148.  * have to wait for it to drain first. */
  149. long expire = jiffies + p->physport->cad->timeout;
  150. int counter;
  151. switch (mode) {
  152. case ECR_PPF: /* Parallel Port FIFO mode */
  153. case ECR_ECP: /* ECP Parallel Port mode */
  154. /* Busy wait for 200us */
  155. for (counter = 0; counter < 40; counter++) {
  156. if (inb (ECONTROL (p)) & 0x01)
  157. break;
  158. if (signal_pending (current)) break;
  159. udelay (5);
  160. }
  162. /* Poll slowly. */
  163. while (!(inb (ECONTROL (p)) & 0x01)) {
  164. if (time_after_eq (jiffies, expire))
  165. /* The FIFO is stuck. */
  166. return -EBUSY;
  167. __set_current_state (TASK_INTERRUPTIBLE);
  168. schedule_timeout ((HZ + 99) / 100);
  169. if (signal_pending (current))
  170. break;
  171. }
  172. }
  173. }
  175. if (mode >= 2 && m >= 2) {
  176. /* We have to go through mode 001 */
  177. oecr &= ~(7 << 5);
  178. oecr |= ECR_PS2 << 5;
  179. ECR_WRITE (p, oecr);
  180. }
  182. /* Set the mode. */
  183. oecr &= ~(7 << 5);
  184. oecr |= m << 5;
  185. ECR_WRITE (p, oecr);
  186. return 0;
  187. }
  189. #ifdef CONFIG_PARPORT_1284
  190. /* Find FIFO lossage; FIFO is reset */
  191. static int get_fifo_residue (struct parport *p)
  192. {
  193. int residue;
  194. int cnfga;
  195. const struct parport_pc_private *priv = p->physport->private_data;
  197. /* Adjust for the contents of the FIFO. */
  198. for (residue = priv->fifo_depth; ; residue--) {
  199. if (inb (ECONTROL (p)) & 0x2)
  200. /* Full up. */
  201. break;
  203. outb (0, FIFO (p));
  204. }
  206. printk (KERN_DEBUG "%s: %d PWords were left in FIFOn", p->name,
  207. residue);
  209. /* Reset the FIFO. */
  210. frob_set_mode (p, ECR_PS2);
  212. /* Now change to config mode and clean up. FIXME */
  213. frob_set_mode (p, ECR_CNF);
  214. cnfga = inb (CONFIGA (p));
  215. printk (KERN_DEBUG "%s: cnfgA contains 0x%02xn", p->name, cnfga);
  217. if (!(cnfga & (1<<2))) {
  218. printk (KERN_DEBUG "%s: Accounting for extra byten", p->name);
  219. residue++;
  220. }
  222. /* Don't care about partial PWords until support is added for
  223.  * PWord != 1 byte. */
  225. /* Back to PS2 mode. */
  226. frob_set_mode (p, ECR_PS2);
  228. DPRINTK (KERN_DEBUG "*** get_fifo_residue: done residue collecting (ecr = 0x%2.2x)n", inb (ECONTROL (p)));
  229. return residue;
  230. }
  231. #endif /* IEEE 1284 support */
  232. #endif /* FIFO support */
  234. /*
  235.  * Clear TIMEOUT BIT in EPP MODE
  236.  *
  237.  * This is also used in SPP detection.
  238.  */
  239. static int clear_epp_timeout(struct parport *pb)
  240. {
  241. unsigned char r;
  243. if (!(parport_pc_read_status(pb) & 0x01))
  244. return 1;
  246. /* To clear timeout some chips require double read */
  247. parport_pc_read_status(pb);
  248. r = parport_pc_read_status(pb);
  249. outb (r | 0x01, STATUS (pb)); /* Some reset by writing 1 */
  250. outb (r & 0xfe, STATUS (pb)); /* Others by writing 0 */
  251. r = parport_pc_read_status(pb);
  253. return !(r & 0x01);
  254. }
  256. /*
  257.  * Access functions.
  258.  *
  259.  * Most of these aren't static because they may be used by the
  260.  * parport_xxx_yyy macros.  extern __inline__ versions of several
  261.  * of these are in parport_pc.h.
  262.  */
  264. static void parport_pc_interrupt(int irq, void *dev_id, struct pt_regs *regs)
  265. {
  266. parport_generic_irq(irq, (struct parport *) dev_id, regs);
  267. }
  269. void parport_pc_write_data(struct parport *p, unsigned char d)
  270. {
  271. outb (d, DATA (p));
  272. }
  274. unsigned char parport_pc_read_data(struct parport *p)
  275. {
  276. return inb (DATA (p));
  277. }
  279. void parport_pc_write_control(struct parport *p, unsigned char d)
  280. {
  281. const unsigned char wm = (PARPORT_CONTROL_STROBE |
  282.   PARPORT_CONTROL_AUTOFD |
  283.   PARPORT_CONTROL_INIT |
  284.   PARPORT_CONTROL_SELECT);
  286. /* Take this out when drivers have adapted to the newer interface. */
  287. if (d & 0x20) {
  288. printk (KERN_DEBUG "%s (%s): use data_reverse for this!n",
  289. p->name, p->cad->name);
  290. parport_pc_data_reverse (p);
  291. }
  293. __parport_pc_frob_control (p, wm, d & wm);
  294. }
  296. unsigned char parport_pc_read_control(struct parport *p)
  297. {
  298. const unsigned char wm = (PARPORT_CONTROL_STROBE |
  299.   PARPORT_CONTROL_AUTOFD |
  300.   PARPORT_CONTROL_INIT |
  301.   PARPORT_CONTROL_SELECT);
  302. const struct parport_pc_private *priv = p->physport->private_data;
  303. return priv->ctr & wm; /* Use soft copy */
  304. }
  306. unsigned char parport_pc_frob_control (struct parport *p, unsigned char mask,
  307.        unsigned char val)
  308. {
  309. const unsigned char wm = (PARPORT_CONTROL_STROBE |
  310.   PARPORT_CONTROL_AUTOFD |
  311.   PARPORT_CONTROL_INIT |
  312.   PARPORT_CONTROL_SELECT);
  314. /* Take this out when drivers have adapted to the newer interface. */
  315. if (mask & 0x20) {
  316. printk (KERN_DEBUG "%s (%s): use data_%s for this!n",
  317. p->name, p->cad->name,
  318. (val & 0x20) ? "reverse" : "forward");
  319. if (val & 0x20)
  320. parport_pc_data_reverse (p);
  321. else
  322. parport_pc_data_forward (p);
  323. }
  325. /* Restrict mask and val to control lines. */
  326. mask &= wm;
  327. val &= wm;
  329. return __parport_pc_frob_control (p, mask, val);
  330. }
  332. unsigned char parport_pc_read_status(struct parport *p)
  333. {
  334. return inb (STATUS (p));
  335. }
  337. void parport_pc_disable_irq(struct parport *p)
  338. {
  339. __parport_pc_frob_control (p, 0x10, 0);
  340. }
  342. void parport_pc_enable_irq(struct parport *p)
  343. {
  344. if (p->irq != PARPORT_IRQ_NONE)
  345. __parport_pc_frob_control (p, 0x10, 0x10);
  346. }
  348. void parport_pc_data_forward (struct parport *p)
  349. {
  350. __parport_pc_frob_control (p, 0x20, 0);
  351. }
  353. void parport_pc_data_reverse (struct parport *p)
  354. {
  355. __parport_pc_frob_control (p, 0x20, 0x20);
  356. }
  358. void parport_pc_init_state(struct pardevice *dev, struct parport_state *s)
  359. {
  360. s->u.pc.ctr = 0xc;
  361. if (dev->irq_func &&
  362.     dev->port->irq != PARPORT_IRQ_NONE)
  363. /* Set ackIntEn */
  364. s->u.pc.ctr |= 0x10;
  366. s->u.pc.ecr = 0x34; /* NetMos chip can cause problems 0x24;
  367.      * D.Gruszka VScom */
  368. }
  370. void parport_pc_save_state(struct parport *p, struct parport_state *s)
  371. {
  372. const struct parport_pc_private *priv = p->physport->private_data;
  373. s->u.pc.ctr = priv->ctr;
  374. if (priv->ecr)
  375. s->u.pc.ecr = inb (ECONTROL (p));
  376. }
  378. void parport_pc_restore_state(struct parport *p, struct parport_state *s)
  379. {
  380. struct parport_pc_private *priv = p->physport->private_data;
  381. register unsigned char c = s->u.pc.ctr & priv->ctr_writable;
  382. outb (c, CONTROL (p));
  383. priv->ctr = c;
  384. if (priv->ecr)
  385. ECR_WRITE (p, s->u.pc.ecr);
  386. }
  388. #ifdef CONFIG_PARPORT_1284
  389. static size_t parport_pc_epp_read_data (struct parport *port, void *buf,
  390. size_t length, int flags)
  391. {
  392. size_t got = 0;
  394. if (flags & PARPORT_W91284PIC) {
  395. unsigned char status;
  396. size_t left = length;
  398. /* use knowledge about data lines..:
  399.  *  nFault is 0 if there is at least 1 byte in the Warp's FIFO
  400.  *  pError is 1 if there are 16 bytes in the Warp's FIFO
  401.  */
  402. status = inb (STATUS (port));
  404. while (!(status & 0x08) && (got < length)) {
  405. if ((left >= 16) && (status & 0x20) && !(status & 0x08)) {
  406. /* can grab 16 bytes from warp fifo */
  407. if (!((long)buf & 0x03)) {
  408. insl (EPPDATA (port), buf, 4);
  409. } else {
  410. insb (EPPDATA (port), buf, 16);
  411. }
  412. buf += 16;
  413. got += 16;
  414. left -= 16;
  415. } else {
  416. /* grab single byte from the warp fifo */
  417. *((char *)buf)++ = inb (EPPDATA (port));
  418. got++;
  419. left--;
  420. }
  421. status = inb (STATUS (port));
  422. if (status & 0x01) {
  423. /* EPP timeout should never occur... */
  424. printk (KERN_DEBUG "%s: EPP timeout occured while talking to "
  425. "w91284pic (should not have done)n", port->name);
  426. clear_epp_timeout (port);
  427. }
  428. }
  429. return got;
  430. }
  431. if ((flags & PARPORT_EPP_FAST) && (length > 1)) {
  432. if (!(((long)buf | length) & 0x03)) {
  433. insl (EPPDATA (port), buf, (length >> 2));
  434. } else {
  435. insb (EPPDATA (port), buf, length);
  436. }
  437. if (inb (STATUS (port)) & 0x01) {
  438. clear_epp_timeout (port);
  439. return -EIO;
  440. }
  441. return length;
  442. }
  443. for (; got < length; got++) {
  444. *((char*)buf)++ = inb (EPPDATA(port));
  445. if (inb (STATUS (port)) & 0x01) {
  446. /* EPP timeout */
  447. clear_epp_timeout (port);
  448. break;
  449. }
  450. }
  452. return got;
  453. }
  455. static size_t parport_pc_epp_write_data (struct parport *port, const void *buf,
  456.  size_t length, int flags)
  457. {
  458. size_t written = 0;
  460. if ((flags & PARPORT_EPP_FAST) && (length > 1)) {
  461. if (!(((long)buf | length) & 0x03)) {
  462. outsl (EPPDATA (port), buf, (length >> 2));
  463. } else {
  464. outsb (EPPDATA (port), buf, length);
  465. }
  466. if (inb (STATUS (port)) & 0x01) {
  467. clear_epp_timeout (port);
  468. return -EIO;
  469. }
  470. return length;
  471. }
  472. for (; written < length; written++) {
  473. outb (*((char*)buf)++, EPPDATA(port));
  474. if (inb (STATUS(port)) & 0x01) {
  475. clear_epp_timeout (port);
  476. break;
  477. }
  478. }
  480. return written;
  481. }
  483. static size_t parport_pc_epp_read_addr (struct parport *port, void *buf,
  484. size_t length, int flags)
  485. {
  486. size_t got = 0;
  488. if ((flags & PARPORT_EPP_FAST) && (length > 1)) {
  489. insb (EPPADDR (port), buf, length);
  490. if (inb (STATUS (port)) & 0x01) {
  491. clear_epp_timeout (port);
  492. return -EIO;
  493. }
  494. return length;
  495. }
  496. for (; got < length; got++) {
  497. *((char*)buf)++ = inb (EPPADDR (port));
  498. if (inb (STATUS (port)) & 0x01) {
  499. clear_epp_timeout (port);
  500. break;
  501. }
  502. }
  504. return got;
  505. }
  507. static size_t parport_pc_epp_write_addr (struct parport *port,
  508.  const void *buf, size_t length,
  509.  int flags)
  510. {
  511. size_t written = 0;
  513. if ((flags & PARPORT_EPP_FAST) && (length > 1)) {
  514. outsb (EPPADDR (port), buf, length);
  515. if (inb (STATUS (port)) & 0x01) {
  516. clear_epp_timeout (port);
  517. return -EIO;
  518. }
  519. return length;
  520. }
  521. for (; written < length; written++) {
  522. outb (*((char*)buf)++, EPPADDR (port));
  523. if (inb (STATUS (port)) & 0x01) {
  524. clear_epp_timeout (port);
  525. break;
  526. }
  527. }
  529. return written;
  530. }
  532. static size_t parport_pc_ecpepp_read_data (struct parport *port, void *buf,
  533.    size_t length, int flags)
  534. {
  535. size_t got;
  537. frob_set_mode (port, ECR_EPP);
  538. parport_pc_data_reverse (port);
  539. parport_pc_write_control (port, 0x4);
  540. got = parport_pc_epp_read_data (port, buf, length, flags);
  541. frob_set_mode (port, ECR_PS2);
  543. return got;
  544. }
  546. static size_t parport_pc_ecpepp_write_data (struct parport *port,
  547.     const void *buf, size_t length,
  548.     int flags)
  549. {
  550. size_t written;
  552. frob_set_mode (port, ECR_EPP);
  553. parport_pc_write_control (port, 0x4);
  554. parport_pc_data_forward (port);
  555. written = parport_pc_epp_write_data (port, buf, length, flags);
  556. frob_set_mode (port, ECR_PS2);
  558. return written;
  559. }
  561. static size_t parport_pc_ecpepp_read_addr (struct parport *port, void *buf,
  562.    size_t length, int flags)
  563. {
  564. size_t got;
  566. frob_set_mode (port, ECR_EPP);
  567. parport_pc_data_reverse (port);
  568. parport_pc_write_control (port, 0x4);
  569. got = parport_pc_epp_read_addr (port, buf, length, flags);
  570. frob_set_mode (port, ECR_PS2);
  572. return got;
  573. }
  575. static size_t parport_pc_ecpepp_write_addr (struct parport *port,
  576.     const void *buf, size_t length,
  577.     int flags)
  578. {
  579. size_t written;
  581. frob_set_mode (port, ECR_EPP);
  582. parport_pc_write_control (port, 0x4);
  583. parport_pc_data_forward (port);
  584. written = parport_pc_epp_write_addr (port, buf, length, flags);
  585. frob_set_mode (port, ECR_PS2);
  587. return written;
  588. }
  589. #endif /* IEEE 1284 support */
  591. #ifdef CONFIG_PARPORT_PC_FIFO
  592. static size_t parport_pc_fifo_write_block_pio (struct parport *port,
  593.        const void *buf, size_t length)
  594. {
  595. int ret = 0;
  596. const unsigned char *bufp = buf;
  597. size_t left = length;
  598. long expire = jiffies + port->physport->cad->timeout;
  599. const int fifo = FIFO (port);
  600. int poll_for = 8; /* 80 usecs */
  601. const struct parport_pc_private *priv = port->physport->private_data;
  602. const int fifo_depth = priv->fifo_depth;
  604. port = port->physport;
  606. /* We don't want to be interrupted every character. */
  607. parport_pc_disable_irq (port);
  608. /* set nErrIntrEn and serviceIntr */
  609. frob_econtrol (port, (1<<4) | (1<<2), (1<<4) | (1<<2));
  611. /* Forward mode. */
  612. parport_pc_data_forward (port); /* Must be in PS2 mode */
  614. while (left) {
  615. unsigned char byte;
  616. unsigned char ecrval = inb (ECONTROL (port));
  617. int i = 0;
  619. if (current->need_resched && time_before (jiffies, expire))
  620. /* Can't yield the port. */
  621. schedule ();
  623. /* Anyone else waiting for the port? */
  624. if (port->waithead) {
  625. printk (KERN_DEBUG "Somebody wants the portn");
  626. break;
  627. }
  629. if (ecrval & 0x02) {
  630. /* FIFO is full. Wait for interrupt. */
  632. /* Clear serviceIntr */
  633. ECR_WRITE (port, ecrval & ~(1<<2));
  634. false_alarm:
  635. ret = parport_wait_event (port, HZ);
  636. if (ret < 0) break;
  637. ret = 0;
  638. if (!time_before (jiffies, expire)) {
  639. /* Timed out. */
  640. printk (KERN_DEBUG "FIFO write timed outn");
  641. break;
  642. }
  643. ecrval = inb (ECONTROL (port));
  644. if (!(ecrval & (1<<2))) {
  645. if (current->need_resched &&
  646.     time_before (jiffies, expire))
  647. schedule ();
  649. goto false_alarm;
  650. }
  652. continue;
  653. }
  655. /* Can't fail now. */
  656. expire = jiffies + port->cad->timeout;
  658. poll:
  659. if (signal_pending (current))
  660. break;
  662. if (ecrval & 0x01) {
  663. /* FIFO is empty. Blast it full. */
  664. const int n = left < fifo_depth ? left : fifo_depth;
  665. outsb (fifo, bufp, n);
  666. bufp += n;
  667. left -= n;
  669. /* Adjust the poll time. */
  670. if (i < (poll_for - 2)) poll_for--;
  671. continue;
  672. } else if (i++ < poll_for) {
  673. udelay (10);
  674. ecrval = inb (ECONTROL (port));
  675. goto poll;
  676. }
  678. /* Half-full (call me an optimist) */
  679. byte = *bufp++;
  680. outb (byte, fifo);
  681. left--;
  682.         }
  684. dump_parport_state ("leave fifo_write_block_pio", port);
  685. return length - left;
  686. }
  688. static size_t parport_pc_fifo_write_block_dma (struct parport *port,
  689.        const void *buf, size_t length)
  690. {
  691. int ret = 0;
  692. unsigned long dmaflag;
  693. size_t left = length;
  694. const struct parport_pc_private *priv = port->physport->private_data;
  695. dma_addr_t dma_addr, dma_handle;
  696. size_t maxlen = 0x10000; /* max 64k per DMA transfer */
  697. unsigned long start = (unsigned long) buf;
  698. unsigned long end = (unsigned long) buf + length - 1;
  700. dump_parport_state ("enter fifo_write_block_dma", port);
  701. if (end < MAX_DMA_ADDRESS) {
  702. /* If it would cross a 64k boundary, cap it at the end. */
  703. if ((start ^ end) & ~0xffffUL)
  704. maxlen = 0x10000 - (start & 0xffff);
  706. dma_addr = dma_handle = pci_map_single(priv->dev, (void *)buf, length,
  707.        PCI_DMA_TODEVICE);
  708.         } else {
  709. /* above 16 MB we use a bounce buffer as ISA-DMA is not possible */
  710. maxlen   = PAGE_SIZE;          /* sizeof(priv->dma_buf) */
  711. dma_addr = priv->dma_handle;
  712. dma_handle = 0;
  713. }
  715. port = port->physport;
  717. /* We don't want to be interrupted every character. */
  718. parport_pc_disable_irq (port);
  719. /* set nErrIntrEn and serviceIntr */
  720. frob_econtrol (port, (1<<4) | (1<<2), (1<<4) | (1<<2));
  722. /* Forward mode. */
  723. parport_pc_data_forward (port); /* Must be in PS2 mode */
  725. while (left) {
  726. long expire = jiffies + port->physport->cad->timeout;
  728. size_t count = left;
  730. if (count > maxlen)
  731. count = maxlen;
  733. if (!dma_handle)   /* bounce buffer ! */
  734. memcpy(priv->dma_buf, buf, count);
  736. dmaflag = claim_dma_lock();
  737. disable_dma(port->dma);
  738. clear_dma_ff(port->dma);
  739. set_dma_mode(port->dma, DMA_MODE_WRITE);
  740. set_dma_addr(port->dma, dma_addr);
  741. set_dma_count(port->dma, count);
  743. /* Set DMA mode */
  744. frob_econtrol (port, 1<<3, 1<<3);
  746. /* Clear serviceIntr */
  747. frob_econtrol (port, 1<<2, 0);
  749. enable_dma(port->dma);
  750. release_dma_lock(dmaflag);
  752. /* assume DMA will be successful */
  753. left -= count;
  754. buf  += count;
  755. if (dma_handle) dma_addr += count;
  757. /* Wait for interrupt. */
  758. false_alarm:
  759. ret = parport_wait_event (port, HZ);
  760. if (ret < 0) break;
  761. ret = 0;
  762. if (!time_before (jiffies, expire)) {
  763. /* Timed out. */
  764. printk (KERN_DEBUG "DMA write timed outn");
  765. break;
  766. }
  767. /* Is serviceIntr set? */
  768. if (!(inb (ECONTROL (port)) & (1<<2))) {
  769. if (current->need_resched)
  770. schedule ();
  772. goto false_alarm;
  773. }
  775. dmaflag = claim_dma_lock();
  776. disable_dma(port->dma);
  777. clear_dma_ff(port->dma);
  778. count = get_dma_residue(port->dma);
  779. release_dma_lock(dmaflag);
  781. if (current->need_resched)
  782. /* Can't yield the port. */
  783. schedule ();
  785. /* Anyone else waiting for the port? */
  786. if (port->waithead) {
  787. printk (KERN_DEBUG "Somebody wants the portn");
  788. break;
  789. }
  791. /* update for possible DMA residue ! */
  792. buf  -= count;
  793. left += count;
  794. if (dma_handle) dma_addr -= count;
  795. }
  797. /* Maybe got here through break, so adjust for DMA residue! */
  798. dmaflag = claim_dma_lock();
  799. disable_dma(port->dma);
  800. clear_dma_ff(port->dma);
  801. left += get_dma_residue(port->dma);
  802. release_dma_lock(dmaflag);
  804. /* Turn off DMA mode */
  805. frob_econtrol (port, 1<<3, 0);
  807. if (dma_handle)
  808. pci_unmap_single(priv->dev, dma_handle, length, PCI_DMA_TODEVICE);
  810. dump_parport_state ("leave fifo_write_block_dma", port);
  811. return length - left;
  812. }
  814. /* Parallel Port FIFO mode (ECP chipsets) */
  815. size_t parport_pc_compat_write_block_pio (struct parport *port,
  816.   const void *buf, size_t length,
  817.   int flags)
  818. {
  819. size_t written;
  820. int r;
  821. long int expire;
  822. const struct parport_pc_private *priv = port->physport->private_data;
  824. /* Special case: a timeout of zero means we cannot call schedule(). */
  825. if (!port->physport->cad->timeout)
  826. return parport_ieee1284_write_compat (port, buf,
  827.       length, flags);
  829. /* Set up parallel port FIFO mode.*/
  830. parport_pc_data_forward (port); /* Must be in PS2 mode */
  831. parport_pc_frob_control (port, PARPORT_CONTROL_STROBE, 0);
  832. r = change_mode (port, ECR_PPF); /* Parallel port FIFO */
  833. if (r)  printk (KERN_DEBUG "%s: Warning change_mode ECR_PPF failedn", port->name);
  835. port->physport->ieee1284.phase = IEEE1284_PH_FWD_DATA;
  837. /* Write the data to the FIFO. */
  838. if (port->dma != PARPORT_DMA_NONE)
  839. written = parport_pc_fifo_write_block_dma (port, buf, length);
  840. else
  841. written = parport_pc_fifo_write_block_pio (port, buf, length);
  843. /* Finish up. */
  844. /* For some hardware we don't want to touch the mode until
  845.  * the FIFO is empty, so allow 4 seconds for each position
  846.  * in the fifo.
  847.  */
  848.         expire = jiffies + (priv->fifo_depth * HZ * 4);
  849. do {
  850. /* Wait for the FIFO to empty */
  851. r = change_mode (port, ECR_PS2);
  852. if (r != -EBUSY) {
  853. break;
  854. }
  855. } while (time_before (jiffies, expire));
  856. if (r == -EBUSY) {
  858. printk (KERN_DEBUG "%s: FIFO is stuckn", port->name);
  860. /* Prevent further data transfer. */
  861. frob_set_mode (port, ECR_TST);
  863. /* Adjust for the contents of the FIFO. */
  864. for (written -= priv->fifo_depth; ; written++) {
  865. if (inb (ECONTROL (port)) & 0x2) {
  866. /* Full up. */
  867. break;
  868. }
  869. outb (0, FIFO (port));
  870. }
  872. /* Reset the FIFO and return to PS2 mode. */
  873. frob_set_mode (port, ECR_PS2);
  874. }
  876. r = parport_wait_peripheral (port,
  877.      PARPORT_STATUS_BUSY,
  878.      PARPORT_STATUS_BUSY);
  879. if (r)
  880. printk (KERN_DEBUG
  881. "%s: BUSY timeout (%d) in compat_write_block_pion", 
  882. port->name, r);
  884. port->physport->ieee1284.phase = IEEE1284_PH_FWD_IDLE;
  886. return written;
  887. }
  889. /* ECP */
  890. #ifdef CONFIG_PARPORT_1284
  891. size_t parport_pc_ecp_write_block_pio (struct parport *port,
  892.        const void *buf, size_t length,
  893.        int flags)
  894. {
  895. size_t written;
  896. int r;
  897. long int expire;
  898. const struct parport_pc_private *priv = port->physport->private_data;
  900. /* Special case: a timeout of zero means we cannot call schedule(). */
  901. if (!port->physport->cad->timeout)
  902. return parport_ieee1284_ecp_write_data (port, buf,
  903. length, flags);
  905. /* Switch to forward mode if necessary. */
  906. if (port->physport->ieee1284.phase != IEEE1284_PH_FWD_IDLE) {
  907. /* Event 47: Set nInit high. */
  908. parport_frob_control (port,
  909.       PARPORT_CONTROL_INIT
  910.       | PARPORT_CONTROL_AUTOFD,
  911.       PARPORT_CONTROL_INIT
  912.       | PARPORT_CONTROL_AUTOFD);
  914. /* Event 49: PError goes high. */
  915. r = parport_wait_peripheral (port,
  916.      PARPORT_STATUS_PAPEROUT,
  917.      PARPORT_STATUS_PAPEROUT);
  918. if (r) {
  919. printk (KERN_DEBUG "%s: PError timeout (%d) "
  920. "in ecp_write_block_pion", port->name, r);
  921. }
  922. }
  924. /* Set up ECP parallel port mode.*/
  925. parport_pc_data_forward (port); /* Must be in PS2 mode */
  926. parport_pc_frob_control (port,
  927.  PARPORT_CONTROL_STROBE |
  928.  PARPORT_CONTROL_AUTOFD,
  929.  0);
  930. r = change_mode (port, ECR_ECP); /* ECP FIFO */
  931. if (r) printk (KERN_DEBUG "%s: Warning change_mode ECR_ECP failedn", port->name);
  932. port->physport->ieee1284.phase = IEEE1284_PH_FWD_DATA;
  934. /* Write the data to the FIFO. */
  935. if (port->dma != PARPORT_DMA_NONE)
  936. written = parport_pc_fifo_write_block_dma (port, buf, length);
  937. else
  938. written = parport_pc_fifo_write_block_pio (port, buf, length);
  940. /* Finish up. */
  941. /* For some hardware we don't want to touch the mode until
  942.  * the FIFO is empty, so allow 4 seconds for each position
  943.  * in the fifo.
  944.  */
  945. expire = jiffies + (priv->fifo_depth * (HZ * 4));
  946. do {
  947. /* Wait for the FIFO to empty */
  948. r = change_mode (port, ECR_PS2);
  949. if (r != -EBUSY) {
  950. break;
  951. }
  952. } while (time_before (jiffies, expire));
  953. if (r == -EBUSY) {
  955. printk (KERN_DEBUG "%s: FIFO is stuckn", port->name);
  957. /* Prevent further data transfer. */
  958. frob_set_mode (port, ECR_TST);
  960. /* Adjust for the contents of the FIFO. */
  961. for (written -= priv->fifo_depth; ; written++) {
  962. if (inb (ECONTROL (port)) & 0x2) {
  963. /* Full up. */
  964. break;
  965. }
  966. outb (0, FIFO (port));
  967. }
  969. /* Reset the FIFO and return to PS2 mode. */
  970. frob_set_mode (port, ECR_PS2);
  972. /* Host transfer recovery. */
  973. parport_pc_data_reverse (port); /* Must be in PS2 mode */
  974. udelay (5);
  975. parport_frob_control (port, PARPORT_CONTROL_INIT, 0);
  976. r = parport_wait_peripheral (port, PARPORT_STATUS_PAPEROUT, 0);
  977. if (r)
  978. printk (KERN_DEBUG "%s: PE,1 timeout (%d) "
  979. "in ecp_write_block_pion", port->name, r);
  981. parport_frob_control (port,
  982.       PARPORT_CONTROL_INIT,
  983.       PARPORT_CONTROL_INIT);
  984. r = parport_wait_peripheral (port,
  985.      PARPORT_STATUS_PAPEROUT,
  986.      PARPORT_STATUS_PAPEROUT);
  987.                 if (r)
  988.                         printk (KERN_DEBUG "%s: PE,2 timeout (%d) "
  989. "in ecp_write_block_pion", port->name, r);
  990. }
  992. r = parport_wait_peripheral (port,
  993.      PARPORT_STATUS_BUSY, 
  994.      PARPORT_STATUS_BUSY);
  995. if(r)
  996. printk (KERN_DEBUG
  997. "%s: BUSY timeout (%d) in ecp_write_block_pion",
  998. port->name, r);
  1000. port->physport->ieee1284.phase = IEEE1284_PH_FWD_IDLE;
  1002. return written;
  1003. }
  1005. size_t parport_pc_ecp_read_block_pio (struct parport *port,
  1006.       void *buf, size_t length, int flags)
  1007. {
  1008. size_t left = length;
  1009. size_t fifofull;
  1010. int r;
  1011. const int fifo = FIFO(port);
  1012. const struct parport_pc_private *priv = port->physport->private_data;
  1013. const int fifo_depth = priv->fifo_depth;
  1014. char *bufp = buf;
  1016. port = port->physport;
  1017. DPRINTK (KERN_DEBUG "parport_pc: parport_pc_ecp_read_block_pion");
  1018. dump_parport_state ("enter fcn", port);
  1020. /* Special case: a timeout of zero means we cannot call schedule(). */
  1021. if (!port->cad->timeout)
  1022. return parport_ieee1284_ecp_read_data (port, buf,
  1023.        length, flags);
  1025. if (port->ieee1284.mode == IEEE1284_MODE_ECPRLE) {
  1026. /* If the peripheral is allowed to send RLE compressed
  1027.  * data, it is possible for a byte to expand to 128
  1028.  * bytes in the FIFO. */
  1029. fifofull = 128;
  1030. } else {
  1031. fifofull = fifo_depth;
  1032. }
  1034. /* If the caller wants less than a full FIFO's worth of data,
  1035.  * go through software emulation.  Otherwise we may have to throw
  1036.  * away data. */
  1037. if (length < fifofull)
  1038. return parport_ieee1284_ecp_read_data (port, buf,
  1039.        length, flags);
  1041. if (port->ieee1284.phase != IEEE1284_PH_REV_IDLE) {
  1042. /* change to reverse-idle phase (must be in forward-idle) */
  1044. /* Event 38: Set nAutoFd low (also make sure nStrobe is high) */
  1045. parport_frob_control (port,
  1046.       PARPORT_CONTROL_AUTOFD
  1047.       | PARPORT_CONTROL_STROBE,
  1048.       PARPORT_CONTROL_AUTOFD);
  1049. parport_pc_data_reverse (port); /* Must be in PS2 mode */
  1050. udelay (5);
  1051. /* Event 39: Set nInit low to initiate bus reversal */
  1052. parport_frob_control (port,
  1053.       PARPORT_CONTROL_INIT,
  1054.       0);
  1055. /* Event 40: Wait for  nAckReverse (PError) to go low */
  1056. r = parport_wait_peripheral (port, PARPORT_STATUS_PAPEROUT, 0);
  1057.                 if (r) {
  1058.                         printk (KERN_DEBUG "%s: PE timeout Event 40 (%d) "
  1059. "in ecp_read_block_pion", port->name, r);
  1060. return 0;
  1061. }
  1062. }
  1064. /* Set up ECP FIFO mode.*/
  1065. /* parport_pc_frob_control (port,
  1066.  PARPORT_CONTROL_STROBE |
  1067.  PARPORT_CONTROL_AUTOFD,
  1068.  PARPORT_CONTROL_AUTOFD); */
  1069. r = change_mode (port, ECR_ECP); /* ECP FIFO */
  1070. if (r) printk (KERN_DEBUG "%s: Warning change_mode ECR_ECP failedn", port->name);
  1072. port->ieee1284.phase = IEEE1284_PH_REV_DATA;
  1074. /* the first byte must be collected manually */
  1075. dump_parport_state ("pre 43", port);
  1076. /* Event 43: Wait for nAck to go low */
  1077. r = parport_wait_peripheral (port, PARPORT_STATUS_ACK, 0);
  1078. if (r) {
  1079. /* timed out while reading -- no data */
  1080. printk (KERN_DEBUG "PIO read timed out (initial byte)n");
  1081. goto out_no_data;
  1082. }
  1083. /* read byte */
  1084. *bufp++ = inb (DATA (port));
  1085. left--;
  1086. dump_parport_state ("43-44", port);
  1087. /* Event 44: nAutoFd (HostAck) goes high to acknowledge */
  1088. parport_pc_frob_control (port,
  1089.  PARPORT_CONTROL_AUTOFD,
  1090.  0);
  1091. dump_parport_state ("pre 45", port);
  1092. /* Event 45: Wait for nAck to go high */
  1093. /* r = parport_wait_peripheral (port, PARPORT_STATUS_ACK, PARPORT_STATUS_ACK); */
  1094. dump_parport_state ("post 45", port);
  1095. r = 0;
  1096. if (r) {
  1097. /* timed out while waiting for peripheral to respond to ack */
  1098. printk (KERN_DEBUG "ECP PIO read timed out (waiting for nAck)n");
  1100. /* keep hold of the byte we've got already */
  1101. goto out_no_data;
  1102. }
  1103. /* Event 46: nAutoFd (HostAck) goes low to accept more data */
  1104. parport_pc_frob_control (port,
  1105.  PARPORT_CONTROL_AUTOFD,
  1106.  PARPORT_CONTROL_AUTOFD);
  1109. dump_parport_state ("rev idle", port);
  1110. /* Do the transfer. */
  1111. while (left > fifofull) {
  1112. int ret;
  1113. long int expire = jiffies + port->cad->timeout;
  1114. unsigned char ecrval = inb (ECONTROL (port));
  1116. if (current->need_resched && time_before (jiffies, expire))
  1117. /* Can't yield the port. */
  1118. schedule ();
  1120. /* At this point, the FIFO may already be full. In
  1121.                  * that case ECP is already holding back the
  1122.                  * peripheral (assuming proper design) with a delayed
  1123.                  * handshake.  Work fast to avoid a peripheral
  1124.                  * timeout.  */
  1126. if (ecrval & 0x01) {
  1127. /* FIFO is empty. Wait for interrupt. */
  1128. dump_parport_state ("FIFO empty", port);
  1130. /* Anyone else waiting for the port? */
  1131. if (port->waithead) {
  1132. printk (KERN_DEBUG "Somebody wants the portn");
  1133. break;
  1134. }
  1136. /* Clear serviceIntr */
  1137. ECR_WRITE (port, ecrval & ~(1<<2));
  1138. false_alarm:
  1139. dump_parport_state ("waiting", port);
  1140. ret = parport_wait_event (port, HZ);
  1141. DPRINTK (KERN_DEBUG "parport_wait_event returned %dn", ret);
  1142. if (ret < 0)
  1143. break;
  1144. ret = 0;
  1145. if (!time_before (jiffies, expire)) {
  1146. /* Timed out. */
  1147. dump_parport_state ("timeout", port);
  1148. printk (KERN_DEBUG "PIO read timed outn");
  1149. break;
  1150. }
  1151. ecrval = inb (ECONTROL (port));
  1152. if (!(ecrval & (1<<2))) {
  1153. if (current->need_resched &&
  1154.     time_before (jiffies, expire)) {
  1155. schedule ();
  1156. }
  1157. goto false_alarm;
  1158. }
  1160. /* Depending on how the FIFO threshold was
  1161.                          * set, how long interrupt service took, and
  1162.                          * how fast the peripheral is, we might be
  1163.                          * lucky and have a just filled FIFO. */
  1164. continue;
  1165. }
  1167. if (ecrval & 0x02) {
  1168. /* FIFO is full. */
  1169. dump_parport_state ("FIFO full", port);
  1170. insb (fifo, bufp, fifo_depth);
  1171. bufp += fifo_depth;
  1172. left -= fifo_depth;
  1173. continue;
  1174. }
  1176. DPRINTK (KERN_DEBUG "*** ecp_read_block_pio: reading one byte from the FIFOn");
  1178. /* FIFO not filled.  We will cycle this loop for a while
  1179.                  * and either the peripheral will fill it faster,
  1180.                  * tripping a fast empty with insb, or we empty it. */
  1181. *bufp++ = inb (fifo);
  1182. left--;
  1183. }
  1185. /* scoop up anything left in the FIFO */
  1186. while (left && !(inb (ECONTROL (port) & 0x01))) {
  1187. *bufp++ = inb (fifo);
  1188. left--;
  1189. }
  1191. port->ieee1284.phase = IEEE1284_PH_REV_IDLE;
  1192. dump_parport_state ("rev idle2", port);
  1194. out_no_data:
  1196. /* Go to forward idle mode to shut the peripheral up (event 47). */
  1197. parport_frob_control (port, PARPORT_CONTROL_INIT, PARPORT_CONTROL_INIT);
  1199. /* event 49: PError goes high */
  1200. r = parport_wait_peripheral (port,
  1201.      PARPORT_STATUS_PAPEROUT,
  1202.      PARPORT_STATUS_PAPEROUT);
  1203. if (r) {
  1204. printk (KERN_DEBUG
  1205. "%s: PE timeout FWDIDLE (%d) in ecp_read_block_pion",
  1206. port->name, r);
  1207. }
  1209. port->ieee1284.phase = IEEE1284_PH_FWD_IDLE;
  1211. /* Finish up. */
  1212. {
  1213. int lost = get_fifo_residue (port);
  1214. if (lost)
  1215. /* Shouldn't happen with compliant peripherals. */
  1216. printk (KERN_DEBUG "%s: DATA LOSS (%d bytes)!n",
  1217. port->name, lost);
  1218. }
  1220. dump_parport_state ("fwd idle", port);
  1221. return length - left;
  1222. }
  1224. #endif /* IEEE 1284 support */
  1225. #endif /* Allowed to use FIFO/DMA */
  1228. /*
  1229.  * ******************************************
  1230.  * INITIALISATION AND MODULE STUFF BELOW HERE
  1231.  * ******************************************
  1232.  */
  1235. void parport_pc_inc_use_count(void)
  1236. {
  1237. #ifdef MODULE
  1238. MOD_INC_USE_COUNT;
  1239. #endif
  1240. }
  1242. void parport_pc_dec_use_count(void)
  1243. {
  1244. #ifdef MODULE
  1245. MOD_DEC_USE_COUNT;
  1246. #endif
  1247. }
  1249. struct parport_operations parport_pc_ops = 
  1250. {
  1251. parport_pc_write_data,
  1252. parport_pc_read_data,
  1254. parport_pc_write_control,
  1255. parport_pc_read_control,
  1256. parport_pc_frob_control,
  1258. parport_pc_read_status,
  1260. parport_pc_enable_irq,
  1261. parport_pc_disable_irq,
  1263. parport_pc_data_forward,
  1264. parport_pc_data_reverse,
  1266. parport_pc_init_state,
  1267. parport_pc_save_state,
  1268. parport_pc_restore_state,
  1270. parport_pc_inc_use_count,
  1271. parport_pc_dec_use_count,
  1273. parport_ieee1284_epp_write_data,
  1274. parport_ieee1284_epp_read_data,
  1275. parport_ieee1284_epp_write_addr,
  1276. parport_ieee1284_epp_read_addr,
  1278. parport_ieee1284_ecp_write_data,
  1279. parport_ieee1284_ecp_read_data,
  1280. parport_ieee1284_ecp_write_addr,
  1282. parport_ieee1284_write_compat,
  1283. parport_ieee1284_read_nibble,
  1284. parport_ieee1284_read_byte,
  1285. };
  1287. #ifdef CONFIG_PARPORT_PC_SUPERIO
  1288. /* Super-IO chipset detection, Winbond, SMSC */
  1289. static void __devinit show_parconfig_smsc37c669(int io, int key)
  1290. {
  1291. int cr1,cr4,cra,cr23,cr26,cr27,i=0;
  1292. static const char *modes[]={ "SPP and Bidirectional (PS/2)",
  1293.      "EPP and SPP",
  1294.      "ECP",
  1295.      "ECP and EPP" };
  1297. outb(key,io);
  1298. outb(key,io);
  1299. outb(1,io);
  1300. cr1=inb(io+1);
  1301. outb(4,io);
  1302. cr4=inb(io+1);
  1303. outb(0x0a,io);
  1304. cra=inb(io+1);
  1305. outb(0x23,io);
  1306. cr23=inb(io+1);
  1307. outb(0x26,io);
  1308. cr26=inb(io+1);
  1309. outb(0x27,io);
  1310. cr27=inb(io+1);
  1311. outb(0xaa,io);
  1313. if (verbose_probing) {
  1314. printk (KERN_INFO "SMSC 37c669 LPT Config: cr_1=0x%02x, 4=0x%02x, "
  1315. "A=0x%2x, 23=0x%02x, 26=0x%02x, 27=0x%02xn",
  1316. cr1,cr4,cra,cr23,cr26,cr27);
  1318. /* The documentation calls DMA and IRQ-Lines by letters, so
  1319.    the board maker can/will wire them
  1320.    appropriately/randomly...  G=reserved H=IDE-irq, */
  1321. printk (KERN_INFO "SMSC LPT Config: io=0x%04x, irq=%c, dma=%c, "
  1322. "fifo threshold=%dn", cr23*4,
  1323. (cr27 &0x0f) ? 'A'-1+(cr27 &0x0f): '-',
  1324. (cr26 &0x0f) ? 'A'-1+(cr26 &0x0f): '-', cra & 0x0f);
  1325. printk(KERN_INFO "SMSC LPT Config: enabled=%s power=%sn",
  1326.        (cr23*4 >=0x100) ?"yes":"no", (cr1 & 4) ? "yes" : "no");
  1327. printk(KERN_INFO "SMSC LPT Config: Port mode=%s, EPP version =%sn",
  1328.        (cr1 & 0x08 ) ? "Standard mode only (SPP)" : modes[cr4 & 0x03], 
  1329.        (cr4 & 0x40) ? "1.7" : "1.9");
  1330. }
  1332. /* Heuristics !  BIOS setup for this mainboard device limits
  1333.    the choices to standard settings, i.e. io-address and IRQ
  1334.    are related, however DMA can be 1 or 3, assume DMA_A=DMA1,
  1335.    DMA_C=DMA3 (this is true e.g. for TYAN 1564D Tomcat IV) */
  1336. if(cr23*4 >=0x100) { /* if active */
  1337. while((superios[i].io!= 0) && (i<NR_SUPERIOS))
  1338. i++;
  1339. if(i==NR_SUPERIOS)
  1340. printk(KERN_INFO "Super-IO: too many chips!n");
  1341. else {
  1342. int d;
  1343. switch (cr23*4) {
  1344. case 0x3bc:
  1345. superios[i].io = 0x3bc;
  1346. superios[i].irq = 7;
  1347. break;
  1348. case 0x378:
  1349. superios[i].io = 0x378;
  1350. superios[i].irq = 7;
  1351. break;
  1352. case 0x278:
  1353. superios[i].io = 0x278;
  1354. superios[i].irq = 5;
  1355. }
  1356. d=(cr26 &0x0f);
  1357. if((d==1) || (d==3)) 
  1358. superios[i].dma= d;
  1359. else
  1360. superios[i].dma= PARPORT_DMA_NONE;
  1361. }
  1362.   }
  1363. }
  1366. static void __devinit show_parconfig_winbond(int io, int key)
  1367. {
  1368. int cr30,cr60,cr61,cr70,cr74,crf0,i=0;
  1369. static const char *modes[] = {
  1370. "Standard (SPP) and Bidirectional(PS/2)", /* 0 */
  1371. "EPP-1.9 and SPP",
  1372. "ECP",
  1373. "ECP and EPP-1.9",
  1374. "Standard (SPP)",
  1375. "EPP-1.7 and SPP", /* 5 */
  1376. "undefined!",
  1377. "ECP and EPP-1.7" };
  1378. static char *irqtypes[] = { "pulsed low, high-Z", "follows nACK" };
  1380. /* The registers are called compatible-PnP because the
  1381.            register layout is modelled after ISA-PnP, the access
  1382.            method is just another ... */
  1383. outb(key,io);
  1384. outb(key,io);
  1385. outb(0x07,io);   /* Register 7: Select Logical Device */
  1386. outb(0x01,io+1); /* LD1 is Parallel Port */
  1387. outb(0x30,io);
  1388. cr30=inb(io+1);
  1389. outb(0x60,io);
  1390. cr60=inb(io+1);
  1391. outb(0x61,io);
  1392. cr61=inb(io+1);
  1393. outb(0x70,io);
  1394. cr70=inb(io+1);
  1395. outb(0x74,io);
  1396. cr74=inb(io+1);
  1397. outb(0xf0,io);
  1398. crf0=inb(io+1);
  1399. outb(0xaa,io);
  1401. if (verbose_probing) {
  1402. printk(KERN_INFO "Winbond LPT Config: cr_30=%02x 60,61=%02x%02x "
  1403.        "70=%02x 74=%02x, f0=%02xn", cr30,cr60,cr61,cr70,cr74,crf0);
  1404. printk(KERN_INFO "Winbond LPT Config: active=%s, io=0x%02x%02x irq=%d, ", 
  1405.        (cr30 & 0x01) ? "yes":"no", cr60,cr61,cr70&0x0f );
  1406. if ((cr74 & 0x07) > 3)
  1407. printk("dma=nonen");
  1408. else
  1409. printk("dma=%dn",cr74 & 0x07);
  1410. printk(KERN_INFO "Winbond LPT Config: irqtype=%s, ECP fifo threshold=%dn",
  1411.        irqtypes[crf0>>7], (crf0>>3)&0x0f);
  1412. printk(KERN_INFO "Winbond LPT Config: Port mode=%sn", modes[crf0 & 0x07]);
  1413. }
  1415. if(cr30 & 0x01) { /* the settings can be interrogated later ... */
  1416. while((superios[i].io!= 0) && (i<NR_SUPERIOS))
  1417. i++;
  1418. if(i==NR_SUPERIOS) 
  1419. printk(KERN_INFO "Super-IO: too many chips!n");
  1420. else {
  1421. superios[i].io = (cr60<<8)|cr61;
  1422. superios[i].irq = cr70&0x0f;
  1423. superios[i].dma = (((cr74 & 0x07) > 3) ?
  1424.    PARPORT_DMA_NONE : (cr74 & 0x07));
  1425. }
  1426. }
  1427. }
  1429. static void __devinit decode_winbond(int efer, int key, int devid, int devrev, int oldid)
  1430. {
  1431. const char *type = "unknown";
  1432. int id,progif=2;
  1434. if (devid == devrev)
  1435. /* simple heuristics, we happened to read some
  1436.                    non-winbond register */
  1437. return;
  1439. id=(devid<<8) | devrev;
  1441. /* Values are from public data sheets pdf files, I can just
  1442.            confirm 83977TF is correct :-) */
  1443. if      (id == 0x9771) type="83977F/AF";
  1444. else if (id == 0x9773) type="83977TF / SMSC 97w33x/97w34x";
  1445. else if (id == 0x9774) type="83977ATF";
  1446. else if ((id & ~0x0f) == 0x5270) type="83977CTF / SMSC 97w36x";
  1447. else if ((id & ~0x0f) == 0x52f0) type="83977EF / SMSC 97w35x";
  1448. else if ((id & ~0x0f) == 0x5210) type="83627";
  1449. else if ((id & ~0x0f) == 0x6010) type="83697HF";
  1450. else if ((oldid &0x0f ) == 0x0a) { type="83877F"; progif=1;}
  1451. else if ((oldid &0x0f ) == 0x0b) { type="83877AF"; progif=1;}
  1452. else if ((oldid &0x0f ) == 0x0c) { type="83877TF"; progif=1;}
  1453. else if ((oldid &0x0f ) == 0x0d) { type="83877ATF"; progif=1;}
  1454. else progif=0;
  1456. if (verbose_probing)
  1457. printk(KERN_INFO "Winbond chip at EFER=0x%x key=0x%02x "
  1458.        "devid=%02x devrev=%02x oldid=%02x type=%sn", 
  1459.        efer, key, devid, devrev, oldid, type);
  1461. if (progif == 2)
  1462. show_parconfig_winbond(efer,key);
  1463. }
  1465. static void __devinit decode_smsc(int efer, int key, int devid, int devrev)
  1466. {
  1467.         const char *type = "unknown";
  1468. void (*func)(int io, int key);
  1469.         int id;
  1471.         if (devid == devrev)
  1472. /* simple heuristics, we happened to read some
  1473.                    non-smsc register */
  1474. return;
  1476. func=NULL;
  1477.         id=(devid<<8) | devrev;
  1479. if (id==0x0302) {type="37c669"; func=show_parconfig_smsc37c669;}
  1480. else if (id==0x6582) type="37c665IR";
  1481. else if (devid==0x65) type="37c665GT";
  1482. else if (devid==0x66) type="37c666GT";
  1484. if (verbose_probing)
  1485. printk(KERN_INFO "SMSC chip at EFER=0x%x "
  1486.        "key=0x%02x devid=%02x devrev=%02x type=%sn",
  1487.        efer, key, devid, devrev, type);
  1489. if (func)
  1490. func(efer,key);
  1491. }
  1494. static void __devinit winbond_check(int io, int key)
  1495. {
  1496. int devid,devrev,oldid,x_devid,x_devrev,x_oldid;
  1498. /* First probe without key */
  1499. outb(0x20,io);
  1500. x_devid=inb(io+1);
  1501. outb(0x21,io);
  1502. x_devrev=inb(io+1);
  1503. outb(0x09,io);
  1504. x_oldid=inb(io+1);
  1506. outb(key,io);
  1507. outb(key,io);     /* Write Magic Sequence to EFER, extended
  1508.                              funtion enable register */
  1509. outb(0x20,io);    /* Write EFIR, extended function index register */
  1510. devid=inb(io+1);  /* Read EFDR, extended function data register */
  1511. outb(0x21,io);
  1512. devrev=inb(io+1);
  1513. outb(0x09,io);
  1514. oldid=inb(io+1);
  1515. outb(0xaa,io);    /* Magic Seal */
  1517. if ((x_devid == devid) && (x_devrev == devrev) && (x_oldid == oldid))
  1518. return; /* protection against false positives */
  1520. decode_winbond(io,key,devid,devrev,oldid);
  1521. }
  1523. static void __devinit winbond_check2(int io,int key)
  1524. {
  1525.         int devid,devrev,oldid,x_devid,x_devrev,x_oldid;
  1527. /* First probe without the key */
  1528. outb(0x20,io+2);
  1529. x_devid=inb(io+2);
  1530. outb(0x21,io+1);
  1531. x_devrev=inb(io+2);
  1532. outb(0x09,io+1);
  1533. x_oldid=inb(io+2);
  1535.         outb(key,io);     /* Write Magic Byte to EFER, extended
  1536.                              funtion enable register */
  1537.         outb(0x20,io+2);  /* Write EFIR, extended function index register */
  1538.         devid=inb(io+2);  /* Read EFDR, extended function data register */
  1539.         outb(0x21,io+1);
  1540.         devrev=inb(io+2);
  1541.         outb(0x09,io+1);
  1542.         oldid=inb(io+2);
  1543.         outb(0xaa,io);    /* Magic Seal */
  1545. if ((x_devid == devid) && (x_devrev == devrev) && (x_oldid == oldid))
  1546. return; /* protection against false positives */
  1548.         decode_winbond(io,key,devid,devrev,oldid);
  1549. }
  1551. static void __devinit smsc_check(int io, int key)
  1552. {
  1553.         int id,rev,oldid,oldrev,x_id,x_rev,x_oldid,x_oldrev;
  1555. /* First probe without the key */
  1556. outb(0x0d,io);
  1557. x_oldid=inb(io+1);
  1558. outb(0x0e,io);
  1559. x_oldrev=inb(io+1);
  1560. outb(0x20,io);
  1561. x_id=inb(io+1);
  1562. outb(0x21,io);
  1563. x_rev=inb(io+1);
  1565.         outb(key,io);
  1566.         outb(key,io);     /* Write Magic Sequence to EFER, extended
  1567.                              funtion enable register */
  1568.         outb(0x0d,io);    /* Write EFIR, extended function index register */
  1569.         oldid=inb(io+1);  /* Read EFDR, extended function data register */
  1570.         outb(0x0e,io);
  1571.         oldrev=inb(io+1);
  1572. outb(0x20,io);
  1573. id=inb(io+1);
  1574. outb(0x21,io);
  1575. rev=inb(io+1);
  1576.         outb(0xaa,io);    /* Magic Seal */
  1578. if ((x_id == id) && (x_oldrev == oldrev) &&
  1579.     (x_oldid == oldid) && (x_rev == rev))
  1580. return; /* protection against false positives */
  1582.         decode_smsc(io,key,oldid,oldrev);
  1583. }
  1586. static void __devinit detect_and_report_winbond (void)
  1587. { 
  1588. if (verbose_probing)
  1589. printk(KERN_DEBUG "Winbond Super-IO detection, now testing ports 3F0,370,250,4E,2E ...n");
  1590. winbond_check(0x3f0,0x87);
  1591. winbond_check(0x370,0x87);
  1592. winbond_check(0x2e ,0x87);
  1593. winbond_check(0x4e ,0x87);
  1594. winbond_check(0x3f0,0x86);
  1595. winbond_check2(0x250,0x88); 
  1596. winbond_check2(0x250,0x89);
  1597. }
  1599. static void __devinit detect_and_report_smsc (void)
  1600. {
  1601. if (verbose_probing)
  1602. printk(KERN_DEBUG "SMSC Super-IO detection, now testing Ports 2F0, 370 ...n");
  1603. smsc_check(0x3f0,0x55);
  1604. smsc_check(0x370,0x55);
  1605. smsc_check(0x3f0,0x44);
  1606. smsc_check(0x370,0x44);
  1607. }
  1608. #endif /* CONFIG_PARPORT_PC_SUPERIO */
  1610. static int __devinit get_superio_dma (struct parport *p)
  1611. {
  1612. int i=0;
  1613. while( (superios[i].io != p->base) && (i<NR_SUPERIOS))
  1614. i++;
  1615. if (i!=NR_SUPERIOS)
  1616. return superios[i].dma;
  1617. return PARPORT_DMA_NONE;
  1618. }
  1620. static int __devinit get_superio_irq (struct parport *p)
  1621. {
  1622. int i=0;
  1623.         while( (superios[i].io != p->base) && (i<NR_SUPERIOS))
  1624.                 i++;
  1625.         if (i!=NR_SUPERIOS)
  1626.                 return superios[i].irq;
  1627.         return PARPORT_IRQ_NONE;
  1628. }
  1631. /* --- Mode detection ------------------------------------- */
  1633. /*
  1634.  * Checks for port existence, all ports support SPP MODE
  1635.  * Returns: 
  1636.  *         0           :  No parallel port at this adress
  1637.  *  PARPORT_MODE_PCSPP :  SPP port detected 
  1638.  *                        (if the user specified an ioport himself,
  1639.  *                         this shall always be the case!)
  1640.  *
  1641.  */
  1642. static int __devinit parport_SPP_supported(struct parport *pb)
  1643. {
  1644. unsigned char r, w;
  1646. /*
  1647.  * first clear an eventually pending EPP timeout 
  1648.  * I (sailer@ife.ee.ethz.ch) have an SMSC chipset
  1649.  * that does not even respond to SPP cycles if an EPP
  1650.  * timeout is pending
  1651.  */
  1652. clear_epp_timeout(pb);
  1654. /* Do a simple read-write test to make sure the port exists. */
  1655. w = 0xc;
  1656. outb (w, CONTROL (pb));
  1658. /* Is there a control register that we can read from?  Some
  1659.  * ports don't allow reads, so read_control just returns a
  1660.  * software copy. Some ports _do_ allow reads, so bypass the
  1661.  * software copy here.  In addition, some bits aren't
  1662.  * writable. */
  1663. r = inb (CONTROL (pb));
  1664. if ((r & 0xf) == w) {
  1665. w = 0xe;
  1666. outb (w, CONTROL (pb));
  1667. r = inb (CONTROL (pb));
  1668. outb (0xc, CONTROL (pb));
  1669. if ((r & 0xf) == w)
  1670. return PARPORT_MODE_PCSPP;
  1671. }
  1673. if (user_specified)
  1674. /* That didn't work, but the user thinks there's a
  1675.  * port here. */
  1676. printk (KERN_INFO "parport 0x%lx (WARNING): CTR: "
  1677. "wrote 0x%02x, read 0x%02xn", pb->base, w, r);
  1679. /* Try the data register.  The data lines aren't tri-stated at
  1680.  * this stage, so we expect back what we wrote. */
  1681. w = 0xaa;
  1682. parport_pc_write_data (pb, w);
  1683. r = parport_pc_read_data (pb);
  1684. if (r == w) {
  1685. w = 0x55;
  1686. parport_pc_write_data (pb, w);
  1687. r = parport_pc_read_data (pb);
  1688. if (r == w)
  1689. return PARPORT_MODE_PCSPP;
  1690. }
  1692. if (user_specified) {
  1693. /* Didn't work, but the user is convinced this is the
  1694.  * place. */
  1695. printk (KERN_INFO "parport 0x%lx (WARNING): DATA: "
  1696. "wrote 0x%02x, read 0x%02xn", pb->base, w, r);
  1697. printk (KERN_INFO "parport 0x%lx: You gave this address, "
  1698. "but there is probably no parallel port there!n",
  1699. pb->base);
  1700. }
  1702. /* It's possible that we can't read the control register or
  1703.  * the data register.  In that case just believe the user. */
  1704. if (user_specified)
  1705. return PARPORT_MODE_PCSPP;
  1707. return 0;
  1708. }
  1710. /* Check for ECR
  1711.  *
  1712.  * Old style XT ports alias io ports every 0x400, hence accessing ECR
  1713.  * on these cards actually accesses the CTR.
  1714.  *
  1715.  * Modern cards don't do this but reading from ECR will return 0xff
  1716.  * regardless of what is written here if the card does NOT support
  1717.  * ECP.
  1718.  *
  1719.  * We first check to see if ECR is the same as CTR.  If not, the low
  1720.  * two bits of ECR aren't writable, so we check by writing ECR and
  1721.  * reading it back to see if it's what we expect.
  1722.  */
  1723. static int __devinit parport_ECR_present(struct parport *pb)
  1724. {
  1725. struct parport_pc_private *priv = pb->private_data;
  1726. unsigned char r = 0xc;
  1728. outb (r, CONTROL (pb));
  1729. if ((inb (ECONTROL (pb)) & 0x3) == (r & 0x3)) {
  1730. outb (r ^ 0x2, CONTROL (pb)); /* Toggle bit 1 */
  1732. r = inb (CONTROL (pb));
  1733. if ((inb (ECONTROL (pb)) & 0x2) == (r & 0x2))
  1734. goto no_reg; /* Sure that no ECR register exists */
  1735. }
  1737. if ((inb (ECONTROL (pb)) & 0x3 ) != 0x1)
  1738. goto no_reg;
  1740. ECR_WRITE (pb, 0x34);
  1741. if (inb (ECONTROL (pb)) != 0x35)
  1742. goto no_reg;
  1744. priv->ecr = 1;
  1745. outb (0xc, CONTROL (pb));
  1747. /* Go to mode 000 */
  1748. frob_set_mode (pb, ECR_SPP);
  1750. return 1;
  1752.  no_reg:
  1753. outb (0xc, CONTROL (pb));
  1754. return 0; 
  1755. }
  1757. #ifdef CONFIG_PARPORT_1284
  1758. /* Detect PS/2 support.
  1759.  *
  1760.  * Bit 5 (0x20) sets the PS/2 data direction; setting this high
  1761.  * allows us to read data from the data lines.  In theory we would get back
  1762.  * 0xff but any peripheral attached to the port may drag some or all of the
  1763.  * lines down to zero.  So if we get back anything that isn't the contents
  1764.  * of the data register we deem PS/2 support to be present. 
  1765.  *
  1766.  * Some SPP ports have "half PS/2" ability - you can't turn off the line
  1767.  * drivers, but an external peripheral with sufficiently beefy drivers of
  1768.  * its own can overpower them and assert its own levels onto the bus, from
  1769.  * where they can then be read back as normal.  Ports with this property
  1770.  * and the right type of device attached are likely to fail the SPP test,
  1771.  * (as they will appear to have stuck bits) and so the fact that they might
  1772.  * be misdetected here is rather academic. 
  1773.  */
  1775. static int __devinit parport_PS2_supported(struct parport *pb)
  1776. {
  1777. int ok = 0;
  1778.   
  1779. clear_epp_timeout(pb);
  1781. /* try to tri-state the buffer */
  1782. parport_pc_data_reverse (pb);
  1784. parport_pc_write_data(pb, 0x55);
  1785. if (parport_pc_read_data(pb) != 0x55) ok++;
  1787. parport_pc_write_data(pb, 0xaa);
  1788. if (parport_pc_read_data(pb) != 0xaa) ok++;
  1790. /* cancel input mode */
  1791. parport_pc_data_forward (pb);
  1793. if (ok) {
  1794. pb->modes |= PARPORT_MODE_TRISTATE;
  1795. } else {
  1796. struct parport_pc_private *priv = pb->private_data;
  1797. priv->ctr_writable &= ~0x20;
  1798. }
  1800. return ok;
  1801. }
  1803. #ifdef CONFIG_PARPORT_PC_FIFO
  1804. static int __devinit parport_ECP_supported(struct parport *pb)
  1805. {
  1806. int i;
  1807. int config, configb;
  1808. int pword;
  1809. struct parport_pc_private *priv = pb->private_data;
  1810. /* Translate ECP intrLine to ISA irq value */
  1811. static const int intrline[]= { 0, 7, 9, 10, 11, 14, 15, 5 }; 
  1813. /* If there is no ECR, we have no hope of supporting ECP. */
  1814. if (!priv->ecr)
  1815. return 0;
  1817. /* Find out FIFO depth */
  1818. ECR_WRITE (pb, ECR_SPP << 5); /* Reset FIFO */
  1819. ECR_WRITE (pb, ECR_TST << 5); /* TEST FIFO */
  1820. for (i=0; i < 1024 && !(inb (ECONTROL (pb)) & 0x02); i++)
  1821. outb (0xaa, FIFO (pb));
  1823. /*
  1824.  * Using LGS chipset it uses ECR register, but
  1825.  * it doesn't support ECP or FIFO MODE
  1826.  */
  1827. if (i == 1024) {
  1828. ECR_WRITE (pb, ECR_SPP << 5);
  1829. return 0;
  1830. }
  1832. priv->fifo_depth = i;
  1833. if (verbose_probing)
  1834. printk (KERN_DEBUG "0x%lx: FIFO is %d bytesn", pb->base, i);
  1836. /* Find out writeIntrThreshold */
  1837. frob_econtrol (pb, 1<<2, 1<<2);
  1838. frob_econtrol (pb, 1<<2, 0);
  1839. for (i = 1; i <= priv->fifo_depth; i++) {
  1840. inb (FIFO (pb));
  1841. udelay (50);
  1842. if (inb (ECONTROL (pb)) & (1<<2))
  1843. break;
  1844. }
  1846. if (i <= priv->fifo_depth) {
  1847. if (verbose_probing)
  1848. printk (KERN_DEBUG "0x%lx: writeIntrThreshold is %dn",
  1849. pb->base, i);
  1850. } else
  1851. /* Number of bytes we know we can write if we get an
  1852.                    interrupt. */
  1853. i = 0;
  1855. priv->writeIntrThreshold = i;
  1857. /* Find out readIntrThreshold */
  1858. frob_set_mode (pb, ECR_PS2); /* Reset FIFO and enable PS2 */
  1859. parport_pc_data_reverse (pb); /* Must be in PS2 mode */
  1860. frob_set_mode (pb, ECR_TST); /* Test FIFO */
  1861. frob_econtrol (pb, 1<<2, 1<<2);
  1862. frob_econtrol (pb, 1<<2, 0);
  1863. for (i = 1; i <= priv->fifo_depth; i++) {
  1864. outb (0xaa, FIFO (pb));
  1865. if (inb (ECONTROL (pb)) & (1<<2))
  1866. break;
  1867. }
  1869. if (i <= priv->fifo_depth) {
  1870. if (verbose_probing)
  1871. printk (KERN_INFO "0x%lx: readIntrThreshold is %dn",
  1872. pb->base, i);
  1873. } else
  1874. /* Number of bytes we can read if we get an interrupt. */
  1875. i = 0;
  1877. priv->readIntrThreshold = i;
  1879. ECR_WRITE (pb, ECR_SPP << 5); /* Reset FIFO */
  1880. ECR_WRITE (pb, 0xf4); /* Configuration mode */
  1881. config = inb (CONFIGA (pb));
  1882. pword = (config >> 4) & 0x7;
  1883. switch (pword) {
  1884. case 0:
  1885. pword = 2;
  1886. printk (KERN_WARNING "0x%lx: Unsupported pword size!n",
  1887. pb->base);
  1888. break;
  1889. case 2:
  1890. pword = 4;
  1891. printk (KERN_WARNING "0x%lx: Unsupported pword size!n",
  1892. pb->base);
  1893. break;
  1894. default:
  1895. printk (KERN_WARNING "0x%lx: Unknown implementation IDn",
  1896. pb->base);
  1897. /* Assume 1 */
  1898. case 1:
  1899. pword = 1;
  1900. }
  1901. priv->pword = pword;
  1903. if (verbose_probing) {
  1904. printk (KERN_DEBUG "0x%lx: PWord is %d bitsn", pb->base, 8 * pword);
  1906. printk (KERN_DEBUG "0x%lx: Interrupts are ISA-%sn", pb->base,
  1907. config & 0x80 ? "Level" : "Pulses");
  1909. configb = inb (CONFIGB (pb));
  1910. printk (KERN_DEBUG "0x%lx: ECP port cfgA=0x%02x cfgB=0x%02xn",
  1911. pb->base, config, configb);
  1912. printk (KERN_DEBUG "0x%lx: ECP settings irq=", pb->base);
  1913. if ((configb >>3) & 0x07)
  1914. printk("%d",intrline[(configb >>3) & 0x07]);
  1915. else
  1916. printk("<none or set by other means>");
  1917. printk (" dma=");
  1918. if( (configb & 0x03 ) == 0x00)
  1919. printk("<none or set by other means>n");
  1920. else
  1921. printk("%dn",configb & 0x07);
  1922. }
  1924. /* Go back to mode 000 */
  1925. frob_set_mode (pb, ECR_SPP);
  1927. return 1;
  1928. }
  1929. #endif
  1931. static int __devinit parport_ECPPS2_supported(struct parport *pb)
  1932. {
  1933. const struct parport_pc_private *priv = pb->private_data;
  1934. int result;
  1935. unsigned char oecr;
  1937. if (!priv->ecr)
  1938. return 0;
  1940. oecr = inb (ECONTROL (pb));
  1941. ECR_WRITE (pb, ECR_PS2 << 5);
  1942. result = parport_PS2_supported(pb);
  1943. ECR_WRITE (pb, oecr);
  1944. return result;
  1945. }
  1947. /* EPP mode detection  */
  1949. static int __devinit parport_EPP_supported(struct parport *pb)
  1950. {
  1951. const struct parport_pc_private *priv = pb->private_data;
  1953. /*
  1954.  * Theory:
  1955.  * Bit 0 of STR is the EPP timeout bit, this bit is 0
  1956.  * when EPP is possible and is set high when an EPP timeout
  1957.  * occurs (EPP uses the HALT line to stop the CPU while it does
  1958.  * the byte transfer, an EPP timeout occurs if the attached
  1959.  * device fails to respond after 10 micro seconds).
  1960.  *
  1961.  * This bit is cleared by either reading it (National Semi)
  1962.  * or writing a 1 to the bit (SMC, UMC, WinBond), others ???
  1963.  * This bit is always high in non EPP modes.
  1964.  */
  1966. /* If EPP timeout bit clear then EPP available */
  1967. if (!clear_epp_timeout(pb)) {
  1968. return 0;  /* No way to clear timeout */
  1969. }
  1971. /* Check for Intel bug. */
  1972. if (priv->ecr) {
  1973. unsigned char i;
  1974. for (i = 0x00; i < 0x80; i += 0x20) {
  1975. ECR_WRITE (pb, i);
  1976. if (clear_epp_timeout (pb)) {
  1977. /* Phony EPP in ECP. */
  1978. return 0;
  1979. }
  1980. }
  1981. }
  1983. pb->modes |= PARPORT_MODE_EPP;
  1985. /* Set up access functions to use EPP hardware. */
  1986. pb->ops->epp_read_data = parport_pc_epp_read_data;
  1987. pb->ops->epp_write_data = parport_pc_epp_write_data;
  1988. pb->ops->epp_read_addr = parport_pc_epp_read_addr;
  1989. pb->ops->epp_write_addr = parport_pc_epp_write_addr;
  1991. return 1;
  1992. }
  1994. static int __devinit parport_ECPEPP_supported(struct parport *pb)
  1995. {
  1996. struct parport_pc_private *priv = pb->private_data;
  1997. int result;
  1998. unsigned char oecr;
  2000. if (!priv->ecr) {
  2001. return 0;
  2002. }
  2004. oecr = inb (ECONTROL (pb));
  2005. /* Search for SMC style EPP+ECP mode */
  2006. ECR_WRITE (pb, 0x80);
  2007. outb (0x04, CONTROL (pb));
  2008. result = parport_EPP_supported(pb);
  2010. ECR_WRITE (pb, oecr);
  2012. if (result) {
  2013. /* Set up access functions to use ECP+EPP hardware. */
  2014. pb->ops->epp_read_data = parport_pc_ecpepp_read_data;
  2015. pb->ops->epp_write_data = parport_pc_ecpepp_write_data;
  2016. pb->ops->epp_read_addr = parport_pc_ecpepp_read_addr;
  2017. pb->ops->epp_write_addr = parport_pc_ecpepp_write_addr;
  2018. }
  2020. return result;
  2021. }
  2023. #else /* No IEEE 1284 support */
  2025. /* Don't bother probing for modes we know we won't use. */
  2026. static int __devinit parport_PS2_supported(struct parport *pb) { return 0; }
  2027. #ifdef CONFIG_PARPORT_PC_FIFO
  2028. static int __devinit parport_ECP_supported(struct parport *pb) { return 0; }
  2029. #endif
  2030. static int __devinit parport_EPP_supported(struct parport *pb) { return 0; }
  2031. static int __devinit parport_ECPEPP_supported(struct parport *pb){return 0;}
  2032. static int __devinit parport_ECPPS2_supported(struct parport *pb){return 0;}
  2034. #endif /* No IEEE 1284 support */
  2036. /* --- IRQ detection -------------------------------------- */
  2038. /* Only if supports ECP mode */
  2039. static int __devinit programmable_irq_support(struct parport *pb)
  2040. {
  2041. int irq, intrLine;
  2042. unsigned char oecr = inb (ECONTROL (pb));
  2043. static const int lookup[8] = {
  2044. PARPORT_IRQ_NONE, 7, 9, 10, 11, 14, 15, 5
  2045. };
  2047. ECR_WRITE (pb, ECR_CNF << 5); /* Configuration MODE */
  2049. intrLine = (inb (CONFIGB (pb)) >> 3) & 0x07;
  2050. irq = lookup[intrLine];
  2052. ECR_WRITE (pb, oecr);
  2053. return irq;
  2054. }
  2056. static int __devinit irq_probe_ECP(struct parport *pb)
  2057. {
  2058. int i;
  2059. unsigned long irqs;
  2061. sti();
  2062. irqs = probe_irq_on();
  2064. ECR_WRITE (pb, ECR_SPP << 5); /* Reset FIFO */
  2065. ECR_WRITE (pb, (ECR_TST << 5) | 0x04);
  2066. ECR_WRITE (pb, ECR_TST << 5);
  2068. /* If Full FIFO sure that writeIntrThreshold is generated */
  2069. for (i=0; i < 1024 && !(inb (ECONTROL (pb)) & 0x02) ; i++) 
  2070. outb (0xaa, FIFO (pb));
  2072. pb->irq = probe_irq_off(irqs);
  2073. ECR_WRITE (pb, ECR_SPP << 5);
  2075. if (pb->irq <= 0)
  2076. pb->irq = PARPORT_IRQ_NONE;
  2078. return pb->irq;
  2079. }
  2081. /*
  2082.  * This detection seems that only works in National Semiconductors
  2083.  * This doesn't work in SMC, LGS, and Winbond 
  2084.  */
  2085. static int __devinit irq_probe_EPP(struct parport *pb)
  2086. {
  2087. #ifndef ADVANCED_DETECT
  2088. return PARPORT_IRQ_NONE;
  2089. #else
  2090. int irqs;
  2091. unsigned char oecr;
  2093. if (pb->modes & PARPORT_MODE_PCECR)
  2094. oecr = inb (ECONTROL (pb));
  2096. sti();
  2097. irqs = probe_irq_on();
  2099. if (pb->modes & PARPORT_MODE_PCECR)
  2100. frob_econtrol (pb, 0x10, 0x10);
  2102. clear_epp_timeout(pb);
  2103. parport_pc_frob_control (pb, 0x20, 0x20);
  2104. parport_pc_frob_control (pb, 0x10, 0x10);
  2105. clear_epp_timeout(pb);
  2107. /* Device isn't expecting an EPP read
  2108.  * and generates an IRQ.
  2109.  */
  2110. parport_pc_read_epp(pb);
  2111. udelay(20);
  2113. pb->irq = probe_irq_off (irqs);
  2114. if (pb->modes & PARPORT_MODE_PCECR)
  2115. ECR_WRITE (pb, oecr);
  2116. parport_pc_write_control(pb, 0xc);
  2118. if (pb->irq <= 0)
  2119. pb->irq = PARPORT_IRQ_NONE;
  2121. return pb->irq;
  2122. #endif /* Advanced detection */
  2123. }
  2125. static int __devinit irq_probe_SPP(struct parport *pb)
  2126. {
  2127. /* Don't even try to do this. */
  2128. return PARPORT_IRQ_NONE;
  2129. }
  2131. /* We will attempt to share interrupt requests since other devices
  2132.  * such as sound cards and network cards seem to like using the
  2133.  * printer IRQs.
  2134.  *
  2135.  * When ECP is available we can autoprobe for IRQs.
  2136.  * NOTE: If we can autoprobe it, we can register the IRQ.
  2137.  */
  2138. static int __devinit parport_irq_probe(struct parport *pb)
  2139. {
  2140. struct parport_pc_private *priv = pb->private_data;
  2142. priv->ctr_writable |= 0x10;
  2144. if (priv->ecr) {
  2145. pb->irq = programmable_irq_support(pb);
  2147. if (pb->irq == PARPORT_IRQ_NONE)
  2148. pb->irq = irq_probe_ECP(pb);
  2149. }
  2151. if ((pb->irq == PARPORT_IRQ_NONE) && priv->ecr &&
  2152.     (pb->modes & PARPORT_MODE_EPP))
  2153. pb->irq = irq_probe_EPP(pb);
  2155. clear_epp_timeout(pb);
  2157. if (pb->irq == PARPORT_IRQ_NONE && (pb->modes & PARPORT_MODE_EPP))
  2158. pb->irq = irq_probe_EPP(pb);
  2160. clear_epp_timeout(pb);
  2162. if (pb->irq == PARPORT_IRQ_NONE)
  2163. pb->irq = irq_probe_SPP(pb);
  2165. if (pb->irq == PARPORT_IRQ_NONE)
  2166. pb->irq = get_superio_irq(pb);
  2168. if (pb->irq == PARPORT_IRQ_NONE)
  2169. priv->ctr_writable &= ~0x10;
  2171. return pb->irq;
  2172. }
  2174. /* --- DMA detection -------------------------------------- */
  2176. /* Only if chipset conforms to ECP ISA Interface Standard */
  2177. static int __devinit programmable_dma_support (struct parport *p)
  2178. {
  2179. unsigned char oecr = inb (ECONTROL (p));
  2180. int dma;
  2182. frob_set_mode (p, ECR_CNF);
  2184. dma = inb (CONFIGB(p)) & 0x07;
  2185. /* 000: Indicates jumpered 8-bit DMA if read-only.
  2186.    100: Indicates jumpered 16-bit DMA if read-only. */
  2187. if ((dma & 0x03) == 0)
  2188. dma = PARPORT_DMA_NONE;
  2190. ECR_WRITE (p, oecr);
  2191. return dma;
  2192. }
  2194. static int __devinit parport_dma_probe (struct parport *p)
  2195. {
  2196. const struct parport_pc_private *priv = p->private_data;
  2197. if (priv->ecr)
  2198. p->dma = programmable_dma_support(p); /* ask ECP chipset first */
  2199. if (p->dma == PARPORT_DMA_NONE) {
  2200. /* ask known Super-IO chips proper, although these
  2201.    claim ECP compatible, some don't report their DMA
  2202.    conforming to ECP standards */
  2203. p->dma = get_superio_dma(p);
  2204. }
  2206. return p->dma;
  2207. }
  2209. /* --- Initialisation code -------------------------------- */
  2211. struct parport *parport_pc_probe_port (unsigned long int base,
  2212.        unsigned long int base_hi,
  2213.        int irq, int dma,
  2214.        struct pci_dev *dev)
  2215. {
  2216. struct parport_pc_private *priv;
  2217. struct parport_operations *ops;
  2218. struct parport tmp;
  2219. struct parport *p = &tmp;
  2220. int probedirq = PARPORT_IRQ_NONE;
  2221. if (check_region(base, 3)) return NULL;
  2222. priv = kmalloc (sizeof (struct parport_pc_private), GFP_KERNEL);
  2223. if (!priv) {
  2224. printk (KERN_DEBUG "parport (0x%lx): no memory!n", base);
  2225. return NULL;
  2226. }
  2227. ops = kmalloc (sizeof (struct parport_operations), GFP_KERNEL);
  2228. if (!ops) {
  2229. printk (KERN_DEBUG "parport (0x%lx): no memory for ops!n",
  2230. base);
  2231. kfree (priv);
  2232. return NULL;
  2233. }
  2234. memcpy (ops, &parport_pc_ops, sizeof (struct parport_operations));
  2235. priv->ctr = 0xc;
  2236. priv->ctr_writable = ~0x10;
  2237. priv->ecr = 0;
  2238. priv->fifo_depth = 0;
  2239. priv->dma_buf = 0;
  2240. priv->dma_handle = 0;
  2241. priv->dev = dev;
  2242. p->base = base;
  2243. p->base_hi = base_hi;
  2244. p->irq = irq;
  2245. p->dma = dma;
  2246. p->modes = PARPORT_MODE_PCSPP | PARPORT_MODE_SAFEININT;
  2247. p->ops = ops;
  2248. p->private_data = priv;
  2249. p->physport = p;
  2251. if (base_hi && !check_region(base_hi,3))
  2252. parport_ECR_present(p);
  2254. if (base != 0x3bc) {
  2255. if (!check_region(base+0x3, 5)) {
  2256. if (!parport_EPP_supported(p))
  2257. parport_ECPEPP_supported(p);
  2258. }
  2259. }
  2260. if (!parport_SPP_supported (p)) {
  2261. /* No port. */
  2262. kfree (priv);
  2263. kfree (ops);
  2264. return NULL;
  2265. }
  2266. if (priv->ecr)
  2267. parport_ECPPS2_supported(p);
  2268. else
  2269. parport_PS2_supported (p);
  2271. if (!(p = parport_register_port(base, PARPORT_IRQ_NONE,
  2272. PARPORT_DMA_NONE, ops))) {
  2273. kfree (priv);
  2274. kfree (ops);
  2275. return NULL;
  2276. }
  2278. p->base_hi = base_hi;
  2279. p->modes = tmp.modes;
  2280. p->size = (p->modes & PARPORT_MODE_EPP)?8:3;
  2281. p->private_data = priv;
  2283. printk(KERN_INFO "%s: PC-style at 0x%lx", p->name, p->base);
  2284. if (p->base_hi && priv->ecr)
  2285. printk(" (0x%lx)", p->base_hi);
  2286. p->irq = irq;
  2287. p->dma = dma;
  2288. if (p->irq == PARPORT_IRQ_AUTO) {
  2289. p->irq = PARPORT_IRQ_NONE;
  2290. parport_irq_probe(p);
  2291. } else if (p->irq == PARPORT_IRQ_PROBEONLY) {
  2292. p->irq = PARPORT_IRQ_NONE;
  2293. parport_irq_probe(p);
  2294. probedirq = p->irq;
  2295. p->irq = PARPORT_IRQ_NONE;
  2296. }
  2297. if (p->irq != PARPORT_IRQ_NONE) {
  2298. printk(", irq %d", p->irq);
  2300. if (p->dma == PARPORT_DMA_AUTO) {
  2301. p->dma = PARPORT_DMA_NONE;
  2302. parport_dma_probe(p);
  2303. }
  2304. }
  2305. if (p->dma == PARPORT_DMA_AUTO) /* To use DMA, giving the irq
  2306.                                            is mandatory (see above) */
  2307. p->dma = PARPORT_DMA_NONE;
  2309. #ifdef CONFIG_PARPORT_PC_FIFO
  2310. if (parport_ECP_supported(p) &&
  2311.     p->dma != PARPORT_DMA_NOFIFO &&
  2312.     priv->fifo_depth > 0 && p->irq != PARPORT_IRQ_NONE) {
  2313. p->modes |= PARPORT_MODE_ECP | PARPORT_MODE_COMPAT;
  2314. p->ops->compat_write_data = parport_pc_compat_write_block_pio;
  2315. #ifdef CONFIG_PARPORT_1284
  2316. p->ops->ecp_write_data = parport_pc_ecp_write_block_pio;
  2317. /* currently broken, but working on it.. (FB) */
  2318. /* p->ops->ecp_read_data = parport_pc_ecp_read_block_pio; */
  2319. #endif /* IEEE 1284 support */
  2320. if (p->dma != PARPORT_DMA_NONE) {
  2321. printk(", dma %d", p->dma);
  2322. p->modes |= PARPORT_MODE_DMA;
  2323. }
  2324. else printk(", using FIFO");
  2325. }
  2326. else
  2327. /* We can't use the DMA channel after all. */
  2328. p->dma = PARPORT_DMA_NONE;
  2329. #endif /* Allowed to use FIFO/DMA */
  2331. printk(" [");
  2332. #define printmode(x) {if(p->modes&PARPORT_MODE_##x){printk("%s%s",f?",":"",#x);f++;}}
  2333. {
  2334. int f = 0;
  2335. printmode(PCSPP);
  2336. printmode(TRISTATE);
  2337. printmode(COMPAT)
  2338. printmode(EPP);
  2339. printmode(ECP);
  2340. printmode(DMA);
  2341. }
  2342. #undef printmode
  2343. #ifndef CONFIG_PARPORT_1284
  2344. printk ("(,...)");
  2345. #endif /* CONFIG_PARPORT_1284 */
  2346. printk("]n");
  2347. if (probedirq != PARPORT_IRQ_NONE) 
  2348. printk(KERN_INFO "%s: irq %d detectedn", p->name, probedirq);
  2349. parport_proc_register(p);
  2351. request_region (p->base, 3, p->name);
  2352. if (p->size > 3)
  2353. request_region (p->base + 3, p->size - 3, p->name);
  2354. if (p->modes & PARPORT_MODE_ECP)
  2355. request_region (p->base_hi, 3, p->name);
  2357. if (p->irq != PARPORT_IRQ_NONE) {
  2358. if (request_irq (p->irq, parport_pc_interrupt,
  2359.  0, p->name, p)) {
  2360. printk (KERN_WARNING "%s: irq %d in use, "
  2361. "resorting to polled operationn",
  2362. p->name, p->irq);
  2363. p->irq = PARPORT_IRQ_NONE;
  2364. p->dma = PARPORT_DMA_NONE;
  2365. }
  2367. #ifdef CONFIG_PARPORT_PC_FIFO
  2368. if (p->dma != PARPORT_DMA_NONE) {
  2369. if (request_dma (p->dma, p->name)) {
  2370. printk (KERN_WARNING "%s: dma %d in use, "
  2371. "resorting to PIO operationn",
  2372. p->name, p->dma);
  2373. p->dma = PARPORT_DMA_NONE;
  2374. } else {
  2375. priv->dma_buf =
  2376.   pci_alloc_consistent(priv->dev,
  2377.        PAGE_SIZE,
  2378.        &priv->dma_handle);
  2379. if (! priv->dma_buf) {
  2380. printk (KERN_WARNING "%s: "
  2381. "cannot get buffer for DMA, "
  2382. "resorting to PIO operationn",
  2383. p->name);
  2384. free_dma(p->dma);
  2385. p->dma = PARPORT_DMA_NONE;
  2386. }
  2387. }
  2388. }
  2389. #endif /* CONFIG_PARPORT_PC_FIFO */
  2390. }
  2392. /* Done probing.  Now put the port into a sensible start-up state. */
  2393. if (priv->ecr)
  2394. /*
  2395.  * Put the ECP detected port in PS2 mode.
  2396.  * Do this also for ports that have ECR but don't do ECP.
  2397.  */
  2398. ECR_WRITE (p, 0x34);
  2400. parport_pc_write_data(p, 0);
  2401. parport_pc_data_forward (p);
  2403. /* Now that we've told the sharing engine about the port, and
  2404.    found out its characteristics, let the high-level drivers
  2405.    know about it. */
  2406. parport_announce_port (p);
  2408. return p;
  2409. }
  2411. void parport_pc_unregister_port (struct parport *p)
  2412. {
  2413. struct parport_pc_private *priv = p->private_data;
  2414. struct parport_operations *ops = p->ops;
  2415. if (p->dma != PARPORT_DMA_NONE)
  2416. free_dma(p->dma);
  2417. if (p->irq != PARPORT_IRQ_NONE)
  2418. free_irq(p->irq, p);
  2419. release_region(p->base, 3);
  2420. if (p->size > 3)
  2421. release_region(p->base + 3, p->size - 3);
  2422. if (p->modes & PARPORT_MODE_ECP)
  2423. release_region(p->base_hi, 3);
  2424. parport_proc_unregister(p);
  2425. if (priv->dma_buf)
  2426. pci_free_consistent(priv->dev, PAGE_SIZE,
  2427.     priv->dma_buf,
  2428.     priv->dma_handle);
  2429. kfree (p->private_data);
  2430. parport_unregister_port(p);
  2431. kfree (ops); /* hope no-one cached it */
  2432. }
  2434. #ifdef CONFIG_PCI
  2436. /* ITE support maintained by Rich Liu <richliu@poorman.org> */
  2437. static int __devinit sio_ite_8872_probe (struct pci_dev *pdev, int autoirq,
  2438.  int autodma)
  2439. {
  2440. short inta_addr[6] = { 0x2A0, 0x2C0, 0x220, 0x240, 0x1E0 };
  2441. u32 ite8872set;
  2442. u32 ite8872_lpt, ite8872_lpthi;
  2443. u8 ite8872_irq, type;
  2444. int irq;
  2445. int i;
  2447. DPRINTK (KERN_DEBUG "sio_ite_8872_probe()n");
  2449. // make sure which one chip
  2450. for(i = 0; i < 5; i++) {
  2451. if (check_region (inta_addr[i], 0x8) >= 0) {
  2452. int test;
  2453. pci_write_config_dword (pdev, 0x60,
  2454. 0xe7000000 | inta_addr[i]);
  2455. pci_write_config_dword (pdev, 0x78,
  2456. 0x00000000 | inta_addr[i]);
  2457. test = inb (inta_addr[i]);
  2458. if (test != 0xff) break;
  2459. }
  2460. }
  2461. if(i >= 5) {
  2462. printk (KERN_INFO "parport_pc: cannot find ITE8872 INTAn");
  2463. return 0;
  2464. }
  2466. type = inb (inta_addr[i] + 0x18);
  2467. type &= 0x0f;
  2469. switch (type) {
  2470. case 0x2:
  2471. printk (KERN_INFO "parport_pc: ITE8871 found (1P)n");
  2472. ite8872set = 0x64200000;
  2473. break;
  2474. case 0xa:
  2475. printk (KERN_INFO "parport_pc: ITE8875 found (1P)n");
  2476. ite8872set = 0x64200000;
  2477. break;
  2478. case 0xe:
  2479. printk (KERN_INFO "parport_pc: ITE8872 found (2S1P)n");
  2480. ite8872set = 0x64e00000;
  2481. break;
  2482. case 0x6:
  2483. printk (KERN_INFO "parport_pc: ITE8873 found (1S)n");
  2484. return 0;
  2485. case 0x8:
  2486. DPRINTK (KERN_DEBUG "parport_pc: ITE8874 found (2S)n");
  2487. return 0;
  2488. default:
  2489. printk (KERN_INFO "parport_pc: unknown ITE887xn");
  2490. printk (KERN_INFO "parport_pc: please mail 'lspci -nvv' "
  2491. "output to Rich.Liu@ite.com.twn");
  2492. return 0;
  2493. }
  2495. pci_read_config_byte (pdev, 0x3c, &ite8872_irq);
  2496. pci_read_config_dword (pdev, 0x1c, &ite8872_lpt);
  2497. ite8872_lpt &= 0x0000ff00;
  2498. pci_read_config_dword (pdev, 0x20, &ite8872_lpthi);
  2499. ite8872_lpthi &= 0x0000ff00;
  2500. pci_write_config_dword (pdev, 0x6c, 0xe3000000 | ite8872_lpt);
  2501. pci_write_config_dword (pdev, 0x70, 0xe3000000 | ite8872_lpthi);
  2502. pci_write_config_dword (pdev, 0x80, (ite8872_lpthi<<16) | ite8872_lpt);
  2503. // SET SPP&EPP , Parallel Port NO DMA , Enable All Function
  2504. // SET Parallel IRQ
  2505. pci_write_config_dword (pdev, 0x9c,
  2506. ite8872set | (ite8872_irq * 0x11111));
  2508. DPRINTK (KERN_DEBUG "ITE887x: The IRQ is %d.n", ite8872_irq);
  2509. DPRINTK (KERN_DEBUG "ITE887x: The PARALLEL I/O port is 0x%x.n",
  2510.  ite8872_lpt);
  2511. DPRINTK (KERN_DEBUG "ITE887x: The PARALLEL I/O porthi is 0x%x.n",
  2512.  ite8872_lpthi);
  2514. /* Let the user (or defaults) steer us away from interrupts */
  2515. irq = ite8872_irq;
  2516. if (autoirq != PARPORT_IRQ_AUTO)
  2517. irq = PARPORT_IRQ_NONE;
  2519. if (parport_pc_probe_port (ite8872_lpt, ite8872_lpthi,
  2520.    irq, PARPORT_DMA_NONE, NULL)) {
  2521. printk (KERN_INFO
  2522. "parport_pc: ITE 8872 parallel port: io=0x%X",
  2523. ite8872_lpt);
  2524. if (irq != PARPORT_IRQ_NONE)
  2525. printk (", irq=%d", irq);
  2526. printk ("n");
  2527. return 1;
  2528. }
  2530. return 0;
  2531. }
  2533. /* Via support maintained by Jeff Garzik <jgarzik@mandrakesoft.com> */
  2534. static int __devinit sio_via_686a_probe (struct pci_dev *pdev, int autoirq,
  2535.  int autodma)
  2536. {
  2537. u8 tmp;
  2538. int dma, irq;
  2539. unsigned port1, port2, have_eppecp;
  2541. /*
  2542.  * unlock super i/o configuration, set 0x85_1
  2543.  */
  2544. pci_read_config_byte (pdev, 0x85, &tmp);
  2545. tmp |= (1 << 1);
  2546. pci_write_config_byte (pdev, 0x85, tmp);
  2548. /* 
  2549.  * Super I/O configuration, index port == 3f0h, data port == 3f1h
  2550.  */
  2552. /* 0xE2_1-0: Parallel Port Mode / Enable */
  2553. outb (0xE2, 0x3F0);
  2554. tmp = inb (0x3F1);
  2556. if ((tmp & 0x03) == 0x03) {
  2557. printk (KERN_INFO "parport_pc: Via 686A parallel port disabled in BIOSn");
  2558. return 0;
  2559. }
  2561. /* 0xE6: Parallel Port I/O Base Address, bits 9-2 */
  2562. outb (0xE6, 0x3F0);
  2563. port1 = inb (0x3F1) << 2;
  2565. switch (port1) {
  2566. case 0x3bc: port2 = 0x7bc; break;
  2567. case 0x378: port2 = 0x778; break;
  2568. case 0x278: port2 = 0x678; break;
  2569. default:
  2570. printk (KERN_INFO "parport_pc: Weird Via 686A parport base 0x%X, ignoringn",
  2571. port1);
  2572. return 0;
  2573. }
  2575. /* 0xF0_5: EPP+ECP enable */
  2576. outb (0xF0, 0x3F0);
  2577. have_eppecp = (inb (0x3F1) & (1 << 5));
  2579. /*
  2580.  * lock super i/o configuration, clear 0x85_1
  2581.  */
  2582. pci_read_config_byte (pdev, 0x85, &tmp);
  2583. tmp &= ~(1 << 1);
  2584. pci_write_config_byte (pdev, 0x85, tmp);
  2586. /*
  2587.  * Get DMA and IRQ from PCI->ISA bridge PCI config registers
  2588.  */
  2590. /* 0x50_3-2: PnP Routing for Parallel Port DRQ */
  2591. pci_read_config_byte (pdev, 0x50, &tmp);
  2592. dma = ((tmp >> 2) & 0x03);
  2594. /* 0x51_7-4: PnP Routing for Parallel Port IRQ */
  2595. pci_read_config_byte (pdev, 0x51, &tmp);
  2596. irq = ((tmp >> 4) & 0x0F);
  2598. /* filter bogus IRQs */
  2599. switch (irq) {
  2600. case 0:
  2601. case 2:
  2602. case 8:
  2603. case 13:
  2604. irq = PARPORT_IRQ_NONE;
  2605. break;
  2607. default: /* do nothing */
  2608. break;
  2609. }
  2611. /* if ECP not enabled, DMA is not enabled, assumed bogus 'dma' value */
  2612. if (!have_eppecp)
  2613. dma = PARPORT_DMA_NONE;
  2615. /* Let the user (or defaults) steer us away from interrupts and DMA */
  2616. if (autoirq != PARPORT_IRQ_AUTO) {
  2617. irq = PARPORT_IRQ_NONE;
  2618. dma = PARPORT_DMA_NONE;
  2619. }
  2620. if (autodma != PARPORT_DMA_AUTO)
  2621. dma = PARPORT_DMA_NONE;
  2623. /* finally, do the probe with values obtained */
  2624. if (parport_pc_probe_port (port1, port2, irq, dma, NULL)) {
  2625. printk (KERN_INFO
  2626. "parport_pc: Via 686A parallel port: io=0x%X", port1);
  2627. if (irq != PARPORT_IRQ_NONE)
  2628. printk (", irq=%d", irq);
  2629. if (dma != PARPORT_DMA_NONE)
  2630. printk (", dma=%d", dma);
  2631. printk ("n");
  2632. return 1;
  2633. }
  2635. printk (KERN_WARNING "parport_pc: Strange, can't probe Via 686A parallel port: io=0x%X, irq=%d, dma=%dn",
  2636. port1, irq, dma);
  2637. return 0;
  2638. }
  2641. enum parport_pc_sio_types {
  2642. sio_via_686a = 0, /* Via VT82C686A motherboard Super I/O */
  2643. sio_ite_8872,
  2644. last_sio
  2645. };
  2647. /* each element directly indexed from enum list, above */
  2648. static struct parport_pc_superio {
  2649. int (*probe) (struct pci_dev *pdev, int autoirq, int autodma);
  2650. } parport_pc_superio_info[] __devinitdata = {
  2651. { sio_via_686a_probe, },
  2652. { sio_ite_8872_probe, },
  2653. };
  2656. enum parport_pc_pci_cards {
  2657. siig_1s1p_10x_550 = last_sio,
  2658. siig_1s1p_10x_650,
  2659. siig_1s1p_10x_850,
  2660. siig_1p_10x,
  2661. siig_2p_10x,
  2662. siig_2s1p_10x_550,
  2663. siig_2s1p_10x_650,
  2664. siig_2s1p_10x_850,
  2665. siig_1p_20x,
  2666. siig_2p_20x,
  2667. siig_2p1s_20x_550,
  2668. siig_2p1s_20x_650,
  2669. siig_2p1s_20x_850,
  2670. siig_1s1p_20x_550,
  2671. siig_1s1p_20x_650,
  2672. siig_1s1p_20x_850,
  2673. siig_2s1p_20x_550,
  2674. siig_2s1p_20x_650,
  2675. siig_2s1p_20x_850,
  2676. lava_parallel,
  2677. lava_parallel_dual_a,
  2678. lava_parallel_dual_b,
  2679. boca_ioppar,
  2680. plx_9050,
  2681. timedia_4078a,
  2682. timedia_4079h,
  2683. timedia_4085h,
  2684. timedia_4088a,
  2685. timedia_4089a,
  2686. timedia_4095a,
  2687. timedia_4096a,
  2688. timedia_4078u,
  2689. timedia_4079a,
  2690. timedia_4085u,
  2691. timedia_4079r,
  2692. timedia_4079s,
  2693. timedia_4079d,
  2694. timedia_4079e,
  2695. timedia_4079f,
  2696. timedia_9079a,
  2697. timedia_9079b,
  2698. timedia_9079c,
  2699. timedia_4006a,
  2700. timedia_4014,
  2701. timedia_4008a,
  2702. timedia_4018,
  2703. timedia_9018a,
  2704. syba_2p_epp,
  2705. syba_1p_ecp,
  2706. titan_010l,
  2707. titan_1284p2,
  2708. avlab_1p,
  2709. avlab_2p,
  2710. oxsemi_954,
  2711. oxsemi_840,
  2712. aks_0100,
  2713. };
  2716. /* each element directly indexed from enum list, above 
  2717.  * (but offset by last_sio) */
  2718. static struct parport_pc_pci {
  2719. int numports;
  2720. struct { /* BAR (base address registers) numbers in the config
  2721.                     space header */
  2722. int lo;
  2723. int hi; /* -1 if not there, >6 for offset-method (max
  2724.                            BAR is 6) */
  2725. } addr[4];
  2726. } cards[] __devinitdata = {
  2727. /* siig_1s1p_10x_550 */ { 1, { { 3, 4 }, } },
  2728. /* siig_1s1p_10x_650 */ { 1, { { 3, 4 }, } },
  2729. /* siig_1s1p_10x_850 */ { 1, { { 3, 4 }, } },
  2730. /* siig_1p_10x */ { 1, { { 2, 3 }, } },
  2731. /* siig_2p_10x */ { 2, { { 2, 3 }, { 4, 5 }, } },
  2732. /* siig_2s1p_10x_550 */ { 1, { { 4, 5 }, } },
  2733. /* siig_2s1p_10x_650 */ { 1, { { 4, 5 }, } },
  2734. /* siig_2s1p_10x_850 */ { 1, { { 4, 5 }, } },
  2735. /* siig_1p_20x */ { 1, { { 0, 1 }, } },
  2736. /* siig_2p_20x */ { 2, { { 0, 1 }, { 2, 3 }, } },
  2737. /* siig_2p1s_20x_550 */ { 2, { { 1, 2 }, { 3, 4 }, } },
  2738. /* siig_2p1s_20x_650 */ { 2, { { 1, 2 }, { 3, 4 }, } },
  2739. /* siig_2p1s_20x_850 */ { 2, { { 1, 2 }, { 3, 4 }, } },
  2740. /* siig_1s1p_20x_550 */ { 1, { { 1, 2 }, } },
  2741. /* siig_1s1p_20x_650 */ { 1, { { 1, 2 }, } },
  2742. /* siig_1s1p_20x_850 */ { 1, { { 1, 2 }, } },
  2743. /* siig_2s1p_20x_550 */ { 1, { { 2, 3 }, } },
  2744. /* siig_2s1p_20x_650 */ { 1, { { 2, 3 }, } },
  2745. /* siig_2s1p_20x_850 */ { 1, { { 2, 3 }, } },
  2746. /* lava_parallel */ { 1, { { 0, -1 }, } },
  2747. /* lava_parallel_dual_a */ { 1, { { 0, -1 }, } },
  2748. /* lava_parallel_dual_b */ { 1, { { 0, -1 }, } },
  2749. /* boca_ioppar */ { 1, { { 0, -1 }, } },
  2750. /* plx_9050 */ { 2, { { 4, -1 }, { 5, -1 }, } },
  2751. /* timedia_4078a */ { 1, { { 2, -1 }, } },
  2752. /* timedia_4079h */             { 1, { { 2, 3 }, } },
  2753. /* timedia_4085h */             { 2, { { 2, -1 }, { 4, -1 }, } },
  2754. /* timedia_4088a */             { 2, { { 2, 3 }, { 4, 5 }, } },
  2755. /* timedia_4089a */             { 2, { { 2, 3 }, { 4, 5 }, } },
  2756. /* timedia_4095a */             { 2, { { 2, 3 }, { 4, 5 }, } },
  2757. /* timedia_4096a */             { 2, { { 2, 3 }, { 4, 5 }, } },
  2758. /* timedia_4078u */             { 1, { { 2, -1 }, } },
  2759. /* timedia_4079a */             { 1, { { 2, 3 }, } },
  2760. /* timedia_4085u */             { 2, { { 2, -1 }, { 4, -1 }, } },
  2761. /* timedia_4079r */             { 1, { { 2, 3 }, } },
  2762. /* timedia_4079s */             { 1, { { 2, 3 }, } },
  2763. /* timedia_4079d */             { 1, { { 2, 3 }, } },
  2764. /* timedia_4079e */             { 1, { { 2, 3 }, } },
  2765. /* timedia_4079f */             { 1, { { 2, 3 }, } },
  2766. /* timedia_9079a */             { 1, { { 2, 3 }, } },
  2767. /* timedia_9079b */             { 1, { { 2, 3 }, } },
  2768. /* timedia_9079c */             { 1, { { 2, 3 }, } },
  2769. /* timedia_4006a */             { 1, { { 0, -1 }, } },
  2770. /* timedia_4014  */             { 2, { { 0, -1 }, { 2, -1 }, } },
  2771. /* timedia_4008a */             { 1, { { 0, 1 }, } },
  2772. /* timedia_4018  */             { 2, { { 0, 1 }, { 2, 3 }, } },
  2773. /* timedia_9018a */             { 2, { { 0, 1 }, { 2, 3 }, } },
  2774. /* SYBA uses fixed offsets in
  2775.                                            a 1K io window */
  2776. /* syba_2p_epp AP138B */ { 2, { { 0, 0x078 }, { 0, 0x178 }, } },
  2777. /* syba_1p_ecp W83787 */ { 1, { { 0, 0x078 }, } },
  2778. /* titan_010l */ { 1, { { 3, -1 }, } },
  2779. /* titan_1284p2 */ { 2, { { 0, 1 }, { 2, 3 }, } },
  2780. /* avlab_1p */ { 1, { { 0, 1}, } },
  2781. /* avlab_2p */ { 2, { { 0, 1}, { 2, 3 },} },
  2782. /* The Oxford Semi cards are unusual: 954 doesn't support ECP,
  2783.  * and 840 locks up if you write 1 to bit 2! */
  2784. /* oxsemi_954 */ { 1, { { 0, -1 }, } },
  2785. /* oxsemi_840 */ { 1, { { 0, -1 }, } },
  2786. /* aks_0100 */ { 1, { { 0, 1 }, } },
  2787. };
  2789. static struct pci_device_id parport_pc_pci_tbl[] __devinitdata = {
  2790. /* Super-IO onboard chips */
  2791. { 0x1106, 0x0686, PCI_ANY_ID, PCI_ANY_ID, 0, 0, sio_via_686a },
  2792. { PCI_VENDOR_ID_ITE, PCI_DEVICE_ID_ITE_8872,
  2793.   PCI_ANY_ID, PCI_ANY_ID, 0, 0, sio_ite_8872 },
  2795. /* PCI cards */
  2796. { PCI_VENDOR_ID_SIIG, PCI_DEVICE_ID_SIIG_1S1P_10x_550,
  2797.   PCI_ANY_ID, PCI_ANY_ID, 0, 0, siig_1s1p_10x_550 },
  2798. { PCI_VENDOR_ID_SIIG, PCI_DEVICE_ID_SIIG_1S1P_10x_650,
  2799.   PCI_ANY_ID, PCI_ANY_ID, 0, 0, siig_1s1p_10x_650 },
  2800. { PCI_VENDOR_ID_SIIG, PCI_DEVICE_ID_SIIG_1S1P_10x_850,
  2801.   PCI_ANY_ID, PCI_ANY_ID, 0, 0, siig_1s1p_10x_850 },
  2802. { PCI_VENDOR_ID_SIIG, PCI_DEVICE_ID_SIIG_1P_10x,
  2803.   PCI_ANY_ID, PCI_ANY_ID, 0, 0, siig_1p_10x },
  2804. { PCI_VENDOR_ID_SIIG, PCI_DEVICE_ID_SIIG_2P_10x,
  2805.   PCI_ANY_ID, PCI_ANY_ID, 0, 0, siig_2p_10x },
  2806. { PCI_VENDOR_ID_SIIG, PCI_DEVICE_ID_SIIG_2S1P_10x_550,
  2807.   PCI_ANY_ID, PCI_ANY_ID, 0, 0, siig_2s1p_10x_550 },
  2808. { PCI_VENDOR_ID_SIIG, PCI_DEVICE_ID_SIIG_2S1P_10x_650,
  2809.   PCI_ANY_ID, PCI_ANY_ID, 0, 0, siig_2s1p_10x_650 },
  2810. { PCI_VENDOR_ID_SIIG, PCI_DEVICE_ID_SIIG_2S1P_10x_850,
  2811.   PCI_ANY_ID, PCI_ANY_ID, 0, 0, siig_2s1p_10x_850 },
  2812. { PCI_VENDOR_ID_SIIG, PCI_DEVICE_ID_SIIG_1P_20x,
  2813.   PCI_ANY_ID, PCI_ANY_ID, 0, 0, siig_1p_20x },
  2814. { PCI_VENDOR_ID_SIIG, PCI_DEVICE_ID_SIIG_2P_20x,
  2815.   PCI_ANY_ID, PCI_ANY_ID, 0, 0, siig_2p_20x },
  2816. { PCI_VENDOR_ID_SIIG, PCI_DEVICE_ID_SIIG_2P1S_20x_550,
  2817.   PCI_ANY_ID, PCI_ANY_ID, 0, 0, siig_2p1s_20x_550 },
  2818. { PCI_VENDOR_ID_SIIG, PCI_DEVICE_ID_SIIG_2P1S_20x_650,
  2819.   PCI_ANY_ID, PCI_ANY_ID, 0, 0, siig_2p1s_20x_650 },
  2820. { PCI_VENDOR_ID_SIIG, PCI_DEVICE_ID_SIIG_2P1S_20x_850,
  2821.   PCI_ANY_ID, PCI_ANY_ID, 0, 0, siig_2p1s_20x_850 },
  2822. { PCI_VENDOR_ID_SIIG, PCI_DEVICE_ID_SIIG_1S1P_20x_550,
  2823.   PCI_ANY_ID, PCI_ANY_ID, 0, 0, siig_2s1p_20x_550 },
  2824. { PCI_VENDOR_ID_SIIG, PCI_DEVICE_ID_SIIG_1S1P_20x_650,
  2825.   PCI_ANY_ID, PCI_ANY_ID, 0, 0, siig_1s1p_20x_650 },
  2826. { PCI_VENDOR_ID_SIIG, PCI_DEVICE_ID_SIIG_1S1P_20x_850,
  2827.   PCI_ANY_ID, PCI_ANY_ID, 0, 0, siig_1s1p_20x_850 },
  2828. { PCI_VENDOR_ID_SIIG, PCI_DEVICE_ID_SIIG_2S1P_20x_550,
  2829.   PCI_ANY_ID, PCI_ANY_ID, 0, 0, siig_2s1p_20x_550 },
  2830. { PCI_VENDOR_ID_SIIG, PCI_DEVICE_ID_SIIG_2S1P_20x_650,
  2831.   PCI_ANY_ID, PCI_ANY_ID, 0, 0, siig_2s1p_20x_650 },
  2832. { PCI_VENDOR_ID_SIIG, PCI_DEVICE_ID_SIIG_2S1P_20x_850,
  2833.   PCI_ANY_ID, PCI_ANY_ID, 0, 0, siig_2s1p_20x_850 },
  2834. { PCI_VENDOR_ID_LAVA, PCI_DEVICE_ID_LAVA_PARALLEL,
  2835.   PCI_ANY_ID, PCI_ANY_ID, 0, 0, lava_parallel },
  2836. { PCI_VENDOR_ID_LAVA, PCI_DEVICE_ID_LAVA_DUAL_PAR_A,
  2837.   PCI_ANY_ID, PCI_ANY_ID, 0, 0, lava_parallel_dual_a },
  2838. { PCI_VENDOR_ID_LAVA, PCI_DEVICE_ID_LAVA_DUAL_PAR_B,
  2839.   PCI_ANY_ID, PCI_ANY_ID, 0, 0, lava_parallel_dual_b },
  2840. { PCI_VENDOR_ID_LAVA, PCI_DEVICE_ID_LAVA_BOCA_IOPPAR,
  2841.   PCI_ANY_ID, PCI_ANY_ID, 0, 0, boca_ioppar },
  2842. { PCI_VENDOR_ID_PLX, PCI_DEVICE_ID_PLX_9050,
  2843.   PCI_SUBVENDOR_ID_EXSYS, PCI_SUBDEVICE_ID_EXSYS_4014, 0,0, plx_9050 },
  2844. /* PCI_VENDOR_ID_TIMEDIA/SUNIX has many differing cards ...*/
  2845. { 0x1409, 0x7168, 0x1409, 0x4078, 0, 0, timedia_4078a },
  2846. { 0x1409, 0x7168, 0x1409, 0x4079, 0, 0, timedia_4079h },
  2847. { 0x1409, 0x7168, 0x1409, 0x4085, 0, 0, timedia_4085h },
  2848. { 0x1409, 0x7168, 0x1409, 0x4088, 0, 0, timedia_4088a },
  2849. { 0x1409, 0x7168, 0x1409, 0x4089, 0, 0, timedia_4089a },
  2850. { 0x1409, 0x7168, 0x1409, 0x4095, 0, 0, timedia_4095a },
  2851. { 0x1409, 0x7168, 0x1409, 0x4096, 0, 0, timedia_4096a },
  2852. { 0x1409, 0x7168, 0x1409, 0x5078, 0, 0, timedia_4078u },
  2853. { 0x1409, 0x7168, 0x1409, 0x5079, 0, 0, timedia_4079a },
  2854. { 0x1409, 0x7168, 0x1409, 0x5085, 0, 0, timedia_4085u },
  2855. { 0x1409, 0x7168, 0x1409, 0x6079, 0, 0, timedia_4079r },
  2856. { 0x1409, 0x7168, 0x1409, 0x7079, 0, 0, timedia_4079s },
  2857. { 0x1409, 0x7168, 0x1409, 0x8079, 0, 0, timedia_4079d },
  2858. { 0x1409, 0x7168, 0x1409, 0x9079, 0, 0, timedia_4079e },
  2859. { 0x1409, 0x7168, 0x1409, 0xa079, 0, 0, timedia_4079f },
  2860. { 0x1409, 0x7168, 0x1409, 0xb079, 0, 0, timedia_9079a },
  2861. { 0x1409, 0x7168, 0x1409, 0xc079, 0, 0, timedia_9079b },
  2862. { 0x1409, 0x7168, 0x1409, 0xd079, 0, 0, timedia_9079c },
  2863. { 0x1409, 0x7268, 0x1409, 0x0101, 0, 0, timedia_4006a },
  2864. { 0x1409, 0x7268, 0x1409, 0x0102, 0, 0, timedia_4014 },
  2865. { 0x1409, 0x7268, 0x1409, 0x0103, 0, 0, timedia_4008a },
  2866. { 0x1409, 0x7268, 0x1409, 0x0104, 0, 0, timedia_4018 },
  2867. { 0x1409, 0x7268, 0x1409, 0x9018, 0, 0, timedia_9018a },
  2868. { PCI_VENDOR_ID_SYBA, PCI_DEVICE_ID_SYBA_2P_EPP,
  2869.   PCI_ANY_ID, PCI_ANY_ID, 0, 0, syba_2p_epp },
  2870. { PCI_VENDOR_ID_SYBA, PCI_DEVICE_ID_SYBA_1P_ECP,
  2871.   PCI_ANY_ID, PCI_ANY_ID, 0, 0, syba_1p_ecp },
  2872. { PCI_VENDOR_ID_TITAN, PCI_DEVICE_ID_TITAN_010L,
  2873.   PCI_ANY_ID, PCI_ANY_ID, 0, 0, titan_010l },
  2874. { 0x9710, 0x9815, 0x1000, 0x0020, 0, 0, titan_1284p2 },
  2875. /* PCI_VENDOR_ID_AVLAB/Intek21 has another bunch of cards ...*/
  2876. { 0x14db, 0x2120, PCI_ANY_ID, PCI_ANY_ID, 0, 0, avlab_1p}, /* AFAVLAB_TK9902 */
  2877. { 0x14db, 0x2121, PCI_ANY_ID, PCI_ANY_ID, 0, 0, avlab_2p},
  2878. { PCI_VENDOR_ID_OXSEMI, PCI_DEVICE_ID_OXSEMI_16PCI954PP,
  2879.   PCI_ANY_ID, PCI_ANY_ID, 0, 0, oxsemi_954 },
  2880. { PCI_VENDOR_ID_OXSEMI, PCI_DEVICE_ID_OXSEMI_12PCI840,
  2881.   PCI_ANY_ID, PCI_ANY_ID, 0, 0, oxsemi_840 },
  2882. { PCI_VENDOR_ID_AKS, PCI_DEVICE_ID_AKS_ALADDINCARD,
  2883.   PCI_ANY_ID, PCI_ANY_ID, 0, 0, aks_0100 },
  2884. { 0, } /* terminate list */
  2885. };
  2886. MODULE_DEVICE_TABLE(pci,parport_pc_pci_tbl);
  2888. static int __devinit parport_pc_pci_probe (struct pci_dev *dev,
  2889.    const struct pci_device_id *id)
  2890. {
  2891. int err, count, n, i = id->driver_data;
  2892. if (i < last_sio)
  2893. /* This is an onboard Super-IO and has already been probed */
  2894. return 0;
  2896. /* This is a PCI card */
  2897. i -= last_sio;
  2898. count = 0;
  2899. if ((err = pci_enable_device (dev)) != 0)
  2900. return err;
  2902. for (n = 0; n < cards[i].numports; n++) {
  2903. int lo = cards[i].addr[n].lo;
  2904. int hi = cards[i].addr[n].hi;
  2905. unsigned long io_lo, io_hi;
  2906. io_lo = pci_resource_start (dev, lo);
  2907. io_hi = 0;
  2908. if ((hi >= 0) && (hi <= 6))
  2909. io_hi = pci_resource_start (dev, hi);
  2910. else if (hi > 6)
  2911. io_lo += hi; /* Reinterpret the meaning of
  2912.                                         "hi" as an offset (see SYBA
  2913.                                         def.) */
  2914. /* TODO: test if sharing interrupts works */
  2915. printk (KERN_DEBUG "PCI parallel port detected: %04x:%04x, "
  2916. "I/O at %#lx(%#lx)n",
  2917. parport_pc_pci_tbl[i + last_sio].vendor,
  2918. parport_pc_pci_tbl[i + last_sio].device, io_lo, io_hi);
  2919. if (parport_pc_probe_port (io_lo, io_hi, PARPORT_IRQ_NONE,
  2920.    PARPORT_DMA_NONE, dev))
  2921. count++;
  2922. }
  2924. return count == 0 ? -ENODEV : 0;
  2925. }
  2927. static struct pci_driver parport_pc_pci_driver = {
  2928. name: "parport_pc",
  2929. id_table: parport_pc_pci_tbl,
  2930. probe: parport_pc_pci_probe,
  2931. };
  2933. static int __init parport_pc_init_superio (int autoirq, int autodma)
  2934. {
  2935. const struct pci_device_id *id;
  2936. struct pci_dev *pdev;
  2937. int ret = 0;
  2939. pci_for_each_dev(pdev) {
  2940. id = pci_match_device (parport_pc_pci_tbl, pdev);
  2941. if (id == NULL || id->driver_data >= last_sio)
  2942. continue;
  2944. if (parport_pc_superio_info[id->driver_data].probe
  2945. (pdev, autoirq, autodma)) {
  2946. ret++;
  2947. }
  2948. }
  2950. return ret; /* number of devices found */
  2951. }
  2952. #else
  2953. static struct pci_driver parport_pc_pci_driver;
  2954. static int __init parport_pc_init_superio(int autoirq, int autodma) {return 0;}
  2955. #endif /* CONFIG_PCI */
  2957. /* This is called by parport_pc_find_nonpci_ports (in asm/parport.h) */
  2958. static int __init __attribute__((unused))
  2959. parport_pc_find_isa_ports (int autoirq, int autodma)
  2960. {
  2961. int count = 0;
  2963. if (parport_pc_probe_port(0x3bc, 0x7bc, autoirq, autodma, NULL))
  2964. count++;
  2965. if (parport_pc_probe_port(0x378, 0x778, autoirq, autodma, NULL))
  2966. count++;
  2967. if (parport_pc_probe_port(0x278, 0x678, autoirq, autodma, NULL))
  2968. count++;
  2970. return count;
  2971. }
  2973. /* This function is called by parport_pc_init if the user didn't
  2974.  * specify any ports to probe.  Its job is to find some ports.  Order
  2975.  * is important here -- we want ISA ports to be registered first,
  2976.  * followed by PCI cards (for least surprise), but before that we want
  2977.  * to do chipset-specific tests for some onboard ports that we know
  2978.  * about.
  2979.  *
  2980.  * autoirq is PARPORT_IRQ_NONE, PARPORT_IRQ_AUTO, or PARPORT_IRQ_PROBEONLY
  2981.  * autodma is PARPORT_DMA_NONE or PARPORT_DMA_AUTO
  2982.  */
  2983. static int __init parport_pc_find_ports (int autoirq, int autodma)
  2984. {
  2985. int count = 0, r;
  2987. #ifdef CONFIG_PARPORT_PC_SUPERIO
  2988. detect_and_report_winbond ();
  2989. detect_and_report_smsc ();
  2990. #endif
  2992. /* Onboard SuperIO chipsets that show themselves on the PCI bus. */
  2993. count += parport_pc_init_superio (autoirq, autodma);
  2995. /* ISA ports and whatever (see asm/parport.h). */
  2996. count += parport_pc_find_nonpci_ports (autoirq, autodma);
  2998. r = pci_register_driver (&parport_pc_pci_driver);
  2999. if (r >= 0) {
  3000. registered_parport = 1;
  3001. count += r;
  3002. }
  3004. return count;
  3005. }
  3007. int __init parport_pc_init (int *io, int *io_hi, int *irq, int *dma)
  3008. {
  3009. int count = 0, i = 0;
  3011. if (io && *io) {
  3012. /* Only probe the ports we were given. */
  3013. user_specified = 1;
  3014. do {
  3015. if ((*io_hi) == PARPORT_IOHI_AUTO)
  3016.        *io_hi = 0x400 + *io;
  3017. if (parport_pc_probe_port(*(io++), *(io_hi++),
  3018.   *(irq++), *(dma++), NULL))
  3019. count++;
  3020. } while (*io && (++i < PARPORT_PC_MAX_PORTS));
  3021. } else {
  3022. count += parport_pc_find_ports (irq[0], dma[0]);
  3023. }
  3025. return count;
  3026. }
  3028. /* Exported symbols. */
  3029. EXPORT_SYMBOL (parport_pc_probe_port);
  3030. EXPORT_SYMBOL (parport_pc_unregister_port);
  3032. #ifdef MODULE
  3033. static int io[PARPORT_PC_MAX_PORTS+1] = { [0 ... PARPORT_PC_MAX_PORTS] = 0 };
  3034. static int io_hi[PARPORT_PC_MAX_PORTS+1] =
  3035. { [0 ... PARPORT_PC_MAX_PORTS] = PARPORT_IOHI_AUTO };
  3036. static int dmaval[PARPORT_PC_MAX_PORTS] = { [0 ... PARPORT_PC_MAX_PORTS-1] = PARPORT_DMA_NONE };
  3037. static int irqval[PARPORT_PC_MAX_PORTS] = { [0 ... PARPORT_PC_MAX_PORTS-1] = PARPORT_IRQ_PROBEONLY };
  3038. static const char *irq[PARPORT_PC_MAX_PORTS] = { NULL, };
  3039. static const char *dma[PARPORT_PC_MAX_PORTS] = { NULL, };
  3041. MODULE_AUTHOR("Phil Blundell, Tim Waugh, others");
  3042. MODULE_DESCRIPTION("PC-style parallel port driver");
  3043. MODULE_LICENSE("GPL");
  3045. MODULE_PARM_DESC(io, "Base I/O address (SPP regs)");
  3046. MODULE_PARM(io, "1-" __MODULE_STRING(PARPORT_PC_MAX_PORTS) "i");
  3047. MODULE_PARM_DESC(io_hi, "Base I/O address (ECR)");
  3048. MODULE_PARM(io_hi, "1-" __MODULE_STRING(PARPORT_PC_MAX_PORTS) "i");
  3049. MODULE_PARM_DESC(irq, "IRQ line");
  3050. MODULE_PARM(irq, "1-" __MODULE_STRING(PARPORT_PC_MAX_PORTS) "s");
  3051. MODULE_PARM_DESC(dma, "DMA channel");
  3052. MODULE_PARM(dma, "1-" __MODULE_STRING(PARPORT_PC_MAX_PORTS) "s");
  3053. #if defined(CONFIG_PARPORT_PC_FIFO) || defined(CONFIG_PARPORT_PC_SUPERIO)
  3054. MODULE_PARM_DESC(verbose_probing, "Log chit-chat during initialisation");
  3055. MODULE_PARM(verbose_probing, "i");
  3056. #endif
  3058. int init_module(void)
  3059. {
  3060. /* Work out how many ports we have, then get parport_share to parse
  3061.    the irq values. */
  3062. unsigned int i;
  3063. int ret;
  3064. for (i = 0; i < PARPORT_PC_MAX_PORTS && io[i]; i++);
  3065. if (i) {
  3066. if (parport_parse_irqs(i, irq, irqval)) return 1;
  3067. if (parport_parse_dmas(i, dma, dmaval)) return 1;
  3068. }
  3069. else {
  3070. /* The user can make us use any IRQs or DMAs we find. */
  3071. int val;
  3073. if (irq[0] && !parport_parse_irqs (1, irq, &val))
  3074. switch (val) {
  3075. case PARPORT_IRQ_NONE:
  3076. case PARPORT_IRQ_AUTO:
  3077. irqval[0] = val;
  3078. break;
  3079. default:
  3080. printk (KERN_WARNING
  3081. "parport_pc: irq specified "
  3082. "without base address.  Use 'io=' "
  3083. "to specify onen");
  3084. }
  3086. if (dma[0] && !parport_parse_dmas (1, dma, &val))
  3087. switch (val) {
  3088. case PARPORT_DMA_NONE:
  3089. case PARPORT_DMA_AUTO:
  3090. dmaval[0] = val;
  3091. break;
  3092. default:
  3093. printk (KERN_WARNING
  3094. "parport_pc: dma specified "
  3095. "without base address.  Use 'io=' "
  3096. "to specify onen");
  3097. }
  3098. }
  3100. ret = !parport_pc_init (io, io_hi, irqval, dmaval);
  3101. if (ret && registered_parport)
  3102. pci_unregister_driver (&parport_pc_pci_driver);
  3104. return ret;
  3105. }
  3107. void cleanup_module(void)
  3108. {
  3109. /* We ought to keep track of which ports are actually ours. */
  3110. struct parport *p = parport_enumerate(), *tmp;
  3112. if (!user_specified)
  3113. pci_unregister_driver (&parport_pc_pci_driver);
  3115. while (p) {
  3116. tmp = p->next;
  3117. if (p->modes & PARPORT_MODE_PCSPP)
  3118. parport_pc_unregister_port (p);
  3120. p = tmp;
  3121. }
  3122. }
  3123. #endif