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