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

Subversion Repositories test_project

[/] [test_project/] [trunk/] [linux_sd_driver/] [drivers/] [mmc/] [core/] [mmc.c] - Blame information for rev 62

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 62 marcus.erl 
/*
2 
 *  linux/drivers/mmc/core/mmc.c
3 
 *
4 
 *  Copyright (C) 2003-2004 Russell King, All Rights Reserved.
5 
 *  Copyright (C) 2005-2007 Pierre Ossman, All Rights Reserved.
6 
 *  MMCv4 support Copyright (C) 2006 Philip Langdale, All Rights Reserved.
7 
 *
8 
 * This program is free software; you can redistribute it and/or modify
9 
 * it under the terms of the GNU General Public License version 2 as
10 
 * published by the Free Software Foundation.
11 
 */
12 
 
13 
#include <linux/err.h>
14 
 
15 
#include <linux/mmc/host.h>
16 
#include <linux/mmc/card.h>
17 
#include <linux/mmc/mmc.h>
18 
 
19 
#include "core.h"
20 
#include "sysfs.h"
21 
#include "bus.h"
22 
#include "mmc_ops.h"
23 
 
24 
static const unsigned int tran_exp[] = {
25 
        10000,          100000,         1000000,        10000000,
26 
        0,               0,               0,               0
27 
};
28 
 
29 
static const unsigned char tran_mant[] = {
30 
        0,       10,     12,     13,     15,     20,     25,     30,
31 
        35,     40,     45,     50,     55,     60,     70,     80,
32 
};
33 
 
34 
static const unsigned int tacc_exp[] = {
35 
        1,      10,     100,    1000,   10000,  100000, 1000000, 10000000,
36 
};
37 
 
38 
static const unsigned int tacc_mant[] = {
39 
        0,       10,     12,     13,     15,     20,     25,     30,
40 
        35,     40,     45,     50,     55,     60,     70,     80,
41 
};
42 
 
43 
#define UNSTUFF_BITS(resp,start,size)                                   \
44 
        ({                                                              \
45 
                const int __size = size;                                \
46 
                const u32 __mask = (__size < 32 ? 1 << __size : 0) - 1;  \
47 
                const int __off = 3 - ((start) / 32);                   \
48 
                const int __shft = (start) & 31;                        \
49 
                u32 __res;                                              \
50 
                                                                        \
51 
                __res = resp[__off] >> __shft;                          \
52 
                if (__size + __shft > 32)                               \
53 
                        __res |= resp[__off-1] << ((32 - __shft) % 32); \
54 
                __res & __mask;                                         \
55 
        })
56 
 
57 
/*
58 
 * Given the decoded CSD structure, decode the raw CID to our CID structure.
59 
 */
