arch/arm-raspi/devs/sdcard/sdcard_ioops.c

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