include/asm-ppc/floppy.h

   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__ */