OpenCores
URL https://opencores.org/ocsvn/usb_fpga_2_04/usb_fpga_2_04/trunk

Subversion Repositories usb_fpga_2_04

[/] [usb_fpga_2_04/] [trunk/] [include/] [ztex-flash1.h] - Blame information for rev 2

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 2 ZTEX 
/*!
2 
   ZTEX Firmware Kit for EZ-USB FX2 Microcontrollers
3 
   Copyright (C) 2009-2014 ZTEX GmbH.
4 
   http://www.ztex.de
5 
 
6 
   This program is free software; you can redistribute it and/or modify
7 
   it under the terms of the GNU General Public License version 3 as
8 
   published by the Free Software Foundation.
9 
 
10 
   This program is distributed in the hope that it will be useful, but
11 
   WITHOUT ANY WARRANTY; without even the implied warranty of
12 
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 
   General Public License for more details.
14 
 
15 
   You should have received a copy of the GNU General Public License
16 
   along with this program; if not, see http://www.gnu.org/licenses/.
17 
!*/
18 
 
19 
/*
20 
    Support for SD cards in SPI mode.
21 
    This module is not MMC compatible anymore since multi block read/write commands are used.
22 
*/
23 
 
24 
#ifeq[MMC_PORT][E]
25 
#define[MMC_bmMODE]
26 
#elifeq[MMC_PORT][A]
27 
#elifeq[MMC_PORT][B]
28 
#elifeq[MMC_PORT][C]
29 
#elifneq[MMC_PORT][D]
30 
#error[Macro `MMC_PORT' is not defined correctly. Valid values are: `A', `B', `C', `D' and `E'.]
31 
#endif
32 
 
33 
#ifndef[ZTEX_FLASH1_H]
34 
#define[ZTEX_FLASH1_H]
35 
 
36 
#define[@CAPABILITY_FLASH;]
37 
 
38 
#ifndef[MMC_PORT]
39 
#error[MMC_PORT not defined]
40 
#endif
41 
 
42 
#ifndef[MMC_BIT_CS]
43 
#error[MMC_BIT_CS not defined]
44 
#endif
45 
 
46 
#ifndef[MMC_BIT_DI]
47 
#error[MMC_BIT_DI not defined]
48 
#endif
49 
 
50 
#ifndef[MMC_BIT_DO]
51 
#error[MMC_BIT_DO not defined]
52 
#endif
53 
 
54 
#ifndef[MMC_BIT_CLK]
55 
#error[MMC_BIT_CLK not defined]
56 
#endif
57 
 
58 
#ifndef[MMC__PORT_DO]
59 
#define[MMC__PORT_DO][MMC_PORT]
60 
#endif
61 
 
62 
#ifdef[MMC_bmMODE]
63 
#ifneq[MMC__PORT_DO][MMC_PORT]
64 
#error[MMC__PORT_DO and MMC_PORT must be equal]
65 
#endif
66 
#endif
67 
 
68 
#define[MMC_bmCS][bmBITMMC_BIT_CS]
69 
#define[MMC_bmDI][bmBITMMC_BIT_DI]
70 
#define[MMC_bmDO][bmBITMMC_BIT_DO]
71 
#define[MMC_bmCLK][bmBITMMC_BIT_CLK]
72 
 
73 
#define[MMC_IO][IOMMC_PORT]
74 
#define[MMC__IO_DO][IOMMC__PORT_DO]
75 
 
76 
#ifndef[MMC_bmMODE]
77 
#define[MMC_CS][IOMMC_PORTMMC_BIT_CS]
78 
#define[MMC_CLK][IOMMC_PORTMMC_BIT_CLK]
79 
#define[MMC_DI][IOMMC_PORTMMC_BIT_DI]
80 
#define[MMC_DO][IOMMC__PORT_DOMMC_BIT_DO]
81 
#endif
82 
 
83 
// may be redefined if the first sectors are reserved (e.g. for a FPGA bitstream)
84 
#define[FLASH_FIRST_FREE_SECTOR][0]
85 
 
86 
__xdata BYTE flash_enabled;     // 0    1: enabled, 0:disabled
87 
__xdata WORD flash_sector_size; // 1    sector size
88 
__xdata DWORD flash_sectors;    // 3    number of sectors
89 
__xdata BYTE flash_ec;          // 7    error code
90 
 
91 
__xdata BYTE mmc_last_cmd;      // 0
92 
__xdata BYTE mmc_response;      // 1
93 
__xdata BYTE mmc_version;       // 2
94 
__xdata BYTE mmc_buffer[16];    // 3
95 
 
96 
__xdata BYTE mmc_ep0_wait;
97 
 
98 
#define[FLASH_EC_CMD_ERROR][1]
99 
#define[FLASH_EC_TIMEOUT][2]
100 
#define[FLASH_EC_BUSY][3]
101 
#define[FLASH_EC_PENDING][4]
102 
#define[FLASH_EC_READ_ERROR][5]
103 
#define[FLASH_EC_WRITE_ERROR][6]
104 
#define[FLASH_EC_NOTSUPPORTED][7]
105 
 
106 
/* *********************************************************************
107 
   ***** mmc_clocks ****************************************************
108 
   ********************************************************************* */
109 
// perform c (256 if c=0) clocks
110 
void mmc_clocks (BYTE c) {
111 
        c;                                      // this avoids stupid warnings
112 
__asm
113 
        mov     r2,dpl
114 
#ifdef[MMC_bmMODE]
115 
        mov     a,_MMC_IO
116 
        anl     a, #(~MMC_bmCLK)
117 
        mov     r3, a
118 
        orl     a, #(MMC_bmCLK)
119 
        mov     r4, a
120 
010014$:
121 
        mov     _MMC_IO,r4
122 
        nop
123 
        mov     _MMC_IO,r3
124 
#else
125 
010014$:
126 
        setb    _MMC_CLK
127 
        nop
128 
        clr     _MMC_CLK
129 
#endif
130 
        djnz    r2,010014$
131 
__endasm;
132 
}
133 
 
134 
 
135 
/* *********************************************************************
136 
   ***** flash_read_byte ***********************************************
137 
   ********************************************************************* */
