home *** CD-ROM | disk | FTP | other *** search
/ PC Welt 2006 November (DVD) / PCWELT_11_2006.ISO / casper / filesystem.squashfs / usr / src / linux-headers-2.6.17-6 / include / asm-ppc / floppy.h < prev    next >
Encoding:
C/C++ Source or Header  |  2006-08-11  |  4.1 KB  |  183 lines

  1. /*
  2.  * Architecture specific parts of the Floppy driver
  3.  *
  4.  * This file is subject to the terms and conditions of the GNU General Public
  5.  * License.  See the file "COPYING" in the main directory of this archive
  6.  * for more details.
  7.  *
  8.  * Copyright (C) 1995
  9.  */
  10. #ifdef __KERNEL__
  11. #ifndef __ASM_PPC_FLOPPY_H
  12. #define __ASM_PPC_FLOPPY_H
  13.  
  14. #define fd_inb(port)        inb_p(port)
  15. #define fd_outb(value,port)    outb_p(value,port)
  16.  
  17. #define fd_disable_dma()    fd_ops->_disable_dma(FLOPPY_DMA)
  18. #define fd_free_dma()           fd_ops->_free_dma(FLOPPY_DMA)
  19. #define fd_get_dma_residue()    fd_ops->_get_dma_residue(FLOPPY_DMA)
  20. #define fd_dma_setup(addr, size, mode, io) fd_ops->_dma_setup(addr, size, mode, io)
  21. #define fd_enable_irq()         enable_irq(FLOPPY_IRQ)
  22. #define fd_disable_irq()        disable_irq(FLOPPY_IRQ)
  23. #define fd_free_irq()           free_irq(FLOPPY_IRQ, NULL);
  24.  
  25. static int fd_request_dma(void);
  26.  
  27. struct fd_dma_ops {
  28.     void (*_disable_dma)(unsigned int dmanr);
  29.     void (*_free_dma)(unsigned int dmanr);
  30.     int (*_get_dma_residue)(unsigned int dummy);
  31.     int (*_dma_setup)(char *addr, unsigned long size, int mode, int io);
  32. };
  33.  
  34. static int virtual_dma_count;
  35. static int virtual_dma_residue;
  36. static char *virtual_dma_addr;
  37. static int virtual_dma_mode;
  38. static int doing_vdma;
  39. static struct fd_dma_ops *fd_ops;
  40.  
  41. static irqreturn_t floppy_hardint(int irq, void *dev_id, struct pt_regs * regs)
  42. {
  43.     unsigned char st;
  44.     int lcount;
  45.     char *lptr;
  46.  
  47.     if (!doing_vdma)
  48.         return floppy_interrupt(irq, dev_id, regs);
  49.  
  50.  
  51.     st = 1;
  52.     for (lcount=virtual_dma_count, lptr=virtual_dma_addr;
  53.          lcount; lcount--, lptr++) {
  54.         st=inb(virtual_dma_port+4) & 0xa0 ;
  55.         if (st != 0xa0)
  56.             break;
  57.         if (virtual_dma_mode)
  58.             outb_p(*lptr, virtual_dma_port+5);
  59.         else
  60.             *lptr = inb_p(virtual_dma_port+5);
  61.     }
  62.     virtual_dma_count = lcount;
  63.     virtual_dma_addr = lptr;
  64.     st = inb(virtual_dma_port+4);
  65.  
  66.     if (st == 0x20)
  67.         return IRQ_HANDLED;
  68.     if (!(st & 0x20)) {
  69.         virtual_dma_residue += virtual_dma_count;
  70.         virtual_dma_count=0;
  71.         doing_vdma = 0;
  72.         floppy_interrupt(irq, dev_id, regs);
  73.         return IRQ_HANDLED;
  74.     }
  75.     return IRQ_HANDLED;
  76. }
  77.  
  78. static void vdma_disable_dma(unsigned int dummy)
  79. {
  80.     doing_vdma = 0;
  81.     virtual_dma_residue += virtual_dma_count;
  82.     virtual_dma_count=0;
  83. }
  84.  
  85. static void vdma_nop(unsigned int dummy)
  86. {
  87. }
  88.  
  89.  
  90. static int vdma_get_dma_residue(unsigned int dummy)
  91. {
  92.     return virtual_dma_count + virtual_dma_residue;
  93. }
  94.  
  95.  
  96. static int fd_request_irq(void)
  97. {
  98.     if (can_use_virtual_dma)
  99.         return request_irq(FLOPPY_IRQ, floppy_hardint,SA_INTERRUPT,
  100.                            "floppy", NULL);
  101.     else
  102.         return request_irq(FLOPPY_IRQ, floppy_interrupt,
  103.                            SA_INTERRUPT|SA_SAMPLE_RANDOM,
  104.                            "floppy", NULL);
  105.  
  106. }
  107.  
  108. static int vdma_dma_setup(char *addr, unsigned long size, int mode, int io)
  109. {
  110.     doing_vdma = 1;
  111.     virtual_dma_port = io;
  112.     virtual_dma_mode = (mode  == DMA_MODE_WRITE);
  113.     virtual_dma_addr = addr;
  114.     virtual_dma_count = size;
  115.     virtual_dma_residue = 0;
  116.     return 0;
  117. }
  118.  
  119. static int hard_dma_setup(char *addr, unsigned long size, int mode, int io)
  120. {
  121.     /* actual, physical DMA */
  122.     doing_vdma = 0;
  123.     clear_dma_ff(FLOPPY_DMA);
  124.     set_dma_mode(FLOPPY_DMA,mode);
  125.     set_dma_addr(FLOPPY_DMA,(unsigned int)virt_to_bus(addr));
  126.     set_dma_count(FLOPPY_DMA,size);
  127.     enable_dma(FLOPPY_DMA);
  128.     return 0;
  129. }
  130.  
  131. static struct fd_dma_ops real_dma_ops =
  132. {
  133.     ._disable_dma = disable_dma,
  134.     ._free_dma = free_dma,
  135.     ._get_dma_residue = get_dma_residue,
  136.     ._dma_setup = hard_dma_setup
  137. };
  138.  
  139. static struct fd_dma_ops virt_dma_ops =
  140. {
  141.     ._disable_dma = vdma_disable_dma,
  142.     ._free_dma = vdma_nop,
  143.     ._get_dma_residue = vdma_get_dma_residue,
  144.     ._dma_setup = vdma_dma_setup
  145. };
  146.  
  147. static int fd_request_dma()
  148. {
  149.     if (can_use_virtual_dma & 1) {
  150.         fd_ops = &virt_dma_ops;
  151.         return 0;
  152.     }
  153.     else {
  154.         fd_ops = &real_dma_ops;
  155.         return request_dma(FLOPPY_DMA, "floppy");
  156.     }
  157. }
  158.  
  159. static int FDC1 = 0x3f0;
  160. static int FDC2 = -1;
  161.  
  162. /*
  163.  * Again, the CMOS information not available
  164.  */
  165. #define FLOPPY0_TYPE 6
  166. #define FLOPPY1_TYPE 0
  167.  
  168. #define N_FDC 2            /* Don't change this! */
  169. #define N_DRIVE 8
  170.  
  171. #define FLOPPY_MOTOR_MASK 0xf0
  172.  
  173. /*
  174.  * The PowerPC has no problems with floppy DMA crossing 64k borders.
  175.  */
  176. #define CROSS_64KB(a,s)    (0)
  177.  
  178. #endif /* __ASM_PPC_FLOPPY_H */
  179.  
  180. #define EXTRA_FLOPPY_PARAMS
  181.  
  182. #endif /* __KERNEL__ */
  183.