60 
static int mmc_decode_cid(struct mmc_card *card)
61 
{
62 
        u32 *resp = card->raw_cid;
63 
 
64 
        /*
65 
         * The selection of the format here is based upon published
66 
         * specs from sandisk and from what people have reported.
67 
         */
68 
        switch (card->csd.mmca_vsn) {
69 
        case 0: /* MMC v1.0 - v1.2 */
70 
        case 1: /* MMC v1.4 */
71 
                card->cid.manfid        = UNSTUFF_BITS(resp, 104, 24);
72 
                card->cid.prod_name[0]   = UNSTUFF_BITS(resp, 96, 8);
73 
                card->cid.prod_name[1]  = UNSTUFF_BITS(resp, 88, 8);
74 
                card->cid.prod_name[2]  = UNSTUFF_BITS(resp, 80, 8);
75 
                card->cid.prod_name[3]  = UNSTUFF_BITS(resp, 72, 8);
76 
                card->cid.prod_name[4]  = UNSTUFF_BITS(resp, 64, 8);
77 
                card->cid.prod_name[5]  = UNSTUFF_BITS(resp, 56, 8);
78 
                card->cid.prod_name[6]  = UNSTUFF_BITS(resp, 48, 8);
79 
                card->cid.hwrev         = UNSTUFF_BITS(resp, 44, 4);
80 
                card->cid.fwrev         = UNSTUFF_BITS(resp, 40, 4);
81 
                card->cid.serial        = UNSTUFF_BITS(resp, 16, 24);
82 
                card->cid.month         = UNSTUFF_BITS(resp, 12, 4);
83 
                card->cid.year          = UNSTUFF_BITS(resp, 8, 4) + 1997;
84 
                break;
85 
 
86 
        case 2: /* MMC v2.0 - v2.2 */
87 
        case 3: /* MMC v3.1 - v3.3 */
88 
        case 4: /* MMC v4 */
89 
                card->cid.manfid        = UNSTUFF_BITS(resp, 120, 8);
90 
                card->cid.oemid         = UNSTUFF_BITS(resp, 104, 16);
91 
                card->cid.prod_name[0]   = UNSTUFF_BITS(resp, 96, 8);
92 
                card->cid.prod_name[1]  = UNSTUFF_BITS(resp, 88, 8);
93 
                card->cid.prod_name[2]  = UNSTUFF_BITS(resp, 80, 8);
94 
                card->cid.prod_name[3]  = UNSTUFF_BITS(resp, 72, 8);
95 
                card->cid.prod_name[4]  = UNSTUFF_BITS(resp, 64, 8);
96 
                card->cid.prod_name[5]  = UNSTUFF_BITS(resp, 56, 8);
97 
                card->cid.serial        = UNSTUFF_BITS(resp, 16, 32);
98 
                card->cid.month         = UNSTUFF_BITS(resp, 12, 4);
99 
                card->cid.year          = UNSTUFF_BITS(resp, 8, 4) + 1997;
100 
                break;
101 
 
102 
        default:
103 
                printk(KERN_ERR "%s: card has unknown MMCA version %d\n",
104 
                        mmc_hostname(card->host), card->csd.mmca_vsn);
105 
                return -EINVAL;
106 
        }
107 
 
108 
        return 0;
109 
}
110 
 
111 
/*
112 
 * Given a 128-bit response, decode to our card CSD structure.
113 
 */
114 
static int mmc_decode_csd(struct mmc_card *card)
115 
{
116 
        struct mmc_csd *csd = &card->csd;
117 
        unsigned int e, m, csd_struct;
118 
        u32 *resp = card->raw_csd;
119 
 
120 
        /*
121 
         * We only understand CSD structure v1.1 and v1.2.
122 
         * v1.2 has extra information in bits 15, 11 and 10.
123 
         */
124 
        csd_struct = UNSTUFF_BITS(resp, 126, 2);
125 
        if (csd_struct != 1 && csd_struct != 2) {
126 
                printk(KERN_ERR "%s: unrecognised CSD structure version %d\n",
127 
                        mmc_hostname(card->host), csd_struct);
128 
                return -EINVAL;
129 
        }
130 
 
131 
        csd->mmca_vsn    = UNSTUFF_BITS(resp, 122, 4);
132 
        m = UNSTUFF_BITS(resp, 115, 4);
133 
        e = UNSTUFF_BITS(resp, 112, 3);
134 
        csd->tacc_ns     = (tacc_exp[e] * tacc_mant[m] + 9) / 10;
135 
        csd->tacc_clks   = UNSTUFF_BITS(resp, 104, 8) * 100;
136 
 
137 
        m = UNSTUFF_BITS(resp, 99, 4);
138 
        e = UNSTUFF_BITS(resp, 96, 3);
139 
        csd->max_dtr      = tran_exp[e] * tran_mant[m];
140 
        csd->cmdclass     = UNSTUFF_BITS(resp, 84, 12);
141 
 
142 
        e = UNSTUFF_BITS(resp, 47, 3);
143 
        m = UNSTUFF_BITS(resp, 62, 12);
144 
        csd->capacity     = (1 + m) << (e + 2);
145 
 
146 
        csd->read_blkbits = UNSTUFF_BITS(resp, 80, 4);
147 
        csd->read_partial = UNSTUFF_BITS(resp, 79, 1);
148 
        csd->write_misalign = UNSTUFF_BITS(resp, 78, 1);
149 
        csd->read_misalign = UNSTUFF_BITS(resp, 77, 1);
150 
        csd->r2w_factor = UNSTUFF_BITS(resp, 26, 3);
151 
        csd->write_blkbits = UNSTUFF_BITS(resp, 22, 4);
152 
        csd->write_partial = UNSTUFF_BITS(resp, 21, 1);
153 
 
154 
        return 0;
155 
}
156 
 