138 
// read a single byte from the flash
139 
BYTE flash_read_byte() { // uses r2,r3,r4
140 
__asm
141 
#ifdef[MMC_bmMODE]
142 
        // 8 - 1 + 8*13 + 1 + 6 = 118 clocks
143 
        mov     a,_MMC_IO
144 
        anl     a, #(~MMC_bmCLK)
145 
        mov     r2, a
146 
        orl     a, #(MMC_bmCLK)
147 
        mov     r3, a
148 
 
149 
        mov     a,_MMC_IO       // 7
150 
        anl     a,#(MMC_bmDO)
151 
        mov     _MMC_IO, r3
152 
        subb    a,#1
153 
        rlc     a
154 
        mov     r4,a
155 
        mov     _MMC_IO, r2
156 
 
157 
        mov     a,_MMC_IO       // 6
158 
        anl     a,#(MMC_bmDO)
159 
        mov     _MMC_IO, r3
160 
        subb    a,#1
161 
        mov     a,r4
162 
        rlc     a
163 
        mov     r4,a
164 
        mov     _MMC_IO, r2
165 
 
166 
        mov     a,_MMC_IO       // 5
167 
        anl     a,#(MMC_bmDO)
168 
        mov     _MMC_IO, r3
169 
        subb    a,#1
170 
        mov     a,r4
171 
        rlc     a
172 
        mov     r4,a
173 
        mov     _MMC_IO, r2
174 
 
175 
        mov     a,_MMC_IO       // 4
176 
        anl     a,#(MMC_bmDO)
177 
        mov     _MMC_IO, r3
178 
        subb    a,#1
179 
        mov     a,r4
180 
        rlc     a
181 
        mov     r4,a
182 
        mov     _MMC_IO, r2
183 
 
184 
        mov     a,_MMC_IO       // 3
185 
        anl     a,#(MMC_bmDO)
186 
        mov     _MMC_IO, r3
187 
        subb    a,#1
188 
        mov     a,r4
189 
        rlc     a
190 
        mov     r4,a
191 
        mov     _MMC_IO, r2
192 
 
193 
        mov     a,_MMC_IO       // 2
194 
        anl     a,#(MMC_bmDO)
195 
        mov     _MMC_IO, r3
196 
        subb    a,#1
197 
        mov     a,r4
198 
        rlc     a
199 
        mov     r4,a
200 
        mov     _MMC_IO, r2
201 
 
202 
        mov     a,_MMC_IO       // 1
203 
        anl     a,#(MMC_bmDO)
204 
        mov     _MMC_IO, r3
205 
        subb    a,#1
206 
        mov     a,r4
207 
        rlc     a
208 
        mov     r4,a
209 
        mov     _MMC_IO, r2
210 
 
211 
        mov     a,_MMC_IO       // 0
212 
        anl     a,#(MMC_bmDO)
213 
        mov     _MMC_IO, r3
214 
        subb    a,#1
215 
        mov     a,r4
216 
        rlc     a
217 
        xrl     a,#255
218 
        mov     _MMC_IO, r2
219 
 
220 
#else
221 
        // 8*7 + 6 = 62 clocks
222 
        mov     c,_MMC_DO       // 7
223 
        setb    _MMC_CLK
224 
        rlc     a
225 
        clr     _MMC_CLK
226 
 
227 
        mov     c,_MMC_DO       // 6
228 
        setb    _MMC_CLK
229 
        rlc     a
230 
        clr     _MMC_CLK
231 
 
232 
        mov     c,_MMC_DO       // 5
233 
        setb    _MMC_CLK
234 
        rlc     a
235 
        clr     _MMC_CLK
236 
 
237 
        mov     c,_MMC_DO       // 4
238 
        setb    _MMC_CLK
239 
        rlc     a
240 
        clr     _MMC_CLK
241 
 
242 
        mov     c,_MMC_DO       // 3
243 
        setb    _MMC_CLK
244 
        rlc     a
245 
        clr     _MMC_CLK
246 
 
247 
        mov     c,_MMC_DO       // 2
248 
        setb    _MMC_CLK
249 
        rlc     a
250 
        clr     _MMC_CLK
251 
 
252 
        mov     c,_MMC_DO       // 1
253 
        setb    _MMC_CLK
254 
        rlc     a
255 
        clr     _MMC_CLK
256 
 
257 
        mov     c,_MMC_DO       // 0
258 
        setb    _MMC_CLK
259 
        rlc     a
260 
        clr     _MMC_CLK
261 
#endif
262 
        mov     dpl,a
263 
        ret
264 
__endasm;
265 
        return 0;                // never ever called (just to avoid warnings)
266 
}
267 
 
268 
/* *********************************************************************
269 
   ***** flash_read ****************************************************
270 
   ********************************************************************* */
