?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Minor changes and fix HAVE_LCD_FLIP
[kugel-rb.git] / firmware / drivers / ata_mmc.c
blob16d06584c50bbd559e0132f4dcd0a8de67f86df6
1 /***************************************************************************
2 * __________ __ ___.
3 * Open \______ \ ____ ____ | | _\_ |__ _______ ___
4 * Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ /
5 * Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < <
6 * Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \
7 * \/ \/ \/ \/ \/
8 * $Id$
9 *
10 * Copyright (C) 2004 by Jens Arnold
11 *
12 * This program is free software; you can redistribute it and/or
13 * modify it under the terms of the GNU General Public License
14 * as published by the Free Software Foundation; either version 2
15 * of the License, or (at your option) any later version.
16 *
17 * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
18 * KIND, either express or implied.
19 *
20 ****************************************************************************/
21 #include <stdbool.h>
22 #include "mmc.h"
23 #include "ata_mmc.h"
24 #include "hotswap.h"
25 #include "ata_idle_notify.h"
26 #include "kernel.h"
27 #include "thread.h"
28 #include "led.h"
29 #include "sh7034.h"
30 #include "system.h"
31 #include "debug.h"
32 #include "panic.h"
33 #include "usb.h"
34 #include "power.h"
35 #include "string.h"
36 #include "hwcompat.h"
37 #include "adc.h"
38 #include "bitswap.h"
39 #include "disk.h" /* for mount/unmount */
40 #include "storage.h"
41
42 #define BLOCK_SIZE 512 /* fixed */
43
44 /* Command definitions */
45 #define CMD_GO_IDLE_STATE 0x40 /* R1 */
46 #define CMD_SEND_OP_COND 0x41 /* R1 */
47 #define CMD_SEND_CSD 0x49 /* R1 */
48 #define CMD_SEND_CID 0x4a /* R1 */
49 #define CMD_STOP_TRANSMISSION 0x4c /* R1 */
50 #define CMD_SEND_STATUS 0x4d /* R2 */
51 #define CMD_SET_BLOCKLEN 0x50 /* R1 */
52 #define CMD_READ_SINGLE_BLOCK 0x51 /* R1 */
53 #define CMD_READ_MULTIPLE_BLOCK 0x52 /* R1 */
54 #define CMD_WRITE_BLOCK 0x58 /* R1b */
55 #define CMD_WRITE_MULTIPLE_BLOCK 0x59 /* R1b */
56 #define CMD_READ_OCR 0x7a /* R3 */
57
58 /* Response formats:
59 R1 = single byte, msb=0, various error flags
60 R1b = R1 + busy token(s)
61 R2 = 2 bytes (1st byte identical to R1), additional flags
62 R3 = 5 bytes (R1 + OCR register)
63 */
64
65 #define R1_PARAMETER_ERR 0x40
66 #define R1_ADDRESS_ERR 0x20
67 #define R1_ERASE_SEQ_ERR 0x10
68 #define R1_COM_CRC_ERR 0x08
69 #define R1_ILLEGAL_CMD 0x04
70 #define R1_ERASE_RESET 0x02
71 #define R1_IN_IDLE_STATE 0x01
72
73 #define R2_OUT_OF_RANGE 0x80
74 #define R2_ERASE_PARAM 0x40
75 #define R2_WP_VIOLATION 0x20
76 #define R2_CARD_ECC_FAIL 0x10
77 #define R2_CC_ERROR 0x08
78 #define R2_ERROR 0x04
79 #define R2_ERASE_SKIP 0x02
80 #define R2_CARD_LOCKED 0x01
81
82 /* Data start tokens */
83
84 #define DT_START_BLOCK 0xfe
85 #define DT_START_WRITE_MULTIPLE 0xfc
86 #define DT_STOP_TRAN 0xfd
87
88 /* for compatibility */
89 static long last_disk_activity = -1;
90
91 /* private variables */
92
93 static struct mutex mmc_mutex;
94
95 #ifdef HAVE_HOTSWAP
96 static bool mmc_monitor_enabled = true;
97 static long mmc_stack[((DEFAULT_STACK_SIZE*2) + 0x800)/sizeof(long)];
98 #else
99 static long mmc_stack[(DEFAULT_STACK_SIZE*2)/sizeof(long)];
100 #endif
101 static const char mmc_thread_name[] = "mmc";
102 static struct event_queue mmc_queue;
103 static bool initialized = false;
104 static bool new_mmc_circuit;
105
106 static enum {
107 MMC_UNKNOWN,
108 MMC_UNTOUCHED,
109 MMC_TOUCHED
110 } mmc_status = MMC_UNKNOWN;
111
112 static enum {
113 SER_POLL_WRITE,
114 SER_POLL_READ,
115 SER_DISABLED
116 } serial_mode;
117
118 static const unsigned char dummy[] = {
119 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF
120 };
121
122 /* 2 buffers used alternatively for writing, including start token,
123 * dummy CRC and an extra byte to keep word alignment. */
124 static unsigned char write_buffer[2][BLOCK_SIZE+4];
125 static int current_buffer = 0;
126 static const unsigned char *send_block_addr = NULL;
127
128 static tCardInfo card_info[2];
129 #ifndef HAVE_MULTIDRIVE
130 static int current_card = 0;
131 #endif
132 static bool last_mmc_status = false;
133 static int countdown = HZ/3; /* for mmc switch debouncing */
134 static bool usb_activity; /* monitoring the USB bridge */
135 static long last_usb_activity;
136
137 /* private function declarations */
138
139 static int select_card(int card_no);
140 static void deselect_card(void);
141 static void setup_sci1(int bitrate_register);
142 static void set_sci1_poll_read(void);
143 static void write_transfer(const unsigned char *buf, int len)
144 __attribute__ ((section(".icode")));
145 static void read_transfer(unsigned char *buf, int len)
146 __attribute__ ((section(".icode")));
147 static unsigned char poll_byte(long timeout);
148 static unsigned char poll_busy(long timeout);
149 static unsigned char send_cmd(int cmd, unsigned long parameter, void *data);
150 static int receive_cxd(unsigned char *buf);
151 static int initialize_card(int card_no);
152 static int receive_block(unsigned char *inbuf, long timeout);
153 static void send_block_prepare(void);
154 static int send_block_send(unsigned char start_token, long timeout,
155 bool prepare_next);
156 static void mmc_tick(void);
157
158 /* implementation */
159
160 void mmc_enable_int_flash_clock(bool on)
161 {
162 /* Internal flash clock is enabled by setting PA12 high with the new
163 * clock circuit, and by setting it low with the old clock circuit */
164 if (on ^ new_mmc_circuit)
165 and_b(~0x10, &PADRH); /* clear clock gate PA12 */
166 else
167 or_b(0x10, &PADRH); /* set clock gate PA12 */
168 }
169
170 static int select_card(int card_no)
171 {
172 mutex_lock(&mmc_mutex);
173 led(true);
174 last_disk_activity = current_tick;
175
176 mmc_enable_int_flash_clock(card_no == 0);
177
178 if (!card_info[card_no].initialized)
179 {
180 setup_sci1(7); /* Initial rate: 375 kbps (need <= 400 per mmc specs) */
181 write_transfer(dummy, 10); /* allow the card to synchronize */
182 while (!(SSR1 & SCI_TEND));
183 }
184
185 if (card_no == 0) /* internal */
186 and_b(~0x04, &PADRH); /* assert CS */
187 else /* external */
188 and_b(~0x02, &PADRH); /* assert CS */
189
190 if (card_info[card_no].initialized)
191 {
192 setup_sci1(card_info[card_no].bitrate_register);
193 return 0;
194 }
195 else
196 {
197 return initialize_card(card_no);
198 }
199 }
200
201 static void deselect_card(void)
202 {
203 while (!(SSR1 & SCI_TEND)); /* wait for end of transfer */
204 or_b(0x06, &PADRH); /* deassert CS (both cards) */
205
206 led(false);
207 mutex_unlock(&mmc_mutex);
208 last_disk_activity = current_tick;
209 }
210
211 static void setup_sci1(int bitrate_register)
212 {
213 while (!(SSR1 & SCI_TEND)); /* wait for end of transfer */
214
215 SCR1 = 0; /* disable serial port */
216 SMR1 = SYNC_MODE; /* no prescale */
217 BRR1 = bitrate_register;
218 SSR1 = 0;
219
220 SCR1 = SCI_TE; /* enable transmitter */
221 serial_mode = SER_POLL_WRITE;
222 }
223
224 static void set_sci1_poll_read(void)
225 {
226 while (!(SSR1 & SCI_TEND)); /* wait for end of transfer */
227 SCR1 = 0; /* disable transmitter (& receiver) */
228 SCR1 = (SCI_TE|SCI_RE); /* re-enable transmitter & receiver */
229 while (!(SSR1 & SCI_TEND)); /* wait for SCI init completion (!) */
230 serial_mode = SER_POLL_READ;
231 TDR1 = 0xFF; /* send do-nothing while reading */
232 }
233
234 static void write_transfer(const unsigned char *buf, int len)
235 {
236 const unsigned char *buf_end = buf + len;
237 register unsigned char data;
238
239 if (serial_mode != SER_POLL_WRITE)
240 {
241 while (!(SSR1 & SCI_TEND)); /* wait for end of transfer */
242 SCR1 = 0; /* disable transmitter & receiver */
243 SSR1 = 0; /* clear all flags */
244 SCR1 = SCI_TE; /* enable transmitter only */
245 serial_mode = SER_POLL_WRITE;
246 }
247
248 while (buf < buf_end)
249 {
250 data = fliptable[(signed char)(*buf++)]; /* bitswap */
251 while (!(SSR1 & SCI_TDRE)); /* wait for end of transfer */
252 TDR1 = data; /* write byte */
253 SSR1 = 0; /* start transmitting */
254 }
255 }
256
257 /* don't call this with len == 0 */
258 static void read_transfer(unsigned char *buf, int len)
259 {
260 unsigned char *buf_end = buf + len - 1;
261 register signed char data;
262
263 if (serial_mode != SER_POLL_READ)
264 set_sci1_poll_read();
265
266 SSR1 = 0; /* start receiving first byte */
267 while (buf < buf_end)
268 {
269 while (!(SSR1 & SCI_RDRF)); /* wait for data */
270 data = RDR1; /* read byte */
271 SSR1 = 0; /* start receiving */
272 *buf++ = fliptable[data]; /* bitswap */
273 }
274 while (!(SSR1 & SCI_RDRF)); /* wait for last byte */
275 *buf = fliptable[(signed char)(RDR1)]; /* read & bitswap */
276 }
277
278 /* returns 0xFF on timeout, timeout is in bytes */
279 static unsigned char poll_byte(long timeout)
280 {
281 long i;
282 unsigned char data = 0; /* stop the compiler complaining */
283
284 if (serial_mode != SER_POLL_READ)
285 set_sci1_poll_read();
286
287 i = 0;
288 do {
289 SSR1 = 0; /* start receiving */
290 while (!(SSR1 & SCI_RDRF)); /* wait for data */
291 data = RDR1; /* read byte */
292 } while ((data == 0xFF) && (++i < timeout));
293
294 return fliptable[(signed char)data];
295 }
296
297 /* returns 0 on timeout, timeout is in bytes */
298 static unsigned char poll_busy(long timeout)
299 {
300 long i;
301 unsigned char data, dummy;
302
303 if (serial_mode != SER_POLL_READ)
304 set_sci1_poll_read();
305
306 /* get data response */
307 SSR1 = 0; /* start receiving */
308 while (!(SSR1 & SCI_RDRF)); /* wait for data */
309 data = fliptable[(signed char)(RDR1)]; /* read byte */
310
311 /* wait until the card is ready again */
312 i = 0;
313 do {
314 SSR1 = 0; /* start receiving */
315 while (!(SSR1 & SCI_RDRF)); /* wait for data */
316 dummy = RDR1; /* read byte */
317 } while ((dummy != 0xFF) && (++i < timeout));
318
319 return (dummy == 0xFF) ? data : 0;
320 }
321
322 /* Send MMC command and get response. Returns R1 byte directly.
323 * Returns further R2 or R3 bytes in *data (can be NULL for other commands) */
324 static unsigned char send_cmd(int cmd, unsigned long parameter, void *data)
325 {
326 static struct {
327 unsigned char cmd;
328 unsigned long parameter;
329 const unsigned char crc7; /* fixed, valid for CMD0 only */
330 const unsigned char trailer;
331 } __attribute__((packed)) command = {0x40, 0, 0x95, 0xFF};
332
333 unsigned char ret;
334
335 command.cmd = cmd;
336 command.parameter = htobe32(parameter);
337
338 write_transfer((unsigned char *)&command, sizeof(command));
339
340 ret = poll_byte(20);
341
342 switch (cmd)
343 {
344 case CMD_SEND_CSD: /* R1 response, leave open */
345 case CMD_SEND_CID:
346 case CMD_READ_SINGLE_BLOCK:
347 case CMD_READ_MULTIPLE_BLOCK:
348 return ret;
349
350 case CMD_SEND_STATUS: /* R2 response, close with dummy */
351 read_transfer(data, 1);
352 break;
353
354 case CMD_READ_OCR: /* R3 response, close with dummy */
355 read_transfer(data, 4);
356 break;
357
358 default: /* R1 response, close with dummy */
359 break; /* also catches block writes */
360 }
361 write_transfer(dummy, 1);
362 return ret;
363 }
364
365 /* Receive CID/ CSD data (16 bytes) */
366 static int receive_cxd(unsigned char *buf)
367 {
368 if (poll_byte(20) != DT_START_BLOCK)
369 {
370 write_transfer(dummy, 1);
371 return -1; /* not start of data */
372 }
373
374 read_transfer(buf, 16);
375 write_transfer(dummy, 3); /* 2 bytes dontcare crc + 1 byte trailer */
376 return 0;
377 }
378
379
380 static int initialize_card(int card_no)
381 {
382 int rc, i;
383 int blk_exp, ts_exp, taac_exp;
384 tCardInfo *card = &card_info[card_no];
385
386 static const char mantissa[] = { /* *10 */
387 0, 10, 12, 13, 15, 20, 25, 30,
388 35, 40, 45, 50, 55, 60, 70, 80
389 };
390 static const int exponent[] = { /* use varies */
391 1, 10, 100, 1000, 10000, 100000, 1000000,
392 10000000, 100000000, 1000000000
393 };
394
395 if (card_no == 1)
396 mmc_status = MMC_TOUCHED;
397
398 /* switch to SPI mode */
399 if (send_cmd(CMD_GO_IDLE_STATE, 0, NULL) != 0x01)
400 return -1; /* error or no response */
401
402 /* initialize card */
403 for (i = HZ;;) /* try for 1 second*/
404 {
405 sleep(1);
406 if (send_cmd(CMD_SEND_OP_COND, 0, NULL) == 0)
407 break;
408 if (--i <= 0)
409 return -2; /* timeout */
410 }
411
412 /* get OCR register */
413 if (send_cmd(CMD_READ_OCR, 0, &card->ocr))
414 return -3;
415 card->ocr = betoh32(card->ocr); /* no-op on big endian */
416
417 /* check voltage */
418 if (!(card->ocr & 0x00100000)) /* 3.2 .. 3.3 V */
419 return -4;
420
421 /* get CSD register */
422 if (send_cmd(CMD_SEND_CSD, 0, NULL))
423 return -5;
424 rc = receive_cxd((unsigned char*)card->csd);
425 if (rc)
426 return rc * 10 - 5;
427
428 blk_exp = card_extract_bits(card->csd, 83, 4);
429 if (blk_exp < 9) /* block size < 512 bytes not supported */
430 return -6;
431
432 card->numblocks = (card_extract_bits(card->csd, 73, 12) + 1)
433 << (card_extract_bits(card->csd, 49, 3) + 2 + blk_exp - 9);
434 card->blocksize = BLOCK_SIZE;
435
436 /* max transmission speed, clock divider */
437 ts_exp = card_extract_bits(card->csd, 98, 3);
438 ts_exp = (ts_exp > 3) ? 3 : ts_exp;
439 card->speed = mantissa[card_extract_bits(card->csd, 102, 4)]
440 * exponent[ts_exp + 4];
441 card->bitrate_register = (FREQ/4-1) / card->speed;
442
443 /* NSAC, TAAC, read timeout */
444 card->nsac = 100 * card_extract_bits(card->csd, 111, 8);
445 card->taac = mantissa[card_extract_bits(card->csd, 118, 4)];
446 taac_exp = card_extract_bits(card->csd, 114, 3);
447 card->read_timeout = ((FREQ/4) / (card->bitrate_register + 1)
448 * card->taac / exponent[9 - taac_exp]
449 + (10 * card->nsac));
450 card->read_timeout /= 8; /* clocks -> bytes */
451 card->taac = card->taac * exponent[taac_exp] / 10;
452
453 /* r2w_factor, write timeout */
454 card->r2w_factor = BIT_N(card_extract_bits(card->csd, 28, 3));
455 card->write_timeout = card->read_timeout * card->r2w_factor;
456
457 if (card->r2w_factor > 32) /* Such cards often need extra read delay */
458 card->read_timeout *= 4;
459
460 /* switch to full speed */
461 setup_sci1(card->bitrate_register);
462
463 /* always use 512 byte blocks */
464 if (send_cmd(CMD_SET_BLOCKLEN, BLOCK_SIZE, NULL))
465 return -7;
466
467 /* get CID register */
468 if (send_cmd(CMD_SEND_CID, 0, NULL))
469 return -8;
470 rc = receive_cxd((unsigned char*)card->cid);
471 if (rc)
472 return rc * 10 - 8;
473
474 card->initialized = true;
475 return 0;
476 }
477
478 tCardInfo *mmc_card_info(int card_no)
479 {
480 tCardInfo *card = &card_info[card_no];
481
482 if (!card->initialized && ((card_no == 0) || mmc_detect()))
483 {
484 select_card(card_no);
485 deselect_card();
486 }
487 return card;
488 }
489
490 /* Receive one block with DMA and bitswap it (chasing bitswap). */
491 static int receive_block(unsigned char *inbuf, long timeout)
492 {
493 unsigned long buf_end;
494
495 if (poll_byte(timeout) != DT_START_BLOCK)
496 {
497 write_transfer(dummy, 1);
498 return -1; /* not start of data */
499 }
500
501 while (!(SSR1 & SCI_TEND)); /* wait for end of transfer */
502
503 SCR1 = 0; /* disable serial */
504 SSR1 = 0; /* clear all flags */
505
506 /* setup DMA channel 0 */
507 CHCR0 = 0; /* disable */
508 SAR0 = RDR1_ADDR;
509 DAR0 = (unsigned long) inbuf;
510 DTCR0 = BLOCK_SIZE;
511 CHCR0 = 0x4601; /* fixed source address, RXI1, enable */
512 DMAOR = 0x0001;
513 SCR1 = (SCI_RE|SCI_RIE); /* kick off DMA */
514
515 /* DMA receives 2 bytes more than DTCR2, but the last 2 bytes are not
516 * stored. The first extra byte is available from RDR1 after the DMA ends,
517 * the second one is lost because of the SCI overrun. However, this
518 * behaviour conveniently discards the crc. */
519
520 yield(); /* be nice */
521
522 /* Bitswap received data, chasing the DMA pointer */
523 buf_end = (unsigned long)inbuf + BLOCK_SIZE;
524 do
525 {
526 /* Call bitswap whenever (a multiple of) 8 bytes are
527 * available (value optimised by experimentation). */
528 int swap_now = (DAR0 - (unsigned long)inbuf) & ~0x00000007;
529 if (swap_now)
530 {
531 bitswap(inbuf, swap_now);
532 inbuf += swap_now;
533 }
534 }
535 while ((unsigned long)inbuf < buf_end);
536
537 while (!(CHCR0 & 0x0002)); /* wait for end of DMA */
538 while (!(SSR1 & SCI_ORER)); /* wait for the trailing bytes */
539 SCR1 = 0;
540 serial_mode = SER_DISABLED;
541
542 write_transfer(dummy, 1); /* send trailer */
543 last_disk_activity = current_tick;
544 return 0;
545 }
546
547 /* Prepare a block for sending by copying it to the next write buffer
548 * and bitswapping it. */
549 static void send_block_prepare(void)
550 {
551 unsigned char *dest;
552
553 current_buffer ^= 1; /* toggle buffer */
554 dest = write_buffer[current_buffer] + 2;
555
556 memcpy(dest, send_block_addr, BLOCK_SIZE);
557 bitswap(dest, BLOCK_SIZE);
558
559 send_block_addr += BLOCK_SIZE;
560 }
561
562 /* Send one block with DMA from the current write buffer, possibly preparing
563 * the next block within the next write buffer in the background. */
564 static int send_block_send(unsigned char start_token, long timeout,
565 bool prepare_next)
566 {
567 int rc = 0;
568 unsigned char *curbuf = write_buffer[current_buffer];
569
570 curbuf[1] = fliptable[(signed char)start_token];
571 *(unsigned short *)(curbuf + BLOCK_SIZE + 2) = 0xFFFF;
572
573 while (!(SSR1 & SCI_TEND)); /* wait for end of transfer */
574
575 SCR1 = 0; /* disable serial */
576 SSR1 = 0; /* clear all flags */
577
578 /* setup DMA channel 0 */
579 CHCR0 = 0; /* disable */
580 SAR0 = (unsigned long)(curbuf + 1);
581 DAR0 = TDR1_ADDR;
582 DTCR0 = BLOCK_SIZE + 3; /* start token + block + dummy crc */
583 CHCR0 = 0x1701; /* fixed dest. address, TXI1, enable */
584 DMAOR = 0x0001;
585 SCR1 = (SCI_TE|SCI_TIE); /* kick off DMA */
586
587 if (prepare_next)
588 send_block_prepare();
589 yield(); /* be nice */
590
591 while (!(CHCR0 & 0x0002)); /* wait for end of DMA */
592 while (!(SSR1 & SCI_TEND)); /* wait for end of transfer */
593 SCR1 = 0;
594 serial_mode = SER_DISABLED;
595
596 if ((poll_busy(timeout) & 0x1F) != 0x05) /* something went wrong */
597 rc = -1;
598
599 write_transfer(dummy, 1);
600 last_disk_activity = current_tick;
601
602 return rc;
603 }
604
605 int mmc_read_sectors(IF_MD2(int drive,)
606 unsigned long start,
607 int incount,
608 void* inbuf)
609 {
610 int rc = 0;
611 int lastblock = 0;
612 unsigned long end_block;
613 tCardInfo *card;
614 #ifndef HAVE_MULTIDRIVE
615 int drive = current_card;
616 #endif
617
618 card = &card_info[drive];
619 rc = select_card(drive);
620 if (rc)
621 {
622 rc = rc * 10 - 1;
623 goto error;
624 }
625
626 end_block = start + incount;
627 if (end_block > card->numblocks)
628 {
629 rc = -2;
630 goto error;
631 }
632
633 /* Some cards don't like reading the very last block with
634 * CMD_READ_MULTIPLE_BLOCK, so make sure this block is always
635 * read with CMD_READ_SINGLE_BLOCK. */
636 if (end_block == card->numblocks)
637 lastblock = 1;
638
639 if (incount > 1)
640 {
641 /* MMC4.2: make multiplication conditional */
642 if (send_cmd(CMD_READ_MULTIPLE_BLOCK, start * BLOCK_SIZE, NULL))
643 {
644 rc = -3;
645 goto error;
646 }
647 while (--incount >= lastblock)
648 {
649 rc = receive_block(inbuf, card->read_timeout);
650 if (rc)
651 {
652 /* If an error occurs during multiple block reading, the
653 * host still needs to send CMD_STOP_TRANSMISSION */
654 send_cmd(CMD_STOP_TRANSMISSION, 0, NULL);
655 rc = rc * 10 - 4;
656 goto error;
657 }
658 inbuf += BLOCK_SIZE;
659 start++;
660 /* ^^ necessary for the abovementioned last block special case */
661 }
662 if (send_cmd(CMD_STOP_TRANSMISSION, 0, NULL))
663 {
664 rc = -5;
665 goto error;
666 }
667 }
668 if (incount > 0)
669 {
670 /* MMC4.2: make multiplication conditional */
671 if (send_cmd(CMD_READ_SINGLE_BLOCK, start * BLOCK_SIZE, NULL))
672 {
673 rc = -6;
674 goto error;
675 }
676 rc = receive_block(inbuf, card->read_timeout);
677 if (rc)
678 {
679 rc = rc * 10 - 7;
680 goto error;
681 }
682 }
683
684 error:
685
686 deselect_card();
687
688 return rc;
689 }
690
691 int mmc_write_sectors(IF_MD2(int drive,)
692 unsigned long start,
693 int count,
694 const void* buf)
695 {
696 int rc = 0;
697 int write_cmd;
698 unsigned char start_token;
699 tCardInfo *card;
700 #ifndef HAVE_MULTIDRIVE
701 int drive = current_card;
702 #endif
703
704 card = &card_info[drive];
705 rc = select_card(drive);
706 if (rc)
707 {
708 rc = rc * 10 - 1;
709 goto error;
710 }
711
712 if (start + count > card->numblocks)
713 panicf("Writing past end of card");
714
715 send_block_addr = buf;
716 send_block_prepare();
717
718 if (count > 1)
719 {
720 write_cmd = CMD_WRITE_MULTIPLE_BLOCK;
721 start_token = DT_START_WRITE_MULTIPLE;
722 }
723 else
724 {
725 write_cmd = CMD_WRITE_BLOCK;
726 start_token = DT_START_BLOCK;
727 }
728 /* MMC4.2: make multiplication conditional */
729 if (send_cmd(write_cmd, start * BLOCK_SIZE, NULL))
730 {
731 rc = -2;
732 goto error;
733 }
734 while (--count >= 0)
735 {
736 rc = send_block_send(start_token, card->write_timeout, count > 0);
737 if (rc)
738 {
739 rc = rc * 10 - 3;
740 break;
741 /* If an error occurs during multiple block writing,
742 * the STOP_TRAN token still needs to be sent. */
743 }
744 }
745 if (write_cmd == CMD_WRITE_MULTIPLE_BLOCK)
746 {
747 static const unsigned char stop_tran = DT_STOP_TRAN;
748 write_transfer(&stop_tran, 1);
749 poll_busy(card->write_timeout);
750 }
751
752 error:
753
754 deselect_card();
755
756 return rc;
757 }
758
759 bool mmc_disk_is_active(void)
760 {
761 /* this is correct unless early return from write gets implemented */
762 return mmc_mutex.locked;
763 }
764
765 static void mmc_thread(void)
766 {
767 struct queue_event ev;
768 bool idle_notified = false;
769
770 while (1) {
771 queue_wait_w_tmo(&mmc_queue, &ev, HZ);
772 switch ( ev.id )
773 {
774 case SYS_USB_CONNECTED:
775 usb_acknowledge(SYS_USB_CONNECTED_ACK);
776 /* Wait until the USB cable is extracted again */
777 usb_wait_for_disconnect(&mmc_queue);
778 break;
779
780 #ifdef HAVE_HOTSWAP
781 case SYS_HOTSWAP_INSERTED:
782 disk_mount(1); /* mount MMC */
783 queue_broadcast(SYS_FS_CHANGED, 0);
784 break;
785
786 case SYS_HOTSWAP_EXTRACTED:
787 disk_unmount(1); /* release "by force" */
788 queue_broadcast(SYS_FS_CHANGED, 0);
789 break;
790 #endif
791
792 default:
793 if (TIME_BEFORE(current_tick, last_disk_activity+(3*HZ)))
794 {
795 idle_notified = false;
796 }
797 else
798 {
799 if (!idle_notified)
800 {
801 call_storage_idle_notifys(false);
802 idle_notified = true;
803 }
804 }
805 break;
806 }
807 }
808 }
809
810 #ifdef HAVE_HOTSWAP
811 void mmc_enable_monitoring(bool on)
812 {
813 mmc_monitor_enabled = on;
814 }
815 #endif
816
817 bool mmc_detect(void)
818 {
819 return (adc_read(ADC_MMC_SWITCH) < 0x200);
820 }
821
822 bool mmc_touched(void)
823 {
824 if (mmc_status == MMC_UNKNOWN) /* try to detect */
825 {
826 mutex_lock(&mmc_mutex);
827 setup_sci1(7); /* safe value */
828 and_b(~0x02, &PADRH); /* assert CS */
829 if (send_cmd(CMD_SEND_OP_COND, 0, NULL) == 0xFF)
830 mmc_status = MMC_UNTOUCHED;
831 else
832 mmc_status = MMC_TOUCHED;
833
834 deselect_card();
835 }
836 return mmc_status == MMC_TOUCHED;
837 }
838
839 bool mmc_usb_active(int delayticks)
840 {
841 /* reading "inactive" is delayed by user-supplied monoflop value */
842 return (usb_activity ||
843 TIME_BEFORE(current_tick, last_usb_activity + delayticks));
844 }
845
846 static void mmc_tick(void)
847 {
848 bool current_status;
849 #ifndef HAVE_HOTSWAP
850 const bool mmc_monitor_enabled = true;
851 #endif
852
853 if (new_mmc_circuit)
854 /* USB bridge activity is 0 on idle, ~527 on active */
855 current_status = adc_read(ADC_USB_ACTIVE) > 0x100;
856 else
857 current_status = adc_read(ADC_USB_ACTIVE) < 0x190;
858
859 if (!current_status && usb_activity)
860 last_usb_activity = current_tick;
861 usb_activity = current_status;
862
863 if (mmc_monitor_enabled)
864 {
865 current_status = mmc_detect();
866 /* Only report when the status has changed */
867 if (current_status != last_mmc_status)
868 {
869 last_mmc_status = current_status;
870 countdown = HZ/3;
871 }
872 else
873 {
874 /* Count down until it gets negative */
875 if (countdown >= 0)
876 countdown--;
877
878 if (countdown == 0)
879 {
880 if (current_status)
881 {
882 queue_broadcast(SYS_HOTSWAP_INSERTED, 0);
883 }
884 else
885 {
886 queue_broadcast(SYS_HOTSWAP_EXTRACTED, 0);
887 mmc_status = MMC_UNTOUCHED;
888 card_info[1].initialized = false;
889 }
890 }
891 }
892 }
893 }
894
895 void mmc_enable(bool on)
896 {
897 PBCR1 &= ~0x0CF0; /* PB13, PB11 and PB10 become GPIO,
898 * if not modified below */
899 if (on)
900 PBCR1 |= 0x08A0; /* as SCK1, TxD1, RxD1 */
901
902 and_b(~0x80, &PADRL); /* assert flash reset */
903 sleep(HZ/100);
904 or_b(0x80, &PADRL); /* de-assert flash reset */
905 sleep(HZ/100);
906 card_info[0].initialized = false;
907 card_info[1].initialized = false;
908 }
909
910 int mmc_init(void)
911 {
912 int rc = 0;
913
914 if (!initialized)
915 {
916 mutex_init(&mmc_mutex);
917 queue_init(&mmc_queue, true);
918 }
919 mutex_lock(&mmc_mutex);
920 led(false);
921
922 last_mmc_status = mmc_detect();
923 #ifndef HAVE_MULTIDRIVE
924 /* Use MMC if inserted, internal flash otherwise */
925 current_card = last_mmc_status ? 1 : 0;
926 #endif
927
928 if (!initialized)
929 {
930 if (!last_mmc_status)
931 mmc_status = MMC_UNTOUCHED;
932
933 /* Port setup */
934 PACR1 &= ~0x0F3C; /* GPIO function for PA13 (flash busy), PA12
935 * (clk gate), PA10 (flash CS), PA9 (MMC CS) */
936 PACR2 &= ~0x4000; /* GPIO for PA7 (flash reset) */
937 PADR |= 0x0680; /* set all the selects + reset high (=inactive) */
938 PAIOR |= 0x1680; /* make outputs for them and the PA12 clock gate */
939
940 PBCR1 &= ~0x0CF0; /* GPIO function for PB13, PB11 and PB10 */
941 PBDR |= 0x2C00; /* SCK1, TxD1 and RxD1 high in GPIO */
942 PBIOR |= 0x2000; /* SCK1 output */
943 PBIOR &= ~0x0C00; /* TxD1, RxD1 input */
944
945 IPRE &= 0x0FFF; /* disable SCI1 interrupts for the CPU */
946
947 new_mmc_circuit = ((HW_MASK & MMC_CLOCK_POLARITY) != 0);
948
949 create_thread(mmc_thread, mmc_stack,
950 sizeof(mmc_stack), 0, mmc_thread_name
951 IF_PRIO(, PRIORITY_SYSTEM)
952 IF_COP(, CPU));
953 tick_add_task(mmc_tick);
954 initialized = true;
955 }
956 mmc_enable(true);
957
958 mutex_unlock(&mmc_mutex);
959 return rc;
960 }
961
962 long mmc_last_disk_activity(void)
963 {
964 return last_disk_activity;
965 }
966
967 #ifdef STORAGE_GET_INFO
968 void mmc_get_info(IF_MD2(int drive,) struct storage_info *info)
969 {
970 #ifndef HAVE_MULTIDRIVE
971 const int drive=0;
972 #endif
973 info->sector_size=card_info[drive].blocksize;
974 info->num_sectors=card_info[drive].numblocks;
975 info->vendor="Rockbox";
976 if(drive==0)
977 {
978 info->product="Internal Storage";
979 }
980 else
981 {
982 info->product="MMC Card Slot";
983 }
984 info->revision="0.00";
985 }
986 #endif
987
988 #ifdef HAVE_HOTSWAP
989 bool mmc_removable(IF_MD_NONVOID(int drive))
990 {
991 #ifndef HAVE_MULTIDRIVE
992 const int drive=0;
993 #endif
994 return (drive==1);
995 }
996
997 bool mmc_present(IF_MD_NONVOID(int drive))
998 {
999 #ifndef HAVE_MULTIDRIVE
1000 const int drive=0;
1001 #endif
1002 if(drive==0)
1003 {
1004 return true;
1005 }
1006 else
1007 {
1008 return mmc_detect();
1009 }
1010 }
1011 #endif
1012
1013
1014 void mmc_sleep(void)
1015 {
1016 }
1017
1018 void mmc_spin(void)
1019 {
1020 }
1021
1022 void mmc_spindown(int seconds)
1023 {
1024 (void)seconds;
1025 }
1026
1027 #ifdef CONFIG_STORAGE_MULTI
1028 int mmc_num_drives(int first_drive)
1029 {
1030 /* We don't care which logical drive number(s) we have been assigned */
1031 (void)first_drive;
1032
1033 #ifdef HAVE_MULTIDRIVE
1034 return 2;
1035 #else
1036 return 1;
1037 #endif
1038 }
1039 #endif
My public Rockbox git repo