?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
oops .. forgot to offset from objects bounds
[AROS.git] / rom / devs / sdcard / sdcard_bus.c
blobeff0dd831f412d9282b0843d07fc21b29a847820
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 <aros/bootloader.h>
10 #include <aros/symbolsets.h>
11 #include <exec/exec.h>
12 #include <exec/resident.h>
13 #include <exec/tasks.h>
14 #include <exec/memory.h>
15 #include <exec/nodes.h>
16 #include <utility/utility.h>
17 #include <libraries/expansion.h>
18 #include <libraries/configvars.h>
19 #include <dos/bptr.h>
20 #include <dos/dosextens.h>
21 #include <dos/filehandler.h>
22
23 #include <proto/exec.h>
24 #include <proto/timer.h>
25 #include <proto/bootloader.h>
26 #include <proto/expansion.h>
27 #include <proto/utility.h>
28 #include <proto/kernel.h>
29
30 #include <asm/bcm2835.h>
31 #include <hardware/mmc.h>
32 #include <hardware/sdhc.h>
33
34 #include <string.h>
35
36 #include "sdcard_base.h"
37 #include "sdcard_bus.h"
38 #include "sdcard_unit.h"
39 #include "timer.h"
40
41 #include LC_LIBDEFS_FILE
42
43 /* Generic "Bus Unit" Functions */
44
45 BOOL FNAME_SDCBUS(StartUnit)(struct sdcard_Unit *sdcUnit)
46 {
47 struct TagItem sdcStartTags[] =
48 {
49 {SDCARD_TAG_CMD, MMC_CMD_SELECT_CARD},
50 {SDCARD_TAG_ARG, sdcUnit->sdcu_CardRCA << 16},
51 {SDCARD_TAG_RSPTYPE, MMC_RSP_R1},
52 {SDCARD_TAG_RSP, 0},
53 {TAG_DONE, 0}
54 };
55
56 DFUNCS(bug("[SDCard%02ld] %s()\n", sdcUnit->sdcu_UnitNum, __PRETTY_FUNCTION__));
57
58 if (sdcUnit->sdcu_Flags & AF_Card_MMC)
59 {
60 FNAME_SDCUNIT(MMCChangeFrequency)(sdcUnit);
61 }
62 else
63 {
64 FNAME_SDCUNIT(SDSCChangeFrequency)(sdcUnit);
65 }
66
67 sdcard_Udelay(1000);
68
69 if ((FNAME_SDCBUS(SendCmd)(sdcStartTags, sdcUnit->sdcu_Bus) != -1) && (FNAME_SDCBUS(WaitCmd)(SDHCI_PS_CMD_INHIBIT, 1000, sdcUnit->sdcu_Bus) != -1))
70 {
71 if (FNAME_SDCUNIT(WaitStatus)(10000, sdcUnit) == -1)
72 {
73 D(bug("[SDCard%02ld] %s: Failed to Wait for Cards status\n", sdcUnit->sdcu_UnitNum, __PRETTY_FUNCTION__));
74 }
75
76 D(bug("[SDCard%02ld] %s: Selected card with RCA %d [select response %08x]\n", sdcUnit->sdcu_UnitNum, __PRETTY_FUNCTION__, sdcUnit->sdcu_CardRCA, sdcStartTags[3].ti_Data));
77 D(bug("[SDCard%02ld] %s: Card is now operating in Transfer Mode\n", sdcUnit->sdcu_UnitNum, __PRETTY_FUNCTION__));
78
79 if (!(sdcUnit->sdcu_Flags & AF_Card_HighCapacity))
80 {
81 sdcStartTags[0].ti_Data = MMC_CMD_SET_BLOCKLEN;
82 sdcStartTags[1].ti_Data = 1 << sdcUnit->sdcu_Bus->sdcb_SectorShift;
83 sdcStartTags[2].ti_Data = MMC_RSP_R1;
84 sdcStartTags[3].ti_Data = 0;
85 if ((FNAME_SDCBUS(SendCmd)(sdcStartTags, sdcUnit->sdcu_Bus) != -1) && (FNAME_SDCBUS(WaitCmd)(SDHCI_PS_CMD_INHIBIT, 1000, sdcUnit->sdcu_Bus) != -1))
86 {
87 D(bug("[SDCard%02ld] %s: Blocklen set to %d\n", sdcUnit->sdcu_UnitNum, __PRETTY_FUNCTION__, sdcStartTags[1].ti_Data));
88 }
89 else
90 {
91 D(bug("[SDCard%02ld] %s: Failed to change Blocklen\n", sdcUnit->sdcu_UnitNum, __PRETTY_FUNCTION__));
92 }
93 }
94
95 if (sdcUnit->sdcu_Flags & AF_Card_MMC)
96 {
97 if (sdcUnit->sdcu_Flags & AF_Card_HighSpeed)
98 {
99 if (sdcUnit->sdcu_Flags & AB_Card_HighSpeed52)
100 FNAME_SDCBUS(SetClock)(52000000, sdcUnit->sdcu_Bus);
101 else
102 FNAME_SDCBUS(SetClock)(26000000, sdcUnit->sdcu_Bus);
103 }
104 else
105 FNAME_SDCBUS(SetClock)(20000000, sdcUnit->sdcu_Bus);
106 }
107 else
108 {
109 if (sdcUnit->sdcu_Flags & AF_Card_HighSpeed)
110 FNAME_SDCBUS(SetClock)(50000000, sdcUnit->sdcu_Bus);
111 else
112 FNAME_SDCBUS(SetClock)(25000000, sdcUnit->sdcu_Bus);
113 }
114 }
115
116 D(bug("[SDCard%02ld] %s: Done.\n", sdcUnit->sdcu_UnitNum, __PRETTY_FUNCTION__));
117
118 return TRUE;
119 }
120
121 ULONG FNAME_SDCUNIT(WaitStatus)(ULONG timeout, struct sdcard_Unit *sdcUnit)
122 {
123 struct TagItem sdcStatusTags[] =
124 {
125 {SDCARD_TAG_CMD, MMC_CMD_SEND_STATUS},
126 {SDCARD_TAG_ARG, sdcUnit->sdcu_CardRCA << 16},
127 {SDCARD_TAG_RSPTYPE, MMC_RSP_R1},
128 {SDCARD_TAG_RSP, 0},
129 {TAG_DONE, 0}
130 };
131
132 UBYTE retryreq = 5;
133
134 DFUNCS(bug("[SDCard%02ld] %s()\n", sdcUnit->sdcu_UnitNum, __PRETTY_FUNCTION__));
135
136 do {
137 if (FNAME_SDCBUS(SendCmd)(sdcStatusTags, sdcUnit->sdcu_Bus) != -1)
138 {
139 if ((sdcStatusTags[3].ti_Data & MMC_STATUS_RDY_FOR_DATA) &&
140 (sdcStatusTags[3].ti_Data & MMC_STATUS_STATE_MASK) != MMC_STATUS_STATE_PRG)
141 break;
142 else if (sdcStatusTags[3].ti_Data & MMC_STATUS_MASK) {
143 bug("[SDCard%02ld] %s: Status [Error = %08x]\n", sdcUnit->sdcu_UnitNum, __PRETTY_FUNCTION__, sdcStatusTags[3].ti_Data);
144 return -1;
145 }
146 } else if (--retryreq < 0)
147 return -1;
148
149 sdcard_Udelay(1000);
150 } while (--timeout > 0);
151
152 if (timeout <= 0) {
153 bug("[SDCard%02ld] %s: Timeout\n", sdcUnit->sdcu_UnitNum, __PRETTY_FUNCTION__);
154 return -1;
155 }
156
157 D(bug("[SDCard%02ld] %s: State = %08x\n", sdcUnit->sdcu_UnitNum, __PRETTY_FUNCTION__, sdcStatusTags[3].ti_Data & MMC_STATUS_STATE_MASK));
158
159 return 0;
160 }
161
162 /* Bus Functions */
163
164 BOOL FNAME_SDCBUS(RegisterUnit)(struct sdcard_Bus *bus)
165 {
166 unsigned int sdcCardPower, timeout = 1000;
167 LIBBASETYPEPTR LIBBASE = bus->sdcb_DeviceBase;
168 ULONG sdcRsp136[4] = {0, 0, 0, 0};
169 struct sdcard_Unit *sdcUnit = NULL;
170 struct DeviceNode *devnode;
171 struct TagItem sdcRegTags[] =
172 {
173 {SDCARD_TAG_CMD, 0},
174 {SDCARD_TAG_ARG, 0},
175 {SDCARD_TAG_RSPTYPE, 0},
176 {SDCARD_TAG_RSP, 0},
177 {TAG_DONE, 0}
178 };
179 BOOL sdcHighCap = FALSE;
180 IPTR pp[24];
181
182 DFUNCS(bug("[SDBus%02u] %s()\n", bus->sdcb_BusNum, __PRETTY_FUNCTION__));
183
184 D(bug("[SDBus%02u] %s: Putting card into Idle state ...\n", bus->sdcb_BusNum, __PRETTY_FUNCTION__));
185 sdcRegTags[0].ti_Data = MMC_CMD_GO_IDLE_STATE;
186 sdcRegTags[1].ti_Data = 0;
187 sdcRegTags[2].ti_Data = MMC_RSP_NONE;
188 if (FNAME_SDCBUS(SendCmd)(sdcRegTags, bus) == -1)
189 {
190 D(bug("[SDBus%02u] %s: Error: Card failed to go idle!\n", bus->sdcb_BusNum, __PRETTY_FUNCTION__));
191 return FALSE;
192 }
193
194 sdcard_Udelay(2000);
195
196 sdcRegTags[0].ti_Data = SD_CMD_SEND_IF_COND;
197 sdcRegTags[1].ti_Data = ((bus->sdcb_Power & 0xFF8000) != 0) << 8 | 0xAA;
198 sdcRegTags[2].ti_Data = MMC_RSP_R7;
199 D(bug("[SDBus%02u] %s: Querying Interface conditions [%08x] ...\n", bus->sdcb_BusNum, __PRETTY_FUNCTION__, sdcRegTags[1].ti_Data));
200
201 if ((FNAME_SDCBUS(SendCmd)(sdcRegTags, bus) != -1) && (FNAME_SDCBUS(WaitCmd)(SDHCI_PS_CMD_INHIBIT, 1000, bus) != -1))
202 {
203 D(bug("[SDBus%02u] %s: Query Response = %08x\n", bus->sdcb_BusNum, __PRETTY_FUNCTION__, sdcRegTags[3].ti_Data));
204 D(bug("[SDBus%02u] %s: SD2.0 Compliant Card .. publishing high-capacity support\n", bus->sdcb_BusNum, __PRETTY_FUNCTION__));
205 sdcHighCap = TRUE;
206 }
207 else
208 {
209 D(bug("[SDBus%02u] %s: SD1.0 Compliant Card\n", bus->sdcb_BusNum, __PRETTY_FUNCTION__));
210 }
211
212 do {
213 D(bug("[SDBus%02u] %s: Preparing for Card App Command ...\n", bus->sdcb_BusNum, __PRETTY_FUNCTION__));
214 sdcRegTags[0].ti_Data = MMC_CMD_APP_CMD;
215 sdcRegTags[1].ti_Data = 0;
216 sdcRegTags[2].ti_Data = MMC_RSP_R1;
217
218 if ((FNAME_SDCBUS(SendCmd)(sdcRegTags, bus) == -1) || (FNAME_SDCBUS(WaitCmd)(SDHCI_PS_CMD_INHIBIT, 1000, bus) == -1))
219 {
220 D(bug("[SDBus%02u] %s: App Command Failed\n", bus->sdcb_BusNum, __PRETTY_FUNCTION__));
221 return FALSE;
222 }
223 D(bug("[SDBus%02u] %s: App Command Response = %08x\n", bus->sdcb_BusNum, __PRETTY_FUNCTION__, sdcRegTags[3].ti_Data));
224
225 sdcRegTags[0].ti_Data = SD_CMD_APP_SEND_OP_COND;
226 sdcRegTags[1].ti_Data = (bus->sdcb_Power & 0xFF8000) | (sdcHighCap ? OCR_HCS : 0);
227 #warning "TODO: Publish support for OCR_S18R/OCR_XPC on capable Hosts"
228 sdcRegTags[2].ti_Data = MMC_RSP_R3;
229
230 D(bug("[SDBus%02u] %s: Querying Operating conditions [%08x] ...\n", bus->sdcb_BusNum, __PRETTY_FUNCTION__, sdcRegTags[1].ti_Data));
231 if ((FNAME_SDCBUS(SendCmd)(sdcRegTags, bus) != -1) && (FNAME_SDCBUS(WaitCmd)(SDHCI_PS_CMD_INHIBIT, 1000, bus) != -1))
232 {
233 D(bug("[SDBus%02u] %s: Query Response = %08x\n", bus->sdcb_BusNum, __PRETTY_FUNCTION__, sdcRegTags[3].ti_Data));
234 sdcard_Udelay(1000);
235 }
236 else
237 {
238 D(bug("[SDBus%02u] %s: Operating condition Query Failed\n", bus->sdcb_BusNum, __PRETTY_FUNCTION__));
239 return FALSE;
240 }
241 } while ((!(sdcRegTags[3].ti_Data & OCR_BUSY)) && (--timeout > 0));
242
243 sdcHighCap = FALSE;
244
245 if (timeout > 0)
246 {
247 D(bug("[SDBus%02u] %s: Card OCR = %08x\n", bus->sdcb_BusNum, __PRETTY_FUNCTION__, (sdcRegTags[3].ti_Data & 0xFFFF00)));
248
249 sdcCardPower = bus->sdcb_Power & (sdcRegTags[3].ti_Data & 0xFFFF00);
250
251 D(bug("[SDBus%02u] %s: Card is now operating in Identification Mode\n", bus->sdcb_BusNum, __PRETTY_FUNCTION__));
252
253 if (sdcRegTags[3].ti_Data & OCR_HCS)
254 {
255 D(bug("[SDBus%02u] %s: High Capacity Card detected\n", bus->sdcb_BusNum, __PRETTY_FUNCTION__));
256 sdcHighCap = TRUE;
257 }
258
259 if (sdcRegTags[3].ti_Data & OCR_S18R)
260 {
261 D(bug("[SDBus%02u] %s: Begin Voltage Switching..\n", bus->sdcb_BusNum, __PRETTY_FUNCTION__));
262 }
263
264 FNAME_SDCBUS(SetPowerLevel)(sdcCardPower, TRUE, bus);
265 sdcard_Udelay(2000);
266
267 /* Put the "card" into identify mode*/
268 D(bug("[SDBus%02u] %s: Querying Card Identification Data ...\n", bus->sdcb_BusNum, __PRETTY_FUNCTION__));
269 sdcRegTags[0].ti_Data = MMC_CMD_ALL_SEND_CID;
270 sdcRegTags[1].ti_Data = 0;
271 sdcRegTags[2].ti_Data = MMC_RSP_R2;
272 sdcRegTags[3].ti_Data = (IPTR)sdcRsp136;
273 if ((FNAME_SDCBUS(SendCmd)(sdcRegTags, bus) != -1) && (FNAME_SDCBUS(WaitCmd)(SDHCI_PS_CMD_INHIBIT, 1000, bus) != -1))
274 {
275 if (sdcRegTags[3].ti_Data)
276 {
277 D(bug("[SDBus%02u] %s: # Card Identification Data (CID) Register\n", bus->sdcb_BusNum, __PRETTY_FUNCTION__));
278 D(bug("[SDBus%02u] %s: # ======================================\n", bus->sdcb_BusNum, __PRETTY_FUNCTION__));
279 D(bug("[SDBus%02u] %s: # Manuafacturer ID (MID) : %06x\n", bus->sdcb_BusNum, __PRETTY_FUNCTION__, FNAME_SDCBUS(Rsp136Unpack)(sdcRsp136, 120, 8)));
280 D(bug("[SDBus%02u] %s: # Product Name (PNM) : %c%c%c%c%c\n", bus->sdcb_BusNum, __PRETTY_FUNCTION__, FNAME_SDCBUS(Rsp136Unpack)(sdcRsp136, 96, 8), FNAME_SDCBUS(Rsp136Unpack)(sdcRsp136, 88, 8), FNAME_SDCBUS(Rsp136Unpack)(sdcRsp136, 80, 8), FNAME_SDCBUS(Rsp136Unpack)(sdcRsp136, 72, 8), FNAME_SDCBUS(Rsp136Unpack)(sdcRsp136, 64, 8)));
281 D(bug("[SDBus%02u] %s: # Product Revision (PRV) : %d.%d\n", bus->sdcb_BusNum, __PRETTY_FUNCTION__, FNAME_SDCBUS(Rsp136Unpack)(sdcRsp136, 60, 4), FNAME_SDCBUS(Rsp136Unpack)(sdcRsp136, 56, 4)));
282 D(bug("[SDBus%02u] %s: # Serial number (PSN) : %08x\n", bus->sdcb_BusNum, __PRETTY_FUNCTION__, FNAME_SDCBUS(Rsp136Unpack)(sdcRsp136, 24, 32)));
283 D(bug("[SDBus%02u] %s: # Manufacturing Date Code (MDT) : %d/%d\n", bus->sdcb_BusNum, __PRETTY_FUNCTION__, FNAME_SDCBUS(Rsp136Unpack)(sdcRsp136, 8, 4), FNAME_SDCBUS(Rsp136Unpack)(sdcRsp136, 12, 8)));
284 D(bug("[SDBus%02u] %s: # CRC7 checksum (CRC7) : %x\n", bus->sdcb_BusNum, __PRETTY_FUNCTION__, FNAME_SDCBUS(Rsp136Unpack)(sdcRsp136, 1, 7)));
285 D(bug("[SDBus%02u] %s: # Reserved : %x\n", bus->sdcb_BusNum, __PRETTY_FUNCTION__, FNAME_SDCBUS(Rsp136Unpack)(sdcRsp136, 0, 1)));
286 }
287
288 D(bug("[SDBus%02u] %s: Querying Card Relative Address... \n", bus->sdcb_BusNum, __PRETTY_FUNCTION__));
289 sdcRegTags[0].ti_Data = SD_CMD_SEND_RELATIVE_ADDR;
290 sdcRegTags[1].ti_Data = 0;
291 sdcRegTags[2].ti_Data = MMC_RSP_R6;
292 sdcRegTags[3].ti_Data = 0;
293 if ((FNAME_SDCBUS(SendCmd)(sdcRegTags, bus) != -1) && (FNAME_SDCBUS(WaitCmd)(SDHCI_PS_CMD_INHIBIT, 1000, bus) != -1))
294 {
295 if ((sdcUnit = AllocVecPooled(LIBBASE->sdcard_MemPool, sizeof(struct sdcard_Unit))) != NULL)
296 {
297 sdcUnit->sdcu_Bus = bus;
298 if ((sdcUnit->sdcu_UnitNum = bus->sdcb_BusUnits->sdcbu_UnitCnt++) > bus->sdcb_BusUnits->sdcbu_UnitMax)
299 {
300 return FALSE;
301 }
302 (&bus->sdcb_BusUnits->sdcbu_Units)[sdcUnit->sdcu_UnitNum] = sdcUnit;
303 sdcUnit->sdcu_UnitNum += bus->sdcb_BusUnits->sdcbu_UnitBase;
304 sdcUnit->sdcu_CardRCA = (sdcRegTags[3].ti_Data >> 16) & 0xFFFF;
305 sdcUnit->sdcu_CardPower = sdcCardPower;
306
307 D(bug("[SDBus%02u] %s: Card RCA = %d\n", bus->sdcb_BusNum, __PRETTY_FUNCTION__, sdcUnit->sdcu_CardRCA));
308
309 sdcRegTags[0].ti_Data = MMC_CMD_SEND_CSD;
310 sdcRegTags[1].ti_Data = sdcUnit->sdcu_CardRCA << 16;
311 sdcRegTags[2].ti_Data = MMC_RSP_R2;
312 sdcRegTags[3].ti_Data = (IPTR)sdcRsp136;
313 D(bug("[SDBus%02u] %s: Querying Card Specific Data [%08x] ...\n", bus->sdcb_BusNum, __PRETTY_FUNCTION__, sdcRegTags[1].ti_Data));
314 if ((FNAME_SDCBUS(SendCmd)(sdcRegTags, bus) != -1) && (FNAME_SDCBUS(WaitCmd)(SDHCI_PS_CMD_INHIBIT, 1000, bus) != -1))
315 {
316 if (FNAME_SDCUNIT(WaitStatus)(10000, sdcUnit) == -1)
317 {
318 D(bug("[SDBus%02lu] %s: Failed to Wait for Cards status\n", bus->sdcb_BusNum, __PRETTY_FUNCTION__));
319 }
320
321 if (sdcRegTags[3].ti_Data)
322 {
323 int __csdstruct = FNAME_SDCBUS(Rsp136Unpack)(sdcRsp136, 126, 2);
324 D(bug("[SDBus%02u] %s: # Card Specific Data (CSD) Register\n", bus->sdcb_BusNum, __PRETTY_FUNCTION__));
325 D(bug("[SDBus%02u] %s: # =================================\n", bus->sdcb_BusNum, __PRETTY_FUNCTION__));
326 D(bug("[SDBus%02u] %s: # CSD_STRUCTURE : %x ", bus->sdcb_BusNum, __PRETTY_FUNCTION__, __csdstruct));
327
328 sdcUnit->sdcu_Read32 = FNAME_SDCIO(ReadSector32);
329 sdcUnit->sdcu_Write32 = FNAME_SDCIO(WriteSector32);
330 sdcUnit->sdcu_Bus->sdcb_BusFlags = AF_Bus_MediaPresent;
331 #if defined(SDHCI_READONLY)
332 sdcUnit->sdcu_Flags = AF_Card_WriteProtect;
333 #endif
334 if (sdcHighCap)
335 {
336 sdcUnit->sdcu_Flags |= AF_Card_HighCapacity;
337 sdcUnit->sdcu_Read64 = FNAME_SDCIO(ReadSector64);
338 sdcUnit->sdcu_Write64 = FNAME_SDCIO(WriteSector64);
339 }
340
341 switch (__csdstruct)
342 {
343 case 0:
344 {
345 D(bug("[SDSC Card]\n"));
346 pp[DE_SIZEBLOCK + 4] = 1 << FNAME_SDCBUS(Rsp136Unpack)(sdcRsp136, 80, 4);
347 pp[DE_SECSPERBLOCK + 4] = pp[DE_SIZEBLOCK + 4] >> 9;
348 pp[DE_HIGHCYL + 4] = ((1 + FNAME_SDCBUS(Rsp136Unpack)(sdcRsp136, 62, 12)) << (FNAME_SDCBUS(Rsp136Unpack)(sdcRsp136, 47, 3) + 2));
349 break;
350 }
351 case 1:
352 {
353 D(bug("[SDHC/XC Card]\n"));
354
355 pp[DE_SECSPERBLOCK + 4] = 2;
356 pp[DE_SIZEBLOCK + 4] = 2 << (10 - 1);
357 pp[DE_HIGHCYL + 4] = ((1 + FNAME_SDCBUS(Rsp136Unpack)(sdcRsp136, 48, 22)) * (2 << (9 - 1)));
358
359 sdcUnit->sdcu_Flags |= AF_Card_MMC;
360
361 break;
362 }
363 default:
364 D(bug("[SDBus%02u] %s: Unsupported Card\n", bus->sdcb_BusNum, __PRETTY_FUNCTION__));
365 return FALSE;
366 }
367
368 sdcUnit->sdcu_Cylinders = pp[DE_HIGHCYL + 4];
369 sdcUnit->sdcu_Heads = 1;
370 sdcUnit->sdcu_Sectors = pp[DE_SECSPERBLOCK + 4];
371 sdcUnit->sdcu_Capacity = sdcUnit->sdcu_Cylinders * sdcUnit->sdcu_Heads * sdcUnit->sdcu_Sectors;
372
373 sdcUnit->sdcu_Eject = FNAME_SDCIO(Eject);
374
375 D(bug("[SDBus%02u] %s: # READ_BL_LEN : %dbytes\n", bus->sdcb_BusNum, __PRETTY_FUNCTION__, pp[DE_SIZEBLOCK + 4] / sdcUnit->sdcu_Sectors));
376 D(bug("[SDBus%02u] %s: # C_SIZE : %d\n", bus->sdcb_BusNum, __PRETTY_FUNCTION__, sdcUnit->sdcu_Cylinders));
377
378 pp[0] = (IPTR)"MMC0";
379 pp[1] = (IPTR)MOD_NAME_STRING;
380 pp[2] = 0;
381 pp[DE_TABLESIZE + 4] = DE_BOOTBLOCKS;
382 pp[DE_NUMHEADS + 4] = sdcUnit->sdcu_Heads;
383 pp[DE_BLKSPERTRACK + 4] = 1;
384 pp[DE_RESERVEDBLKS + 4] = 2;
385 pp[DE_LOWCYL + 4] = 0;
386 pp[DE_NUMBUFFERS + 4] = 10;
387 pp[DE_BUFMEMTYPE + 4] = MEMF_PUBLIC | MEMF_31BIT;
388 pp[DE_MAXTRANSFER + 4] = 0x00200000;
389 pp[DE_MASK + 4] = 0x7FFFFFFE;
390 pp[DE_BOOTPRI + 4] = 0;
391 pp[DE_DOSTYPE + 4] = AROS_MAKE_ID('D','O','S','\001');
392 pp[DE_CONTROL + 4] = 0;
393 pp[DE_BOOTBLOCKS + 4] = 2;
394
395 devnode = MakeDosNode(pp);
396
397 if (devnode)
398 {
399 bug("[SDBus%02u] %b: [%ldMB Capacity]\n", bus->sdcb_BusNum, devnode->dn_Name, (ULONG)((sdcUnit->sdcu_Capacity >> 11) & 0xFFFFFFFFul));
400 D(bug("[SDBus%02u] %s: StartCyl:%d, EndCyl:%d ..\n", bus->sdcb_BusNum, __PRETTY_FUNCTION__,
401 pp[DE_LOWCYL + 4], pp[DE_HIGHCYL + 4]));
402 D(bug("[SDBus%02u] %s: BlockSize:%d, SectorsPerBlock:%d ..\n", bus->sdcb_BusNum, __PRETTY_FUNCTION__,
403 pp[DE_SIZEBLOCK + 4], sdcUnit->sdcu_Sectors));
404
405 AddBootNode(pp[DE_BOOTPRI + 4], ADNF_STARTPROC, devnode, NULL);
406 D(bug("[SDBus%02u] %s: Unit detection complete\n", bus->sdcb_BusNum, __PRETTY_FUNCTION__));
407
408 return TRUE;
409 }
410 }
411 }
412 else
413 {
414 D(bug("[SDBus%02u] %s: Card failed to send CSD\n", bus->sdcb_BusNum, __PRETTY_FUNCTION__));
415 }
416 }
417 else
418 {
419 D(bug("[SDBus%02u] %s: Failed to allocate Unit\n", bus->sdcb_BusNum, __PRETTY_FUNCTION__));
420 }
421 }
422 else
423 {
424 D(bug("[SDBus%02u] %s: Card failed to send RCA\n", bus->sdcb_BusNum, __PRETTY_FUNCTION__));
425 }
426 }
427 else
428 {
429 D(bug("[SDBus%02u] %s: Card failed to send CID\n", bus->sdcb_BusNum, __PRETTY_FUNCTION__));
430 }
431 }
432 else
433 {
434 D(bug("[SDBus%02u] %s: Card failed to initialise\n", bus->sdcb_BusNum, __PRETTY_FUNCTION__));
435 }
436
437 return FALSE;
438 }
439
440 void FNAME_SDCBUS(ReleaseUnit)(struct sdcard_Bus *bus)
441 {
442 DFUNCS(bug("[SDBus%02u] %s()\n", bus->sdcb_BusNum, __PRETTY_FUNCTION__));
443 }
444
445 void FNAME_SDCBUS(SoftReset)(UBYTE mask, struct sdcard_Bus *bus)
446 {
447 ULONG timeout = 100;
448
449 DFUNCS(bug("[SDBus%02u] %s()\n", bus->sdcb_BusNum, __PRETTY_FUNCTION__));
450
451 bus->sdcb_IOWriteByte(SDHCI_RESET, mask, bus);
452 while (bus->sdcb_IOReadByte(SDHCI_RESET, bus) & mask) {
453 if (timeout == 0) {
454 bug("[SDBus%02u] %s: Timeout\n", bus->sdcb_BusNum, __PRETTY_FUNCTION__);
455 break;
456 }
457 sdcard_Udelay(1000);
458 timeout--;
459 }
460 }
461
462 void FNAME_SDCBUS(SetClock)(ULONG speed, struct sdcard_Bus *bus)
463 {
464 ULONG sdcClkDiv, timeout;
465 UWORD sdcClkCtrlCur, sdcClkCtrl;
466
467 DFUNCS(bug("[SDBus%02u] %s()\n", bus->sdcb_BusNum, __PRETTY_FUNCTION__));
468
469 sdcClkCtrlCur = bus->sdcb_IOReadWord(SDHCI_CLOCK_CONTROL, bus);
470
471 sdcClkDiv = FNAME_SDCBUS(GetClockDiv)(speed, bus);
472
473 sdcClkCtrl = (sdcClkDiv & SDHCI_DIV_MASK) << SDHCI_DIVIDER_SHIFT;
474 sdcClkCtrl |= ((sdcClkDiv & SDHCI_DIV_HI_MASK) >> SDHCI_DIV_MASK_LEN) << SDHCI_DIVIDER_HI_SHIFT;
475
476 if (sdcClkCtrl != (sdcClkCtrlCur & ~(SDHCI_CLOCK_INT_EN|SDHCI_CLOCK_INT_STABLE|SDHCI_CLOCK_CARD_EN)))
477 {
478 bus->sdcb_IOWriteWord(SDHCI_CLOCK_CONTROL, 0, bus);
479
480 D(bug("[SDBus%02u] %s: Changing CLOCK_CONTROL [0x%04x -> 0x%04x] (div %d)\n", bus->sdcb_BusNum, __PRETTY_FUNCTION__, sdcClkCtrlCur & ~(SDHCI_CLOCK_INT_EN|SDHCI_CLOCK_INT_STABLE|SDHCI_CLOCK_CARD_EN), sdcClkCtrl, sdcClkDiv));
481
482 bus->sdcb_IOWriteWord(SDHCI_CLOCK_CONTROL, (sdcClkCtrl | SDHCI_CLOCK_INT_EN), bus);
483
484 timeout = 20;
485 while (!((sdcClkCtrl = bus->sdcb_IOReadWord(SDHCI_CLOCK_CONTROL, bus)) & SDHCI_CLOCK_INT_STABLE)) {
486 if (timeout == 0) {
487 bug("[SDBus%02u] %s: SDHCI Clock failed to stabilise\n", bus->sdcb_BusNum, __PRETTY_FUNCTION__);
488 break;
489 }
490 sdcard_Udelay(1000);
491 timeout --;
492 }
493 }
494 else
495 if (sdcClkCtrlCur & SDHCI_CLOCK_CARD_EN)
496 return;
497
498 D(bug("[SDBus%02u] %s: Enabling clock...\n", bus->sdcb_BusNum, __PRETTY_FUNCTION__));
499 sdcClkCtrl |= SDHCI_CLOCK_CARD_EN;
500 bus->sdcb_IOWriteWord(SDHCI_CLOCK_CONTROL, sdcClkCtrl, bus);
501 }
502
503 void FNAME_SDCBUS(SetPowerLevel)(ULONG supportedlvls, BOOL lowest, struct sdcard_Bus *bus)
504 {
505 UBYTE sdcReg = 0, lvlCur;
506
507 DFUNCS(bug("[SDBus%02u] %s()\n", bus->sdcb_BusNum, __PRETTY_FUNCTION__));
508
509 if (lowest)
510 {
511 if (supportedlvls & MMC_VDD_165_195)
512 sdcReg = SDHCI_POWER_180;
513 else if (supportedlvls & (MMC_VDD_290_300|MMC_VDD_300_310))
514 sdcReg = SDHCI_POWER_300;
515 else if (supportedlvls & (MMC_VDD_320_330|MMC_VDD_330_340))
516 sdcReg = SDHCI_POWER_330;
517 }
518 else
519 {
520 if (supportedlvls & (MMC_VDD_320_330|MMC_VDD_330_340))
521 sdcReg = SDHCI_POWER_330;
522 else if (supportedlvls & (MMC_VDD_290_300|MMC_VDD_300_310))
523 sdcReg = SDHCI_POWER_300;
524 else if (supportedlvls & MMC_VDD_165_195)
525 sdcReg = SDHCI_POWER_180;
526 }
527
528 lvlCur = bus->sdcb_IOReadByte(SDHCI_POWER_CONTROL, bus);
529 if ((lvlCur & ~SDHCI_POWER_ON) != sdcReg)
530 {
531 D(bug("[SDBus%02u] %s: Changing Power Lvl [0x%x -> 0x%x]\n", bus->sdcb_BusNum, __PRETTY_FUNCTION__, lvlCur & ~SDHCI_POWER_ON, sdcReg));
532 bus->sdcb_IOWriteByte(SDHCI_POWER_CONTROL, sdcReg, bus);
533 sdcReg |= SDHCI_POWER_ON;
534 bus->sdcb_IOWriteByte(SDHCI_POWER_CONTROL, sdcReg, bus);
535 }
536 else
537 {
538 if (!(lvlCur & SDHCI_POWER_ON))
539 {
540 D(bug("[SDBus%02u] %s: Enabling Power Lvl [0x%x]\n", bus->sdcb_BusNum, __PRETTY_FUNCTION__, lvlCur));
541 lvlCur |= SDHCI_POWER_ON;
542 bus->sdcb_IOWriteByte(SDHCI_POWER_CONTROL, lvlCur, bus);
543 }
544 }
545 }
546
547 ULONG FNAME_SDCBUS(SendCmd)(struct TagItem *CmdTags, struct sdcard_Bus *bus)
548 {
549 UWORD sdCommand = (UWORD)GetTagData(SDCARD_TAG_CMD, 0, CmdTags);
550 ULONG sdArg = GetTagData(SDCARD_TAG_ARG, 0, CmdTags);
551 ULONG sdResponseType = GetTagData(SDCARD_TAG_RSPTYPE, MMC_RSP_NONE, CmdTags);
552 ULONG sdDataLen = 0, sdDataFlags;
553
554 UWORD sdcTransMode = 0, sdCommandFlags;
555 ULONG sdcInhibitMask = SDHCI_PS_CMD_INHIBIT;
556 ULONG timeout = 10;
557 ULONG retVal = 0;
558
559 DFUNCS(bug("[SDBus%02u] %s()\n", bus->sdcb_BusNum, __PRETTY_FUNCTION__));
560
561 if ((sdDataLen = GetTagData(SDCARD_TAG_DATALEN, 0, CmdTags)) > 0)
562 {
563 sdDataFlags = GetTagData(SDCARD_TAG_DATAFLAGS, 0, CmdTags);
564 };
565
566 /* Dont wait for DATA inihibit for stop commands */
567 if (sdCommand != MMC_CMD_STOP_TRANSMISSION)
568 sdcInhibitMask |= SDHCI_PS_DATA_INHIBIT;
569
570 while (bus->sdcb_IOReadLong(SDHCI_PRESENT_STATE, bus) & sdcInhibitMask) {
571 if (timeout == 0) {
572 bug("[SDBus%02u] %s: Controller failed to release inhibited bit(s).\n", bus->sdcb_BusNum, __PRETTY_FUNCTION__);
573 bug("[SDBus%02u] %s: failed bit(s) = %08x\n", bus->sdcb_BusNum, __PRETTY_FUNCTION__, bus->sdcb_IOReadLong(SDHCI_PRESENT_STATE, bus) & sdcInhibitMask);
574
575 bug("[SDBus%02u] %s: Reseting SDHCI CMD/DATA\n", bus->sdcb_BusNum, __PRETTY_FUNCTION__);
576
577 FNAME_SDCBUS(SoftReset)(SDHCI_RESET_CMD, bus);
578 FNAME_SDCBUS(SoftReset)(SDHCI_RESET_DATA, bus);
579
580 return -1;
581 }
582 sdcard_Udelay(1000);
583 timeout--;
584 }
585
586 if (!(sdResponseType & MMC_RSP_PRESENT))
587 sdCommandFlags = SDHCI_CMD_RESP_NONE;
588 else if (sdResponseType & MMC_RSP_136)
589 sdCommandFlags = SDHCI_CMD_RESP_LONG;
590 else if (sdResponseType & MMC_RSP_BUSY)
591 sdCommandFlags = SDHCI_CMD_RESP_SHORT_BUSY;
592 else
593 sdCommandFlags = SDHCI_CMD_RESP_SHORT;
594
595 if (sdResponseType & MMC_RSP_CRC)
596 sdCommandFlags |= SDHCI_CMD_CRC;
597 if (sdResponseType & MMC_RSP_OPCODE)
598 sdCommandFlags |= SDHCI_CMD_INDEX;
599 if (sdDataLen > 0)
600 sdCommandFlags |= SDHCI_CMD_DATA;
601
602 if (sdDataLen > 0) {
603 sdcTransMode = SDHCI_TRANSMOD_BLK_CNT_EN;
604 DTRANS(bug("[SDBus%02u] %s: Configuring Data Transfer\n", bus->sdcb_BusNum, __PRETTY_FUNCTION__));
605
606 if (bus->sdcb_LEDCtrl)
607 bus->sdcb_LEDCtrl(LED_ON);
608
609 bus->sdcb_IOWriteByte(SDHCI_TIMEOUT_CONTROL, SDHCI_TIMEOUT_MAX, bus);
610
611 bus->sdcb_IOWriteWord(SDHCI_BLOCK_SIZE, ((1 << 16) | ((sdDataLen > (1 << bus->sdcb_SectorShift)) ? (1 << bus->sdcb_SectorShift) : sdDataLen)), bus);
612 if ((sdDataLen >> bus->sdcb_SectorShift) > 1)
613 {
614 sdcTransMode |= SDHCI_TRANSMOD_MULTI;
615 bus->sdcb_IOWriteWord(SDHCI_BLOCK_COUNT, sdDataLen >> bus->sdcb_SectorShift, bus);
616 }
617 else
618 {
619 bus->sdcb_IOWriteWord(SDHCI_BLOCK_COUNT, 1, bus);
620 }
621
622 if (sdDataFlags == MMC_DATA_READ)
623 sdcTransMode |= SDHCI_TRANSMOD_READ;
624
625 if (!(bus->sdcb_Quirks & AF_Quirk_AtomicTMAndCMD))
626 {
627 bus->sdcb_IOWriteWord(SDHCI_TRANSFER_MODE, sdcTransMode, bus);
628 }
629
630 DTRANS(bug("[SDBus%02u] %s: Mode %08x [%d x %dBytes]\n", bus->sdcb_BusNum, __PRETTY_FUNCTION__, sdcTransMode, (((sdDataLen >> bus->sdcb_SectorShift) > 0) ? (sdDataLen >> bus->sdcb_SectorShift) : 1), ((sdDataLen > (1 << bus->sdcb_SectorShift)) ? (1 << bus->sdcb_SectorShift) : sdDataLen)));
631 }
632
633 bus->sdcb_RespListener = CmdTags;
634 if (sdDataLen > 0)
635 bus->sdcb_DataListener = CmdTags;
636
637 bus->sdcb_IOWriteLong(SDHCI_ARGUMENT, sdArg, bus);
638 if ((bus->sdcb_Quirks & AF_Quirk_AtomicTMAndCMD) && (sdcTransMode))
639 {
640 bus->sdcb_IOWriteLong(SDHCI_TRANSFER_MODE, (SDHCI_MAKE_CMD(sdCommand, sdCommandFlags) << 16) | sdcTransMode, bus);
641 }
642 else
643 {
644 bus->sdcb_IOWriteWord(SDHCI_COMMAND, SDHCI_MAKE_CMD(sdCommand, sdCommandFlags), bus);
645 }
646
647 D(bug("[SDBus%02u] %s: CMD %02d Sent\n", bus->sdcb_BusNum, __PRETTY_FUNCTION__, sdCommand));
648
649 return retVal;
650 }
651
652 ULONG FNAME_SDCBUS(FinishCmd)(struct TagItem *CmdTags, struct sdcard_Bus *bus)
653 {
654 struct TagItem *Response = NULL;
655
656 D(UWORD sdCommand = (UWORD)GetTagData(SDCARD_TAG_CMD, 0, CmdTags));
657 ULONG sdResponseType = GetTagData(SDCARD_TAG_RSPTYPE, MMC_RSP_NONE, CmdTags);
658 ULONG retVal = 0;
659
660 DFUNCS(bug("[SDBus%02u] %s()\n", bus->sdcb_BusNum, __PRETTY_FUNCTION__));
661
662 if (sdResponseType != MMC_RSP_NONE)
663 {
664 if ((Response = FindTagItem(SDCARD_TAG_RSP, CmdTags)) != NULL)
665 {
666 D(bug("[SDBus%02u] %s: Reading CMD %02d Response ", bus->sdcb_BusNum, __PRETTY_FUNCTION__, sdCommand));
667 if (sdResponseType & MMC_RSP_136)
668 {
669 D(bug("[136bit]\n"));
670 if (Response->ti_Data)
671 {
672 ULONG i;
673 for (i = 0; i < 4; i ++)
674 {
675 ((ULONG *)Response->ti_Data)[i] = bus->sdcb_IOReadLong(SDHCI_RESPONSE + (3 - i) * 4, bus) << 8;
676 if (i != 3)
677 ((ULONG *)Response->ti_Data)[i] |= bus->sdcb_IOReadByte(SDHCI_RESPONSE + (3 - i) * 4 - 1, bus);
678 }
679 D(bug("[SDBus%02u] %s: %08x%08x%08x%08x\n", bus->sdcb_BusNum, __PRETTY_FUNCTION__, ((ULONG *)Response->ti_Data)[0], ((ULONG *)Response->ti_Data)[1], ((ULONG *)Response->ti_Data)[2], ((ULONG *)Response->ti_Data)[3]));
680 }
681 }
682 else
683 {
684 Response->ti_Data = bus->sdcb_IOReadLong(SDHCI_RESPONSE, bus);
685 D(bug("[= %08x]\n", Response->ti_Data));
686 }
687 }
688 }
689
690 return retVal;
691 }
692
693 ULONG FNAME_SDCBUS(FinishData)(struct TagItem *DataTags, struct sdcard_Bus *bus)
694 {
695 DTRANS(UWORD sdCommand = (UWORD)GetTagData(SDCARD_TAG_CMD, 0, DataTags));
696 ULONG sdcStateMask, sdCommandMask,
697 sdData, sdDataMode, sdDataLen, sdcReg = 0;
698 struct TagItem *sdDataLenTag = NULL;
699 ULONG timeout = 1000;
700 ULONG retVal = 0;
701
702 DFUNCS(bug("[SDBus%02u] %s()\n", bus->sdcb_BusNum, __PRETTY_FUNCTION__));
703
704 if ((sdData = GetTagData(SDCARD_TAG_DATA, 0, DataTags)) != 0)
705 {
706 if ((sdDataLenTag = FindTagItem(SDCARD_TAG_DATALEN, DataTags)) == NULL)
707 sdData = 0;
708 else
709 {
710 sdDataLen = sdDataLenTag->ti_Data;
711 if ((sdDataMode = GetTagData(SDCARD_TAG_DATAFLAGS, MMC_DATA_READ, DataTags)) == MMC_DATA_READ)
712 {
713 sdcStateMask = SDHCI_PS_DATA_AVAILABLE;
714 sdCommandMask = SDHCI_INT_DATA_AVAIL;
715 }
716 else
717 {
718 sdcStateMask = SDHCI_PS_SPACE_AVAILABLE;
719 sdCommandMask = SDHCI_INT_SPACE_AVAIL;
720 }
721 }
722 };
723
724 if (sdData)
725 {
726 DTRANS(bug("[SDBus%02u] %s: Transfering CMD %02d Data..\n", bus->sdcb_BusNum, __PRETTY_FUNCTION__, sdCommand));
727 do {
728 bus->sdcb_BusStatus = bus->sdcb_IOReadLong(SDHCI_INT_STATUS, bus);
729 if (bus->sdcb_BusStatus & SDHCI_INT_ERROR) {
730 bug("[SDBus%02u] %s: Error [status 0x%X]!\n", bus->sdcb_BusNum, __PRETTY_FUNCTION__, bus->sdcb_BusStatus);
731 retVal = -1;
732 break;
733 }
734
735 if ((bus->sdcb_BusStatus & sdCommandMask) && (bus->sdcb_IOReadLong(SDHCI_PRESENT_STATE, bus) & sdcStateMask)) {
736 ULONG currbyte, tranlen = (sdDataLen > (1 << bus->sdcb_SectorShift)) ? (1 << bus->sdcb_SectorShift) : sdDataLen;
737
738 DTRANS(bug("[SDBus%02u] %s: Attempting to %s %dbytes\n", bus->sdcb_BusNum, __PRETTY_FUNCTION__, ((sdDataMode == MMC_DATA_READ) ? "read" : "write"), tranlen));
739 for (currbyte = 0; currbyte < tranlen; currbyte++)
740 {
741 DTRANS(DUMP(
742 if ((currbyte % 16) == 0)
743 {
744 bug("[SDBus%02u] %s: ", bus->sdcb_BusNum, __PRETTY_FUNCTION__);
745 }
746 ))
747 if (sdDataMode == MMC_DATA_READ)
748 {
749 if ((currbyte % 4) == 0)
750 {
751 sdcReg = bus->sdcb_IOReadLong(SDHCI_BUFFER, bus);
752 }
753 *(UBYTE *)sdData = sdcReg & 0xFF;
754 }
755 else
756 sdcReg |= *(UBYTE *)sdData << (currbyte % 4);
757
758 sdData++;
759 sdDataLen--;
760 if (sdDataMode != MMC_DATA_READ)
761 {
762 if (((currbyte % 4) == 3) || (sdDataLen == 0))
763 {
764 bus->sdcb_IOWriteLong(SDHCI_BUFFER, *(ULONG *)(sdData - 3), bus);
765 }
766 }
767 else
768 sdcReg >>= 8;
769 DTRANS(DUMP(
770 if ((currbyte % 4) == 3)
771 {
772 bug(" %08x", *(ULONG *)(sdData - 3));
773 }
774 if ((currbyte % 16) == 15)
775 {
776 bug("\n");
777 }
778 ))
779 }
780 DTRANS(DUMP(
781 if ((currbyte % 16) != 0)
782 {
783 bug("\n");
784 }
785 ))
786 }
787 else if (!(bus->sdcb_BusStatus & SDHCI_INT_DATA_END))
788 {
789 sdcard_Udelay(1000);
790
791 if (timeout-- <= 0)
792 {
793 bug("[SDBus%02u] %s: Timeout!\n", bus->sdcb_BusNum, __PRETTY_FUNCTION__);
794 retVal = -1;
795 break;
796 }
797 }
798 } while ((sdDataLen > 0) && (!(bus->sdcb_BusStatus & SDHCI_INT_DATA_END)));
799
800 if (bus->sdcb_LEDCtrl)
801 bus->sdcb_LEDCtrl(LED_OFF);
802
803 sdDataLenTag->ti_Data -= sdDataLen;
804 }
805
806 return retVal;
807 }
808
809 ULONG FNAME_SDCBUS(WaitCmd)(ULONG mask, ULONG timeout, struct sdcard_Bus *bus)
810 {
811 bug("[SDBus%02u] %s()\n", bus->sdcb_BusNum, __PRETTY_FUNCTION__);
812
813 while (bus->sdcb_IOReadLong(SDHCI_PRESENT_STATE, bus) & mask) {
814 sdcard_Udelay(1000);
815
816 if ((bus->sdcb_BusStatus & SDHCI_INT_ERROR) == SDHCI_INT_ERROR)
817 break;
818
819 if (--timeout <= 0)
820 break;
821 }
822
823 if ((timeout <= 0) || (bus->sdcb_BusStatus & SDHCI_INT_ERROR))
824 {
825 return -1;
826 }
827
828 return 0;
829 }
830
831
832 ULONG FNAME_SDCBUS(Rsp136Unpack)(ULONG *buf, ULONG offset, const ULONG len)
833 {
834 const ULONG mask = ((len < 32) ? (1 << len) : 0) - 1;
835 const ULONG shift = (offset) & 0x1F;
836 ULONG retval;
837
838 retval = buf[3 - (offset >> 5)] >> shift;
839 if (len + shift > 32)
840 retval |= buf[3 - (offset >> 5) - 1] << ((32 - shift) % 32);
841
842 return (retval & mask);
843 }
844
845 /********** BUS IRQ HANDLER **************/
846
847 void FNAME_SDCBUS(BusIRQ)(struct sdcard_Bus *bus, void *_unused)
848 {
849 BOOL error = FALSE;
850
851 DIRQ(bug("[SDBus%02u] %s(bus @ 0x%p)\n", bus->sdcb_BusNum, __PRETTY_FUNCTION__, bus));
852
853 if (!(bus))
854 {
855 DIRQ(bug("[SDBus%02u] %s: Bad Params!\n", __PRETTY_FUNCTION__));
856 return;
857 }
858
859 bus->sdcb_BusStatus = bus->sdcb_IOReadLong(SDHCI_INT_STATUS, bus);
860
861 if (!(bus->sdcb_BusStatus & SDHCI_INT_ERROR))
862 {
863 DIRQ(bug("[SDBus%02u] %s: Status = %08x\n", bus->sdcb_BusNum, __PRETTY_FUNCTION__, bus->sdcb_BusStatus));
864
865 if (bus->sdcb_BusStatus & (SDHCI_INT_CARD_INSERT|SDHCI_INT_CARD_REMOVE))
866 {
867 bus->sdcb_IOWriteLong(SDHCI_INT_STATUS, (bus->sdcb_BusStatus & (SDHCI_INT_CARD_INSERT|SDHCI_INT_CARD_REMOVE)), bus);
868
869 bus->sdcb_BusFlags &= ~AF_Bus_MediaPresent;
870 bus->sdcb_BusFlags |= AF_Bus_MediaChanged;
871
872 if (bus->sdcb_BusStatus & SDHCI_INT_CARD_INSERT)
873 bus->sdcb_BusFlags |= AF_Bus_MediaPresent;
874
875 bus->sdcb_BusStatus &= ~(SDHCI_INT_CARD_INSERT|SDHCI_INT_CARD_REMOVE);
876
877 if (bus->sdcb_Task)
878 Signal(bus->sdcb_Task, (1L << bus->sdcb_MediaSig));
879 }
880 if (bus->sdcb_BusStatus & SDHCI_INT_CMD_MASK)
881 {
882 bus->sdcb_IOWriteLong(SDHCI_INT_STATUS, (bus->sdcb_BusStatus & SDHCI_INT_CMD_MASK), bus);
883
884 if ((bus->sdcb_BusStatus & SDHCI_INT_RESPONSE) &&
885 (bus->sdcb_RespListener))
886 {
887 if (FNAME_SDCBUS(FinishCmd)(bus->sdcb_RespListener, bus) == -1)
888 error = TRUE;
889 bus->sdcb_RespListener = NULL;
890 }
891 bus->sdcb_BusStatus &= ~SDHCI_INT_CMD_MASK;
892 }
893 if (bus->sdcb_BusStatus & SDHCI_INT_DATA_MASK)
894 {
895 if ((bus->sdcb_BusStatus & (SDHCI_INT_DATA_AVAIL|SDHCI_INT_SPACE_AVAIL)) &&
896 (bus->sdcb_DataListener))
897 {
898 if (FNAME_SDCBUS(FinishData)(bus->sdcb_DataListener, bus) == -1)
899 error = TRUE;
900 bus->sdcb_DataListener = NULL;
901 bus->sdcb_IOWriteLong(SDHCI_INT_STATUS, (bus->sdcb_BusStatus & (SDHCI_INT_DATA_AVAIL|SDHCI_INT_SPACE_AVAIL)), bus);
902 bus->sdcb_BusStatus &= ~SDHCI_INT_DATA_MASK;
903 }
904 else
905 {
906 bus->sdcb_IOWriteLong(SDHCI_INT_STATUS, (bus->sdcb_BusStatus & SDHCI_INT_DATA_MASK), bus);
907 bus->sdcb_BusStatus &= ~SDHCI_INT_DATA_MASK;
908 }
909 }
910 }
911 else
912 {
913 bug("[SDBus%02u] %s: ERROR [Status = %08x]\n", bus->sdcb_BusNum, __PRETTY_FUNCTION__, bus->sdcb_BusStatus);
914 if (bus->sdcb_BusStatus & SDHCI_INT_ACMD12ERR)
915 {
916 bug("[SDBus%02u] %s: [acmd12err = %04x ]\n", bus->sdcb_BusNum, __PRETTY_FUNCTION__, bus->sdcb_IOReadWord(SDHCI_ACMD12_ERR, bus));
917 }
918 error = TRUE;
919 }
920
921 if (error)
922 {
923 if (bus->sdcb_BusStatus & bus->sdcb_IntrMask)
924 {
925 bug("[SDBus%02u] %s: Clearing Unhandled Interrupts [%08x]\n", bus->sdcb_BusNum, __PRETTY_FUNCTION__, bus->sdcb_BusStatus & bus->sdcb_IntrMask);
926 bus->sdcb_IOWriteLong(SDHCI_INT_STATUS, bus->sdcb_BusStatus & bus->sdcb_IntrMask, bus);
927 bus->sdcb_BusStatus &= ~bus->sdcb_IntrMask;
928 }
929 bug("[SDBus%02u] %s: Reseting SDHCI CMD/DATA\n", bus->sdcb_BusNum, __PRETTY_FUNCTION__);
930
931 FNAME_SDCBUS(SoftReset)(SDHCI_RESET_CMD, bus);
932 FNAME_SDCBUS(SoftReset)(SDHCI_RESET_DATA, bus);
933 }
934 DIRQ(bug("[SDBus%02u] %s: Done.\n", bus->sdcb_BusNum, __PRETTY_FUNCTION__));
935 }
936
937 /********** BUS MANAGEMENT TASK **************/
938
939 void FNAME_SDCBUS(BusTask)(struct sdcard_Bus *bus)
940 {
941 LIBBASETYPEPTR LIBBASE = bus->sdcb_DeviceBase;
942 struct IORequest *msg;
943 ULONG sig, tasksig;
944
945 DFUNCS(bug("[SDBus%02u] %s()\n", bus->sdcb_BusNum, __PRETTY_FUNCTION__));
946
947 bus->sdcb_Timer = sdcard_OpenTimer(LIBBASE);
948
949 /* Get the signal used for sleeping */
950 bus->sdcb_Task = FindTask(0);
951
952 D(bug("[SDBus%02u] %s: Task @ 0x%p\n", bus->sdcb_BusNum, __PRETTY_FUNCTION__, bus->sdcb_Task));
953
954 bus->sdcb_TaskSig = AllocSignal(-1);
955 if ((bus->sdcb_MediaSig = AllocSignal(-1)) == -1)
956 {
957 D(bug("[SDBus%02u] %s: failed to allocate Media Change sigbit\n", bus->sdcb_BusNum, __PRETTY_FUNCTION__));
958 }
959
960 /* Failed to get it? Use SIGBREAKB_CTRL_E instead */
961 if (bus->sdcb_TaskSig < 0)
962 bus->sdcb_TaskSig = SIGBREAKB_CTRL_E;
963
964 sig = ((1L << bus->sdcb_MsgPort->mp_SigBit)|(1L << bus->sdcb_TaskSig)|(1L << bus->sdcb_MediaSig));
965
966 DINIT(bug("[SDBus%02u] %s: TaskSig: %d, MediaSig: %d\n", bus->sdcb_BusNum, __PRETTY_FUNCTION__, bus->sdcb_TaskSig, bus->sdcb_MediaSig));
967
968 /* Install IRQ handler */
969 if ((bus->sdcb_IRQHandle = KrnAddIRQHandler(bus->sdcb_BusIRQ, FNAME_SDCBUS(BusIRQ), bus, NULL)) != NULL)
970 {
971 DINIT(bug("[SDBus%02u] %s: IRQHandle @ 0x%p for IRQ#%ld\n", bus->sdcb_BusNum, __PRETTY_FUNCTION__, bus->sdcb_IRQHandle, bus->sdcb_BusIRQ));
972
973 DINIT(bug("[SDBus%02u] %s: Masking chipset Interrupts...\n", bus->sdcb_BusNum, __PRETTY_FUNCTION__));
974
975 bus->sdcb_IOWriteLong(SDHCI_INT_ENABLE, bus->sdcb_IntrMask, bus);
976 bus->sdcb_IOWriteLong(SDHCI_SIGNAL_ENABLE, bus->sdcb_IntrMask, bus);
977 }
978
979 for (;;)
980 {
981 tasksig = Wait(sig);
982
983 if ((tasksig & (1L << bus->sdcb_MediaSig)) && (bus->sdcb_BusFlags & AF_Bus_MediaChanged))
984 {
985 D(bug("[SDBus%02u] %s: detected unit change\n", bus->sdcb_BusNum, __PRETTY_FUNCTION__));
986 D(bug("[SDBus%02u] %s: Card %s Detected!\n", bus->sdcb_BusNum, __PRETTY_FUNCTION__, (bus->sdcb_BusFlags & AF_Bus_MediaPresent) ? "Insert" : "Eject" ));
987 if (bus->sdcb_BusFlags & AF_Bus_MediaPresent)
988 {
989 FNAME_SDCBUS(RegisterUnit)(bus);
990 }
991 else
992 {
993 FNAME_SDCBUS(ReleaseUnit)(bus);
994 }
995 }
996
997 /* Defer IORequest processing if the bus is active */
998 if ((tasksig & (1L << bus->sdcb_MsgPort->mp_SigBit)) && (!(bus->sdcb_BusFlags & AF_Bus_Active)))
999 {
1000 /* process pending requests .. */
1001 bus->sdcb_BusFlags |= AF_Bus_Active;
1002 while ((msg = (struct IORequest *)GetMsg(bus->sdcb_MsgPort)))
1003 {
1004 /* And do IO's */
1005 if (FNAME_SDC(HandleIO)(msg))
1006 {
1007 ReplyMsg((struct Message *)msg);
1008 }
1009 }
1010 bus->sdcb_BusFlags &= ~AF_Bus_Active;
1011 }
1012 }
1013 }
Mirror of AROS' svn.