release/src-rt-6.x.4708/linux/linux-2.6.36/arch/cris/arch-v10/kernel/dma.c

   1 /* Wrapper for DMA channel allocator that updates DMA client muxing.
   2  * Copyright 2004-2007, Axis Communications AB
   3  */
   4
   5 #include <linux/kernel.h>
   6 #include <linux/module.h>
   7 #include <linux/errno.h>
   8
   9 #include <asm/dma.h>
  10 #include <arch/svinto.h>
  11
  12 /* Macro to access ETRAX 100 registers */
  13 #define SETS(var, reg, field, val) var = (var & ~IO_MASK_(reg##_, field##_)) | \
  14                                           IO_STATE_(reg##_, field##_, _##val)
  15
  16
  17 static char used_dma_channels[MAX_DMA_CHANNELS];
  18 static const char * used_dma_channels_users[MAX_DMA_CHANNELS];
  19
  20 int cris_request_dma(unsigned int dmanr, const char * device_id,
  21                      unsigned options, enum dma_owner owner)
  22 {
  23         unsigned long flags;
  24         unsigned long int gens;
  25         int fail = -EINVAL;
  26
  27         if (dmanr >= MAX_DMA_CHANNELS) {
  28                 printk(KERN_CRIT "cris_request_dma: invalid DMA channel %u\n", dmanr);
  29                 return -EINVAL;
  30         }
  31
  32         local_irq_save(flags);
  33         if (used_dma_channels[dmanr]) {
  34                 local_irq_restore(flags);
  35                 if (options & DMA_VERBOSE_ON_ERROR) {
  36                         printk(KERN_CRIT "Failed to request DMA %i for %s, already allocated by %s\n", dmanr, device_id, used_dma_channels_users[dmanr]);
  37                 }
  38                 if (options & DMA_PANIC_ON_ERROR) {
  39                         panic("request_dma error!");
  40                 }
  41                 return -EBUSY;
  42         }
  43
  44         gens = genconfig_shadow;
  45
  46         switch(owner)
  47         {
  48         case dma_eth:
  49                 if ((dmanr != NETWORK_TX_DMA_NBR) &&
  50                     (dmanr != NETWORK_RX_DMA_NBR)) {
  51                         printk(KERN_CRIT "Invalid DMA channel for eth\n");
  52                         goto bail;
  53                 }
  54                 break;
  55         case dma_ser0:
  56                 if (dmanr == SER0_TX_DMA_NBR) {
  57                         SETS(gens, R_GEN_CONFIG, dma6, serial0);
  58                 } else if (dmanr == SER0_RX_DMA_NBR) {
  59                         SETS(gens, R_GEN_CONFIG, dma7, serial0);
  60                 } else {
  61                         printk(KERN_CRIT "Invalid DMA channel for ser0\n");
  62                         goto bail;
  63                 }
  64                 break;
  65         case dma_ser1:
  66                 if (dmanr == SER1_TX_DMA_NBR) {
  67                         SETS(gens, R_GEN_CONFIG, dma8, serial1);
  68                 } else if (dmanr == SER1_RX_DMA_NBR) {
  69                         SETS(gens, R_GEN_CONFIG, dma9, serial1);
  70                 } else {
  71                         printk(KERN_CRIT "Invalid DMA channel for ser1\n");
  72                         goto bail;
  73                 }
  74                 break;
  75         case dma_ser2:
  76                 if (dmanr == SER2_TX_DMA_NBR) {
  77                         SETS(gens, R_GEN_CONFIG, dma2, serial2);
  78                 } else if (dmanr == SER2_RX_DMA_NBR) {
  79                         SETS(gens, R_GEN_CONFIG, dma3, serial2);
  80                 } else {
  81                         printk(KERN_CRIT "Invalid DMA channel for ser2\n");
  82                         goto bail;
  83                 }
  84                 break;
  85         case dma_ser3:
  86                 if (dmanr == SER3_TX_DMA_NBR) {
  87                         SETS(gens, R_GEN_CONFIG, dma4, serial3);
  88                 } else if (dmanr == SER3_RX_DMA_NBR) {
  89                         SETS(gens, R_GEN_CONFIG, dma5, serial3);
  90                 } else {
  91                         printk(KERN_CRIT "Invalid DMA channel for ser3\n");
  92                         goto bail;
  93                 }
  94                 break;
  95         case dma_ata:
  96                 if (dmanr == ATA_TX_DMA_NBR) {
  97                         SETS(gens, R_GEN_CONFIG, dma2, ata);
  98                 } else if (dmanr == ATA_RX_DMA_NBR) {
  99                         SETS(gens, R_GEN_CONFIG, dma3, ata);
 100                 } else {
 101                         printk(KERN_CRIT "Invalid DMA channel for ata\n");
 102                         goto bail;
 103                 }
 104                 break;
 105         case dma_ext0:
 106                 if (dmanr == EXTDMA0_TX_DMA_NBR) {
 107                         SETS(gens, R_GEN_CONFIG, dma4, extdma0);
 108                 } else if (dmanr == EXTDMA0_RX_DMA_NBR) {
 109                         SETS(gens, R_GEN_CONFIG, dma5, extdma0);
 110                 } else {
 111                         printk(KERN_CRIT "Invalid DMA channel for ext0\n");
 112                         goto bail;
 113                 }
 114                 break;
 115         case dma_ext1:
 116                 if (dmanr == EXTDMA1_TX_DMA_NBR) {
 117                         SETS(gens, R_GEN_CONFIG, dma6, extdma1);
 118                 } else if (dmanr == EXTDMA1_RX_DMA_NBR) {
 119                         SETS(gens, R_GEN_CONFIG, dma7, extdma1);
 120                 } else {
 121                         printk(KERN_CRIT "Invalid DMA channel for ext1\n");
 122                         goto bail;
 123                 }
 124                 break;
 125         case dma_int6:
 126                 if (dmanr == MEM2MEM_RX_DMA_NBR) {
 127                         SETS(gens, R_GEN_CONFIG, dma7, intdma6);
 128                 } else {
 129                         printk(KERN_CRIT "Invalid DMA channel for int6\n");
 130                         goto bail;
 131                 }
 132                 break;
 133         case dma_int7:
 134                 if (dmanr == MEM2MEM_TX_DMA_NBR) {
 135                         SETS(gens, R_GEN_CONFIG, dma6, intdma7);
 136                 } else {
 137                         printk(KERN_CRIT "Invalid DMA channel for int7\n");
 138                         goto bail;
 139                 }
 140                 break;
 141         case dma_usb:
 142                 if (dmanr == USB_TX_DMA_NBR) {
 143                         SETS(gens, R_GEN_CONFIG, dma8, usb);
 144                 } else if (dmanr == USB_RX_DMA_NBR) {
 145                         SETS(gens, R_GEN_CONFIG, dma9, usb);
 146                 } else {
 147                         printk(KERN_CRIT "Invalid DMA channel for usb\n");
 148                         goto bail;
 149                 }
 150                 break;
 151         case dma_scsi0:
 152                 if (dmanr == SCSI0_TX_DMA_NBR) {
 153                         SETS(gens, R_GEN_CONFIG, dma2, scsi0);
 154                 } else if (dmanr == SCSI0_RX_DMA_NBR) {
 155                         SETS(gens, R_GEN_CONFIG, dma3, scsi0);
 156                 } else {
 157                         printk(KERN_CRIT "Invalid DMA channel for scsi0\n");
 158                         goto bail;
 159                 }
 160                 break;
 161         case dma_scsi1:
 162                 if (dmanr == SCSI1_TX_DMA_NBR) {
 163                         SETS(gens, R_GEN_CONFIG, dma4, scsi1);
 164                 } else if (dmanr == SCSI1_RX_DMA_NBR) {
 165                         SETS(gens, R_GEN_CONFIG, dma5, scsi1);
 166                 } else {
 167                         printk(KERN_CRIT "Invalid DMA channel for scsi1\n");
 168                         goto bail;
 169                 }
 170                 break;
 171         case dma_par0:
 172                 if (dmanr == PAR0_TX_DMA_NBR) {
 173                         SETS(gens, R_GEN_CONFIG, dma2, par0);
 174                 } else if (dmanr == PAR0_RX_DMA_NBR) {
 175                         SETS(gens, R_GEN_CONFIG, dma3, par0);
 176                 } else {
 177                         printk(KERN_CRIT "Invalid DMA channel for par0\n");
 178                         goto bail;
 179                 }
 180                 break;
 181         case dma_par1:
 182                 if (dmanr == PAR1_TX_DMA_NBR) {
 183                         SETS(gens, R_GEN_CONFIG, dma4, par1);
 184                 } else if (dmanr == PAR1_RX_DMA_NBR) {
 185                         SETS(gens, R_GEN_CONFIG, dma5, par1);
 186                 } else {
 187                         printk(KERN_CRIT "Invalid DMA channel for par1\n");
 188                         goto bail;
 189                 }
 190                 break;
 191         default:
 192                 printk(KERN_CRIT "Invalid DMA owner.\n");
 193                 goto bail;
 194         }
 195
 196         used_dma_channels[dmanr] = 1;
 197         used_dma_channels_users[dmanr] = device_id;
 198
 199         {
 200                 volatile int i;
 201                 genconfig_shadow = gens;
 202                 *R_GEN_CONFIG = genconfig_shadow;
 203                 /* Wait 12 cycles before doing any DMA command */
 204                 for(i = 6; i > 0; i--)
 205                         nop();
 206         }
 207         fail = 0;
 208  bail:
 209         local_irq_restore(flags);
 210         return fail;
 211 }
 212
 213 void cris_free_dma(unsigned int dmanr, const char * device_id)
 214 {
 215         unsigned long flags;
 216         if (dmanr >= MAX_DMA_CHANNELS) {
 217                 printk(KERN_CRIT "cris_free_dma: invalid DMA channel %u\n", dmanr);
 218                 return;
 219         }
 220
 221         local_irq_save(flags);
 222         if (!used_dma_channels[dmanr]) {
 223                 printk(KERN_CRIT "cris_free_dma: DMA channel %u not allocated\n", dmanr);
 224         } else if (device_id != used_dma_channels_users[dmanr]) {
 225                 printk(KERN_CRIT "cris_free_dma: DMA channel %u not allocated by device\n", dmanr);
 226         } else {
 227                 switch(dmanr)
 228                 {
 229                 case 0:
 230                         *R_DMA_CH0_CMD = IO_STATE(R_DMA_CH0_CMD, cmd, reset);
 231                         while (IO_EXTRACT(R_DMA_CH0_CMD, cmd, *R_DMA_CH0_CMD) ==
 232                                IO_STATE_VALUE(R_DMA_CH0_CMD, cmd, reset));
 233                         break;
 234                 case 1:
 235                         *R_DMA_CH1_CMD = IO_STATE(R_DMA_CH1_CMD, cmd, reset);
 236                         while (IO_EXTRACT(R_DMA_CH1_CMD, cmd, *R_DMA_CH1_CMD) ==
 237                                IO_STATE_VALUE(R_DMA_CH1_CMD, cmd, reset));
 238                         break;
 239                 case 2:
 240                         *R_DMA_CH2_CMD = IO_STATE(R_DMA_CH2_CMD, cmd, reset);
 241                         while (IO_EXTRACT(R_DMA_CH2_CMD, cmd, *R_DMA_CH2_CMD) ==
 242                                IO_STATE_VALUE(R_DMA_CH2_CMD, cmd, reset));
 243                         break;
 244                 case 3:
 245                         *R_DMA_CH3_CMD = IO_STATE(R_DMA_CH3_CMD, cmd, reset);
 246                         while (IO_EXTRACT(R_DMA_CH3_CMD, cmd, *R_DMA_CH3_CMD) ==
 247                                IO_STATE_VALUE(R_DMA_CH3_CMD, cmd, reset));
 248                         break;
 249                 case 4:
 250                         *R_DMA_CH4_CMD = IO_STATE(R_DMA_CH4_CMD, cmd, reset);
 251                         while (IO_EXTRACT(R_DMA_CH4_CMD, cmd, *R_DMA_CH4_CMD) ==
 252                                IO_STATE_VALUE(R_DMA_CH4_CMD, cmd, reset));
 253                         break;
 254                 case 5:
 255                         *R_DMA_CH5_CMD = IO_STATE(R_DMA_CH5_CMD, cmd, reset);
 256                         while (IO_EXTRACT(R_DMA_CH5_CMD, cmd, *R_DMA_CH5_CMD) ==
 257                                IO_STATE_VALUE(R_DMA_CH5_CMD, cmd, reset));
 258                         break;
 259                 case 6:
 260                         *R_DMA_CH6_CMD = IO_STATE(R_DMA_CH6_CMD, cmd, reset);
 261                         while (IO_EXTRACT(R_DMA_CH6_CMD, cmd, *R_DMA_CH6_CMD) ==
 262                                IO_STATE_VALUE(R_DMA_CH6_CMD, cmd, reset));
 263                         break;
 264                 case 7:
 265                         *R_DMA_CH7_CMD = IO_STATE(R_DMA_CH7_CMD, cmd, reset);
 266                         while (IO_EXTRACT(R_DMA_CH7_CMD, cmd, *R_DMA_CH7_CMD) ==
 267                                IO_STATE_VALUE(R_DMA_CH7_CMD, cmd, reset));
 268                         break;
 269                 case 8:
 270                         *R_DMA_CH8_CMD = IO_STATE(R_DMA_CH8_CMD, cmd, reset);
 271                         while (IO_EXTRACT(R_DMA_CH8_CMD, cmd, *R_DMA_CH8_CMD) ==
 272                                IO_STATE_VALUE(R_DMA_CH8_CMD, cmd, reset));
 273                         break;
 274                 case 9:
 275                         *R_DMA_CH9_CMD = IO_STATE(R_DMA_CH9_CMD, cmd, reset);
 276                         while (IO_EXTRACT(R_DMA_CH9_CMD, cmd, *R_DMA_CH9_CMD) ==
 277                                IO_STATE_VALUE(R_DMA_CH9_CMD, cmd, reset));
 278                         break;
 279                 }
 280                 used_dma_channels[dmanr] = 0;
 281         }
 282         local_irq_restore(flags);
 283 }
 284
 285 EXPORT_SYMBOL(cris_request_dma);
 286 EXPORT_SYMBOL(cris_free_dma);