271 
// read len (256 if len=0) bytes from the flash to the buffer
272 
void flash_read(__xdata BYTE *buf, BYTE len) {
273 
        *buf;                                   // this avoids stupid warnings
274 
        len;                                    // this too
275 
__asm                                           // *buf is in dptr, len is in _flash_read_PARM_2
276 
        mov     r2,_flash_read_PARM_2
277 
#ifdef[MMC_bmMODE]
278 
        mov     a,_MMC_IO
279 
        anl     a, #(~MMC_bmCLK)
280 
        mov     r5, a
281 
        orl     a, #(MMC_bmCLK)
282 
        mov     r3, a
283 
 
284 
010012$:
285 
        // 8 + len*(-1 + 8*13 - 1 + 2 + 9) + 4 = 12 + len*113 clocks
286 
        mov     a,_MMC_IO       // 7
287 
        anl     a,#(MMC_bmDO)
288 
        mov     _MMC_IO, r3
289 
        subb    a,#1
290 
        rlc     a
291 
        mov     r4,a
292 
        mov     _MMC_IO, r5
293 
 
294 
        mov     a,_MMC_IO       // 6
295 
        anl     a,#(MMC_bmDO)
296 
        mov     _MMC_IO, r3
297 
        subb    a,#1
298 
        mov     a,r4
299 
        rlc     a
300 
        mov     r4,a
301 
        mov     _MMC_IO, r5
302 
 
303 
        mov     a,_MMC_IO       // 5
304 
        anl     a,#(MMC_bmDO)
305 
        mov     _MMC_IO, r3
306 
        subb    a,#1
307 
        mov     a,r4
308 
        rlc     a
309 
        mov     r4,a
310 
        mov     _MMC_IO, r5
311 
 
312 
        mov     a,_MMC_IO       // 4
313 
        anl     a,#(MMC_bmDO)
314 
        mov     _MMC_IO, r3
315 
        subb    a,#1
316 
        mov     a,r4
317 
        rlc     a
318 
        mov     r4,a
319 
        mov     _MMC_IO, r5
320 
 
321 
        mov     a,_MMC_IO       // 3
322 
        anl     a,#(MMC_bmDO)
323 
        mov     _MMC_IO, r3
324 
        subb    a,#1
325 
        mov     a,r4
326 
        rlc     a
327 
        mov     r4,a
328 
        mov     _MMC_IO, r5
329 
 
330 
        mov     a,_MMC_IO       // 2
331 
        anl     a,#(MMC_bmDO)
332 
        mov     _MMC_IO, r3
333 
        subb    a,#1
334 
        mov     a,r4
335 
        rlc     a
336 
        mov     r4,a
337 
        mov     _MMC_IO, r5
338 
 
339 
        mov     a,_MMC_IO       // 1
340 
        anl     a,#(MMC_bmDO)
341 
        mov     _MMC_IO, r3
342 
        subb    a,#1
343 
        mov     a,r4
344 
        rlc     a
345 
        mov     r4,a
346 
        mov     _MMC_IO, r5
347 
 
348 
        mov     a,_MMC_IO       // 0
349 
        anl     a,#(MMC_bmDO)
350 
        mov     _MMC_IO, r3
351 
        subb    a,#1
352 
        mov     a,r4
353 
        rlc     a
354 
        xrl     a,#255
355 
        mov     _MMC_IO, r5
356 
#else
357 
010012$:
358 
        // 2 + len*(8*7 + 9) + 4 = 6 + len*65 clocks
359 
        mov     c,_MMC_DO       // 7
360 
        setb    _MMC_CLK
361 
        rlc     a
362 
        clr     _MMC_CLK
363 
 
364 
        mov     c,_MMC_DO       // 6
365 
        setb    _MMC_CLK
366 
        rlc     a
367 
        clr     _MMC_CLK
368 
 
369 
        mov     c,_MMC_DO       // 5
370 
        setb    _MMC_CLK
371 
        rlc     a
372 
        clr     _MMC_CLK
373 
 
374 
        mov     c,_MMC_DO       // 4
375 
        setb    _MMC_CLK
376 
        rlc     a
377 
        clr     _MMC_CLK
378 
 
379 
        mov     c,_MMC_DO       // 3
380 
        setb    _MMC_CLK
381 
        rlc     a
382 
        clr     _MMC_CLK
383 
 
384 
        mov     c,_MMC_DO       // 2
385 
        setb    _MMC_CLK
386 
        rlc     a
387 
        clr     _MMC_CLK
388 
 
389 
        mov     c,_MMC_DO       // 1
390 
        setb    _MMC_CLK
391 
        rlc     a
392 
        clr     _MMC_CLK
393 
 
394 
        mov     c,_MMC_DO       // 0
395 
        setb    _MMC_CLK
396 
        rlc     a
397 
        clr     _MMC_CLK
398 
#endif
399 
        movx    @dptr,a
400 
        inc     dptr
401 
        djnz    r2,010012$
402 
__endasm;
403 
}
404 
 
405 
/* *********************************************************************
406 
   ***** flash_write_byte **********************************************
407 
   ********************************************************************* */
408 
// send one bytes from buffer buf to the card
409 
void flash_write_byte (BYTE b) {        // b is in dpl
410 
        b;                              // this avoids stupid warnings
411 
__asm
412 
#ifdef[MMC_bmMODE]
413 
        // up to 7 + 8*12 + 6 = 109 clocks
414 
        mov     a,_MMC_IO
415 
        anl     a, #(255 - MMC_bmCLK - MMC_bmDI )
416 
        mov     r3, a
417 
        mov     a,dpl
418 
 
419 
        rlc     a               // 7
420 
        mov     _MMC_IO,r3
421 
        jnc     0100157$
422 
        orl     _MMC_IO, #(MMC_bmDI)
423 
0100157$:
424 
        orl     _MMC_IO, #(MMC_bmCLK)
425 
 
426 
        rlc     a               // 6
427 
        mov     _MMC_IO,r3
428 
        jnc     0100156$
429 
        orl     _MMC_IO, #(MMC_bmDI)
430 
0100156$:
431 
        orl     _MMC_IO, #(MMC_bmCLK)
432 
 
433 
        rlc     a               // 5
434 
        mov     _MMC_IO,r3
435 
        jnc     0100155$
436 
        orl     _MMC_IO, #(MMC_bmDI)
437 
0100155$:
438 
        orl     _MMC_IO, #(MMC_bmCLK)
439 
 
440 
        rlc     a               // 4
441 
        mov     _MMC_IO,r3
442 
        jnc     0100154$
443 
        orl     _MMC_IO, #(MMC_bmDI)
444 
0100154$:
445 
        orl     _MMC_IO, #(MMC_bmCLK)
446 
 
447 
        rlc     a               // 3
448 
        mov     _MMC_IO,r3
449 
        jnc     0100153$
450 
        orl     _MMC_IO, #(MMC_bmDI)
451 
0100153$:
452 
        orl     _MMC_IO, #(MMC_bmCLK)
453 
 
454 
        rlc     a               // 2
455 
        mov     _MMC_IO,r3
456 
        jnc     0100152$
457 
        orl     _MMC_IO, #(MMC_bmDI)
458 
0100152$:
459 
        orl     _MMC_IO, #(MMC_bmCLK)
460 
 
461 
        rlc     a               // 1
462 
        mov     _MMC_IO,r3
463 
        jnc     0100151$
464 
        orl     _MMC_IO, #(MMC_bmDI)
465 
0100151$:
466 
        orl     _MMC_IO, #(MMC_bmCLK)
467 
 
468 
        rlc     a               // 0
469 
        mov     _MMC_IO,r3
470 
        jnc     0100150$
471 
        orl     _MMC_IO, #(MMC_bmDI)
472 
0100150$:
473 
        orl     _MMC_IO, #(MMC_bmCLK)
474 
 
475 
        mov     _MMC_IO,r3
476 
#else
477 
        // 3 + 8*7 + 4 = 63 clocks
478 
        mov     a,dpl
479 
        rlc     a               // 7
480 
 
481 
        mov     _MMC_DI,c
482 
        setb    _MMC_CLK
483 
        rlc     a               // 6
484 
        clr     _MMC_CLK
485 
 
486 
        mov     _MMC_DI,c
487 
        setb    _MMC_CLK
488 
        rlc     a               // 5
489 
        clr     _MMC_CLK
490 
 
491 
        mov     _MMC_DI,c
492 
        setb    _MMC_CLK
493 
        rlc     a               // 4
494 
        clr     _MMC_CLK
495 
 
496 
        mov     _MMC_DI,c
497 
        setb    _MMC_CLK
498 
        rlc     a               // 3
499 
        clr     _MMC_CLK
500 
 
501 
        mov     _MMC_DI,c
502 
        setb    _MMC_CLK
503 
        rlc     a               // 2
504 
        clr     _MMC_CLK
505 
 
506 
        mov     _MMC_DI,c
507 
        setb    _MMC_CLK
508 
        rlc     a               // 1
509 
        clr     _MMC_CLK
510 
 
511 
        mov     _MMC_DI,c
512 
        setb    _MMC_CLK
513 
        rlc     a               // 0
514 
        clr     _MMC_CLK
515 
 
516 
        mov     _MMC_DI,c
517 
        setb    _MMC_CLK
518 
        nop
519 
        clr     _MMC_CLK
520 
#endif
521 
__endasm;
522 
}
523 
 
