The-Homebrew-Cloud/mini
2
0
Fork 0
mirror of https://github.com/fail0verflow/mini.git synced 2024-06-25 20:46:09 +02:00
Code Issues Packages Projects Releases Wiki Activity

sdhc/sdmmc is getting closer to read valid data :>

Browse Source
This commit is contained in:
Sven Peter 2009-04-12 13:17:44 +02:00 committed by bushing
parent cccd6f5332
commit 2ad64f59a8
5 changed files with 148 additions and 26 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

22
diskio.c
View File

@ -7,6 +7,7 @@
#include "diskio.h"
#include "string.h"
#include "sdmmc.h"
//#include "sdhc.h"
#ifndef MEM2_BSS
@ -23,15 +24,11 @@ DSTATUS disk_initialize (
BYTE drv /* Physical drive nmuber (0..) */
)
{
s32 ret;
// sd_init(&sdhci, 0);
// ret = sd_mount(&sdhci);
if (ret < 0)
if (sdmmc_check_card(SDMMC_DEFAULT_DEVICE) == SDMMC_NO_CARD)
return STA_NOINIT;
else
return disk_status(drv);
sdmmc_ack_card(SDMMC_DEFAULT_DEVICE);
return disk_status(drv);
}
@ -46,7 +43,10 @@ DSTATUS disk_status (
// if (sd_inserted(&sdhci) == 0)
// return STA_NODISK;
return 0;
if (sdmmc_check_card(SDMMC_DEFAULT_DEVICE) == SDMMC_INSERTED)
return 0;
else
return STA_NODISK;
}
@ -66,10 +66,10 @@ DRESULT disk_read (
res = RES_OK;
for (i = 0; i < count; i++) {
/* if (sd_read(&sdhci, sector + i, 1, buffer) != 0) {
if (sdmmc_read(SDMMC_DEFAULT_DEVICE, sector+i, 1, buffer) != 0){
res = RES_ERROR;
break;
}*/
}
memcpy(buff + i * 512, buffer, 512);
}

2
mini.ld
View File

