rom/devs/sdcard/sdcard_ioops.c

   1 /*
   2     Copyright © 2013, The AROS Development Team. All rights reserved.
   3     $Id$
   4 */
   5
   6 #define DEBUG 0
   7 #include <aros/debug.h>
   8
   9 #include <exec/types.h>
  10 #include <exec/exec.h>
  11 #include <exec/resident.h>
  12 #include <utility/utility.h>
  13 #include <oop/oop.h>
  14
  15 #include <proto/exec.h>
  16 #include <devices/cd.h>
  17 #include <devices/timer.h>
  18
  19 #include <hardware/mmc.h>
  20 #include <hardware/sdhc.h>
  21
  22 #include "sdcard_base.h"
  23 #include "sdcard_unit.h"
  24
  25 static BOOL sdcard_WaitBusyTO(struct sdcard_Unit *unit, UWORD tout, BOOL irq, UBYTE *stout);
  26
  27 #define DEVHEAD_VAL 0x40
  28
  29 static void sdcard_strcpy(const UBYTE *str1, UBYTE *str2, ULONG size)
  30 {
  31     register int i = size;
  32
  33     while (size--)
  34         str2[size ^ 1] = str1[size];
  35
  36     while (i > 0 && str2[--i] <= ' ')
  37         str2[i] = '\0';
  38 }
  39
  40 /*
  41  * a STUB function for commands not supported by this particular device
  42  */
  43 static BYTE sdcard_STUB(struct sdcard_Unit *unit)
  44 {
  45     DERROR(bug("[SDCard%02ld] CALLED STUB FUNCTION (GENERIC). OPERATION IS NOT SUPPORTED BY DEVICE\n", unit->sdcu_UnitNum));
  46     return CDERR_NOCMD;
  47 }
  48
  49 static BYTE sdcard_STUB_IO32(struct sdcard_Unit *unit, ULONG blk, ULONG len,
  50     APTR buf, ULONG* act)
  51 {
  52     DERROR(bug("[SDCard%02ld] CALLED STUB FUNCTION (IO32). OPERATION IS NOT SUPPORTED BY DEVICE\n", unit->sdcu_UnitNum));
  53     DERROR(bug("[SDCard%02ld] -- IO ACCESS TO BLOCK %08lx, LENGTH %08lx\n", unit->sdcu_UnitNum, blk, len));
  54     return CDERR_NOCMD;
  55 }
  56
  57 static BYTE sdcard_STUB_IO64(struct sdcard_Unit *unit, UQUAD blk, ULONG len,
  58     APTR buf, ULONG* act)
  59 {
  60     DERROR(bug("[SDCard%02ld] CALLED STUB FUNCTION (IO64). OPERATION IS NOT SUPPORTED BY DEVICE\n", unit->sdcu_UnitNum));
  61     DERROR(bug("[SDCard%02ld] -- IO ACCESS TO BLOCK %08lx:%08lx, LENGTH %08lx\n", unit->sdcu_UnitNum, (blk >> 32), (blk & 0xffffffff), len));
  62     return CDERR_NOCMD;
  63 }
  64
  65 static BYTE sdcard_STUB_SCSI(struct sdcard_Unit *unit, struct SCSICmd* cmd)
  66 {
  67     DERROR(bug("[SDCard%02ld] CALLED STUB FUNCTION (IOSCSI). OPERATION IS NOT SUPPORTED BY DEVICE\n", unit->sdcu_UnitNum));
  68     return CDERR_NOCMD;
  69 }
  70
  71 static inline BOOL sdcard_SelectUnit(struct sdcard_Unit* unit)
  72 {
  73     return TRUE;
  74 }
  75
  76 void sdcard_IRQSetHandler(struct sdcard_Unit *unit, void (*handler)(struct sdcard_Unit*, UBYTE), APTR piomem, ULONG blklen, ULONG piolen)
  77 {
  78
  79 }
  80
  81 void sdcard_IRQNoData(struct sdcard_Unit *unit, UBYTE status)
  82 {
  83
  84 }
  85
  86 void sdcard_IRQPIORead(struct sdcard_Unit *unit, UBYTE status)
  87 {
  88
  89 }
  90
  91 void sdcard_PIOWriteBlk(struct sdcard_Unit *unit)
  92 {
  93
  94 }
  95
  96 void sdcard_IRQPIOWrite(struct sdcard_Unit *unit, UBYTE status)
  97 {
  98
  99 }
 100
 101 void sdcard_IRQDMAReadWrite(struct sdcard_Unit *unit, UBYTE status)
 102 {
 103
 104 }
 105
 106 /*
 107  * wait for timeout or drive ready
 108  */
 109 BOOL sdcard_WaitBusyTO(struct sdcard_Unit *unit, UWORD tout, BOOL irq, UBYTE *stout)
 110 {
 111     BYTE err = 0;
 112     return err;
 113 }
 114
 115 /*
 116  * 32bit Read operations
 117  */
 118 BYTE FNAME_SDCIO(ReadSector32)(struct sdcard_Unit *unit, ULONG block,
 119     ULONG count, APTR buffer, ULONG *act)
 120 {
 121     struct TagItem sdcReadTags[] =
 122     {
 123         {SDCARD_TAG_CMD,         MMC_CMD_READ_SINGLE_BLOCK},
 124         {SDCARD_TAG_ARG,         block},
 125         {SDCARD_TAG_RSPTYPE,     MMC_RSP_R1},
 126         {SDCARD_TAG_RSP,         0},
 127         {SDCARD_TAG_DATA,        (IPTR)buffer},
 128         {SDCARD_TAG_DATALEN,     count * (1 << unit->sdcu_Bus->sdcb_SectorShift)},
 129         {SDCARD_TAG_DATAFLAGS,   MMC_DATA_READ},
 130         {TAG_DONE,            0}
 131     };
 132     BYTE retVal = 0;
 133
 134     D(bug("[SDCard%02ld] %s()\n", unit->sdcu_UnitNum, __PRETTY_FUNCTION__));
 135
 136     *act = 0;
 137
 138     if (count > 1)
 139         sdcReadTags[0].ti_Data = MMC_CMD_READ_MULTIPLE_BLOCK;
 140
 141     if (!(unit->sdcu_Flags & AF_Card_HighCapacity))
 142         sdcReadTags[1].ti_Data <<= unit->sdcu_Bus->sdcb_SectorShift;
 143
 144     D(bug("[SDCard%02ld] %s: Sending CMD %d, block %08x, len %d [buffer @ 0x%p]\n", unit->sdcu_UnitNum, __PRETTY_FUNCTION__,
 145         sdcReadTags[0].ti_Data, sdcReadTags[1].ti_Data, sdcReadTags[5].ti_Data, sdcReadTags[4].ti_Data));
 146
 147     if (FNAME_SDCBUS(SendCmd)(sdcReadTags, unit->sdcu_Bus) != -1)
 148     {
 149         if (FNAME_SDCBUS(WaitCmd)(SDHCI_INT_DATA_AVAIL|SDHCI_INT_DATA_END, 1000, unit->sdcu_Bus) != -1)
 150         {
 151             if (count > 1)
 152             {
 153                 DTRANS(bug("[SDCard%02ld] %s: Finishing transaction ..\n", unit->sdcu_UnitNum, __PRETTY_FUNCTION__));
 154                 sdcReadTags[0].ti_Data = MMC_CMD_STOP_TRANSMISSION;
 155                 sdcReadTags[1].ti_Data = 0;
 156                 sdcReadTags[2].ti_Data = MMC_RSP_R1b;
 157                 sdcReadTags[4].ti_Tag = TAG_DONE;
 158                 if (FNAME_SDCBUS(SendCmd)(sdcReadTags, unit->sdcu_Bus) == -1)
 159                 {
 160                     bug("[SDCard%02ld] %s: Failed to terminate Read operation\n", unit->sdcu_UnitNum, __PRETTY_FUNCTION__);
 161                     count = 0;
 162                     retVal = IOERR_ABORTED;
 163                 }
 164             }
 165         }
 166         else
 167         {
 168             D(bug("[SDCard%02ld] %s: Transfer error\n", unit->sdcu_UnitNum, __PRETTY_FUNCTION__));
 169             count = 0;
 170             retVal = IOERR_ABORTED;
 171         }
 172     }
 173     else
 174     {
 175         bug("[SDCard%02ld] %s: Error ..\n", unit->sdcu_UnitNum, __PRETTY_FUNCTION__);
 176         count = 0;
 177         retVal = IOERR_ABORTED;
 178     }
 179
 180     *act = count << unit->sdcu_Bus->sdcb_SectorShift;
 181
 182     DTRANS(bug("[SDCard%02ld] %s: %d bytes Read\n", unit->sdcu_UnitNum, __PRETTY_FUNCTION__, *act));
 183
 184     return retVal;
 185 }
 186
 187 BYTE FNAME_SDCIO(ReadMultiple32)(struct sdcard_Unit *unit, ULONG block,
 188     ULONG count, APTR buffer, ULONG *act)
 189 {
 190
 191     D(bug("[SDCard%02ld] %s()\n", unit->sdcu_UnitNum, __PRETTY_FUNCTION__));
 192
 193     return IOERR_NOCMD;
 194 }
 195
 196 BYTE FNAME_SDCIO(ReadDMA32)(struct sdcard_Unit *unit, ULONG block,
 197     ULONG count, APTR buffer, ULONG *act)
 198 {
 199     D(bug("[SDCard%02ld] %s()\n", unit->sdcu_UnitNum, __PRETTY_FUNCTION__));
 200
 201     return IOERR_NOCMD;
 202 }
 203
 204 /*
 205  * 64bit Read operations
 206  */
 207 BYTE FNAME_SDCIO(ReadSector64)(struct sdcard_Unit *unit, UQUAD block,
 208     ULONG count, APTR buffer, ULONG *act)
 209 {
 210     D(bug("[SDCard%02ld] %s()\n", unit->sdcu_UnitNum, __PRETTY_FUNCTION__));
 211
 212     return IOERR_NOCMD;
 213 }
 214
 215 BYTE FNAME_SDCIO(ReadMultiple64)(struct sdcard_Unit *unit, UQUAD block,
 216     ULONG count, APTR buffer, ULONG *act)
 217 {
 218     D(bug("[SDCard%02ld] %s()\n", unit->sdcu_UnitNum, __PRETTY_FUNCTION__));
 219
 220     return IOERR_NOCMD;
 221 }
 222
 223 BYTE FNAME_SDCIO(ReadDMA64)(struct sdcard_Unit *unit, UQUAD block,
 224     ULONG count, APTR buffer, ULONG *act)
 225 {
 226     D(bug("[SDCard%02ld] %s()\n", unit->sdcu_UnitNum, __PRETTY_FUNCTION__));
 227
 228     return IOERR_NOCMD;
 229 }
 230
 231 /*
 232  * 32bit Write operations
 233  */
 234 BYTE FNAME_SDCIO(WriteSector32)(struct sdcard_Unit *unit, ULONG block,
 235     ULONG count, APTR buffer, ULONG *act)
 236 {
 237     D(bug("[SDCard%02ld] %s()\n", unit->sdcu_UnitNum, __PRETTY_FUNCTION__));
 238
 239     return IOERR_NOCMD;
 240 }
 241
 242 BYTE FNAME_SDCIO(WriteMultiple32)(struct sdcard_Unit *unit, ULONG block,
 243     ULONG count, APTR buffer, ULONG *act)
 244 {
 245     D(bug("[SDCard%02ld] %s()\n", unit->sdcu_UnitNum, __PRETTY_FUNCTION__));
 246
 247     return IOERR_NOCMD;
 248 }
 249
 250 BYTE FNAME_SDCIO(WriteDMA32)(struct sdcard_Unit *unit, ULONG block,
 251     ULONG count, APTR buffer, ULONG *act)
 252 {
 253     D(bug("[SDCard%02ld] %s()\n", unit->sdcu_UnitNum, __PRETTY_FUNCTION__));
 254
 255     return IOERR_NOCMD;
 256 }
 257
 258 /*
 259  * 64bit Write operations
 260  */
 261 BYTE FNAME_SDCIO(WriteSector64)(struct sdcard_Unit *unit, UQUAD block,
 262     ULONG count, APTR buffer, ULONG *act)
 263 {
 264     D(bug("[SDCard%02ld] %s()\n", unit->sdcu_UnitNum, __PRETTY_FUNCTION__));
 265
 266     return IOERR_NOCMD;
 267 }
 268
 269 BYTE FNAME_SDCIO(WriteMultiple64)(struct sdcard_Unit *unit, UQUAD block,
 270     ULONG count, APTR buffer, ULONG *act)
 271 {
 272     D(bug("[SDCard%02ld] %s()\n", unit->sdcu_UnitNum, __PRETTY_FUNCTION__));
 273
 274     return IOERR_NOCMD;
 275 }
 276
 277 BYTE FNAME_SDCIO(WriteDMA64)(struct sdcard_Unit *unit, UQUAD block,
 278     ULONG count, APTR buffer, ULONG *act)
 279 {
 280     D(bug("[SDCard%02ld] %s()\n", unit->sdcu_UnitNum, __PRETTY_FUNCTION__));
 281
 282     return IOERR_NOCMD;
 283 }
 284
 285 /*
 286  * miscellaneous
 287  */
 288 BYTE FNAME_SDCIO(Eject)(struct sdcard_Unit *unit)
 289 {
 290     D(bug("[SDCard%02ld] %s()\n", unit->sdcu_UnitNum, __PRETTY_FUNCTION__));
 291
 292     return IOERR_NOCMD;
 293 }