524 
/* *********************************************************************
525 
   ***** flash_write ***************************************************
526 
   ********************************************************************* */
527 
// write len (256 id len=0) bytes from the buffer to the flash
528 
void flash_write(__xdata BYTE *buf, BYTE len) {
529 
        *buf;                                   // this avoids stupid warnings
530 
        len;                                    // this too
531 
__asm                                           // *buf is in dptr, len is in _flash_read_PARM_2
532 
        mov     r2,_flash_read_PARM_2
533 
#ifdef[MMC_bmMODE]
534 
        // 7 + len*(2 + 8*12 + 7 ) + 6 = 13 + len*105 clocks
535 
        mov     a,_MMC_IO
536 
        anl     a, #(255 - MMC_bmCLK - MMC_bmDI )
537 
        mov     r3, a
538 
010013$:
539 
        movx    a,@dptr
540 
 
541 
        rlc     a               // 7
542 
        mov     _MMC_IO,r3
543 
        jnc     0100167$
544 
        orl     _MMC_IO, #(MMC_bmDI)
545 
0100167$:
546 
        orl     _MMC_IO, #(MMC_bmCLK)
547 
 
548 
        rlc     a               // 6
549 
        mov     _MMC_IO,r3
550 
        jnc     0100166$
551 
        orl     _MMC_IO, #(MMC_bmDI)
552 
0100166$:
553 
        orl     _MMC_IO, #(MMC_bmCLK)
554 
 
555 
        rlc     a               // 5
556 
        mov     _MMC_IO,r3
557 
        jnc     0100165$
558 
        orl     _MMC_IO, #(MMC_bmDI)
559 
0100165$:
560 
        orl     _MMC_IO, #(MMC_bmCLK)
561 
 
562 
        rlc     a               // 4
563 
        mov     _MMC_IO,r3
564 
        jnc     0100164$
565 
        orl     _MMC_IO, #(MMC_bmDI)
566 
0100164$:
567 
        orl     _MMC_IO, #(MMC_bmCLK)
568 
 
569 
        rlc     a               // 3
570 
        mov     _MMC_IO,r3
571 
        jnc     0100163$
572 
        orl     _MMC_IO, #(MMC_bmDI)
573 
0100163$:
574 
        orl     _MMC_IO, #(MMC_bmCLK)
575 
 
576 
        rlc     a               // 2
577 
        mov     _MMC_IO,r3
578 
        jnc     0100162$
579 
        orl     _MMC_IO, #(MMC_bmDI)
580 
0100162$:
581 
        orl     _MMC_IO, #(MMC_bmCLK)
582 
 
583 
        rlc     a               // 1
584 
        mov     _MMC_IO,r3
585 
        jnc     0100161$
586 
        orl     _MMC_IO, #(MMC_bmDI)
587 
0100161$:
588 
        orl     _MMC_IO, #(MMC_bmCLK)
589 
 
590 
        rlc     a               // 0
591 
        mov     _MMC_IO,r3
592 
        jnc     0100160$
593 
        orl     _MMC_IO, #(MMC_bmDI)
594 
0100160$:
595 
        orl     _MMC_IO, #(MMC_bmCLK)
596 
 
597 
        inc     dptr
598 
        djnz    r2,010013$
599 
 
600 
        mov     _MMC_IO,r3
601 
#else
602 
010013$:
603 
        // 2 + len*(3 + 8*7 - 1 + 7 ) + 4 = 6 + len*65 clocks
604 
        movx    a,@dptr
605 
        rlc     a               // 7
606 
 
607 
        mov     _MMC_DI,c
608 
        setb    _MMC_CLK
609 
        rlc     a               // 6
610 
        clr     _MMC_CLK
611 
 
612 
        mov     _MMC_DI,c
613 
        setb    _MMC_CLK
614 
        rlc     a               // 5
615 
        clr     _MMC_CLK
616 
 
617 
        mov     _MMC_DI,c
618 
        setb    _MMC_CLK
619 
        rlc     a               // 4
620 
        clr     _MMC_CLK
621 
 
622 
        mov     _MMC_DI,c
623 
        setb    _MMC_CLK
624 
        rlc     a               // 3
625 
        clr     _MMC_CLK
626 
 
627 
        mov     _MMC_DI,c
628 
        setb    _MMC_CLK
629 
        rlc     a               // 2
630 
        clr     _MMC_CLK
631 
 
632 
        mov     _MMC_DI,c
633 
        setb    _MMC_CLK
634 
        rlc     a               // 1
635 
        clr     _MMC_CLK
636 
 
637 
        mov     _MMC_DI,c
638 
        setb    _MMC_CLK
639 
        rlc     a               // 0
640 
        clr     _MMC_CLK
641 
 
642 
        mov     _MMC_DI,c
643 
        setb    _MMC_CLK
644 
        inc     dptr
645 
        clr     _MMC_CLK
646 
 
647 
        djnz    r2,010013$
648 
#endif
649 
__endasm;
650 
}
651 
 
652 
/* *********************************************************************
653 
   ***** mmc_wait_busy *************************************************
654 
   ********************************************************************* */
655 
BYTE mmc_wait_busy () {
656 
    WORD i;
657 
    flash_ec = FLASH_EC_BUSY;
658 
    MMC_IO |= MMC_bmDI;                         // avoids that in-data is interpreted as command
659 
    for (i=0; (flash_read_byte()!=255) && i<65535; i++ ) ;
660 
//    for (i=0; (flash_read_byte()==0) && i<65535; i++ ) ;
661 
    if ( MMC__IO_DO & MMC_bmDO ) {
662 
        flash_ec = 0;
663 
        return 0;
664 
    }
665 
    return 1;
666 
}
667 
 
668 
/* *********************************************************************
669 
   ***** mmc_select ****************************************************
670 
   ********************************************************************* */
671 
/*
672 
   select the card (CS) and waits if busy
673 
   returns 1 if busy
674 
*/
675 
BYTE mmc_select() {
676 
    MMC_IO |= MMC_bmCS;                         // CS = 1
677 
    mmc_clocks(8);                              // 8 dummy clocks to finish a previous command
678 
    MMC_IO &= ~MMC_bmCS;                        // CS = 0
679 
 
680 
    return mmc_wait_busy();
681 
}
682 
 
