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

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

嵌入式Linux

开发平台：

Unix_Linux

bpp.c：源码内容
  1. /*
  2.  * drivers/sbus/char/bpp.c
  3.  *
  4.  * Copyright (c) 1995 Picture Elements
  5.  *      Stephen Williams (steve@icarus.com)
  6.  *      Gus Baldauf (gbaldauf@ix.netcom.com)
  7.  *
  8.  * Linux/SPARC port by Peter Zaitcev.
  9.  * Integration into SPARC tree by Tom Dyas.
  10.  */
  13. #include <linux/kernel.h>
  14. #include <linux/module.h>
  15. #include <linux/version.h>
  16. #include <linux/fs.h>
  17. #include <linux/errno.h>
  18. #include <linux/sched.h>
  19. #include <linux/smp_lock.h>
  20. #include <linux/spinlock.h>
  21. #include <linux/timer.h>
  22. #include <linux/ioport.h>
  23. #include <linux/major.h>
  24. #include <linux/devfs_fs_kernel.h>
  26. #include <asm/uaccess.h>
  27. #include <asm/io.h>
  29. #if defined(__i386__)
  30. # include <asm/system.h>
  31. # include <asm/segment.h>
  32. #endif
  34. #if defined(__sparc__)
  35. # include <linux/init.h>
  36. # include <linux/delay.h>         /* udelay() */
  38. # include <asm/oplib.h>           /* OpenProm Library */
  39. # include <asm/sbus.h>
  40. #endif
  42. #include <asm/bpp.h>
  44. #define BPP_PROBE_CODE 0x55
  45. #define BPP_DELAY 100
  47. static const unsigned  BPP_MAJOR = LP_MAJOR;
  48. static const char* dev_name = "bpp";
  50. /* When switching from compatibility to a mode where I can read, try
  51.    the following mode first. */
  53. /* const unsigned char DEFAULT_ECP = 0x10; */
  54. static const unsigned char DEFAULT_ECP = 0x30;
  55. static const unsigned char DEFAULT_NIBBLE = 0x00;
  57. /*
  58.  * These are 1284 time constraints, in units of jiffies.
  59.  */
  61. static const unsigned long TIME_PSetup = 1;
  62. static const unsigned long TIME_PResponse = 6;
  63. static const unsigned long TIME_IDLE_LIMIT = 2000;
  65. /*
  66.  * One instance per supported subdevice...
  67.  */
  68. # define BPP_NO 3
  70. enum IEEE_Mode { COMPATIBILITY, NIBBLE, ECP, ECP_RLE, EPP };
  72. struct inst {
  73.       unsigned present  : 1; /* True if the hardware exists */
  74.       unsigned enhanced : 1; /* True if the hardware in "enhanced" */
  75.       unsigned opened   : 1; /* True if the device is opened already */
  76.       unsigned run_flag : 1; /* True if waiting for a repeate byte */
  78.       unsigned char direction; /* 0 --> out, 0x20 --> IN */
  79.       unsigned char pp_state; /* State of host controlled pins. */
  80.       enum IEEE_Mode mode;
  82.       unsigned char run_length;
  83.       unsigned char repeat_byte;
  85.       /* These members manage timeouts for programmed delays */
  86.       wait_queue_head_t wait_queue;
  87.       struct timer_list timer_list;
  88. };
  90. static struct inst instances[BPP_NO];
  92. #if defined(__i386__)
  94. const unsigned short base_addrs[BPP_NO] = { 0x278, 0x378, 0x3bc };
  96. /*
  97.  * These are for data access.
  98.  * Control lines accesses are hidden in set_bits() and get_bits().
  99.  * The exeption is the probe procedure, which is system-dependent.
  100.  */
  101. #define bpp_outb_p(data, base)  outb_p((data), (base))
  102. #define bpp_inb(base)  inb(base)
  103. #define bpp_inb_p(base)  inb_p(base)
  105. /*
  106.  * This method takes the pin values mask and sets the hardware pins to
  107.  * the requested value: 1 == high voltage, 0 == low voltage. This
  108.  * burries the annoying PC bit inversion and preserves the direction
  109.  * flag.
  110.  */
  111. static void set_pins(unsigned short pins, unsigned minor)
  112. {
  113.       unsigned char bits = instances[minor].direction;  /* == 0x20 */
  115.       if (! (pins & BPP_PP_nStrobe))   bits |= 1;
  116.       if (! (pins & BPP_PP_nAutoFd))   bits |= 2;
  117.       if (   pins & BPP_PP_nInit)      bits |= 4;
  118.       if (! (pins & BPP_PP_nSelectIn)) bits |= 8;
  120.       instances[minor].pp_state = bits;
  122.       outb_p(bits, base_addrs[minor]+2);
  123. }
  125. static unsigned short get_pins(unsigned minor)
  126. {
  127.       unsigned short bits = 0;
  129.       unsigned value = instances[minor].pp_state;
  130.       if (! (value & 0x01)) bits |= BPP_PP_nStrobe;
  131.       if (! (value & 0x02)) bits |= BPP_PP_nAutoFd;
  132.       if (value & 0x04)     bits |= BPP_PP_nInit;
  133.       if (! (value & 0x08)) bits |= BPP_PP_nSelectIn;
  135.       value = inb_p(base_addrs[minor]+1);
  136.       if (value & 0x08)     bits |= BPP_GP_nFault;
  137.       if (value & 0x10)     bits |= BPP_GP_Select;
  138.       if (value & 0x20)     bits |= BPP_GP_PError;
  139.       if (value & 0x40)     bits |= BPP_GP_nAck;
  140.       if (! (value & 0x80)) bits |= BPP_GP_Busy;
  142.       return bits;
  143. }
  145. #endif /* __i386__ */
  147. #if defined(__sparc__)
  149. /*
  150.  * Register block
  151.  */
  152.       /* DMA registers */
  153. #define BPP_CSR      0x00
  154. #define BPP_ADDR     0x04
  155. #define BPP_BCNT     0x08
  156. #define BPP_TST_CSR  0x0C
  157.       /* Parallel Port registers */
  158. #define BPP_HCR      0x10
  159. #define BPP_OCR      0x12
  160. #define BPP_DR       0x14
  161. #define BPP_TCR      0x15
  162. #define BPP_OR       0x16
  163. #define BPP_IR       0x17
  164. #define BPP_ICR      0x18
  165. #define BPP_SIZE     0x1A
  167. /* BPP_CSR.  Bits of type RW1 are cleared with writting '1'. */
  168. #define P_DEV_ID_MASK   0xf0000000      /* R   */
  169. #define P_DEV_ID_ZEBRA  0x40000000
  170. #define P_DEV_ID_L64854 0xa0000000      /*      == NCR 89C100+89C105. Pity. */
  171. #define P_NA_LOADED     0x08000000      /* R    NA wirtten but was not used */
  172. #define P_A_LOADED      0x04000000      /* R    */
  173. #define P_DMA_ON        0x02000000      /* R    DMA is not disabled */
  174. #define P_EN_NEXT       0x01000000      /* RW   */
  175. #define P_TCI_DIS       0x00800000      /* RW   TCI forbidden from interrupts */
  176. #define P_DIAG          0x00100000      /* RW   Disables draining and resetting
  177.                                                 of P-FIFO on loading of P_ADDR*/
  178. #define P_BURST_SIZE    0x000c0000      /* RW   SBus burst size */
  179. #define P_BURST_8       0x00000000
  180. #define P_BURST_4       0x00040000
  181. #define P_BURST_1       0x00080000      /*      "No burst" write */
  182. #define P_TC            0x00004000      /* RW1  Term Count, can be cleared when
  183.                                            P_EN_NEXT=1 */
  184. #define P_EN_CNT        0x00002000      /* RW   */
  185. #define P_EN_DMA        0x00000200      /* RW   */
  186. #define P_WRITE         0x00000100      /* R    DMA dir, 1=to ram, 0=to port */
  187. #define P_RESET         0x00000080      /* RW   */
  188. #define P_SLAVE_ERR     0x00000040      /* RW1  Access size error */
  189. #define P_INVALIDATE    0x00000020      /* W    Drop P-FIFO */
  190. #define P_INT_EN        0x00000010      /* RW   OK to P_INT_PEND||P_ERR_PEND */
  191. #define P_DRAINING      0x0000000c      /* R    P-FIFO is draining to memory */
  192. #define P_ERR_PEND      0x00000002      /* R    */
  193. #define P_INT_PEND      0x00000001      /* R    */
  195. /* BPP_HCR. Time is in increments of SBus clock. */
  196. #define P_HCR_TEST      0x8000      /* Allows buried counters to be read */
  197. #define P_HCR_DSW       0x7f00      /* Data strobe width (in ticks) */
  198. #define P_HCR_DDS       0x007f      /* Data setup before strobe (in ticks) */
  200. /* BPP_OCR. */
  201. #define P_OCR_MEM_CLR   0x8000
  202. #define P_OCR_DATA_SRC  0x4000      /* )                  */
  203. #define P_OCR_DS_DSEL   0x2000      /* )  Bidirectional      */
  204. #define P_OCR_BUSY_DSEL 0x1000      /* )    selects            */
  205. #define P_OCR_ACK_DSEL  0x0800      /* )                  */
  206. #define P_OCR_EN_DIAG   0x0400
  207. #define P_OCR_BUSY_OP   0x0200      /* Busy operation */
  208. #define P_OCR_ACK_OP    0x0100      /* Ack operation */
  209. #define P_OCR_SRST      0x0080      /* Reset state machines. Not selfcleaning. */
  210. #define P_OCR_IDLE      0x0008      /* PP data transfer state machine is idle */
  211. #define P_OCR_V_ILCK    0x0002      /* Versatec faded. Zebra only. */
  212. #define P_OCR_EN_VER    0x0001      /* Enable Versatec (0 - enable). Zebra only. */
  214. /* BPP_TCR */
  215. #define P_TCR_DIR       0x08
  216. #define P_TCR_BUSY      0x04
  217. #define P_TCR_ACK       0x02
  218. #define P_TCR_DS        0x01        /* Strobe */
  220. /* BPP_OR */
  221. #define P_OR_V3         0x20        /* )                 */
  222. #define P_OR_V2         0x10        /* ) on Zebra only   */
  223. #define P_OR_V1         0x08        /* )                 */
  224. #define P_OR_INIT       0x04
  225. #define P_OR_AFXN       0x02        /* Auto Feed */
  226. #define P_OR_SLCT_IN    0x01
  228. /* BPP_IR */
  229. #define P_IR_PE         0x04
  230. #define P_IR_SLCT       0x02
  231. #define P_IR_ERR        0x01
  233. /* BPP_ICR */
  234. #define P_DS_IRQ        0x8000      /* RW1  */
  235. #define P_ACK_IRQ       0x4000      /* RW1  */
  236. #define P_BUSY_IRQ      0x2000      /* RW1  */
  237. #define P_PE_IRQ        0x1000      /* RW1  */
  238. #define P_SLCT_IRQ      0x0800      /* RW1  */
  239. #define P_ERR_IRQ       0x0400      /* RW1  */
  240. #define P_DS_IRQ_EN     0x0200      /* RW   Always on rising edge */
  241. #define P_ACK_IRQ_EN    0x0100      /* RW   Always on rising edge */
  242. #define P_BUSY_IRP      0x0080      /* RW   1= rising edge */
  243. #define P_BUSY_IRQ_EN   0x0040      /* RW   */
  244. #define P_PE_IRP        0x0020      /* RW   1= rising edge */
  245. #define P_PE_IRQ_EN     0x0010      /* RW   */
  246. #define P_SLCT_IRP      0x0008      /* RW   1= rising edge */
  247. #define P_SLCT_IRQ_EN   0x0004      /* RW   */
  248. #define P_ERR_IRP       0x0002      /* RW1  1= rising edge */
  249. #define P_ERR_IRQ_EN    0x0001      /* RW   */
  251. unsigned long base_addrs[BPP_NO];
  253. #define bpp_outb_p(data, base) sbus_writeb(data, (base) + BPP_DR)
  254. #define bpp_inb_p(base) sbus_readb((base) + BPP_DR)
  255. #define bpp_inb(base) sbus_readb((base) + BPP_DR)
  257. static void set_pins(unsigned short pins, unsigned minor)
  258. {
  259.       unsigned long base = base_addrs[minor];
  260.       unsigned char bits_tcr = 0, bits_or = 0;
  262.       if (instances[minor].direction & 0x20) bits_tcr |= P_TCR_DIR;
  263.       if (   pins & BPP_PP_nStrobe)          bits_tcr |= P_TCR_DS;
  265.       if (   pins & BPP_PP_nAutoFd)          bits_or |= P_OR_AFXN;
  266.       if (! (pins & BPP_PP_nInit))           bits_or |= P_OR_INIT;
  267.       if (! (pins & BPP_PP_nSelectIn))       bits_or |= P_OR_SLCT_IN;
  269.       sbus_writeb(bits_or, base + BPP_OR);
  270.       sbus_writeb(bits_tcr, base + BPP_TCR);
  271. }
  273. /*
  274.  * i386 people read output pins from a software image.
  275.  * We may get them back from hardware.
  276.  * Again, inversion of pins must he buried here.
  277.  */
  278. static unsigned short get_pins(unsigned minor)
  279. {
  280.       unsigned long base = base_addrs[minor];
  281.       unsigned short bits = 0;
  282.       unsigned value_tcr = sbus_readb(base + BPP_TCR);
  283.       unsigned value_ir = sbus_readb(base + BPP_IR);
  284.       unsigned value_or = sbus_readb(base + BPP_OR);
  286.       if (value_tcr & P_TCR_DS)         bits |= BPP_PP_nStrobe;
  287.       if (value_or & P_OR_AFXN)         bits |= BPP_PP_nAutoFd;
  288.       if (! (value_or & P_OR_INIT))     bits |= BPP_PP_nInit;
  289.       if (! (value_or & P_OR_SLCT_IN))  bits |= BPP_PP_nSelectIn;
  291.       if (value_ir & P_IR_ERR)          bits |= BPP_GP_nFault;
  292.       if (! (value_ir & P_IR_SLCT))     bits |= BPP_GP_Select;
  293.       if (! (value_ir & P_IR_PE))       bits |= BPP_GP_PError;
  294.       if (! (value_tcr & P_TCR_ACK))    bits |= BPP_GP_nAck;
  295.       if (value_tcr & P_TCR_BUSY)       bits |= BPP_GP_Busy;
  297.       return bits;
  298. }
  300. #endif /* __sparc__ */
  302. static void bpp_wake_up(unsigned long val)
  303. { wake_up(&instances[val].wait_queue); }
  305. static void snooze(unsigned long snooze_time, unsigned minor)
  306. {
  307.       instances[minor].timer_list.expires = jiffies + snooze_time + 1;
  308.       instances[minor].timer_list.data    = minor;
  309.       add_timer(&instances[minor].timer_list);
  310.       sleep_on (&instances[minor].wait_queue);
  311. }
  313. static int wait_for(unsigned short set, unsigned short clr,
  314.                unsigned long delay, unsigned minor)
  315. {
  316.       unsigned short pins = get_pins(minor);
  318.       unsigned long extime = 0;
  320.       /*
  321.        * Try a real fast scan for the first jiffy, in case the device
  322.        * responds real good. The first while loop guesses an expire
  323.        * time accounting for possible wraparound of jiffies.
  324.        */
  325.       while (time_after_eq(jiffies, extime)) extime = jiffies + 1;
  326.       while ( (time_before(jiffies, extime))
  327.               && (((pins & set) != set) || ((pins & clr) != 0)) ) {
  328.             pins = get_pins(minor);
  329.       }
  331.       delay -= 1;
  333.       /*
  334.        * If my delay expired or the pins are still not where I want
  335.        * them, then resort to using the timer and greatly reduce my
  336.        * sample rate. If the peripheral is going to be slow, this will
  337.        * give the CPU up to some more worthy process.
  338.        */
  339.       while ( delay && (((pins & set) != set) || ((pins & clr) != 0)) ) {
  341.             snooze(1, minor);
  342.             pins = get_pins(minor);
  343.             delay -= 1;
  344.       }
  346.       if (delay == 0) return -1;
  347.       else return pins;
  348. }
  350. /*
  351.  * Return ZERO(0) If the negotiation succeeds, an errno otherwise. An
  352.  * errno means something broke, and I do not yet know how to fix it.
  353.  */
  354. static int negotiate(unsigned char mode, unsigned minor)
  355. {
  356.       int rc;
  357.       unsigned short pins = get_pins(minor);
  358.       if (pins & BPP_PP_nSelectIn) return -EIO;
  361.         /* Event 0: Write the mode to the data lines */
  362.       bpp_outb_p(mode, base_addrs[minor]);
  364.       snooze(TIME_PSetup, minor);
  366.         /* Event 1: Strobe the mode code into the peripheral */
  367.       set_pins(BPP_PP_nSelectIn|BPP_PP_nStrobe|BPP_PP_nInit, minor);
  369.         /* Wait for Event 2: Peripheral responds as a 1284 device. */
  370.       rc = wait_for(BPP_GP_PError|BPP_GP_Select|BPP_GP_nFault,
  371.                 BPP_GP_nAck,
  372.                 TIME_PResponse,
  373.                 minor);
  375.       if (rc == -1) return -ETIMEDOUT;
  377.         /* Event 3: latch extensibility request */
  378.       set_pins(BPP_PP_nSelectIn|BPP_PP_nInit, minor);
  380.         /* ... quick nap while peripheral ponders the byte i'm sending...*/
  381.       snooze(1, minor);
  383.         /* Event 4: restore strobe, to ACK peripheral's response. */
  384.       set_pins(BPP_PP_nSelectIn|BPP_PP_nAutoFd|BPP_PP_nStrobe|BPP_PP_nInit, minor);
  386.         /* Wait for Event 6: Peripheral latches response bits */
  387.       rc = wait_for(BPP_GP_nAck, 0, TIME_PSetup+TIME_PResponse, minor);
  388.       if (rc == -1) return -EIO;
  390.         /* A 1284 device cannot refuse nibble mode */
  391.       if (mode == DEFAULT_NIBBLE) return 0;
  393.       if (pins & BPP_GP_Select) return 0;
  395.       return -EPROTONOSUPPORT;
  396. }
  398. static int terminate(unsigned minor)
  399. {
  400.       int rc;
  402.         /* Event 22: Request termination of 1284 mode */
  403.       set_pins(BPP_PP_nAutoFd|BPP_PP_nStrobe|BPP_PP_nInit, minor);
  405.         /* Wait for Events 23 and 24: ACK termination request. */
  406.       rc = wait_for(BPP_GP_Busy|BPP_GP_nFault,
  407.                 BPP_GP_nAck,
  408.                 TIME_PSetup+TIME_PResponse,
  409.                 minor);
  411.       instances[minor].direction = 0;
  412.       instances[minor].mode = COMPATIBILITY;
  414.       if (rc == -1) {
  415.           return -EIO;
  416.       }
  418.         /* Event 25: Handshake by lowering nAutoFd */
  419.       set_pins(BPP_PP_nStrobe|BPP_PP_nInit, minor);
  421.         /* Event 26: Peripheral wiggles lines... */
  423.         /* Event 27: Peripheral sets nAck HIGH to ack handshake */
  424.       rc = wait_for(BPP_GP_nAck, 0, TIME_PResponse, minor);
  425.       if (rc == -1) {
  426.           set_pins(BPP_PP_nAutoFd|BPP_PP_nStrobe|BPP_PP_nInit, minor);
  427.           return -EIO;
  428.       }
  430.         /* Event 28: Finish phase by raising nAutoFd */
  431.       set_pins(BPP_PP_nAutoFd|BPP_PP_nStrobe|BPP_PP_nInit, minor);
  433.       return 0;
  434. }
  436. static spinlock_t bpp_open_lock = SPIN_LOCK_UNLOCKED;
  438. /*
  439.  * Allow only one process to open the device at a time.
  440.  */
  441. static int bpp_open(struct inode *inode, struct file *f)
  442. {
  443.       unsigned minor = MINOR(inode->i_rdev);
  444.       int ret;
  446.       spin_lock(&bpp_open_lock);
  447.       ret = 0;
  448.       if (minor >= BPP_NO) {
  449.       ret = -ENODEV;
  450.       } else {
  451.       if (! instances[minor].present) {
  452.       ret = -ENODEV;
  453.       } else {
  454.       if (instances[minor].opened) 
  455.       ret = -EBUSY;
  456.       else
  457.       instances[minor].opened = 1;
  458.       }
  459.       }
  460.       spin_unlock(&bpp_open_lock);
  462.       return ret;
  463. }
  465. /*
  466.  * When the process closes the device, this method is called to clean
  467.  * up and reset the hardware. Always leave the device in compatibility
  468.  * mode as this is a reasonable place to clean up from messes made by
  469.  * ioctls, or other mayhem.
  470.  */
  471. static int bpp_release(struct inode *inode, struct file *f)
  472. {
  473.       unsigned minor = MINOR(inode->i_rdev);
  475.       spin_lock(&bpp_open_lock);
  476.       instances[minor].opened = 0;
  478.       if (instances[minor].mode != COMPATIBILITY)
  479.       terminate(minor);
  481.       spin_unlock(&bpp_open_lock);
  483.       return 0;
  484. }
  486. static long read_nibble(unsigned minor, char *c, unsigned long cnt)
  487. {
  488.       unsigned long remaining = cnt;
  489.       long rc;
  491.       while (remaining > 0) {
  492.           unsigned char byte = 0;
  493.           int pins;
  495.           /* Event 7: request nibble */
  496.           set_pins(BPP_PP_nSelectIn|BPP_PP_nStrobe, minor);
  498.           /* Wait for event 9: Peripher strobes first nibble */
  499.           pins = wait_for(0, BPP_GP_nAck, TIME_IDLE_LIMIT, minor);
  500.           if (pins == -1) return -ETIMEDOUT;
  502.           /* Event 10: I handshake nibble */
  503.           set_pins(BPP_PP_nSelectIn|BPP_PP_nStrobe|BPP_PP_nAutoFd, minor);
  504.           if (pins & BPP_GP_nFault) byte |= 0x01;
  505.           if (pins & BPP_GP_Select) byte |= 0x02;
  506.           if (pins & BPP_GP_PError) byte |= 0x04;
  507.           if (pins & BPP_GP_Busy)   byte |= 0x08;
  509.           /* Wait for event 11: Peripheral handshakes nibble */
  510.           rc = wait_for(BPP_GP_nAck, 0, TIME_PResponse, minor);
  512.           /* Event 7: request nibble */
  513.           set_pins(BPP_PP_nSelectIn|BPP_PP_nStrobe, minor);
  515.           /* Wait for event 9: Peripher strobes first nibble */
  516.           pins = wait_for(0, BPP_GP_nAck, TIME_PResponse, minor);
  517.           if (rc == -1) return -ETIMEDOUT;
  519.           /* Event 10: I handshake nibble */
  520.           set_pins(BPP_PP_nSelectIn|BPP_PP_nStrobe|BPP_PP_nAutoFd, minor);
  521.           if (pins & BPP_GP_nFault) byte |= 0x10;
  522.           if (pins & BPP_GP_Select) byte |= 0x20;
  523.           if (pins & BPP_GP_PError) byte |= 0x40;
  524.           if (pins & BPP_GP_Busy)   byte |= 0x80;
  526.           if (put_user(byte, c))
  527.   return -EFAULT;
  528.           c += 1;
  529.           remaining -= 1;
  531.           /* Wait for event 11: Peripheral handshakes nibble */
  532.           rc = wait_for(BPP_GP_nAck, 0, TIME_PResponse, minor);
  533.           if (rc == -1) return -EIO;
  534.       }
  536.       return cnt - remaining;
  537. }
  539. static long read_ecp(unsigned minor, char *c, unsigned long cnt)
  540. {
  541.       unsigned long remaining;
  542.       long rc;
  544.         /* Turn ECP mode from forward to reverse if needed. */
  545.       if (! instances[minor].direction) {
  546.           unsigned short pins = get_pins(minor);
  548.             /* Event 38: Turn the bus around */
  549.           instances[minor].direction = 0x20;
  550.           pins &= ~BPP_PP_nAutoFd;
  551.           set_pins(pins, minor);
  553.             /* Event 39: Set pins for reverse mode. */
  554.           snooze(TIME_PSetup, minor);
  555.           set_pins(BPP_PP_nStrobe|BPP_PP_nSelectIn, minor);
  557.             /* Wait for event 40: Peripheral ready to be strobed */
  558.           rc = wait_for(0, BPP_GP_PError, TIME_PResponse, minor);
  559.           if (rc == -1) return -ETIMEDOUT;
  560.       }
  562.       remaining = cnt;
  564.       while (remaining > 0) {
  566.             /* If there is a run length for a repeated byte, repeat */
  567.             /* that byte a few times. */
  568.           if (instances[minor].run_length && !instances[minor].run_flag) {
  570.               char buffer[128];
  571.               unsigned idx;
  572.               unsigned repeat = remaining < instances[minor].run_length
  573.                                      ? remaining
  574.                                : instances[minor].run_length;
  576.               for (idx = 0 ;  idx < repeat ;  idx += 1)
  577.                 buffer[idx] = instances[minor].repeat_byte;
  579.               if (copy_to_user(c, buffer, repeat))
  580.       return -EFAULT;
  581.               remaining -= repeat;
  582.               c += repeat;
  583.               instances[minor].run_length -= repeat;
  584.           }
  586.           if (remaining == 0) break;
  589.             /* Wait for Event 43: Data active on the bus. */
  590.           rc = wait_for(0, BPP_GP_nAck, TIME_IDLE_LIMIT, minor);
  591.           if (rc == -1) break;
  593.           if (rc & BPP_GP_Busy) {
  594.                 /* OK, this is data. read it in. */
  595.               unsigned char byte = bpp_inb(base_addrs[minor]);
  596.               if (put_user(byte, c))
  597.       return -EFAULT;
  598.               c += 1;
  599.               remaining -= 1;
  601.               if (instances[minor].run_flag) {
  602.                   instances[minor].repeat_byte = byte;
  603.                   instances[minor].run_flag = 0;
  604.               }
  606.           } else {
  607.               unsigned char byte = bpp_inb(base_addrs[minor]);
  608.               if (byte & 0x80) {
  609.                   printk("bpp%d: "
  610.                          "Ignoring ECP channel %u from device.n",
  611.                          minor, byte & 0x7f);
  612.               } else {
  613.                   instances[minor].run_length = byte;
  614.                   instances[minor].run_flag = 1;
  615.               }
  616.           }
  618.             /* Event 44: I got it. */
  619.           set_pins(BPP_PP_nStrobe|BPP_PP_nAutoFd|BPP_PP_nSelectIn, minor);
  621.             /* Wait for event 45: peripheral handshake */
  622.           rc = wait_for(BPP_GP_nAck, 0, TIME_PResponse, minor);
  623.           if (rc == -1) return -ETIMEDOUT;
  625.              /* Event 46: Finish handshake */
  626.           set_pins(BPP_PP_nStrobe|BPP_PP_nSelectIn, minor);
  628.       }
  631.       return cnt - remaining;
  632. }
  634. static ssize_t bpp_read(struct file *f, char *c, size_t cnt, loff_t * ppos)
  635. {
  636.       long rc;
  637.       const unsigned minor = MINOR(f->f_dentry->d_inode->i_rdev);
  638.       if (minor >= BPP_NO) return -ENODEV;
  639.       if (!instances[minor].present) return -ENODEV;
  641.       switch (instances[minor].mode) {
  643.         default:
  644.           if (instances[minor].mode != COMPATIBILITY)
  645.             terminate(minor);
  647.           if (instances[minor].enhanced) {
  648.               /* For now, do all reads with ECP-RLE mode */
  649.               unsigned short pins;
  651.               rc = negotiate(DEFAULT_ECP, minor);
  652.               if (rc < 0) break;
  654.               instances[minor].mode = ECP_RLE;
  656.               /* Event 30: set nAutoFd low to setup for ECP mode */
  657.               pins = get_pins(minor);
  658.               pins &= ~BPP_PP_nAutoFd;
  659.               set_pins(pins, minor);
  661.               /* Wait for Event 31: peripheral ready */
  662.               rc = wait_for(BPP_GP_PError, 0, TIME_PResponse, minor);
  663.               if (rc == -1) return -ETIMEDOUT;
  665.               rc = read_ecp(minor, c, cnt);
  667.           } else {
  668.               rc = negotiate(DEFAULT_NIBBLE, minor);
  669.               if (rc < 0) break;
  671.               instances[minor].mode = NIBBLE;
  673.               rc = read_nibble(minor, c, cnt);
  674.           }
  675.           break;
  677.         case NIBBLE:
  678.           rc = read_nibble(minor, c, cnt);
  679.           break;
  681.         case ECP:
  682.         case ECP_RLE:
  683.           rc = read_ecp(minor, c, cnt);
  684.           break;
  686.       }
  689.       return rc;
  690. }
  692. /*
  693.  * Compatibility mode handshaking is a matter of writing data,
  694.  * strobing it, and waiting for the printer to stop being busy.
  695.  */
  696. static long write_compat(unsigned minor, const char *c, unsigned long cnt)
  697. {
  698.       long rc;
  699.       unsigned short pins = get_pins(minor);
  701.       unsigned long remaining = cnt;
  704.       while (remaining > 0) {
  705.             unsigned char byte;
  707.             if (get_user(byte, c))
  708.     return -EFAULT;
  709.             c += 1;
  711.             rc = wait_for(BPP_GP_nAck, BPP_GP_Busy, TIME_IDLE_LIMIT, minor);
  712.             if (rc == -1) return -ETIMEDOUT;
  714.             bpp_outb_p(byte, base_addrs[minor]);
  715.             remaining -= 1;
  716.           /* snooze(1, minor); */
  718.           pins &= ~BPP_PP_nStrobe;
  719.           set_pins(pins, minor);
  721.           rc = wait_for(BPP_GP_Busy, 0, TIME_PResponse, minor);
  723.           pins |= BPP_PP_nStrobe;
  724.           set_pins(pins, minor);
  725.       }
  727.       return cnt - remaining;
  728. }
  730. /*
  731.  * Write data using ECP mode. Watch out that the port may be set up
  732.  * for reading. If so, turn the port around.
  733.  */
  734. static long write_ecp(unsigned minor, const char *c, unsigned long cnt)
  735. {
  736.       unsigned short pins = get_pins(minor);
  737.       unsigned long remaining = cnt;
  739.       if (instances[minor].direction) {
  740.           int rc;
  742.             /* Event 47 Request bus be turned around */
  743.           pins |= BPP_PP_nInit;
  744.           set_pins(pins, minor);
  746.             /* Wait for Event 49: Peripheral relinquished bus */
  747.           rc = wait_for(BPP_GP_PError, 0, TIME_PResponse, minor);
  749.           pins |= BPP_PP_nAutoFd;
  750.           instances[minor].direction = 0;
  751.           set_pins(pins, minor);
  752.       }
  754.       while (remaining > 0) {
  755.           unsigned char byte;
  756.           int rc;
  758.           if (get_user(byte, c))
  759.   return -EFAULT;
  761.           rc = wait_for(0, BPP_GP_Busy, TIME_PResponse, minor);
  762.           if (rc == -1) return -ETIMEDOUT;
  764.           c += 1;
  766.           bpp_outb_p(byte, base_addrs[minor]);
  768.           pins &= ~BPP_PP_nStrobe;
  769.           set_pins(pins, minor);
  771.           pins |= BPP_PP_nStrobe;
  772.           rc = wait_for(BPP_GP_Busy, 0, TIME_PResponse, minor);
  773.           if (rc == -1) return -EIO;
  775.           set_pins(pins, minor);
  776.       }
  778.       return cnt - remaining;
  779. }
  781. /*
  782.  * Write to the peripheral. Be sensitive of the current mode. If I'm
  783.  * in a mode that can be turned around (ECP) then just do
  784.  * that. Otherwise, terminate and do my writing in compat mode. This
  785.  * is the safest course as any device can handle it.
  786.  */
  787. static ssize_t bpp_write(struct file *f, const char *c, size_t cnt, loff_t * ppos)
  788. {
  789.       long errno = 0;
  790.       const unsigned minor = MINOR(f->f_dentry->d_inode->i_rdev);
  791.       if (minor >= BPP_NO) return -ENODEV;
  792.       if (!instances[minor].present) return -ENODEV;
  794.       switch (instances[minor].mode) {
  796.         case ECP:
  797.         case ECP_RLE:
  798.           errno = write_ecp(minor, c, cnt);
  799.           break;
  800.         case COMPATIBILITY:
  801.           errno = write_compat(minor, c, cnt);
  802.           break;
  803.         default:
  804.           terminate(minor);
  805.           errno = write_compat(minor, c, cnt);
  806.       }
  808.       return errno;
  809. }
  811. static int bpp_ioctl(struct inode *inode, struct file *f, unsigned int cmd,
  812.  unsigned long arg)
  813. {
  814.       int errno = 0;
  816.       unsigned minor = MINOR(inode->i_rdev);
  817.       if (minor >= BPP_NO) return -ENODEV;
  818.       if (!instances[minor].present) return -ENODEV;
  821.       switch (cmd) {
  823.         case BPP_PUT_PINS:
  824.           set_pins(arg, minor);
  825.           break;
  827.         case BPP_GET_PINS:
  828.           errno = get_pins(minor);
  829.           break;
  831.         case BPP_PUT_DATA:
  832.           bpp_outb_p(arg, base_addrs[minor]);
  833.           break;
  835.         case BPP_GET_DATA:
  836.           errno = bpp_inb_p(base_addrs[minor]);
  837.           break;
  839.         case BPP_SET_INPUT:
  840.           if (arg)
  841.             if (instances[minor].enhanced) {
  842.                 unsigned short bits = get_pins(minor);
  843.                 instances[minor].direction = 0x20;
  844.                 set_pins(bits, minor);
  845.             } else {
  846.                 errno = -ENOTTY;
  847.             }
  848.           else {
  849.               unsigned short bits = get_pins(minor);
  850.               instances[minor].direction = 0x00;
  851.               set_pins(bits, minor);
  852.           }
  853.           break;
  855.         default:
  856.             errno = -EINVAL;
  857.       }
  859.       return errno;
  860. }
  862. static struct file_operations bpp_fops = {
  863. owner: THIS_MODULE,
  864. read: bpp_read,
  865. write: bpp_write,
  866. ioctl: bpp_ioctl,
  867. open: bpp_open,
  868. release: bpp_release,
  869. };
  871. #if defined(__i386__)
  873. #define collectLptPorts()  {}
  875. static void probeLptPort(unsigned idx)
  876. {
  877.       unsigned int testvalue;
  878.       const unsigned short lpAddr = base_addrs[idx];
  880.       instances[idx].present = 0;
  881.       instances[idx].enhanced = 0;
  882.       instances[idx].direction = 0;
  883.       instances[idx].mode = COMPATIBILITY;
  884.       instances[idx].wait_queue = 0;
  885.       instances[idx].run_length = 0;
  886.       instances[idx].run_flag = 0;
  887.       init_timer(&instances[idx].timer_list);
  888.       instances[idx].timer_list.function = bpp_wake_up;
  889.       if (check_region(lpAddr,3)) return;
  891.       /*
  892.        * First, make sure the instance exists. Do this by writing to
  893.        * the data latch and reading the value back. If the port *is*
  894.        * present, test to see if it supports extended-mode
  895.        * operation. This will be required for IEEE1284 reverse
  896.        * transfers.
  897.        */
  899.       outb_p(BPP_PROBE_CODE, lpAddr);
  900.       for (testvalue=0; testvalue<BPP_DELAY; testvalue++)
  901.             ;
  902.       testvalue = inb_p(lpAddr);
  903.       if (testvalue == BPP_PROBE_CODE) {
  904.             unsigned save;
  905.             instances[idx].present = 1;
  907.             request_region(lpAddr,3, dev_name);
  908.             save = inb_p(lpAddr+2);
  909.             for (testvalue=0; testvalue<BPP_DELAY; testvalue++)
  910.                   ;
  911.             outb_p(save|0x20, lpAddr+2);
  912.             for (testvalue=0; testvalue<BPP_DELAY; testvalue++)
  913.                   ;
  914.             outb_p(~BPP_PROBE_CODE, lpAddr);
  915.             for (testvalue=0; testvalue<BPP_DELAY; testvalue++)
  916.                   ;
  917.             testvalue = inb_p(lpAddr);
  918.             if ((testvalue&0xff) == (0xff&~BPP_PROBE_CODE))
  919.                   instances[idx].enhanced = 0;
  920.             else
  921.                   instances[idx].enhanced = 1;
  922.             outb_p(save, lpAddr+2);
  923.       }
  925.       /*
  926.        * Leave the port in compat idle mode.
  927.        */
  928.       set_pins(BPP_PP_nAutoFd|BPP_PP_nStrobe|BPP_PP_nInit, idx);
  930.       printk("bpp%d: Port at 0x%03x: Enhanced mode %sn", idx, base_addrs[idx],
  931.             instances[idx].enhanced? "SUPPORTED" : "UNAVAILABLE");
  932. }
  934. static inline void freeLptPort(int idx)
  935. {
  936.       release_region(base_addrs[idx], 3);
  937. }
  939. #endif
  941. #if defined(__sparc__)
  943. static unsigned long map_bpp(struct sbus_dev *dev, int idx)
  944. {
  945.       return sbus_ioremap(&dev->resource[0], 0, BPP_SIZE, "bpp");
  946. }
  948. static int collectLptPorts(void)
  949. {
  950. struct sbus_bus *bus;
  951. struct sbus_dev *dev;
  952. int count;
  954. count = 0;
  955. for_all_sbusdev(dev, bus) {
  956. if (strcmp(dev->prom_name, "SUNW,bpp") == 0) {
  957. if (count >= BPP_NO) {
  958. printk(KERN_NOTICE
  959.        "bpp: More than %d bpp ports,"
  960.        " rest is ignoredn", BPP_NO);
  961. return count;
  962. }
  963. base_addrs[count] = map_bpp(dev, count);
  964. count++;
  965. }
  966. }
  967. return count;
  968. }
  970. static void probeLptPort(unsigned idx)
  971. {
  972.       unsigned long rp = base_addrs[idx];
  973.       __u32 csr;
  974.       char *brand;
  976.       instances[idx].present = 0;
  977.       instances[idx].enhanced = 0;
  978.       instances[idx].direction = 0;
  979.       instances[idx].mode = COMPATIBILITY;
  980.       init_waitqueue_head(&instances[idx].wait_queue);
  981.       instances[idx].run_length = 0;
  982.       instances[idx].run_flag = 0;
  983.       init_timer(&instances[idx].timer_list);
  984.       instances[idx].timer_list.function = bpp_wake_up;
  986.       if (rp == 0) return;
  988.       instances[idx].present = 1;
  989.       instances[idx].enhanced = 1;   /* Sure */
  991.       csr = sbus_readl(rp + BPP_CSR);
  992.       if ((csr & P_DRAINING) != 0 && (csr & P_ERR_PEND) == 0) {
  993.             udelay(20);
  994.             csr = sbus_readl(rp + BPP_CSR);
  995.             if ((csr & P_DRAINING) != 0 && (csr & P_ERR_PEND) == 0) {
  996.                   printk("bpp%d: DRAINING still active (0x%08x)n", idx, csr);
  997.             }
  998.       }
  999.       printk("bpp%d: reset with 0x%08x ..", idx, csr);
  1000.       sbus_writel((csr | P_RESET) & ~P_INT_EN, rp + BPP_CSR);
  1001.       udelay(500);
  1002.       sbus_writel(sbus_readl(rp + BPP_CSR) & ~P_RESET, rp + BPP_CSR);
  1003.       csr = sbus_readl(rp + BPP_CSR);
  1004.       printk(" done with csr=0x%08x ocr=0x%04xn",
  1005.          csr, sbus_readw(rp + BPP_OCR));
  1007.       switch (csr & P_DEV_ID_MASK) {
  1008.       case P_DEV_ID_ZEBRA:
  1009.             brand = "Zebra";
  1010.             break;
  1011.       case P_DEV_ID_L64854:
  1012.             brand = "DMA2";
  1013.             break;
  1014.       default:
  1015.             brand = "Unknown";
  1016.       }
  1017.       printk("bpp%d: %s at 0x%lxn", idx, brand, rp);
  1019.       /*
  1020.        * Leave the port in compat idle mode.
  1021.        */
  1022.       set_pins(BPP_PP_nAutoFd|BPP_PP_nStrobe|BPP_PP_nInit, idx);
  1024.       return;
  1025. }
  1027. static inline void freeLptPort(int idx)
  1028. {
  1029.       sbus_iounmap(base_addrs[idx], BPP_SIZE);
  1030. }
  1032. #endif
  1034. static devfs_handle_t devfs_handle;
  1036. static int __init bpp_init(void)
  1037. {
  1038. int rc;
  1039. unsigned idx;
  1041. rc = collectLptPorts();
  1042. if (rc == 0)
  1043. return -ENODEV;
  1045. rc = devfs_register_chrdev(BPP_MAJOR, dev_name, &bpp_fops);
  1046. if (rc < 0)
  1047. return rc;
  1049. for (idx = 0; idx < BPP_NO; idx += 1) {
  1050. instances[idx].opened = 0;
  1051. probeLptPort(idx);
  1052. }
  1053. devfs_handle = devfs_mk_dir (NULL, "bpp", NULL);
  1054. devfs_register_series (devfs_handle, "%u", BPP_NO, DEVFS_FL_DEFAULT,
  1055.        BPP_MAJOR, 0, S_IFCHR | S_IRUSR | S_IWUSR,
  1056.        &bpp_fops, NULL);
  1058. return 0;
  1059. }
  1061. static void __exit bpp_cleanup(void)
  1062. {
  1063. unsigned idx;
  1065. devfs_unregister (devfs_handle);
  1066. devfs_unregister_chrdev(BPP_MAJOR, dev_name);
  1068. for (idx = 0 ;  idx < BPP_NO ;  idx += 1) {
  1069. if (instances[idx].present)
  1070. freeLptPort(idx);
  1071. }
  1072. }
  1074. module_init(bpp_init);
  1075. module_exit(bpp_cleanup);