include/asm-x86/mca_dma.h

   1 #ifndef MCA_DMA_H
   2 #define MCA_DMA_H
   3
   4 #include <asm/io.h>
   5 #include <linux/ioport.h>
   6
   7 /*
   8  * Microchannel specific DMA stuff.  DMA on an MCA machine is fairly similar to
   9  *   standard PC dma, but it certainly has its quirks.  DMA register addresses
  10  *   are in a different place and there are some added functions.  Most of this
  11  *   should be pretty obvious on inspection.  Note that the user must divide
  12  *   count by 2 when using 16-bit dma; that is not handled by these functions.
  13  *
  14  * Ramen Noodles are yummy.
  15  *
  16  *  1998 Tymm Twillman <tymm@computer.org>
  17  */
  18
  19 /*
  20  * Registers that are used by the DMA controller; FN is the function register
  21  *   (tell the controller what to do) and EXE is the execution register (how
  22  *   to do it)
  23  */
  24
  25 #define MCA_DMA_REG_FN  0x18
  26 #define MCA_DMA_REG_EXE 0x1A
  27
  28 /*
  29  * Functions that the DMA controller can do
  30  */
  31
  32 #define MCA_DMA_FN_SET_IO       0x00
  33 #define MCA_DMA_FN_SET_ADDR     0x20
  34 #define MCA_DMA_FN_GET_ADDR     0x30
  35 #define MCA_DMA_FN_SET_COUNT    0x40
  36 #define MCA_DMA_FN_GET_COUNT    0x50
  37 #define MCA_DMA_FN_GET_STATUS   0x60
  38 #define MCA_DMA_FN_SET_MODE     0x70
  39 #define MCA_DMA_FN_SET_ARBUS    0x80
  40 #define MCA_DMA_FN_MASK         0x90
  41 #define MCA_DMA_FN_RESET_MASK   0xA0
  42 #define MCA_DMA_FN_MASTER_CLEAR 0xD0
  43
  44 /*
  45  * Modes (used by setting MCA_DMA_FN_MODE in the function register)
  46  *
  47  * Note that the MODE_READ is read from memory (write to device), and
  48  *   MODE_WRITE is vice-versa.
  49  */
  50
  51 #define MCA_DMA_MODE_XFER  0x04  /* read by default */
  52 #define MCA_DMA_MODE_READ  0x04  /* same as XFER */
  53 #define MCA_DMA_MODE_WRITE 0x08  /* OR with MODE_XFER to use */
  54 #define MCA_DMA_MODE_IO    0x01  /* DMA from IO register */
  55 #define MCA_DMA_MODE_16    0x40  /* 16 bit xfers */
  56
  57
  58 /**
  59  *      mca_enable_dma  -       channel to enable DMA on
  60  *      @dmanr: DMA channel
  61  *
  62  *      Enable the MCA bus DMA on a channel. This can be called from
  63  *      IRQ context.
  64  */
  65
  66 static __inline__ void mca_enable_dma(unsigned int dmanr)
  67 {
  68         outb(MCA_DMA_FN_RESET_MASK | dmanr, MCA_DMA_REG_FN);
  69 }
  70
  71 /**
  72  *      mca_disble_dma  -       channel to disable DMA on
  73  *      @dmanr: DMA channel
  74  *
  75  *      Enable the MCA bus DMA on a channel. This can be called from
  76  *      IRQ context.
  77  */
  78
  79 static __inline__ void mca_disable_dma(unsigned int dmanr)
  80 {
  81         outb(MCA_DMA_FN_MASK | dmanr, MCA_DMA_REG_FN);
  82 }
  83
  84 /**
  85  *      mca_set_dma_addr -      load a 24bit DMA address
  86  *      @dmanr: DMA channel
  87  *      @a: 24bit bus address
  88  *
  89  *      Load the address register in the DMA controller. This has a 24bit
  90  *      limitation (16Mb).
  91  */
  92
  93 static __inline__ void mca_set_dma_addr(unsigned int dmanr, unsigned int a)
  94 {
  95         outb(MCA_DMA_FN_SET_ADDR | dmanr, MCA_DMA_REG_FN);
  96         outb(a & 0xff, MCA_DMA_REG_EXE);
  97         outb((a >> 8) & 0xff, MCA_DMA_REG_EXE);
  98         outb((a >> 16) & 0xff, MCA_DMA_REG_EXE);
  99 }
 100
 101 /**
 102  *      mca_get_dma_addr -      load a 24bit DMA address
 103  *      @dmanr: DMA channel
 104  *
 105  *      Read the address register in the DMA controller. This has a 24bit
 106  *      limitation (16Mb). The return is a bus address.
 107  */
 108
 109 static __inline__ unsigned int mca_get_dma_addr(unsigned int dmanr)
 110 {
 111         unsigned int addr;
 112
 113         outb(MCA_DMA_FN_GET_ADDR | dmanr, MCA_DMA_REG_FN);
 114         addr = inb(MCA_DMA_REG_EXE);
 115         addr |= inb(MCA_DMA_REG_EXE) << 8;
 116         addr |= inb(MCA_DMA_REG_EXE) << 16;
 117
 118         return addr;
 119 }
 120
 121 /**
 122  *      mca_set_dma_count -     load a 16bit transfer count
 123  *      @dmanr: DMA channel
 124  *      @count: count
 125  *
 126  *      Set the DMA count for this channel. This can be up to 64Kbytes.
 127  *      Setting a count of zero will not do what you expect.
 128  */
 129
 130 static __inline__ void mca_set_dma_count(unsigned int dmanr, unsigned int count)
 131 {
 132         count--;  /* transfers one more than count -- correct for this */
 133
 134         outb(MCA_DMA_FN_SET_COUNT | dmanr, MCA_DMA_REG_FN);
 135         outb(count & 0xff, MCA_DMA_REG_EXE);
 136         outb((count >> 8) & 0xff, MCA_DMA_REG_EXE);
 137 }
 138
 139 /**
 140  *      mca_get_dma_residue -   get the remaining bytes to transfer
 141  *      @dmanr: DMA channel
 142  *
 143  *      This function returns the number of bytes left to transfer
 144  *      on this DMA channel.
 145  */
 146
 147 static __inline__ unsigned int mca_get_dma_residue(unsigned int dmanr)
 148 {
 149         unsigned short count;
 150
 151         outb(MCA_DMA_FN_GET_COUNT | dmanr, MCA_DMA_REG_FN);
 152         count = 1 + inb(MCA_DMA_REG_EXE);
 153         count += inb(MCA_DMA_REG_EXE) << 8;
 154
 155         return count;
 156 }
 157
 158 /**
 159  *      mca_set_dma_io -        set the port for an I/O transfer
 160  *      @dmanr: DMA channel
 161  *      @io_addr: an I/O port number
 162  *
 163  *      Unlike the ISA bus DMA controllers the DMA on MCA bus can transfer
 164  *      with an I/O port target.
 165  */
 166
 167 static __inline__ void mca_set_dma_io(unsigned int dmanr, unsigned int io_addr)
 168 {
 169         /*
 170          * DMA from a port address -- set the io address
 171          */
 172
 173         outb(MCA_DMA_FN_SET_IO | dmanr, MCA_DMA_REG_FN);
 174         outb(io_addr & 0xff, MCA_DMA_REG_EXE);
 175         outb((io_addr >>  8) & 0xff, MCA_DMA_REG_EXE);
 176 }
 177
 178 /**
 179  *      mca_set_dma_mode -      set the DMA mode
 180  *      @dmanr: DMA channel
 181  *      @mode: mode to set
 182  *
 183  *      The DMA controller supports several modes. The mode values you can
 184  *      set are-
 185  *
 186  *      %MCA_DMA_MODE_READ when reading from the DMA device.
 187  *
 188  *      %MCA_DMA_MODE_WRITE to writing to the DMA device.
 189  *
 190  *      %MCA_DMA_MODE_IO to do DMA to or from an I/O port.
 191  *
 192  *      %MCA_DMA_MODE_16 to do 16bit transfers.
 193  */
 194
 195 static __inline__ void mca_set_dma_mode(unsigned int dmanr, unsigned int mode)
 196 {
 197         outb(MCA_DMA_FN_SET_MODE | dmanr, MCA_DMA_REG_FN);
 198         outb(mode, MCA_DMA_REG_EXE);
 199 }
 200
 201 #endif /* MCA_DMA_H */