683 
/* *********************************************************************
684 
   ***** mmc_deselect **************************************************
685 
   ********************************************************************* */
686 
// de-select the card (CS) and waits if busy
687 
void mmc_deselect() {
688 
    MMC_IO |= MMC_bmDI;                         // CS = 1
689 
    mmc_clocks(8);                              // 8 dummy clocks to finish a previous command
690 
    MMC_IO |= MMC_bmCS;                         // CS = 1
691 
    mmc_clocks(8);                              // 8 more dummy clocks
692 
}
693 
 
694 
/* *********************************************************************
695 
   ***** mmc_read_response *********************************************
696 
   ********************************************************************* */
697 
// read the first response byte
698 
BYTE mmc_read_response() {
699 
        MMC_IO |= MMC_bmDI;                     // avoids that in-data is interpreted as command
700 
__asm
701 
        mov     r2,#0x255
702 
010010$:
703 
        lcall   _flash_read_byte
704 
        mov     a,dpl
705 
        jnb     acc.7,010011$
706 
        djnz    r2, 010010$
707 
 
708 
010011$:
709 
        mov     dptr,#_mmc_response
710 
        movx    @dptr,a
711 
        mov     dpl,a
712 
        ret
713 
__endasm;
714 
        return 0;                                // never ever called, just to avoid stupid warnings
715 
}
716 
 
717 
/* *********************************************************************
718 
   ***** mmc_send_cmd **************************************************
719 
   ********************************************************************* */
720 
// send a command
721 
#define[mmc_send_cmd(][,$1.$2.$3.$4,$5);][{                     // send a command, argument=0
722 
    mmc_clocks(8);                              // 8 dummy clocks
723 
    mmc_last_cmd = $0;
724 
    mmc_buffer[0] = 64 | ($0 & 127);
725 
    mmc_buffer[1] = $1;
726 
    mmc_buffer[2] = $2;
727 
    mmc_buffer[3] = $3;
728 
    mmc_buffer[4] = $4;
729 
    mmc_buffer[5] = $5 | 1;
730 
    flash_write(mmc_buffer,6);
731 
    mmc_read_response();
732 
}]
733 
 
734 
/* *********************************************************************
735 
   ***** mmc_wait_start ************************************************
736 
   ********************************************************************* */
737 
/*
738 
   wait for the start byte
739 
   returns 1 on error
740 
*/
741 
BYTE mmc_wait_start() {
742 
    WORD to;
743 
    to=0;
744 
    MMC_IO |= MMC_bmDI;                         // avoids that in-data is interpreted as command
745 
    while ( flash_read_byte() != 0xfe ) {       // wait for the start byte
746 
        if ( ++to == 0 )                         // 65536 * 8 clocks
747 
            return 1;
748 
    }
749 
    return 0;
750 
}
751 
 
752 
/* *********************************************************************
753 
   ***** flash_read_init ***********************************************
754 
   ********************************************************************* */
755 
/*
756 
   Start the initialization sequence for reading sector s.
757 
   The whole sector must be read.
758 
   returns an error code (FLASH_EC_*). 0 means no error.
759 
*/
760 
BYTE flash_read_init(DWORD s) {
761 
    if ( (MMC_IO & MMC_bmCS) == 0 ) {
762 
        return FLASH_EC_PENDING;                // we interrupted a pending Flash operation
763 
    }
764 
    if ( mmc_select() ) {                       // select the card
765 
        mmc_deselect();
766 
        return FLASH_EC_BUSY;
767 
    }
768 
    mmc_clocks(8);                              // 8 dummy clocks
769 
    mmc_last_cmd = 18;
770 
    mmc_buffer[0] = 18 | 64;
771 
    if ( mmc_version == 0 ) {
772 
        s = s << 1;
773 
        mmc_buffer[1] = s >> 16;
774 
        mmc_buffer[2] = s >> 8;
775 
        mmc_buffer[3] = s;
776 
        mmc_buffer[4] = 0;
777 
    }
778 
    else {
779 
        mmc_buffer[1] = s >> 24;
780 
        mmc_buffer[2] = s >> 16;
781 
        mmc_buffer[3] = s >> 8;
782 
        mmc_buffer[4] = s;
783 
    }
784 
    mmc_buffer[5] = 1;
785 
    flash_write(mmc_buffer,6);
786 
    mmc_read_response();
787 
    if ( mmc_response != 0 ) {
788 
        mmc_deselect();
789 
        return FLASH_EC_CMD_ERROR;
790 
    }
791 
 
792 
    if ( mmc_wait_start() ) {                   // wait for the start byte
793 
        mmc_deselect();
794 
        return FLASH_EC_TIMEOUT;
795 
    }
796 
    return 0;
797 
}
798 
 
799 
/* *********************************************************************
800 
   ***** flash_read_next ***********************************************
801 
   ********************************************************************* */
802 
/*
803 
   Initialization sequence for reading the next sector.
804 
   The whole sector must be read.
805 
   returns an error code (FLASH_EC_*). 0 means no error.
806 
*/
807 
BYTE flash_read_next() {
808 
    mmc_clocks(16);                             // 16 CRC clocks
809 
    if ( mmc_wait_start() ) {                   // wait for the start byte
810 
        mmc_deselect();
811 
        return FLASH_EC_TIMEOUT;
812 
    }
813 
    return 0;
814 
}
815 
 
816 
/* *********************************************************************
817 
   ***** flash_read_finish *********************************************
818 
   ********************************************************************* */
819 
/*
820 
   Reads n dummy bytes (the whole sector has to be read out)
821 
   and runs the finalization sequence for a sector read.
822 
*/
823 
void flash_read_finish(WORD n) {
824 
    while ( n > 32 ) {
825 
        mmc_clocks(0);                   // 256 clocks = 32 dummy bytes
826 
        n-=32;
827 
    }
828 
    if ( n>0) mmc_clocks(n << 3);
829 
    mmc_clocks(16);                     // 16 CRC clocks
830 
    mmc_send_cmd(12, 0.0.0.0, 0);        // stop transmission command, errors are ignored
831 
//    mmc_wait_busy();                  // not required here
832 
    mmc_clocks(8);                      // 8 dummy clocks
833 
   mmc_deselect();
834 
}
835 
 
836 
 
837 
/* *********************************************************************
838 
   ***** flash_write_init **********************************************
839 
   ********************************************************************* */
