?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
revert between 56095 -> 55830 in arch
[AROS.git] / rom / devs / sdcard / sdcard_bus.c
blob4ecfd2eb50d90a86634e46b78464e45c4d068540
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|SDHCI_PS_DATA_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|SDHCI_PS_DATA_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) && (FNAME_SDCBUS(WaitCmd)(SDHCI_PS_CMD_INHIBIT|SDHCI_PS_DATA_INHIBIT, 1000, 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) || (FNAME_SDCBUS(WaitCmd)(SDHCI_PS_CMD_INHIBIT|SDHCI_PS_DATA_INHIBIT, 1000, 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|SDHCI_PS_DATA_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|SDHCI_PS_DATA_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|SDHCI_PS_DATA_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|SDHCI_PS_DATA_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|SDHCI_PS_DATA_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|SDHCI_PS_DATA_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 #undef DFUNCS
547 #define DFUNCS(x) /*x*/
548 #undef DTRANS
549 #define DTRANS(x) /*x*/
550 #undef D
551 #define D(x) /*x*/
552
553 ULONG FNAME_SDCBUS(SendCmd)(struct TagItem *CmdTags, struct sdcard_Bus *bus)
554 {
555 UWORD sdCommand = (UWORD)GetTagData(SDCARD_TAG_CMD, 0, CmdTags);
556 ULONG sdArg = GetTagData(SDCARD_TAG_ARG, 0, CmdTags);
557 ULONG sdResponseType = GetTagData(SDCARD_TAG_RSPTYPE, MMC_RSP_NONE, CmdTags);
558 ULONG sdDataLen = 0, sdDataFlags;
559
560 UWORD sdcTransMode = 0, sdCommandFlags;
561 ULONG sdcInhibitMask = SDHCI_PS_CMD_INHIBIT;
562 ULONG timeout = 10;
563 ULONG retVal = 0;
564
565 DFUNCS(bug("[SDBus%02u] %s()\n", bus->sdcb_BusNum, __PRETTY_FUNCTION__));
566
567 if ((sdDataLen = GetTagData(SDCARD_TAG_DATALEN, 0, CmdTags)) > 0)
568 {
569 sdDataFlags = GetTagData(SDCARD_TAG_DATAFLAGS, 0, CmdTags);
570 };
571
572 bug("SendCmd(%d,%d)\n", sdCommand, sdDataLen);
573
574 /* Dont wait for DATA inihibit for stop commands */
575 if (sdCommand != MMC_CMD_STOP_TRANSMISSION)
576 sdcInhibitMask |= SDHCI_PS_DATA_INHIBIT;
577
578 while (bus->sdcb_IOReadLong(SDHCI_PRESENT_STATE, bus) & sdcInhibitMask) {
579 if (timeout == 0) {
580 bug("[SDBus%02u] %s: Controller failed to release inhibited bit(s).\n", bus->sdcb_BusNum, __PRETTY_FUNCTION__);
581 bug("[SDBus%02u] %s: failed bit(s) = %08x\n", bus->sdcb_BusNum, __PRETTY_FUNCTION__, bus->sdcb_IOReadLong(SDHCI_PRESENT_STATE, bus) & sdcInhibitMask);
582
583 bug("[SDBus%02u] %s: Reseting SDHCI CMD/DATA\n", bus->sdcb_BusNum, __PRETTY_FUNCTION__);
584
585 FNAME_SDCBUS(SoftReset)(SDHCI_RESET_CMD, bus);
586 FNAME_SDCBUS(SoftReset)(SDHCI_RESET_DATA, bus);
587
588 return -1;
589 }
590 sdcard_Udelay(1000);
591 timeout--;
592 }
593
594 if (!(sdResponseType & MMC_RSP_PRESENT))
595 sdCommandFlags = SDHCI_CMD_RESP_NONE;
596 else if (sdResponseType & MMC_RSP_136)
597 sdCommandFlags = SDHCI_CMD_RESP_LONG;
598 else if (sdResponseType & MMC_RSP_BUSY)
599 sdCommandFlags = SDHCI_CMD_RESP_SHORT_BUSY;
600 else
601 sdCommandFlags = SDHCI_CMD_RESP_SHORT;
602
603 if (sdResponseType & MMC_RSP_CRC)
604 sdCommandFlags |= SDHCI_CMD_CRC;
605 if (sdResponseType & MMC_RSP_OPCODE)
606 sdCommandFlags |= SDHCI_CMD_INDEX;
607 if (sdDataLen > 0)
608 sdCommandFlags |= SDHCI_CMD_DATA;
609
610 if (sdDataLen > 0) {
611 sdcTransMode = SDHCI_TRANSMOD_BLK_CNT_EN;
612 DTRANS(bug("[SDBus%02u] %s: Configuring Data Transfer\n", bus->sdcb_BusNum, __PRETTY_FUNCTION__));
613
614 if (bus->sdcb_LEDCtrl)
615 bus->sdcb_LEDCtrl(LED_ON);
616
617 bus->sdcb_IOWriteByte(SDHCI_TIMEOUT_CONTROL, SDHCI_TIMEOUT_MAX, bus);
618
619 bus->sdcb_IOWriteWord(SDHCI_BLOCK_SIZE, ((1 << 16) | ((sdDataLen > (1 << bus->sdcb_SectorShift)) ? (1 << bus->sdcb_SectorShift) : sdDataLen)), bus);
620 if ((sdDataLen >> bus->sdcb_SectorShift) > 1)
621 {
622 sdcTransMode |= SDHCI_TRANSMOD_MULTI;
623 bus->sdcb_IOWriteWord(SDHCI_BLOCK_COUNT, sdDataLen >> bus->sdcb_SectorShift, bus);
624 }
625 else
626 {
627 bus->sdcb_IOWriteWord(SDHCI_BLOCK_COUNT, 1, bus);
628 }
629
630 if (sdDataFlags == MMC_DATA_READ)
631 sdcTransMode |= SDHCI_TRANSMOD_READ;
632
633 if (!(bus->sdcb_Quirks & AF_Quirk_AtomicTMAndCMD))
634 {
635 bus->sdcb_IOWriteWord(SDHCI_TRANSFER_MODE, sdcTransMode, bus);
636 }
637
638 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)));
639 }
640
641 bus->sdcb_RespListener = CmdTags;
642 if (sdDataLen > 0)
643 bus->sdcb_DataListener = CmdTags;
644
645 SetSignal(0, 1L << bus->sdcb_CommandSig);
646
647 bus->sdcb_IOWriteLong(SDHCI_ARGUMENT, sdArg, bus);
648 if ((bus->sdcb_Quirks & AF_Quirk_AtomicTMAndCMD) && (sdcTransMode))
649 {
650 bus->sdcb_IOWriteLong(SDHCI_TRANSFER_MODE, (SDHCI_MAKE_CMD(sdCommand, sdCommandFlags) << 16) | sdcTransMode, bus);
651 }
652 else
653 {
654 bus->sdcb_IOWriteWord(SDHCI_COMMAND, SDHCI_MAKE_CMD(sdCommand, sdCommandFlags), bus);
655 }
656
657 //bug("Delay01Delay02\n");
658
659 D(bug("[SDBus%02u] %s: CMD %02d Sent\n", bus->sdcb_BusNum, __PRETTY_FUNCTION__, sdCommand));
660
661 return retVal;
662 }
663
664 #undef DFUNCS
665 #define DFUNCS(x) /* */
666 #undef DTRANS
667 #define DTRANS(x) /* */
668 #undef D
669 #define D(x) /* */
670
671
672 ULONG FNAME_SDCBUS(FinishCmd)(struct TagItem *CmdTags, struct sdcard_Bus *bus)
673 {
674 struct TagItem *Response = NULL;
675
676 D(UWORD sdCommand = (UWORD)GetTagData(SDCARD_TAG_CMD, 0, CmdTags));
677 ULONG sdResponseType = GetTagData(SDCARD_TAG_RSPTYPE, MMC_RSP_NONE, CmdTags);
678 ULONG retVal = 0;
679
680 DFUNCS(bug("[SDBus%02u] %s()\n", bus->sdcb_BusNum, __PRETTY_FUNCTION__));
681
682 if (sdResponseType != MMC_RSP_NONE)
683 {
684 if ((Response = FindTagItem(SDCARD_TAG_RSP, CmdTags)) != NULL)
685 {
686 D(bug("[SDBus%02u] %s: Reading CMD %02d Response ", bus->sdcb_BusNum, __PRETTY_FUNCTION__, sdCommand));
687 if (sdResponseType & MMC_RSP_136)
688 {
689 D(bug("[136bit]\n"));
690 if (Response->ti_Data)
691 {
692 ULONG i;
693 for (i = 0; i < 4; i ++)
694 {
695 ((ULONG *)Response->ti_Data)[i] = bus->sdcb_IOReadLong(SDHCI_RESPONSE + (3 - i) * 4, bus) << 8;
696 if (i != 3)
697 ((ULONG *)Response->ti_Data)[i] |= bus->sdcb_IOReadByte(SDHCI_RESPONSE + (3 - i) * 4 - 1, bus);
698 }
699 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]));
700 }
701 }
702 else
703 {
704 Response->ti_Data = bus->sdcb_IOReadLong(SDHCI_RESPONSE, bus);
705 D(bug("[= %08x]\n", Response->ti_Data));
706 }
707 }
708 }
709
710 return retVal;
711 }
712
713 ULONG FNAME_SDCBUS(FinishData)(struct TagItem *DataTags, struct sdcard_Bus *bus)
714 {
715 DTRANS(UWORD sdCommand = (UWORD)GetTagData(SDCARD_TAG_CMD, 0, DataTags));
716 ULONG sdcStateMask, sdCommandMask,
717 sdData, sdDataMode, sdDataLen, sdcReg = 0;
718 struct TagItem *sdDataLenTag = NULL;
719 ULONG timeout = 1000;
720 ULONG retVal = 0;
721
722 DFUNCS(bug("[SDBus%02u] %s()\n", bus->sdcb_BusNum, __PRETTY_FUNCTION__));
723
724 if ((sdData = GetTagData(SDCARD_TAG_DATA, 0, DataTags)) != 0)
725 {
726 if ((sdDataLenTag = FindTagItem(SDCARD_TAG_DATALEN, DataTags)) == NULL)
727 sdData = 0;
728 else
729 {
730 sdDataLen = sdDataLenTag->ti_Data;
731 if ((sdDataMode = GetTagData(SDCARD_TAG_DATAFLAGS, MMC_DATA_READ, DataTags)) == MMC_DATA_READ)
732 {
733 sdcStateMask = SDHCI_PS_DATA_AVAILABLE;
734 sdCommandMask = SDHCI_INT_DATA_AVAIL;
735 }
736 else
737 {
738 sdcStateMask = SDHCI_PS_SPACE_AVAILABLE;
739 sdCommandMask = SDHCI_INT_SPACE_AVAIL;
740 }
741 }
742 };
743
744 if (sdData)
745 {
746 DTRANS(bug("[SDBus%02u] %s: Transfering CMD %02d Data..\n", bus->sdcb_BusNum, __PRETTY_FUNCTION__, sdCommand));
747 do {
748 bus->sdcb_BusStatus = bus->sdcb_IOReadLong(SDHCI_INT_STATUS, bus);
749 if (bus->sdcb_BusStatus & SDHCI_INT_ERROR) {
750 bug("[SDBus%02u] %s: Error [status 0x%X]!\n", bus->sdcb_BusNum, __PRETTY_FUNCTION__, bus->sdcb_BusStatus);
751 retVal = -1;
752 break;
753 }
754
755 if ((bus->sdcb_BusStatus & sdCommandMask) && (bus->sdcb_IOReadLong(SDHCI_PRESENT_STATE, bus) & sdcStateMask)) {
756 ULONG currbyte, tranlen = (sdDataLen > (1 << bus->sdcb_SectorShift)) ? (1 << bus->sdcb_SectorShift) : sdDataLen;
757
758 DTRANS(bug("[SDBus%02u] %s: Attempting to %s %dbytes\n", bus->sdcb_BusNum, __PRETTY_FUNCTION__, ((sdDataMode == MMC_DATA_READ) ? "read" : "write"), tranlen));
759 for (currbyte = 0; currbyte < tranlen; currbyte++)
760 {
761 DTRANS(DUMP(
762 if ((currbyte % 16) == 0)
763 {
764 bug("[SDBus%02u] %s: ", bus->sdcb_BusNum, __PRETTY_FUNCTION__);
765 }
766 ))
767 if (sdDataMode == MMC_DATA_READ)
768 {
769 if ((currbyte % 4) == 0)
770 {
771 sdcReg = bus->sdcb_IOReadLong(SDHCI_BUFFER, bus);
772 }
773 *(UBYTE *)sdData = sdcReg & 0xFF;
774 }
775 else
776 sdcReg |= *(UBYTE *)sdData << (currbyte % 4);
777
778 sdData++;
779 sdDataLen--;
780 if (sdDataMode != MMC_DATA_READ)
781 {
782 if (((currbyte % 4) == 3) || (sdDataLen == 0))
783 {
784 bus->sdcb_IOWriteLong(SDHCI_BUFFER, *(ULONG *)(sdData - 3), bus);
785 }
786 }
787 else
788 sdcReg >>= 8;
789 DTRANS(DUMP(
790 if ((currbyte % 4) == 3)
791 {
792 bug(" %08x", *(ULONG *)(sdData - 3));
793 }
794 if ((currbyte % 16) == 15)
795 {
796 bug("\n");
797 }
798 ))
799 }
800 DTRANS(DUMP(
801 if ((currbyte % 16) != 0)
802 {
803 bug("\n");
804 }
805 ))
806 }
807 else if (!(bus->sdcb_BusStatus & SDHCI_INT_DATA_END))
808 {
809 sdcard_Udelay(1000);
810
811 if (timeout-- <= 0)
812 {
813 bug("[SDBus%02u] %s: Timeout!\n", bus->sdcb_BusNum, __PRETTY_FUNCTION__);
814 retVal = -1;
815 break;
816 }
817 }
818 } while ((sdDataLen > 0) && (!(bus->sdcb_BusStatus & SDHCI_INT_DATA_END)));
819
820 if (bus->sdcb_LEDCtrl)
821 bus->sdcb_LEDCtrl(LED_OFF);
822
823 sdDataLenTag->ti_Data -= sdDataLen;
824 }
825
826 return retVal;
827 }
828
829 ULONG FNAME_SDCBUS(WaitCmd)(ULONG mask, ULONG timeout, struct sdcard_Bus *bus)
830 {
831 D(bug("[SDBus%02u] %s(), task %p %s\n", bus->sdcb_BusNum, __PRETTY_FUNCTION__, FindTask(NULL), FindTask(NULL)->tc_Node.ln_Name));
832 D(bug("Task=%p\n", bus->sdcb_Task));
833 if (bus->sdcb_Task == FindTask(NULL))
834 {
835 D(bug("Waiting for signal %d\n", bus->sdcb_CommandSig));
836 Wait(1L << bus->sdcb_CommandSig);
837 }
838 else
839 {
840 D(bug("\nNot a Bus task!\n\n"));
841 sdcard_Udelay(1000);
842 }
843
844 while (bus->sdcb_IOReadLong(SDHCI_PRESENT_STATE, bus) & mask) {
845 sdcard_Udelay(1000);
846
847 if ((bus->sdcb_BusStatus & SDHCI_INT_ERROR) == SDHCI_INT_ERROR)
848 break;
849
850 if (--timeout <= 0)
851 break;
852 }
853
854 if ((timeout <= 0) || (bus->sdcb_BusStatus & SDHCI_INT_ERROR))
855 {
856 return -1;
857 }
858
859 return 0;
860 }
861
862
863 ULONG FNAME_SDCBUS(Rsp136Unpack)(ULONG *buf, ULONG offset, const ULONG len)
864 {
865 const ULONG mask = ((len < 32) ? (1 << len) : 0) - 1;
866 const ULONG shift = (offset) & 0x1F;
867 ULONG retval;
868
869 retval = buf[3 - (offset >> 5)] >> shift;
870 if (len + shift > 32)
871 retval |= buf[3 - (offset >> 5) - 1] << ((32 - shift) % 32);
872
873 return (retval & mask);
874 }
875
876 /********** BUS IRQ HANDLER **************/
877
878 #undef DIRQ
879 #define DIRQ(x) x
880
881 void FNAME_SDCBUS(BusIRQ)(struct sdcard_Bus *bus, void *_unused)
882 {
883 BOOL error = FALSE;
884
885 DIRQ(bug("[SDBus%02u] %s(bus @ 0x%p)\n", bus->sdcb_BusNum, __PRETTY_FUNCTION__, bus));
886
887 if (!(bus))
888 {
889 DIRQ(bug("[SDBus%02u] %s: Bad Params!\n", __PRETTY_FUNCTION__));
890 return;
891 }
892
893 bus->sdcb_BusStatus = bus->sdcb_IOReadLong(SDHCI_INT_STATUS, bus);
894
895 if (!(bus->sdcb_BusStatus & SDHCI_INT_ERROR))
896 {
897 DIRQ(bug("[SDBus%02u] %s: Status = %08x\n", bus->sdcb_BusNum, __PRETTY_FUNCTION__, bus->sdcb_BusStatus));
898
899 if (bus->sdcb_BusStatus & (SDHCI_INT_CARD_INSERT|SDHCI_INT_CARD_REMOVE))
900 {
901 bus->sdcb_IOWriteLong(SDHCI_INT_STATUS, (bus->sdcb_BusStatus & (SDHCI_INT_CARD_INSERT|SDHCI_INT_CARD_REMOVE)), bus);
902
903 bus->sdcb_BusFlags &= ~AF_Bus_MediaPresent;
904 bus->sdcb_BusFlags |= AF_Bus_MediaChanged;
905
906 if (bus->sdcb_BusStatus & SDHCI_INT_CARD_INSERT)
907 bus->sdcb_BusFlags |= AF_Bus_MediaPresent;
908
909 bus->sdcb_BusStatus &= ~(SDHCI_INT_CARD_INSERT|SDHCI_INT_CARD_REMOVE);
910
911 if (bus->sdcb_Task)
912 Signal(bus->sdcb_Task, (1L << bus->sdcb_MediaSig));
913 }
914 if (bus->sdcb_BusStatus & SDHCI_INT_CMD_MASK)
915 {
916 bus->sdcb_IOWriteLong(SDHCI_INT_STATUS, (bus->sdcb_BusStatus & SDHCI_INT_CMD_MASK), bus);
917
918 if ((bus->sdcb_BusStatus & SDHCI_INT_RESPONSE) &&
919 (bus->sdcb_RespListener))
920 {
921 if (FNAME_SDCBUS(FinishCmd)(bus->sdcb_RespListener, bus) == -1)
922 error = TRUE;
923 bus->sdcb_RespListener = NULL;
924 }
925 if (bus->sdcb_Task && (bus->sdcb_BusStatus & SDHCI_INT_RESPONSE))
926 {
927 DIRQ(bug("Signalling task %p (%s) with signal %d\n", bus->sdcb_Task, bus->sdcb_Task->tc_Node.ln_Name, bus->sdcb_CommandSig));
928 Signal(bus->sdcb_Task, 1L << bus->sdcb_CommandSig);
929 }
930
931 bus->sdcb_BusStatus &= ~SDHCI_INT_CMD_MASK;
932 }
933 if (bus->sdcb_BusStatus & SDHCI_INT_DATA_MASK)
934 {
935 if ((bus->sdcb_BusStatus & (SDHCI_INT_DATA_AVAIL|SDHCI_INT_SPACE_AVAIL)) &&
936 (bus->sdcb_DataListener))
937 {
938 if (FNAME_SDCBUS(FinishData)(bus->sdcb_DataListener, bus) == -1)
939 error = TRUE;
940 bus->sdcb_DataListener = NULL;
941 bus->sdcb_IOWriteLong(SDHCI_INT_STATUS, (bus->sdcb_BusStatus & (SDHCI_INT_DATA_AVAIL|SDHCI_INT_SPACE_AVAIL)), bus);
942 bus->sdcb_BusStatus &= ~SDHCI_INT_DATA_MASK;
943 }
944 else
945 {
946 bus->sdcb_IOWriteLong(SDHCI_INT_STATUS, (bus->sdcb_BusStatus & SDHCI_INT_DATA_MASK), bus);
947 bus->sdcb_BusStatus &= ~SDHCI_INT_DATA_MASK;
948 }
949 }
950 }
951 else
952 {
953 bug("[SDBus%02u] %s: ERROR [Status = %08x]\n", bus->sdcb_BusNum, __PRETTY_FUNCTION__, bus->sdcb_BusStatus);
954 if (bus->sdcb_BusStatus & SDHCI_INT_ACMD12ERR)
955 {
956 bug("[SDBus%02u] %s: [acmd12err = %04x ]\n", bus->sdcb_BusNum, __PRETTY_FUNCTION__, bus->sdcb_IOReadWord(SDHCI_ACMD12_ERR, bus));
957 }
958 error = TRUE;
959 }
960
961 if (error)
962 {
963 if (bus->sdcb_BusStatus & bus->sdcb_IntrMask)
964 {
965 bug("[SDBus%02u] %s: Clearing Unhandled Interrupts [%08x]\n", bus->sdcb_BusNum, __PRETTY_FUNCTION__, bus->sdcb_BusStatus & bus->sdcb_IntrMask);
966 bus->sdcb_IOWriteLong(SDHCI_INT_STATUS, bus->sdcb_BusStatus & bus->sdcb_IntrMask, bus);
967 bus->sdcb_BusStatus &= ~bus->sdcb_IntrMask;
968 }
969 bug("[SDBus%02u] %s: Reseting SDHCI CMD/DATA\n", bus->sdcb_BusNum, __PRETTY_FUNCTION__);
970
971 FNAME_SDCBUS(SoftReset)(SDHCI_RESET_CMD, bus);
972 FNAME_SDCBUS(SoftReset)(SDHCI_RESET_DATA, bus);
973 }
974 DIRQ(bug("[SDBus%02u] %s: Done.\n", bus->sdcb_BusNum, __PRETTY_FUNCTION__));
975 }
976
977 #undef DIRQ
978 #define DIRQ(x) /* x */
979 /********** BUS MANAGEMENT TASK **************/
980
981 void FNAME_SDCBUS(BusTask)(struct sdcard_Bus *bus)
982 {
983 LIBBASETYPEPTR LIBBASE = bus->sdcb_DeviceBase;
984 struct IORequest *msg;
985 ULONG sig, tasksig;
986
987 DFUNCS(bug("[SDBus%02u] %s()\n", bus->sdcb_BusNum, __PRETTY_FUNCTION__));
988
989 bus->sdcb_Timer = sdcard_OpenTimer(LIBBASE);
990
991 /* Get the signal used for sleeping */
992 bus->sdcb_Task = FindTask(0);
993
994 D(bug("[SDBus%02u] %s: Task @ 0x%p\n", bus->sdcb_BusNum, __PRETTY_FUNCTION__, bus->sdcb_Task));
995
996 bus->sdcb_TaskSig = AllocSignal(-1);
997 if ((bus->sdcb_MediaSig = AllocSignal(-1)) == -1)
998 {
999 D(bug("[SDBus%02u] %s: failed to allocate Media Change sigbit\n", bus->sdcb_BusNum, __PRETTY_FUNCTION__));
1000 }
1001
1002 if ((bus->sdcb_CommandSig = AllocSignal(-1)) == -1)
1003 {
1004 D(bug("[SDBus%02u] %s: failed to allocate Command Completed sigbit\n", bus->sdcb_BusNum, __PRETTY_FUNCTION__));
1005 }
1006
1007 /* Failed to get it? Use SIGBREAKB_CTRL_E instead */
1008 if (bus->sdcb_TaskSig < 0)
1009 bus->sdcb_TaskSig = SIGBREAKB_CTRL_E;
1010
1011 sig = ((1L << bus->sdcb_MsgPort->mp_SigBit)|(1L << bus->sdcb_TaskSig)|(1L << bus->sdcb_MediaSig));
1012
1013 DINIT(bug("[SDBus%02u] %s: TaskSig: %d, MediaSig: %d\n", bus->sdcb_BusNum, __PRETTY_FUNCTION__, bus->sdcb_TaskSig, bus->sdcb_MediaSig));
1014
1015 /* Install IRQ handler */
1016 if ((bus->sdcb_IRQHandle = KrnAddIRQHandler(bus->sdcb_BusIRQ, FNAME_SDCBUS(BusIRQ), bus, NULL)) != NULL)
1017 {
1018 DINIT(bug("[SDBus%02u] %s: IRQHandle @ 0x%p for IRQ#%ld\n", bus->sdcb_BusNum, __PRETTY_FUNCTION__, bus->sdcb_IRQHandle, bus->sdcb_BusIRQ));
1019
1020 DINIT(bug("[SDBus%02u] %s: Masking chipset Interrupts...\n", bus->sdcb_BusNum, __PRETTY_FUNCTION__));
1021
1022 bus->sdcb_IOWriteLong(SDHCI_INT_ENABLE, bus->sdcb_IntrMask, bus);
1023 bus->sdcb_IOWriteLong(SDHCI_SIGNAL_ENABLE, bus->sdcb_IntrMask, bus);
1024 }
1025
1026 for (;;)
1027 {
1028 tasksig = Wait(sig);
1029
1030 if ((tasksig & (1L << bus->sdcb_MediaSig)) && (bus->sdcb_BusFlags & AF_Bus_MediaChanged))
1031 {
1032 D(bug("[SDBus%02u] %s: detected unit change\n", bus->sdcb_BusNum, __PRETTY_FUNCTION__));
1033 D(bug("[SDBus%02u] %s: Card %s Detected!\n", bus->sdcb_BusNum, __PRETTY_FUNCTION__, (bus->sdcb_BusFlags & AF_Bus_MediaPresent) ? "Insert" : "Eject" ));
1034 if (bus->sdcb_BusFlags & AF_Bus_MediaPresent)
1035 {
1036 FNAME_SDCBUS(RegisterUnit)(bus);
1037 }
1038 else
1039 {
1040 FNAME_SDCBUS(ReleaseUnit)(bus);
1041 }
1042 }
1043
1044 /* Defer IORequest processing if the bus is active */
1045 if ((tasksig & (1L << bus->sdcb_MsgPort->mp_SigBit)) && (!(bus->sdcb_BusFlags & AF_Bus_Active)))
1046 {
1047 /* process pending requests .. */
1048 bus->sdcb_BusFlags |= AF_Bus_Active;
1049 while ((msg = (struct IORequest *)GetMsg(bus->sdcb_MsgPort)))
1050 {
1051 /* And do IO's */
1052 if (FNAME_SDC(HandleIO)(msg))
1053 {
1054 ReplyMsg((struct Message *)msg);
1055 }
1056 }
1057 bus->sdcb_BusFlags &= ~AF_Bus_Active;
1058 }
1059 }
1060 }
Mirror of AROS' svn.