157 
/*
158 
 * Read and decode extended CSD.
159 
 */
160 
static int mmc_read_ext_csd(struct mmc_card *card)
161 
{
162 
        int err;
163 
        u8 *ext_csd;
164 
        unsigned int ext_csd_struct;
165 
 
166 
        BUG_ON(!card);
167 
 
168 
        if (card->csd.mmca_vsn < CSD_SPEC_VER_4)
169 
                return 0;
170 
 
171 
        /*
172 
         * As the ext_csd is so large and mostly unused, we don't store the
173 
         * raw block in mmc_card.
174 
         */
175 
        ext_csd = kmalloc(512, GFP_KERNEL);
176 
        if (!ext_csd) {
177 
                printk(KERN_ERR "%s: could not allocate a buffer to "
178 
                        "receive the ext_csd.\n", mmc_hostname(card->host));
179 
                return -ENOMEM;
180 
        }
181 
 
182 
        err = mmc_send_ext_csd(card, ext_csd);
183 
        if (err) {
184 
                /*
185 
                 * We all hosts that cannot perform the command
186 
                 * to fail more gracefully
187 
                 */
188 
                if (err != -EINVAL)
189 
                        goto out;
190 
 
191 
                /*
192 
                 * High capacity cards should have this "magic" size
193 
                 * stored in their CSD.
194 
                 */
195 
                if (card->csd.capacity == (4096 * 512)) {
196 
                        printk(KERN_ERR "%s: unable to read EXT_CSD "
197 
                                "on a possible high capacity card. "
198 
                                "Card will be ignored.\n",
199 
                                mmc_hostname(card->host));
200 
                } else {
201 
                        printk(KERN_WARNING "%s: unable to read "
202 
                                "EXT_CSD, performance might "
203 
                                "suffer.\n",
204 
                                mmc_hostname(card->host));
205 
                        err = 0;
206 
                }
207 
 
208 
                goto out;
209 
        }
210 
 
211 
        ext_csd_struct = ext_csd[EXT_CSD_REV];
212 
        if (ext_csd_struct > 2) {
213 
                printk(KERN_ERR "%s: unrecognised EXT_CSD structure "
214 
                        "version %d\n", mmc_hostname(card->host),
215 
                        ext_csd_struct);
216 
                err = -EINVAL;
217 
                goto out;
218 
        }
219 
 
220 
        if (ext_csd_struct >= 2) {
221 
                card->ext_csd.sectors =
222 
                        ext_csd[EXT_CSD_SEC_CNT + 0] << 0 |
223 
                        ext_csd[EXT_CSD_SEC_CNT + 1] << 8 |
224 
                        ext_csd[EXT_CSD_SEC_CNT + 2] << 16 |
225 
                        ext_csd[EXT_CSD_SEC_CNT + 3] << 24;
226 
                if (card->ext_csd.sectors)
227 
                        mmc_card_set_blockaddr(card);
228 
        }
229 
 
230 
        switch (ext_csd[EXT_CSD_CARD_TYPE]) {
231 
        case EXT_CSD_CARD_TYPE_52 | EXT_CSD_CARD_TYPE_26:
232 
                card->ext_csd.hs_max_dtr = 52000000;
233 
                break;
234 
        case EXT_CSD_CARD_TYPE_26:
235 
                card->ext_csd.hs_max_dtr = 26000000;
236 
                break;
237 
        default:
238 
                /* MMC v4 spec says this cannot happen */
239 
                printk(KERN_WARNING "%s: card is mmc v4 but doesn't "
240 
                        "support any high-speed modes.\n",
241 
                        mmc_hostname(card->host));
242 
                goto out;
243 
        }
244 
 
245 
out:
246 
        kfree(ext_csd);
247 
 
248 
        return err;
249 
}
250 
 
251 
/*
252 
 * Handle the detection and initialisation of a card.
253 
 *
254 
 * In the case of a resume, "curcard" will contain the card
255 
 * we're trying to reinitialise.
256 
 */
257 
static int mmc_init_card(struct mmc_host *host, u32 ocr,
258 
        struct mmc_card *oldcard)