840 
/*
841 
   Start the initialization sequence for writing sector s
842 
   The whole sector must be written.
843 
   returns an error code (FLASH_EC_*). 0 means no error.
844 
*/
845 
BYTE flash_write_init(DWORD s) {
846 
    if ( (MMC_IO & MMC_bmCS) == 0 ) {
847 
        return FLASH_EC_PENDING;                // we interrupted a pending Flash operation
848 
    }
849 
    if ( mmc_select() ) {                       // select the card
850 
        mmc_deselect();
851 
        return FLASH_EC_BUSY;
852 
    }
853 
    mmc_clocks(8);                              // 8 dummy clocks
854 
    mmc_last_cmd = 25;
855 
    mmc_buffer[0] = 25 | 64;
856 
    if ( mmc_version == 0 ) {
857 
        s = s << 1;
858 
        mmc_buffer[1] = s >> 16;
859 
        mmc_buffer[2] = s >> 8;
860 
        mmc_buffer[3] = s;
861 
        mmc_buffer[4] = 0;
862 
    }
863 
    else {
864 
        mmc_buffer[1] = s >> 24;
865 
        mmc_buffer[2] = s >> 16;
866 
        mmc_buffer[3] = s >> 8;
867 
        mmc_buffer[4] = s;
868 
    }
869 
    mmc_buffer[5] = 1;
870 
    flash_write(mmc_buffer,6);
871 
    mmc_read_response();
872 
    if ( mmc_response != 0 ) {
873 
        mmc_deselect();
874 
        return FLASH_EC_CMD_ERROR;
875 
    }
876 
 
877 
    MMC_IO |= MMC_bmDI;
878 
    mmc_clocks(8);                              // send one dummy byte
879 
    flash_write_byte( 0xfc );                   // send the start byte
880 
    return 0;
881 
}
882 
 
883 
/* *********************************************************************
884 
   ***** flash_write_finish_sector *************************************
885 
   ********************************************************************* */
886 
/*
887 
   Writes the rest of the sector (n dummy bytes + CRC, the whole sector has to be written)
888 
   but do not run the finalization procedure. This is done by flash_write_finish
889 
   or flash_write_next, i.e. these functions must be called after flash_write_finish_sector.
890 
 
891 
   Between flash_write_finish / flash_write_next and flash_write_finish_sector some code
892 
   may be executed because flash_write_finish / flash_write_next start with
893 
   mmc_wait_busy().
894 
 
895 
   Returns an error code (FLASH_EC_*). 0 means no error.
896 
*/
897 
BYTE flash_write_finish_sector (WORD n) {
898 
    MMC_IO &= ~MMC_bmDI;                        // value of the dummy data is 0
899 
    while ( n > 32 ) {
900 
        mmc_clocks(0);                           // 256 clocks = 32 dummy bytes
901 
        n-=32;
902 
    }
903 
    if ( n>0) mmc_clocks(n << 3);
904 
 
905 
    MMC_IO |= MMC_bmDI;
906 
    mmc_clocks(16);                             // 16 CRC clocks
907 
 
908 
    if ( (flash_read_byte() & 0xf) != 5 ) {     // data response: last four bits must be 5
909 
       flash_ec = FLASH_EC_WRITE_ERROR;
910 
       mmc_send_cmd(12, 0.0.0.0, 0);             // stop transmission command, errors are ignored
911 
       mmc_clocks(8);                           // 8 dummy clocks
912 
       mmc_deselect();
913 
       return FLASH_EC_WRITE_ERROR;
914 
    }
915 
    return 0;
916 
}
917 
 
918 
/* *********************************************************************
919 
   ***** flash_write_finish ********************************************
920 
   ********************************************************************* */
921 
/*
922 
   Stops the write transimssion, see flash_write_finish1.
923 
*/
924 
void flash_write_finish () {
925 
    mmc_wait_busy();
926 
    flash_write_byte( 0xfd );                   // send the stop byte
927 
    mmc_clocks(8);                              // 8 dummy clocks
928 
    mmc_deselect();
929 
}
930 
 
931 
/* *********************************************************************
932 
   ***** flash_write_next **********************************************
933 
   ********************************************************************* */
934 
/*
935 
   Prepare the nexte sector for writing, see flash_write_finish_sector.
936 
*/
937 
void flash_write_next () {
938 
    mmc_wait_busy();
939 
    flash_write_byte( 0xfc );                   // send the stop byte
940 
}
941 
 
942 
/* *********************************************************************
943 
   ***** flash_init ****************************************************
944 
   ********************************************************************* */