@ -5,7 +5,7 @@ EXTERN(__ipc_info)
ENTRY(_start)
__stack_size = 0x800;
__irqstack_size = 0x400; /* blame the bsd's sdhc_intr function */
__irqstack_size = 0x200; /* blame the bsd's sdhc_intr function */
__excstack_size = 0x100;
MEMORY {

24
sdhc.c
View File

@ -45,7 +45,7 @@
#include "utils.h"
#include "ipc.h"
#define SDHC_DEBUG 0
#define SDHC_DEBUG 1
#define SDHC_COMMAND_TIMEOUT 0
#define SDHC_BUFFER_TIMEOUT 0
@ -159,7 +159,7 @@ void sdhc_read_data(struct sdhc_host *, u_char *, int);
void sdhc_write_data(struct sdhc_host *, u_char *, int);
#ifdef SDHC_DEBUG
int sdhcdebug = 0;
int sdhcdebug = 2;
#define DPRINTF(n,s) do { if ((n) <= sdhcdebug) gecko_printf s; } while (0)
void sdhc_dump_regs(struct sdhc_host *);
#else
@ -972,8 +972,8 @@ sdhc_intr(void *arg)
/* Acknowledge the interrupts we are about to handle. */
HWRITE2(hp, SDHC_NINTR_STATUS, status);
DPRINTF(2,("%s: interrupt status=%d\n", HDEVNAME(hp),
status));
// DPRINTF(2,("%s: interrupt status=%d\n", HDEVNAME(hp),
// status));
/* Claim this interrupt. */
@ -988,11 +988,11 @@ sdhc_intr(void *arg)
/* Acknowledge error interrupts. */
error = HREAD2(hp, SDHC_EINTR_STATUS);
HWRITE2(hp, SDHC_EINTR_STATUS, error);
DPRINTF(2,("%s: error interrupt, status=%d\n",
HDEVNAME(hp), error));
// DPRINTF(2,("%s: error interrupt, status=%d\n",
// HDEVNAME(hp), error));
if (ISSET(error, SDHC_CMD_TIMEOUT_ERROR|
SDHC_DATA_TIMEOUT_ERROR)) {
SDHC_DATA_TIMEOUT_ERROR)) {
hp->intr_error_status |= error;
hp->intr_status |= status;
wakeup(&hp->intr_status);
@ -1004,7 +1004,7 @@ sdhc_intr(void *arg)
* TODO: move request to slow queue to make sure that
* we're not blocking other IRQs
*/
if (ISSET(status, SDHC_CARD_REMOVAL|SDHC_CARD_INSERTION)) {
if (ISSET(status, SDHC_CARD_REMOVAL|SDHC_CARD_INSERTION)) {
ipc_request req;
memset(&req, 0, sizeof(req));
req.device = IPC_DEV_SD;
@ -1019,7 +1019,7 @@ sdhc_intr(void *arg)
*/
if (ISSET(status, SDHC_BUFFER_READ_READY|
SDHC_BUFFER_WRITE_READY|SDHC_COMMAND_COMPLETE|
SDHC_TRANSFER_COMPLETE)) {
SDHC_TRANSFER_COMPLETE)) {
hp->intr_status |= status;
wakeup(&hp->intr_status);
}
@ -1027,8 +1027,8 @@ sdhc_intr(void *arg)
/*
* Service SD card interrupts.
*/
if (ISSET(status, SDHC_CARD_INTERRUPT)) {
DPRINTF(0,("%s: card interrupt\n", HDEVNAME(hp)));
if (ISSET(status, SDHC_CARD_INTERRUPT)) {
// DPRINTF(0,("%s: card interrupt\n", HDEVNAME(hp)));
HCLR2(hp, SDHC_NINTR_STATUS_EN, SDHC_CARD_INTERRUPT);
// sdmmc_card_intr(hp->sdmmc);
}
@ -1064,7 +1064,7 @@ sdhc_dump_regs(struct sdhc_host *hp)
#endif
#include "hollywood.h"
static struct sdhc_softc __softc;
static struct sdhc_softc __softc MEM2_BSS;
void sdhc_irq(void)
{

111
sdmmc.c
View File

@ -47,12 +47,14 @@ struct sdmmc_card {
int no;
int inserted;
int sdhc_blockmode;
int selected;
int new_card; // set to 1 everytime a new card is inserted
u32 cid;
u16 rca;
};
static struct sdmmc_card cards[SDHC_MAX_HOSTS];
static struct sdmmc_card cards[SDHC_MAX_HOSTS] MEM2_BSS;
static int n_cards = 0;
static inline int sdmmc_host_reset(struct sdmmc_card *card)
@ -129,6 +131,7 @@ void sdmmc_needs_discover(struct device *dev)
DPRINTF(0, ("sdmmc: card %d needs discovery.\n", no));
sdmmc_host_reset(c);
c->new_card = 1;
if (!sdmmc_host_card_detect(c)) {
DPRINTF(1, ("sdmmc: card %d (no longer?) inserted.\n", no));
@ -209,6 +212,11 @@ void sdmmc_needs_discover(struct device *dev)
goto out_power;
}
if (ISSET(MMC_R1(cmd.c_resp), SD_OCR_SDHC_CAP))
c->sdhc_blockmode = 1;
else
c->sdhc_blockmode = 0;
DPRINTF(2, ("sdmmc: MMC_ALL_SEND_CID\n"));
memset(&cmd, 0, sizeof(cmd));
cmd.c_opcode = MMC_ALL_SEND_CID;
@ -237,7 +245,23 @@ void sdmmc_needs_discover(struct device *dev)
c->rca = MMC_R1(cmd.c_resp)>>16;
DPRINTF(2, ("sdmmc: rca: %08x\n", c->rca));
c->selected = 0;
c->inserted = 1;
sdmmc_select(dev);
DPRINTF(2, ("sdmmc: MMC_SET_BLOCKLEN\n"));
memset(&cmd, 0, sizeof(cmd));
cmd.c_opcode = MMC_SET_BLOCKLEN;
cmd.c_arg = SDMMC_DEFAULT_BLOCKLEN;
cmd.c_flags = SCF_RSP_R1;
sdmmc_host_exec_command(c, &cmd);
if (cmd.c_error) {
gecko_printf("sdmmc: MMC_SET_BLOCKLEN failed with %d for card %d\n",
cmd.c_error, no);
c->inserted = c->selected = 0;
goto out_clock;
}
return;
out_clock:
@ -286,3 +310,88 @@ out:
#endif
}
int sdmmc_select(struct device *dev)
{
int no = (int)dev;
struct sdmmc_card *c = &cards[no];
struct sdmmc_command cmd;
DPRINTF(2, ("sdmmc: MMC_SELECT_CARD\n"));
memset(&cmd, 0, sizeof(cmd));
cmd.c_opcode = MMC_SELECT_CARD;
cmd.c_arg = ((u32)c->rca)<<16;;
cmd.c_flags = SCF_RSP_R1;
sdmmc_host_exec_command(c, &cmd);
if (cmd.c_error) {
gecko_printf("sdmmc: MMC_SELECT card failed with %d for %d.\n",
cmd.c_error, no);
return -1;
}
c->selected = 1;
return 0;
}
int sdmmc_check_card(struct device *dev)
{
int no = (int)dev;
struct sdmmc_card *c = &cards[no];
if (c->inserted == 0)
return SDMMC_NO_CARD;
if (c->new_card == 1)
return SDMMC_NEW_CARD;
return SDMMC_INSERTED;
}
void sdmmc_ack_card(struct device *dev)
{
int no = (int)dev;
struct sdmmc_card *c = &cards[no];
c->new_card = 0;
}
int sdmmc_read(struct device *dev, u32 blk_start, u32 blk_count, void *data)
{
int no = (int)dev;
struct sdmmc_card *c = &cards[no];
struct sdmmc_command cmd;
if (c->inserted == 0) {
gecko_printf("sdmmc: READ: no card inserted.\n");
return -1;
}
if (c->selected == 0) {
if (sdmmc_select(dev) < 0) {
gecko_printf("sdmmc: READ: cannot select card.\n");
return -1;
}
}
if (c->new_card == 1) {
gecko_printf("sdmmc: new card inserted but not acknowledged yet.\n");
return -1;
}
DPRINTF(2, ("sdmmc: MMC_READ_BLOCK_MULTIPLE\n"));
memset(&cmd, 0, sizeof(cmd));
cmd.c_opcode = MMC_READ_BLOCK_MULTIPLE;
if (c->sdhc_blockmode)
cmd.c_arg = blk_start;
else
cmd.c_arg = blk_start * SDMMC_DEFAULT_BLOCKLEN;
cmd.c_data = data;
cmd.c_datalen = blk_count * SDMMC_DEFAULT_BLOCKLEN;
cmd.c_blklen = SDMMC_DEFAULT_BLOCKLEN;
cmd.c_flags = SCF_RSP_R1 | SCF_CMD_READ;
sdmmc_host_exec_command(c, &cmd);
if (cmd.c_error) {
gecko_printf("sdmmc: MMC_READ_BLOCK_MULTIPLE failed for "
"card %d with %d", no, cmd.c_error);
return -1;
}
gecko_printf("success!!\n");
return 0;
}

15
sdmmc.h
View File

@ -22,12 +22,25 @@ Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
#ifndef __SDMMC_H__
#define __SDMMC_H__ 1
#include "sdmmcvar.h"
#include "bsdtypes.h"
#include "sdmmcchip.h"
#include "sdmmcvar.h"
#define SDMMC_DEFAULT_CLOCK 25000
#define SDMMC_DEFAULT_BLOCKLEN 512
#define SDMMC_NO_CARD 1
#define SDMMC_NEW_CARD 2
#define SDMMC_INSERTED 3
// HACK
#define SDMMC_DEFAULT_DEVICE ((struct device *)0)
struct device *sdmmc_attach(struct sdmmc_chip_functions *functions,
sdmmc_chipset_handle_t handle, const char *name, int no);
void sdmmc_needs_discover(struct device *dev);
int sdmmc_select(struct device *dev);
int sdmmc_check_card(struct device *dev);
void sdmmc_ack_card(struct device *dev);
int sdmmc_read(struct device *dev, u32 blk_start, u32 blk_count, void *data);
#endif