259 
{
260 
        struct mmc_card *card;
261 
        int err;
262 
        u32 cid[4];
263 
        unsigned int max_dtr;
264 
 
265 
        BUG_ON(!host);
266 
        WARN_ON(!host->claimed);
267 
 
268 
        /*
269 
         * Since we're changing the OCR value, we seem to
270 
         * need to tell some cards to go back to the idle
271 
         * state.  We wait 1ms to give cards time to
272 
         * respond.
273 
         */
274 
        mmc_go_idle(host);
275 
 
276 
        /* The extra bit indicates that we support high capacity */
277 
        err = mmc_send_op_cond(host, ocr | (1 << 30), NULL);
278 
        if (err)
279 
                goto err;
280 
 
281 
        /*
282 
         * For SPI, enable CRC as appropriate.
283 
         */
284 
        if (mmc_host_is_spi(host)) {
285 
                err = mmc_spi_set_crc(host, use_spi_crc);
286 
                if (err)
287 
                        goto err;
288 
        }
289 
 
290 
        /*
291 
         * Fetch CID from card.
292 
         */
293 
        if (mmc_host_is_spi(host))
294 
                err = mmc_send_cid(host, cid);
295 
        else
296 
                err = mmc_all_send_cid(host, cid);
297 
        if (err)
298 
                goto err;
299 
 
300 
        if (oldcard) {
301 
                if (memcmp(cid, oldcard->raw_cid, sizeof(cid)) != 0) {
302 
                        err = -ENOENT;
303 
                        goto err;
304 
                }
305 
 
306 
                card = oldcard;
307 
        } else {
308 
                /*
309 
                 * Allocate card structure.
310 
                 */
311 
                card = mmc_alloc_card(host);
312 
                if (IS_ERR(card)) {
313 
                        err = PTR_ERR(card);
314 
                        goto err;
315 
                }
316 
 
317 
                card->type = MMC_TYPE_MMC;
318 
                card->rca = 1;
319 
                memcpy(card->raw_cid, cid, sizeof(card->raw_cid));
320 
        }
321 
 
322 
        /*
323 
         * For native busses:  set card RCA and quit open drain mode.
324 
         */
325 
        if (!mmc_host_is_spi(host)) {
326 
                err = mmc_set_relative_addr(card);
327 
                if (err)
328 
                        goto free_card;
329 
 
330 
                mmc_set_bus_mode(host, MMC_BUSMODE_PUSHPULL);
331 
        }
332 
 
333 
        if (!oldcard) {
334 
                /*
335 
                 * Fetch CSD from card.
336 
                 */
337 
                err = mmc_send_csd(card, card->raw_csd);
338 
                if (err)
339 
                        goto free_card;
340 
 
341 
                err = mmc_decode_csd(card);
342 
                if (err)
343 
                        goto free_card;
344 
                err = mmc_decode_cid(card);
345 
                if (err)
346 
                        goto free_card;
347 
        }
348 
 
349 
        /*
350 
         * Select card, as all following commands rely on that.
351 
         */
352 
        if (!mmc_host_is_spi(host)) {
353 
                err = mmc_select_card(card);
354 
                if (err)
355 
                        goto free_card;
356 
        }
357 
 
358 
        if (!oldcard) {
359 
                /*
360 
                 * Fetch and process extended CSD.
361 
                 */
362 
                err = mmc_read_ext_csd(card);
363 
                if (err)
364 
                        goto free_card;
365 
        }
366 
 
367 
        /*
368 
         * Activate high speed (if supported)
369 
         */
370 
        if ((card->ext_csd.hs_max_dtr != 0) &&
371 
                (host->caps & MMC_CAP_MMC_HIGHSPEED)) {
372 
                err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
373 
                        EXT_CSD_HS_TIMING, 1);
374 
                if (err)
375 
                        goto free_card;
376 
 
377 
                mmc_card_set_highspeed(card);
378 
 
379 
                mmc_set_timing(card->host, MMC_TIMING_MMC_HS);
380 
        }
381 
 
382 
        /*
383 
         * Compute bus speed.
384 
         */
385 
        max_dtr = (unsigned int)-1;
386 
 
387 
        if (mmc_card_highspeed(card)) {
388 
                if (max_dtr > card->ext_csd.hs_max_dtr)
389 
                        max_dtr = card->ext_csd.hs_max_dtr;
390 
        } else if (max_dtr > card->csd.max_dtr) {
391 
                max_dtr = card->csd.max_dtr;
392 
        }