945 
// init the card
946 
void flash_init() {
947 
    BYTE i, j, k;
948 
 
949 
#ifeq[UFM_1_15X_DETECTION_ENABLED][1]
950 
    if ( is_ufm_1_15x ) {
951 
        flash_enabled = 0;
952 
        flash_ec = FLASH_EC_NOTSUPPORTED;
953 
        return;
954 
    }
955 
#endif
956 
 
957 
    flash_enabled = 1;
958 
    flash_sector_size = 512;
959 
    mmc_version = 0;
960 
 
961 
    OEMMC_PORT = OEMMC_PORT | ( MMC_bmCS | MMC_bmDI | MMC_bmCLK );
962 
    OEMMC__PORT_DO = OEMMC__PORT_DO & ~MMC_bmDO;
963 
 
964 
    MMC_IO |= MMC_bmDI;
965 
    MMC_IO |= MMC_bmCS;
966 
    mmc_clocks(0);                               // 256 clocks
967 
 
968 
    mmc_select();                               // select te card
969 
    flash_ec = FLASH_EC_BUSY;
970 
 
971 
    mmc_send_cmd(0, 0.0.0.0, 0x95);              // send reset command
972 
    if ( mmc_response & ~1 ) {                  // check for errors
973 
        wait(50);
974 
        mmc_send_cmd(0, 0.0.0.0, 0x95);          // 2nd try
975 
        if ( mmc_response & ~1 )                // check for errors
976 
            goto mmc_init_cmd_err;
977 
    }
978 
 
979 
    // send cmd8, valid ? 2.0 mode : 1.xx mode
980 
    mmc_send_cmd(8, 0.0.1.0xaa, 0x87);
981 
    if ( ( mmc_response & bmBIT2) == 0 ) {
982 
        if ( (mmc_response & 0xfe) != 0 )
983 
            goto mmc_init_cmd_err;
984 
        flash_read(mmc_buffer,4);
985 
        if ( ( (mmc_buffer[2] & 15) != 1) || (mmc_buffer[3] != 0xaa ) ) {
986 
            flash_ec = FLASH_EC_NOTSUPPORTED;
987 
            goto mmc_init_err;
988 
        }
989 
        mmc_version=1;
990 
    }
991 
 
992 
    // CMD1 is not recommended, therefore we try ACMD41 first
993 
    k=mmc_version ? 64 : 0;
994 
    mmc_send_cmd(55, 0.0.0.0, 0);
995 
    if ( (mmc_response & 0xfe) == 0 )
996 
        mmc_send_cmd(41, k.0.0.0, 0);
997 
    j = mmc_response & 0xfe;
998 
 
999 
    for ( i=0; mmc_response != 0 && i<255; i++ ) {        // send the init command and wait wait (up to 1s) until ready
1000 
        wait(4);
1001 
        if ( j ) {
1002 
            mmc_send_cmd(1, k.0.0.0, 0xff);
1003 
        }
1004 
        else {
1005 
            mmc_send_cmd(55, 0.0.0.0, 0);
1006 
            mmc_send_cmd(41, k.0.0.0, 0);
1007 
        }
1008 
    }
1009 
    if ( mmc_response != 0 ) {                   // check for errors
1010 
        goto mmc_init_cmd_err;
1011 
    }
1012 
 
1013 
    if ( mmc_version ) {
1014 
        mmc_send_cmd(58, 0.0.0.0, 0);            // check the high capacity mode
1015 
        if ( mmc_response != 0 )                 // check for errors
1016 
            goto mmc_init_cmd_err;
1017 
        flash_read(mmc_buffer,4);
1018 
        if ( (mmc_buffer[0] & 64) == 0 )  // card in standard capacity mode
1019 
            mmc_version = 0;
1020 
    }
1021 
 
1022 
    mmc_send_cmd(9, 0.0.0.0, 0);         // read the CSD
1023 
    if ( mmc_wait_start() ) {
1024 
        flash_ec = FLASH_EC_TIMEOUT;
1025 
        goto mmc_init_err;
1026 
    }
1027 
    flash_read(mmc_buffer,16);
1028 
    mmc_clocks(16);                             // CRC is clocked out
1029 
 
1030 
    mmc_buffer[0] &= 192;
1031 
    if ( (mmc_buffer[0] & 192) == 0  ) {
1032 
        i = (mmc_buffer[5] & 15) + ((mmc_buffer[10] >> 7) | ((mmc_buffer[9] & 3) << 1)) - 7;
1033 
        flash_sectors = ((mmc_buffer[8] >> 6) | (mmc_buffer[7] << 2) | ((mmc_buffer[6] & 3) << 10)) + 1;
1034 
        flash_sectors = flash_sectors << i;
1035 
    }
1036 
    else if ( (mmc_buffer[0] & 192) == 64  ) { // todo
1037 
        flash_sectors = ( ( ((DWORD)(mmc_buffer[7] & 63) << 16) | (mmc_buffer[8] << 8) | mmc_buffer[9]  ) +1 ) << 10;
1038 
    }
1039 
    else {
1040 
        flash_ec = FLASH_EC_NOTSUPPORTED;
1041 
        goto mmc_init_err;
1042 
    }
1043 
 
1044 
    flash_ec = 0;
1045 
    mmc_deselect();
1046 
 
1047 
    return;
1048 
 
1049 
mmc_init_cmd_err:
1050 
    flash_ec = FLASH_EC_CMD_ERROR;
1051 
mmc_init_err:
1052 
    flash_enabled = 0;
1053 
    mmc_deselect();
1054 
}
1055 
 
1056 
 
1057 
/* *********************************************************************
1058 
   ***** EP0 vendor request 0x40 ***************************************
1059 
   ********************************************************************* */
1060 
// send mmc information structure (card size, error status,  ...) to the host
1061 
ADD_EP0_VENDOR_REQUEST((0x40,,
1062 
    MEM_COPY1(flash_enabled,EP0BUF,8);
1063 
    EP0BCH = 0;
1064 
    EP0BCL = 8;
1065 
,,
1066 
));;
1067 
 
1068 
/* *********************************************************************
1069 
   ***** EP0 vendor request 0x41 ***************************************
1070 
   ********************************************************************* */
1071 
void mmc_read_ep0 () {
1072 
    if ( mmc_ep0_wait ) {
1073 
        mmc_ep0_wait = 0;
1074 
        if ( mmc_wait_start() ) {               // wait for the start byte of the next block
1075 
            flash_ec = FLASH_EC_TIMEOUT;
1076 
            mmc_send_cmd(12, 0.0.0.0, 0);        // stop transmission command
1077 
            mmc_clocks(8);                      // 8 dummy clocks
1078 
            mmc_deselect();
1079 
            return;
1080 
        }
1081 
    }
1082 
 
1083 
    flash_read(EP0BUF, ep0_payload_transfer);
1084 
    if ( ep0_payload_remaining == 0 ) {
1085 
        mmc_clocks(16);                         // 16 CRC clocks
1086 
        mmc_send_cmd(12, 0.0.0.0, 0);            // stop transmission command, errors are ignored
1087 
//      mmc_wait_busy();                        // not required here
1088 
        mmc_clocks(8);                          // 8 dummy clocks
1089 
        mmc_deselect();
1090 
    }
1091 
    else if ( (ep0_payload_remaining & 511) == 0 ) {
1092 
        mmc_clocks(16);                         // 16 CRC clocks
1093 
        mmc_ep0_wait = 1;
1094 
    }
1095 
}
1096 
 
1097 
ADD_EP0_VENDOR_REQUEST((0x41,,                  // read integer number of sectotrs
1098 
    if ( (MMC_IO & MMC_bmCS) == 0 ) {
1099 
        flash_ec = FLASH_EC_PENDING;            // we interrupted a pending Flash operation
1100 
        EP0_STALL;
1101 
    }
1102 
    if ( mmc_select() ) {                       // select the card
1103 
        mmc_deselect();
1104 
        EP0_STALL;
1105 
    }
1106 
    mmc_clocks(8);                              // 8 dummy clocks
1107 
    mmc_last_cmd = 18;
1108 
    mmc_buffer[0] = 18 | 64;
1109 
    if ( mmc_version == 0 ) {
1110 
__asm
1111 
    clr c
1112 
    mov dptr,#(_SETUPDAT + 2)
1113 
    movx a,@dptr
1114 
    mov dptr,#(_mmc_buffer + 3)
1115 
    rlc a
1116 
    movx @dptr,a
1117 
 
1118 
    mov dptr,#(_SETUPDAT + 3)
1119 
    movx a,@dptr
1120 
    mov dptr,#(_mmc_buffer + 2)
1121 
    rlc a
1122 
    movx @dptr,a
1123 
 
1124 
    mov dptr,#(_SETUPDAT + 4)
1125 
    movx a,@dptr
1126 
    mov dptr,#(_mmc_buffer + 1)
1127 
    rlc a
1128 
    movx @dptr,a
1129 
__endasm;
1130 
        mmc_buffer[4] = 0;
1131 
    }
1132 
    else {
1133 
        mmc_buffer[1] = SETUPDAT[5];
1134 
        mmc_buffer[2] = SETUPDAT[4];
1135 
        mmc_buffer[3] = SETUPDAT[3];
1136 
        mmc_buffer[4] = SETUPDAT[2];
1137 
    }
1138 
    mmc_buffer[5] = 1;
1139 
    flash_write(mmc_buffer,6);
1140 
    mmc_read_response();
1141 
    if ( mmc_response != 0 ) {
1142 
        flash_ec = FLASH_EC_CMD_ERROR;
1143 
        mmc_deselect();
1144 
        EP0_STALL;
1145 
    }
1146 
 
1147 
    mmc_ep0_wait = 1;
1148 
    mmc_read_ep0();
1149 
    if ( flash_ec != 0 ) {
1150 
        EP0_STALL;
1151 
    }
1152 
    EP0BCH = 0;
1153 
    EP0BCL = ep0_payload_transfer;
1154 
,,
1155 
    if ( ep0_payload_transfer != 0 ) {
1156 
        flash_ec = 0;
1157 
        mmc_read_ep0();
1158 
        if ( flash_ec != 0 ) {
1159 
            EP0_STALL;
1160 
        }
1161 
    }
1162 
    EP0BCH = 0;
1163 
    EP0BCL = ep0_payload_transfer;
1164 
));;
1165 
 
