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-parisc / floppy.h < prev    next >
Encoding:
C/C++ Source or Header  |  2006-08-11  |  6.7 KB  |  278 lines
  1. /*    Architecture specific parts of the Floppy driver
  2.  *
  3.  *    Linux/PA-RISC Project (http://www.parisc-linux.org/)
  4.  *    Copyright (C) 2000 Matthew Wilcox (willy a debian . org)
  5.  *    Copyright (C) 2000 Dave Kennedy
  6.  *
  7.  *    This program is free software; you can redistribute it and/or modify
  8.  *    it under the terms of the GNU General Public License as published by
  9.  *    the Free Software Foundation; either version 2 of the License, or
  10.  *    (at your option) any later version.
  11.  *
  12.  *    This program is distributed in the hope that it will be useful,
  13.  *    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14.  *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15.  *    GNU General Public License for more details.
  16.  *
  17.  *    You should have received a copy of the GNU General Public License
  18.  *    along with this program; if not, write to the Free Software
  19.  *    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  20.  */
  21. #ifndef __ASM_PARISC_FLOPPY_H
  22. #define __ASM_PARISC_FLOPPY_H
  23.  
  24. #include <linux/vmalloc.h>
  25.  
  26.  
  27. /*
  28.  * The DMA channel used by the floppy controller cannot access data at
  29.  * addresses >= 16MB
  30.  *
  31.  * Went back to the 1MB limit, as some people had problems with the floppy
  32.  * driver otherwise. It doesn't matter much for performance anyway, as most
  33.  * floppy accesses go through the track buffer.
  34.  */
  35. #define _CROSS_64KB(a,s,vdma) \
  36. (!vdma && ((unsigned long)(a)/K_64 != ((unsigned long)(a) + (s) - 1) / K_64))
  37.  
  38. #define CROSS_64KB(a,s) _CROSS_64KB(a,s,use_virtual_dma & 1)
  39.  
  40.  
  41. #define SW fd_routine[use_virtual_dma&1]
  42. #define CSW fd_routine[can_use_virtual_dma & 1]
  43.  
  44.  
  45. #define fd_inb(port)            readb(port)
  46. #define fd_outb(value, port)        writeb(value, port)
  47.  
  48. #define fd_request_dma()        CSW._request_dma(FLOPPY_DMA,"floppy")
  49. #define fd_free_dma()           CSW._free_dma(FLOPPY_DMA)
  50. #define fd_enable_irq()         enable_irq(FLOPPY_IRQ)
  51. #define fd_disable_irq()        disable_irq(FLOPPY_IRQ)
  52. #define fd_free_irq()        free_irq(FLOPPY_IRQ, NULL)
  53. #define fd_get_dma_residue()    SW._get_dma_residue(FLOPPY_DMA)
  54. #define fd_dma_mem_alloc(size)    SW._dma_mem_alloc(size)
  55. #define fd_dma_setup(addr, size, mode, io) SW._dma_setup(addr, size, mode, io)
  56.  
  57. #define FLOPPY_CAN_FALLBACK_ON_NODMA
  58.  
  59. static int virtual_dma_count=0;
  60. static int virtual_dma_residue=0;
  61. static char *virtual_dma_addr=0;
  62. static int virtual_dma_mode=0;
  63. static int doing_pdma=0;
  64.  
  65. static void floppy_hardint(int irq, void *dev_id, struct pt_regs * regs)
  66. {
  67.     register unsigned char st;
  68.  
  69. #undef TRACE_FLPY_INT
  70.  
  71. #ifdef TRACE_FLPY_INT
  72.     static int calls=0;
  73.     static int bytes=0;
  74.     static int dma_wait=0;
  75. #endif
  76.     if (!doing_pdma) {
  77.         floppy_interrupt(irq, dev_id, regs);
  78.         return;
  79.     }
  80.  
  81. #ifdef TRACE_FLPY_INT
  82.     if(!calls)
  83.         bytes = virtual_dma_count;
  84. #endif
  85.  
  86.     {
  87.         register int lcount;
  88.         register char *lptr = virtual_dma_addr;
  89.  
  90.         for (lcount = virtual_dma_count; lcount; lcount--) {
  91.             st = fd_inb(virtual_dma_port+4) & 0xa0 ;
  92.             if (st != 0xa0) 
  93.                 break;
  94.             if (virtual_dma_mode) {
  95.                 fd_outb(*lptr, virtual_dma_port+5);
  96.             } else {
  97.                 *lptr = fd_inb(virtual_dma_port+5);
  98.             }
  99.             lptr++;
  100.         }
  101.         virtual_dma_count = lcount;
  102.         virtual_dma_addr = lptr;
  103.         st = fd_inb(virtual_dma_port+4);
  104.     }
  105.  
  106. #ifdef TRACE_FLPY_INT
  107.     calls++;
  108. #endif
  109.     if (st == 0x20)
  110.         return;
  111.     if (!(st & 0x20)) {
  112.         virtual_dma_residue += virtual_dma_count;
  113.         virtual_dma_count = 0;
  114. #ifdef TRACE_FLPY_INT
  115.         printk("count=%x, residue=%x calls=%d bytes=%d dma_wait=%d\n", 
  116.                virtual_dma_count, virtual_dma_residue, calls, bytes,
  117.                dma_wait);
  118.         calls = 0;
  119.         dma_wait=0;
  120. #endif
  121.         doing_pdma = 0;
  122.         floppy_interrupt(irq, dev_id, regs);
  123.         return;
  124.     }
  125. #ifdef TRACE_FLPY_INT
  126.     if (!virtual_dma_count)
  127.         dma_wait++;
  128. #endif
  129. }
  130.  
  131. static void fd_disable_dma(void)
  132. {
  133.     if(! (can_use_virtual_dma & 1))
  134.         disable_dma(FLOPPY_DMA);
  135.     doing_pdma = 0;
  136.     virtual_dma_residue += virtual_dma_count;
  137.     virtual_dma_count=0;
  138. }
  139.  
  140. static int vdma_request_dma(unsigned int dmanr, const char * device_id)
  141. {
  142.     return 0;
  143. }
  144.  
  145. static void vdma_nop(unsigned int dummy)
  146. {
  147. }
  148.  
  149.  
  150. static int vdma_get_dma_residue(unsigned int dummy)
  151. {
  152.     return virtual_dma_count + virtual_dma_residue;
  153. }
  154.  
  155.  
  156. static int fd_request_irq(void)
  157. {
  158.     if(can_use_virtual_dma)
  159.         return request_irq(FLOPPY_IRQ, floppy_hardint,SA_INTERRUPT,
  160.                            "floppy", NULL);
  161.     else
  162.         return request_irq(FLOPPY_IRQ, floppy_interrupt,
  163.                            SA_INTERRUPT|SA_SAMPLE_RANDOM,
  164.                            "floppy", NULL);    
  165.  
  166. }
  167.  
  168. static unsigned long dma_mem_alloc(unsigned long size)
  169. {
  170.     return __get_dma_pages(GFP_KERNEL, get_order(size));
  171. }
  172.  
  173.  
  174. static unsigned long vdma_mem_alloc(unsigned long size)
  175. {
  176.     return (unsigned long) vmalloc(size);
  177.  
  178. }
  179.  
  180. #define nodma_mem_alloc(size) vdma_mem_alloc(size)
  181.  
  182. static void _fd_dma_mem_free(unsigned long addr, unsigned long size)
  183. {
  184.     if((unsigned int) addr >= (unsigned int) high_memory)
  185.         return vfree((void *)addr);
  186.     else
  187.         free_pages(addr, get_order(size));        
  188. }
  189.  
  190. #define fd_dma_mem_free(addr, size)  _fd_dma_mem_free(addr, size) 
  191.  
  192. static void _fd_chose_dma_mode(char *addr, unsigned long size)
  193. {
  194.     if(can_use_virtual_dma == 2) {
  195.         if((unsigned int) addr >= (unsigned int) high_memory ||
  196.            virt_to_bus(addr) >= 0x1000000 ||
  197.            _CROSS_64KB(addr, size, 0))
  198.             use_virtual_dma = 1;
  199.         else
  200.             use_virtual_dma = 0;
  201.     } else {
  202.         use_virtual_dma = can_use_virtual_dma & 1;
  203.     }
  204. }
  205.  
  206. #define fd_chose_dma_mode(addr, size) _fd_chose_dma_mode(addr, size)
  207.  
  208.  
  209. static int vdma_dma_setup(char *addr, unsigned long size, int mode, int io)
  210. {
  211.     doing_pdma = 1;
  212.     virtual_dma_port = io;
  213.     virtual_dma_mode = (mode  == DMA_MODE_WRITE);
  214.     virtual_dma_addr = addr;
  215.     virtual_dma_count = size;
  216.     virtual_dma_residue = 0;
  217.     return 0;
  218. }
  219.  
  220. static int hard_dma_setup(char *addr, unsigned long size, int mode, int io)
  221. {
  222. #ifdef FLOPPY_SANITY_CHECK
  223.     if (CROSS_64KB(addr, size)) {
  224.         printk("DMA crossing 64-K boundary %p-%p\n", addr, addr+size);
  225.         return -1;
  226.     }
  227. #endif
  228.     /* actual, physical DMA */
  229.     doing_pdma = 0;
  230.     clear_dma_ff(FLOPPY_DMA);
  231.     set_dma_mode(FLOPPY_DMA,mode);
  232.     set_dma_addr(FLOPPY_DMA,virt_to_bus(addr));
  233.     set_dma_count(FLOPPY_DMA,size);
  234.     enable_dma(FLOPPY_DMA);
  235.     return 0;
  236. }
  237.  
  238. static struct fd_routine_l {
  239.     int (*_request_dma)(unsigned int dmanr, const char * device_id);
  240.     void (*_free_dma)(unsigned int dmanr);
  241.     int (*_get_dma_residue)(unsigned int dummy);
  242.     unsigned long (*_dma_mem_alloc) (unsigned long size);
  243.     int (*_dma_setup)(char *addr, unsigned long size, int mode, int io);
  244. } fd_routine[] = {
  245.     {
  246.         request_dma,
  247.         free_dma,
  248.         get_dma_residue,
  249.         dma_mem_alloc,
  250.         hard_dma_setup
  251.     },
  252.     {
  253.         vdma_request_dma,
  254.         vdma_nop,
  255.         vdma_get_dma_residue,
  256.         vdma_mem_alloc,
  257.         vdma_dma_setup
  258.     }
  259. };
  260.  
  261.  
  262. static int FDC1 = 0x3f0; /* Lies.  Floppy controller is memory mapped, not io mapped */
  263. static int FDC2 = -1;
  264.  
  265. #define FLOPPY0_TYPE    0
  266. #define FLOPPY1_TYPE    0
  267.  
  268. #define N_FDC 1
  269. #define N_DRIVE 8
  270.  
  271. #define FLOPPY_MOTOR_MASK 0xf0
  272.  
  273. #define AUTO_DMA
  274.  
  275. #define EXTRA_FLOPPY_PARAMS
  276.  
  277. #endif /* __ASM_PARISC_FLOPPY_H */
  278.