393 
 
394 
        mmc_set_clock(host, max_dtr);
395 
 
396 
        /*
397 
         * Activate wide bus (if supported).
398 
         */
399 
        if ((card->csd.mmca_vsn >= CSD_SPEC_VER_4) &&
400 
                (host->caps & MMC_CAP_4_BIT_DATA)) {
401 
                err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
402 
                        EXT_CSD_BUS_WIDTH, EXT_CSD_BUS_WIDTH_4);
403 
                if (err)
404 
                        goto free_card;
405 
 
406 
                mmc_set_bus_width(card->host, MMC_BUS_WIDTH_4);
407 
        }
408 
 
409 
        if (!oldcard)
410 
                host->card = card;
411 
 
412 
        return 0;
413 
 
414 
free_card:
415 
        if (!oldcard)
416 
                mmc_remove_card(card);
417 
err:
418 
 
419 
        return err;
420 
}
421 
 
422 
/*
423 
 * Host is being removed. Free up the current card.
424 
 */
425 
static void mmc_remove(struct mmc_host *host)
426 
{
427 
        BUG_ON(!host);
428 
        BUG_ON(!host->card);
429 
 
430 
        mmc_remove_card(host->card);
431 
        host->card = NULL;
432 
}
433 
 
434 
/*
435 
 * Card detection callback from host.
436 
 */
437 
static void mmc_detect(struct mmc_host *host)
438 
{
439 
        int err;
440 
 
441 
        BUG_ON(!host);
442 
        BUG_ON(!host->card);
443 
 
444 
        mmc_claim_host(host);
445 
 
446 
        /*
447 
         * Just check if our card has been removed.
448 
         */
449 
        err = mmc_send_status(host->card, NULL);
450 
 
451 
        mmc_release_host(host);
452 
 
453 
        if (err) {
454 
                mmc_remove(host);
455 
 
456 
                mmc_claim_host(host);
457 
                mmc_detach_bus(host);
458 
                mmc_release_host(host);
459 
        }
460 
}
461 
 
462 
MMC_ATTR_FN(cid, "%08x%08x%08x%08x\n", card->raw_cid[0], card->raw_cid[1],
463 
        card->raw_cid[2], card->raw_cid[3]);
464 
MMC_ATTR_FN(csd, "%08x%08x%08x%08x\n", card->raw_csd[0], card->raw_csd[1],
465 
        card->raw_csd[2], card->raw_csd[3]);
466 
MMC_ATTR_FN(date, "%02d/%04d\n", card->cid.month, card->cid.year);
467 
MMC_ATTR_FN(fwrev, "0x%x\n", card->cid.fwrev);
468 
MMC_ATTR_FN(hwrev, "0x%x\n", card->cid.hwrev);
469 
MMC_ATTR_FN(manfid, "0x%06x\n", card->cid.manfid);
470 
MMC_ATTR_FN(name, "%s\n", card->cid.prod_name);
471 
MMC_ATTR_FN(oemid, "0x%04x\n", card->cid.oemid);
472 
MMC_ATTR_FN(serial, "0x%08x\n", card->cid.serial);
473 
 
474 
static struct device_attribute mmc_dev_attrs[] = {
475 
        MMC_ATTR_RO(cid),
476 
        MMC_ATTR_RO(csd),
477 
        MMC_ATTR_RO(date),
478 
        MMC_ATTR_RO(fwrev),
479 
        MMC_ATTR_RO(hwrev),
480 
        MMC_ATTR_RO(manfid),
481 
        MMC_ATTR_RO(name),
482 
        MMC_ATTR_RO(oemid),
483 
        MMC_ATTR_RO(serial),
484 
        __ATTR_NULL,
485 
};
486 
 
487 
/*
488 
 * Adds sysfs entries as relevant.
489 
 */
490 
static int mmc_sysfs_add(struct mmc_host *host, struct mmc_card *card)
491 
{
492 
        int ret;
493 
 
494 
        ret = mmc_add_attrs(card, mmc_dev_attrs);
495 
        if (ret < 0)
496 
                return ret;
497 
 
498 
        return 0;
499 
}
500 
 
501 
/*
502 
 * Removes the sysfs entries added by mmc_sysfs_add().
503 
 */