1166 
/* *********************************************************************
1167 
   ***** EP0 vendor command 0x42 ***************************************
1168 
   ********************************************************************* */
1169 
void mmc_send_ep0 () {
1170 
    if ( mmc_ep0_wait ) {
1171 
        mmc_ep0_wait = 0;
1172 
        mmc_wait_busy();
1173 
        flash_write_byte( 0xfc );                       // send the start byte of the next data block
1174 
    }
1175 
 
1176 
    flash_write(EP0BUF, ep0_payload_transfer);
1177 
    if ( (ep0_payload_remaining & 511) == 0 ) {
1178 
        MMC_IO |= MMC_bmDI;
1179 
        mmc_clocks(16);                                 // 16 CRC clocks
1180 
 
1181 
        if ( (flash_read_byte() & 0xf) != 5 ) {         // data response: last four bits must be 5
1182 
           flash_ec = FLASH_EC_WRITE_ERROR;
1183 
           mmc_send_cmd(12, 0.0.0.0, 0);         // stop transmission command, errors are ignored
1184 
           mmc_clocks(8);                               // 8 dummy clocks
1185 
           mmc_deselect();
1186 
        }
1187 
 
1188 
        if ( ep0_payload_remaining != 0 ) {
1189 
            mmc_ep0_wait = 1;
1190 
        }
1191 
        else {
1192 
            mmc_wait_busy();
1193 
            flash_write_byte( 0xfd );                   // send the stop byte
1194 
            mmc_clocks(8);                              // 8 dummy clocks
1195 
            mmc_deselect();
1196 
        }
1197 
    }
1198 
}
1199 
 
1200 
ADD_EP0_VENDOR_COMMAND((0x42,,                  // write integer number of sectors
1201 
    if ( (MMC_IO & MMC_bmCS) == 0 ) {
1202 
        flash_ec = FLASH_EC_PENDING;            // we interrupted a pending Flash operation
1203 
        EP0_STALL;
1204 
    }
1205 
    if ( mmc_select() ) {                       // select the card
1206 
        mmc_deselect();
1207 
        EP0_STALL;
1208 
    }
1209 
    mmc_clocks(8);                              // 8 dummy clocks
1210 
    mmc_last_cmd = 25;
1211 
    mmc_buffer[0] = 25 | 64;
1212 
    if ( mmc_version == 0 ) {
1213 
__asm
1214 
    clr c
1215 
    mov dptr,#(_SETUPDAT + 2)
1216 
    movx a,@dptr
1217 
    mov dptr,#(_mmc_buffer + 3)
1218 
    rlc a
1219 
    movx @dptr,a
1220 
 
1221 
    mov dptr,#(_SETUPDAT + 3)
1222 
    movx a,@dptr
1223 
    mov dptr,#(_mmc_buffer + 2)
1224 
    rlc a
1225 
    movx @dptr,a
1226 
 
1227 
    mov dptr,#(_SETUPDAT + 4)
1228 
    movx a,@dptr
1229 
    mov dptr,#(_mmc_buffer + 1)
1230 
    rlc a
1231 
    movx @dptr,a
1232 
__endasm;
1233 
        mmc_buffer[4] = 0;
1234 
    }
1235 
    else {
1236 
        mmc_buffer[1] = SETUPDAT[5];
1237 
        mmc_buffer[2] = SETUPDAT[4];
1238 
        mmc_buffer[3] = SETUPDAT[3];
1239 
        mmc_buffer[4] = SETUPDAT[2];
1240 
    }
1241 
 
1242 
    mmc_buffer[5] = 1;
1243 
    flash_write(mmc_buffer,6);
1244 
    mmc_read_response();
1245 
    if ( mmc_response != 0 ) {
1246 
        flash_ec = FLASH_EC_CMD_ERROR;
1247 
        mmc_deselect();
1248 
        EP0_STALL;
1249 
    }
1250 
 
1251 
    MMC_IO |= MMC_bmDI;
1252 
    mmc_clocks(8);                              // send one dummy byte
1253 
    flash_write_byte( 0xfc );                   // send the start byte
1254 
    mmc_ep0_wait = 0;
1255 
,,
1256 
    if ( ep0_payload_transfer != 0 ) {
1257 
        flash_ec = 0;
1258 
        mmc_send_ep0();
1259 
        if ( flash_ec != 0 ) {
1260 
            EP0_STALL;
1261 
        }
1262 
    }
1263 
));;
1264 
 
1265 
/* *********************************************************************
1266 
   ***** EP0 vendor request 0x43 ***************************************
1267 
   ********************************************************************* */
1268 
// send detailed MMC status plus debug information
1269 
ADD_EP0_VENDOR_REQUEST((0x43,,                  // this may interrupt a pending operation
1270 
    MEM_COPY1(flash_ec,EP0BUF+2,20);
1271 
    EP0BUF[22] = (MMC__IO_DO & MMC_bmDO) == 0;
1272 
    mmc_select();
1273 
    mmc_send_cmd(13, 0.0.0.0, 0);
1274 
    EP0BUF[0] = mmc_response;
1275 
    EP0BUF[1] = flash_read_byte();
1276 
    mmc_deselect();
1277 
    EP0BCH = 0;
1278 
    EP0BCL = 23;
1279 
,,
1280 
));;
1281 
 
1282 
#endif  /*ZTEX_FLASH1_H*/

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.