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