504 
static void mmc_sysfs_remove(struct mmc_host *host, struct mmc_card *card)
505 
{
506 
        mmc_remove_attrs(card, mmc_dev_attrs);
507 
}
508 
 
509 
#ifdef CONFIG_MMC_UNSAFE_RESUME
510 
 
511 
/*
512 
 * Suspend callback from host.
513 
 */
514 
static void mmc_suspend(struct mmc_host *host)
515 
{
516 
        BUG_ON(!host);
517 
        BUG_ON(!host->card);
518 
 
519 
        mmc_claim_host(host);
520 
        if (!mmc_host_is_spi(host))
521 
                mmc_deselect_cards(host);
522 
        host->card->state &= ~MMC_STATE_HIGHSPEED;
523 
        mmc_release_host(host);
524 
}
525 
 
526 
/*
527 
 * Resume callback from host.
528 
 *
529 
 * This function tries to determine if the same card is still present
530 
 * and, if so, restore all state to it.
531 
 */
532 
static void mmc_resume(struct mmc_host *host)
533 
{
534 
        int err;
535 
 
536 
        BUG_ON(!host);
537 
        BUG_ON(!host->card);
538 
 
539 
        mmc_claim_host(host);
540 
        err = mmc_init_card(host, host->ocr, host->card);
541 
        mmc_release_host(host);
542 
 
543 
        if (err) {
544 
                mmc_remove(host);
545 
 
546 
                mmc_claim_host(host);
547 
                mmc_detach_bus(host);
548 
                mmc_release_host(host);
549 
        }
550 
 
551 
}
552 
 
553 
#else
554 
 
555 
#define mmc_suspend NULL
556 
#define mmc_resume NULL
557 
 
558 
#endif
559 
 
560 
static const struct mmc_bus_ops mmc_ops = {
561 
        .remove = mmc_remove,
562 
        .detect = mmc_detect,
563 
        .sysfs_add = mmc_sysfs_add,
564 
        .sysfs_remove = mmc_sysfs_remove,
565 
        .suspend = mmc_suspend,
566 
        .resume = mmc_resume,
567 
};
568 
 
569 
/*
570 
 * Starting point for MMC card init.
571 
 */
572 
int mmc_attach_mmc(struct mmc_host *host, u32 ocr)
573 
{
574 
        int err;
575 
 
576 
        BUG_ON(!host);
577 
        WARN_ON(!host->claimed);
578 
 
579 
        mmc_attach_bus(host, &mmc_ops);
580 
 
581 
        /*
582 
         * We need to get OCR a different way for SPI.
583 
         */
584 
        if (mmc_host_is_spi(host)) {
585 
                err = mmc_spi_read_ocr(host, 1, &ocr);
586 
                if (err)
587 
                        goto err;
588 
        }
589 
 
590 
        /*
591 
         * Sanity check the voltages that the card claims to
592 
         * support.
593 
         */
594 
        if (ocr & 0x7F) {
595 
                printk(KERN_WARNING "%s: card claims to support voltages "
596 
                       "below the defined range. These will be ignored.\n",
597 
                       mmc_hostname(host));
598 
                ocr &= ~0x7F;
599 
        }
600 
 
601 
        host->ocr = mmc_select_voltage(host, ocr);
602 
 
603 
        /*
604 
         * Can we support the voltage of the card?
605 
         */
606 
        if (!host->ocr) {
607 
                err = -EINVAL;
608 
                goto err;
609 
        }
610 
 
611 
        /*
612 
         * Detect and init the card.
613 
         */
614 
        err = mmc_init_card(host, host->ocr, NULL);
615 
        if (err)
616 
                goto err;
617 
 
618 
        mmc_release_host(host);
619 
 
620 
        err = mmc_add_card(host->card);
621 
        if (err)
622 
                goto remove_card;
623 
 
624 
        return 0;
625 
 
626 
remove_card:
627 
        mmc_remove_card(host->card);
628 
        host->card = NULL;
629 
        mmc_claim_host(host);
630 
err:
631 
        mmc_detach_bus(host);
632 
        mmc_release_host(host);
633 
 
634 
        printk(KERN_ERR "%s: error %d whilst initialising MMC card\n",
635 
                mmc_hostname(host), err);
636 
 
637 
        return err;
638 
}
639 
 

powered by: WebSVN 2.1.0

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