rom/devs/ata/dma_generic.c

   1 /*
   2     Copyright © 2004-2012, The AROS Development Team. All rights reserved
   3     $Id$
   4
   5     Desc:
   6     Lang: English
   7 */
   8
   9 #include <aros/debug.h>
  10
  11 #include <exec/types.h>
  12 #include <exec/exec.h>
  13 #include <exec/resident.h>
  14 #include <utility/utility.h>
  15 #include <dos/bptr.h>
  16
  17 #include <proto/exec.h>
  18
  19 #include "ata.h"
  20
  21 /*
  22     Prepare PRD entries for sectors transfer. This function assumes that no one
  23     else will even touch PRD. It should be however truth, as for given bus all
  24     ATA accesses are protected with a semaphore.
  25 */
  26 LONG dma_Setup(APTR addr, ULONG len, BOOL read, struct PRDEntry* array)
  27 {
  28     ULONG tmp = 0, rem = 0;
  29     ULONG flg = read ? DMA_ReadFromRAM : 0;
  30     IPTR phy_mem;
  31     LONG items = 0;
  32
  33     D(bug("[ATA  ] dma_Setup(addr %p, len %d, PRDEntry  @ %p for %s)\n", addr, len, array, read ? "READ" : "WRITE"));
  34
  35     /*
  36      * in future you may have to put this in prd construction procedure
  37      */
  38     while (0 < len)
  39     {
  40         tmp = len;
  41         phy_mem = (IPTR)CachePreDMA(addr, &tmp, flg);
  42
  43         D(bug("[ATA  ] dma_Setup: Translating V:%p > P:%p (%ld bytes)\n", addr, phy_mem, tmp));
  44         /*
  45          * update all addresses for the next call
  46          */
  47         addr = &((UBYTE*)addr)[tmp];
  48         len -= tmp;
  49         flg |= DMA_Continue;
  50
  51         /*
  52          * check if we're crossing the magic 64k boundary:
  53          */
  54         while (0 < tmp)
  55         {
  56             /*
  57              * politely say what sucks
  58              */
  59             if (phy_mem > 0xffffffffull)
  60             {
  61                 bug("[ATA  ] dma_Setup: ERROR: ATA DMA POINTERS BEYOND MAXIMUM ALLOWED ADDRESS!\n");
  62                 return 0;
  63             }
  64             if (items > PRD_MAX)
  65             {
  66                 bug("[ATA  ] dma_Setup: ERROR: ATA DMA PRD TABLE SIZE TOO LARGE\n");
  67                 return 0;
  68             }
  69
  70             /*
  71              * calculate remainder and see if it is larger of the current memory block.
  72              * if smaller, adjust its size.
  73              */
  74             rem = 0x10000 - (phy_mem & 0xffff);
  75             if (rem > tmp)
  76                 rem = tmp;
  77             /*
  78              * update PRD with address and remainder
  79              */
  80             D(bug("[ATA  ] dma_Setup: Inserting into PRD Table: %p / %ld @ %p\n", phy_mem, rem, array));
  81             array->prde_Address = AROS_LONG2LE(phy_mem);
  82             array->prde_Length  = AROS_LONG2LE((rem & 0xffff));
  83             ++array;
  84             ++items;
  85
  86             /*
  87              * update locals ;-)
  88              */
  89             phy_mem += rem;
  90             tmp -= rem;
  91         }
  92     }
  93
  94     if (items > 0)
  95     {
  96         --array;
  97         array->prde_Length |= AROS_LONG2LE(PRDE_EOT);
  98     }
  99     D(bug("[ATA  ] dma_Setup: PRD Table set - %ld items in total.\n", items));
 100
 101     /*
 102      * PRD table all set.
 103      */
 104     return items;
 105 }
 106
 107
 108 BOOL dma_SetupPRD(struct ata_Unit *unit, APTR buffer, ULONG sectors, BOOL io)
 109 {
 110    return dma_SetupPRDSize(unit, buffer, sectors << unit->au_SectorShift, io);
 111 }
 112
 113 BOOL dma_SetupPRDSize(struct ata_Unit *unit, APTR buffer, ULONG size, BOOL read)
 114 {
 115     LONG items = 0;
 116     IPTR prd_phys;
 117     ULONG length;
 118
 119     D(bug("[ATA%02ld] dma_SetupPRDSize(buffer @ %p, %ld bytes, PRD @ %x for %s)\n", unit->au_UnitNum, buffer, size, unit->au_Bus->ab_PRD, read ? "READ" : "WRITE"));
 120
 121     items = dma_Setup(buffer, size, read, unit->au_Bus->ab_PRD);
 122
 123     if (0 == items)
 124         return FALSE;
 125
 126     length = items * sizeof(struct PRDEntry);
 127
 128     prd_phys = (IPTR)CachePreDMA(unit->au_Bus->ab_PRD, &length, DMA_ReadFromRAM);
 129
 130     ATA_OUTL(prd_phys, dma_PRD, unit->au_DMAPort);
 131
 132     if (read)
 133         ATA_OUT(DMA_WRITE, dma_Command, unit->au_DMAPort); /* inverse logic */
 134     else
 135         ATA_OUT(DMA_READ, dma_Command, unit->au_DMAPort);
 136     return TRUE;
 137 }
 138
 139 VOID dma_Cleanup(APTR addr, ULONG len, BOOL read)
 140 {
 141     ULONG tmp = 0;
 142     ULONG flg = read ? DMA_ReadFromRAM : 0;
 143
 144     D(bug("[ATA  ] dma_Cleanup(%p, %d bytes)\n", addr, len));
 145
 146     while (len > 0)
 147     {
 148         tmp = len;
 149         CachePostDMA(addr, &tmp, flg);
 150         addr = &((UBYTE*)addr)[tmp];
 151         len -= tmp;
 152         flg |= DMA_Continue;
 153     }
 154 }
 155
 156 VOID dma_StartDMA(struct ata_Unit *unit)
 157 {
 158     D(bug("[ATA%02ld] dma_StartDMA()\n", unit->au_UnitNum));
 159     ATA_OUT(ATA_IN(dma_Command, unit->au_DMAPort) | DMA_START, dma_Command, unit->au_DMAPort);
 160 }
 161
 162 VOID dma_StopDMA(struct ata_Unit *unit)
 163 {
 164     D(bug("[ATA%02ld] dma_StopDMA()\n", unit->au_UnitNum));
 165     ATA_OUT(ATA_IN(dma_Command, unit->au_DMAPort) & ~DMA_START, dma_Command, unit->au_DMAPort);
 166 }
 167