libs/rt-thread-official
libs
/
rt-thread-official
mirror of https://github.com/RT-Thread/rt-thread.git
4
0
Fork 0
Code Issues Releases Wiki Activity
rt-thread-official/bsp/allwinner/libraries/sunxi-hal/hal/source/sdmmc/sdio.c

2293 lines
62 KiB
C
Raw Blame History

/*
* Copyright (C) 2017 ALLWINNERTECH TECHNOLOGY CO., LTD. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the
* distribution.
* 3. Neither the name of ALLWINNERTECH TECHNOLOGY CO., LTD. nor the names of
* its contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include "stdint.h"
#include "sys/param.h"
#include "sys/endian.h"
#include "hal_sdhost.h"
#include "sdmmc.h"
#include "sdio.h"
#include "_sd_define.h"
#include "_core.h"
#include "_sdio.h"
#ifdef CONFIG_USE_SDIO
//inline int mmc_io_rw_direct(struct mmc_card *card, int32_t write, uint32_t fn, uint32_t addr, uint8_t in, uint8_t *out);
#define SDIO_MIN(a, b) MIN(a, b)
/*
* Calculate the maximum byte mode transfer size
*/
static inline unsigned int sdio_max_byte_size(struct sdio_func *func)
{
unsigned mval = func->card->host->max_blk_size;
//if (mmc_blksz_for_byte_mode(func->card))
// mval = min(mval, func->cur_blksize);
//else
mval = SDIO_MIN(mval, func->max_blksize);
//if (mmc_card_broken_byte_mode_512(func->card))
return SDIO_MIN(mval, 511u);
return SDIO_MIN(mval, 512u); /* maximum size for byte mode */
}
#ifdef CONFIG_SDIO_USE_FUNS
static int32_t cistpl_vers_1(struct mmc_card *card, struct sdio_func *func,
const unsigned char *buf, uint32_t size)
{
uint32_t i, nr_strings;
char **buffer, *string;
/* Find all null-terminated (including zero length) strings in
the TPLLV1_INFO field. Trailing garbage is ignored. */
buf += 2;
size -= 2;
nr_strings = 0;
for (i = 0; i < size; i++) {
if (buf[i] == 0xff)
break;
if (buf[i] == 0)
nr_strings++;
}
if (nr_strings == 0)
return 0;
size = i;
buffer = HAL_Malloc(sizeof(char *) * nr_strings + size);
SDC_Memset(buffer, 0, sizeof(char *) * nr_strings + size);
if (!buffer)
return -1;
string = (char*)(buffer + nr_strings);
for (i = 0; i < nr_strings; i++) {
buffer[i] = string;
strcpy(string, (char *)buf);
string += strlen(string) + 1;
buf += strlen((char *)buf) + 1;
}
if (func) {
func->num_info = nr_strings;
func->info = (const char**)buffer;
} else {
card->num_info = nr_strings;
card->info = (const int8_t **)buffer;
}
return 0;
}
static int32_t cistpl_manfid(struct mmc_card *card, struct sdio_func *func,
const unsigned char *buf, unsigned size)
{
uint32_t vendor, device;
/* TPLMID_MANF */
vendor = buf[0] | (buf[1] << 8);
/* TPLMID_CARD */
device = buf[2] | (buf[3] << 8);
if (func) {
func->vendor = vendor;
func->device = device;
} else {
card->cis.vendor = vendor;
card->cis.device = device;
}
return 0;
}
static const unsigned char speed_val[16] =
{ 0, 10, 12, 13, 15, 20, 25, 30, 35, 40, 45, 50, 55, 60, 70, 80 };
static const uint32_t speed_unit[8] =
{ 10000, 100000, 1000000, 10000000, 0, 0, 0, 0 };
typedef int32_t (tpl_parse_t)(struct mmc_card *, struct sdio_func *, const unsigned char *, unsigned);
struct cis_tpl {
unsigned char code;
unsigned char min_size;
tpl_parse_t *parse;
};
static int32_t cis_tpl_parse(struct mmc_card *card, struct sdio_func *func,
const char *tpl_descr,
const struct cis_tpl *tpl, int32_t tpl_count,
uint8_t code, const uint8_t *buf, uint32_t size)
{
int32_t i, ret = 0;
/* look for a matching code in the table */
for (i = 0; i < tpl_count; i++, tpl++) {
if (tpl->code == code)
break;
}
if (i < tpl_count) {
if (size >= tpl->min_size) {
if (tpl->parse)
ret = tpl->parse(card, func, buf, size);
else
ret = 0; /* known tuple, not parsed */
} else {
/* invalid tuple */
ret = -1;
}
if (ret) {
SD_LOGW("%s: bad %s tuple 0x%02x (%u bytes)\n",
__func__, tpl_descr, (unsigned int)code, (unsigned int)size);
}
} else {
/* warn about unknown tuples */
SD_LOGW("%s: queuing unknown CIS tuple 0x%02x (%u bytes)\n",
__func__, (unsigned int)code, (unsigned int)size);
}
return ret;
}
static int32_t cistpl_funce_common(struct mmc_card *card, struct sdio_func *func,
const unsigned char *buf, unsigned size)
{
/* Only valid for the common CIS (function 0) */
if (func)
return -1;
/* TPLFE_FN0_BLK_SIZE */
card->cis.blksize = buf[1] | (buf[2] << 8);
/* TPLFE_MAX_TRAN_SPEED */
card->cis.max_dtr = speed_val[(buf[3] >> 3) & 15] *
speed_unit[buf[3] & 7];
return 0;
}
static int32_t cistpl_funce_func(struct mmc_card *card, struct sdio_func *func,
const unsigned char *buf, uint32_t size)
{
uint32_t vsn;
uint32_t min_size;
/* Only valid for the individual function's CIS (1-7) */
if (!func)
return -1;
/*
* This tuple has a different length depending on the SDIO spec
* version.
*/
vsn = func->card->cccr.sdio_vsn;
min_size = (vsn == SDIO_SDIO_REV_1_00) ? 28 : 42;
if (size < min_size)
return -1;
/* TPLFE_MAX_BLK_SIZE */
func->max_blksize = buf[12] | (buf[13] << 8);
/* TPLFE_ENABLE_TIMEOUT_VAL, present in ver 1.1 and above */
#ifdef CONFIG_MMC_ERASE
if (vsn > SDIO_SDIO_REV_1_00)
func->enable_timeout = (buf[28] | (buf[29] << 8)) * 10;
else
func->enable_timeout = jiffies_to_msecs(HZ);
#endif
return 0;
}
/*
* Known TPLFE_TYPEs table for CISTPL_FUNCE tuples.
*
* Note that, unlike PCMCIA, CISTPL_FUNCE tuples are not parsed depending
* on the TPLFID_FUNCTION value of the previous CISTPL_FUNCID as on SDIO
* TPLFID_FUNCTION is always hardcoded to 0x0C.
*/
static const struct cis_tpl cis_tpl_funce_list[] = {
{ (unsigned char)0x00, (unsigned char)4, (tpl_parse_t *)cistpl_funce_common },
{ (unsigned char)0x01, (unsigned char)0, (tpl_parse_t *)cistpl_funce_func },
{ (unsigned char)0x04, (unsigned char)(1+1+6), NULL/* CISTPL_FUNCE_LAN_NODE_ID */ },
};
static int32_t cistpl_funce(struct mmc_card *card, struct sdio_func *func,
const unsigned char *buf, unsigned size)
{
if (size < 1)
return -1;
return cis_tpl_parse(card, func, "CISTPL_FUNCE",
cis_tpl_funce_list,
HAL_ARRAY_SIZE(cis_tpl_funce_list),
buf[0], buf, size);
}
/* Known TPL_CODEs table for CIS tuples */
static const struct cis_tpl cis_tpl_list[] = {
{ 0x15, 3, (tpl_parse_t *)cistpl_vers_1 },
{ 0x20, 4, (tpl_parse_t *)cistpl_manfid },
{ 0x21, 2, NULL/* cistpl_funcid */ },
{ 0x22, 0, (tpl_parse_t *)cistpl_funce },
};
static int32_t sdio_read_cis(struct mmc_card *card, struct sdio_func *func)
{
int32_t ret;
struct sdio_func_tuple *this, **prev;
uint32_t i, ptr = 0;
/*
* Note that this works for the common CIS (function number 0) as
* well as a function's CIS * since SDIO_CCCR_CIS and SDIO_FBR_CIS
* have the same offset.
*/
for (i = 0; i < 3; i++) {
uint8_t x, fn;
if (func)
fn = func->num;
else
fn = 0;
ret = mmc_io_rw_direct(card, 0, FN0, SDIO_FBR_BASE(fn) + SDIO_FBR_CIS + i, 0, &x);
if (ret)
return ret;
ptr |= x << (i * 8);
}
if (func)
prev = &func->tuples;
else
prev = &card->tuples;
if (*prev) {
SD_LOGE("%s,%d no prev found\n", __func__, __LINE__);
return -1;
}
do {
uint8_t tpl_code, tpl_link;
ret = mmc_io_rw_direct(card, 0, FN0, ptr++, 0, &tpl_code);
if (ret)
break;
/* 0xff means we're done */
if (tpl_code == 0xff)
break;
/* null entries have no link field or data */
if (tpl_code == 0x00)
continue;
ret = mmc_io_rw_direct(card, 0, FN0, ptr++, 0, &tpl_link);
if (ret)
break;
/* a size of 0xff also means we're done */
if (tpl_link == 0xff)
break;
this = HAL_Malloc(sizeof(*this) + tpl_link);
if (!this)
return -1;
for (i = 0; i < tpl_link; i++) {
ret = mmc_io_rw_direct(card, 0, FN0, ptr + i, 0, &this->data[i]);
if (ret)
break;
}
if (ret) {
HAL_Free(this);
break;
}
/* Try to parse the CIS tuple */
ret = cis_tpl_parse(card, func, "CIS",
cis_tpl_list, HAL_ARRAY_SIZE(cis_tpl_list),
tpl_code, this->data, tpl_link);
if (ret == -1) {
/*
* The tuple is unknown or known but not parsed.
* Queue the tuple for the function driver.
*/
this->next = NULL;
this->code = tpl_code;
this->size = tpl_link;
*prev = this;
prev = &this->next;
/* keep on analyzing tuples */
ret = 0;
} else {
/*
* We don't need the tuple anymore if it was
* successfully parsed by the SDIO core or if it is
* not going to be queued for a driver.
*/
HAL_Free(this);
}
ptr += tpl_link;
} while (!ret);
/*
* Link in all unknown tuples found in the common CIS so that
* drivers don't have to go digging in two places.
*/
if (func)
*prev = card->tuples;
return ret;
}
int32_t sdio_read_common_cis(struct mmc_card *card)
{
return sdio_read_cis(card, NULL);
}
void sdio_free_common_cis(struct mmc_card *card)
{
struct sdio_func_tuple *tuple, *victim;
tuple = card->tuples;
while (tuple) {
victim = tuple;
tuple = tuple->next;
HAL_Free(victim);
}
card->tuples = NULL;
}
void sdio_free_func_cis(struct sdio_func *func)
{
struct sdio_func_tuple *tuple, *victim;
tuple = func->tuples;
while (tuple && tuple != func->card->tuples) {
victim = tuple;
tuple = tuple->next;
HAL_Free(victim);
}
func->tuples = NULL;
}
int sdio_read_func_cis(struct sdio_func *func)
{
int ret;
ret = sdio_read_cis(func->card, func);
if (ret)
return ret;
/*
* Since we've linked to tuples in the card structure,
* we must make sure we have a reference to it.
*/
// get_device(&func->card->dev);
/*
* Vendor/device id is optional for function CIS, so
* copy it from the card structure as needed.
*/
if (func->vendor == 0) {
func->vendor = func->card->cis.vendor;
func->device = func->card->cis.device;
}
return 0;
}
static int32_t sdio_read_fbr(struct sdio_func *func)
{
int32_t ret;
unsigned char data;
//if (mmc_card_nonstd_func_interface(func->card)) {
// func->class = SDIO_CLASS_NONE;
// return 0;
//}
ret = mmc_io_rw_direct(func->card, 0, FN0,
SDIO_FBR_BASE(func->num) + SDIO_FBR_STD_IF, 0, &data);
if (ret)
goto out;
data &= 0x0f;
if (data == 0x0f) {
ret = mmc_io_rw_direct(func->card, 0, FN0,
SDIO_FBR_BASE(func->num) + SDIO_FBR_STD_IF_EXT, 0, &data);
if (ret)
goto out;
}
func->class = data;
out:
return ret;
}
#endif
static int32_t mmc_send_io_op_cond(struct mmc_card *card, uint32_t ocr, uint32_t *rocr)
{
struct mmc_command cmd = {0};
uint32_t i, err = 0;
cmd.opcode = SD_IO_SEND_OP_COND;
cmd.arg = ocr;
cmd.flags = MMC_RSP_SPI_R4 | MMC_RSP_R4 | MMC_CMD_BCR;
for (i = 1000; i; i--) {
err = mmc_wait_for_cmd(card->host, &cmd);
if (err)
break;
/* if we're just probing, do a single pass */
if (ocr == 0)
break;
/* otherwise wait until reset completes */
if (cmd.resp[0] & MMC_CARD_BUSY)
break;
err = -1;
mmc_mdelay(1);
}
if (rocr)
*rocr = cmd.resp[0];
return err;
}
int32_t
mmc_io_rw_direct_host(struct mmc_host *host, int32_t write, uint32_t fn,
uint32_t addr, uint8_t in, uint8_t *out)
{
struct mmc_command cmd = {0};
int32_t err;
uint32_t temp;
if (!host) {
SD_LOGE_RAW(ROM_ERR_MASK, "%s,%d no host exist!\n", __func__, __LINE__);
return -1;
}
if (fn > 7) {
SDC_LOGE("%s,%d wrong fn:%ld!\n", __func__, __LINE__, HAL_PR_SZ_L(fn));
return -1;
}
SDC_LOGD("%s,fun %ld, raw %d ,addr %lx,wrte data %x\n", write?"Write":"Read", HAL_PR_SZ_L(fn), (write && out)?1:0, HAL_PR_SZ_L(addr), in);
/* sanity check */
if (addr & ~0x1FFFF)
return -1;
cmd.opcode = SD_IO_RW_DIRECT;
cmd.arg = write ? 0x80000000 : 0x00000000;
cmd.arg |= fn << 28;
cmd.arg |= (write && out) ? 0x08000000 : 0x00000000;
cmd.arg |= addr << 9;
cmd.arg |= in;
cmd.flags = MMC_RSP_SPI_R5 | MMC_RSP_R5 | MMC_CMD_AC;
err = mmc_wait_for_cmd(host, &cmd);
if (err)
return err;
temp = cmd.resp[0];
if (temp & 0xcf00) {
SDC_LOGE("CMD52 %s Operation Error:%s%s%s%s%s !\n",
write ? "wirte" : "read",
temp&0x8000 ? " CMDCRCErr" : "",
temp&0x4000 ? " ILLEGALCmd" : "",
temp&0x800 ? " GenERR" : "",
temp&0x200 ? " FucNumErr" : "",
temp&0x100 ? " ArgOutRange" : "");
}
if (cmd.resp[0] & R5_ERROR)
return -1;
if (cmd.resp[0] & R5_FUNCTION_NUMBER)
return -1;
if (cmd.resp[0] & R5_OUT_OF_RANGE)
return -1;
if (out) {
*out = cmd.resp[0] & 0xFF;
}
return 0;
}
int mmc_io_rw_direct(struct mmc_card *card, int32_t write, uint32_t fn, uint32_t addr, uint8_t in, uint8_t *out)
{
if (!card) {
SD_LOGE_RAW(ROM_ERR_MASK, "%s,%d no card exist!\n", __func__, __LINE__);
return -1;
}
return mmc_io_rw_direct_host(card->host, write, fn, addr, in, out);
}
/**
* SDIO Spec: CMD53 is 48 bit long. read or write multiple I/O registers with a
* single command
* ----------------------------------------------------------------------------
* S|D|CMDIND|R|FUN|BLOCK MODE|OP CODE|REGISTER ADDRESS|BYTE/BLOCK COUNT|CRC7|E
* ----------------------------------------------------------------------------
* @ret : RET_OK, RET_FAIL
*/
int32_t
mmc_io_rw_extended(struct mmc_card *card, uint8_t write, uint8_t fn, uint32_t addr, uint32_t incr_addr,
const void *buf, uint32_t blocks, uint32_t blksz)
{
struct mmc_request mrq;
struct mmc_command cmd = {0};
struct mmc_data data = {0};
struct scatterlist sg = {0};
int32_t ret;
if (fn > 7) {
SD_LOGE("%s,%d err fn:%d\n", __func__, __LINE__, fn);
return -1;
}
SDC_WARN_ON(blksz == 0);
/* sanity check */
if (addr & ~0x1FFFF)
return -1;
cmd.opcode = SD_IO_RW_EXTENDED; /* cmd53 --index */
cmd.arg = write ? 0x80000000 : 0x00000000; /* write/read --flag */
cmd.arg |= fn << 28; /* function number */
cmd.arg |= incr_addr ? 0x04000000 : 0x00000000; /* incrementing address */
cmd.arg |= addr << 9;
if (blocks == 0 )
cmd.arg |= (blksz == 512) ? 0 : blksz; /* byte mode */
else
cmd.arg |= 0x08000000| blocks; /* block mode */
cmd.flags = MMC_RSP_SPI_R5 | MMC_RSP_R5 | MMC_CMD_ADTC;
data.blksz = blksz;
data.blocks = blocks ? blocks : 1;
data.flags = write ? MMC_DATA_WRITE : MMC_DATA_READ;
data.sg = &sg;
data.sg_len = 1;
sg.buffer = (void *)buf;
sg.len = data.blksz * data.blocks;
mrq.cmd = &cmd;
mrq.data = &data;
SD_LOGD("starting %s CMD%ld add %lx,arg 0x%08lx flags %lx\n", write?"Write":"Read", HAL_PR_SZ_L(cmd.opcode), HAL_PR_SZ_L(addr), HAL_PR_SZ_L(cmd.arg), HAL_PR_SZ_L(cmd.flags));
SD_LOGD("blksz %ld blocks %ld flags %lx\n", HAL_PR_SZ_L(data.blksz), HAL_PR_SZ_L(data.blocks), HAL_PR_SZ_L(data.flags));
ret = mmc_wait_for_req(card->host, &mrq);
if (ret) {
SD_LOGE("SDC write operation failed\n");
}
if (cmd.resp[0] & R5_ERROR)
return -1;
if (cmd.resp[0] & R5_FUNCTION_NUMBER)
return -1;
if (cmd.resp[0] & R5_OUT_OF_RANGE)
return -1;
// printf("%s,%d,%x\n", __FUNCTION__,__LINE__, sg.buffer);
return ret;
}
/**
* read/write IO memory in Block/Stream mode with fixed/increaming address
* This will split an arbitrarily sized data transfer into several IO_RW_EXTENDED commands.
* @func_num: function number
* @write: IOMEM_WR:write, IOMEM_RD:read
* @addr: address of register read from or write to
* @incr_addr: 1: in, 0: not, used for fifio
* @buf: pointer to data buffer
* @size: block counter(block mode)/byte counter(byte mode)
* @ret: RET_OK, RET_FAIL
*/
static int32_t
sdio_io_rw_ext_helper(struct mmc_card *card, uint8_t func_num, int32_t write, uint32_t addr,
uint32_t incr_addr, uint8_t *buf, uint32_t size)
{
uint32_t remainder = size;
int32_t ret = -1;
uint32_t blocks;
int32_t fn_bsize;
uint8_t *buf_tmp = buf;
/* Do the bulk of the transfer using block mode (if supported). */
//if (func->card->cccr.multi_block && (size > sdio_max_byte_size(func))) {
fn_bsize = card->fn_bsize[func_num];
/* Do the bulk of the transfer using block mode (if supported). */
while (remainder >= fn_bsize) {
blocks = remainder / fn_bsize;
size = blocks * fn_bsize;
ret = mmc_io_rw_extended(card, write, func_num, addr, incr_addr, buf, blocks, fn_bsize);
if (ret) {
SD_LOGE("%s,%d %s IO%x [%lx] SZ:%ld Err:%ld !!\n", __func__, __LINE__,
write?"W":"R", func_num, HAL_PR_SZ_L(addr), HAL_PR_SZ_L(size), HAL_PR_SZ_L(ret));
return ret;
}
remainder -= size;
buf += size;
if (incr_addr)
addr += size;
}
/* Write the remainder using byte mode. */
while (remainder > 0) {
size = SDIO_MIN(remainder, 512);
ret = mmc_io_rw_extended(card, write, func_num, addr, incr_addr, buf, 0, size);
if (ret) {
SD_LOGE("%s,%d %s IO%x [%lx] SZ:%ld Err:%ld !!\n", __func__, __LINE__,
write?"W":"R", func_num, HAL_PR_SZ_L(addr), HAL_PR_SZ_L(size), HAL_PR_SZ_L(ret));
return ret;
}
remainder -= size;
buf += size;
if (incr_addr)
addr += size;
}
// printf("%s,%d,%x %x,%x\n", __FUNCTION__,__LINE__, buf_tmp,(uint32_t)buf_tmp, (uint32_t)buf);
return ret;
}
/**
* sdio_readb - read a single byte from a SDIO function
* @func_num: SDIO function to access
* @addr: address to read
* @err_ret: optional status value from transfer
*
* Reads a single byte from the address space of a given SDIO
* function. If there is a problem reading the address, 0xff
* is returned and @err_ret will contain the error code.
*/
uint8_t sdio_readb(struct mmc_card *card, uint32_t func_num, uint32_t addr, int32_t *err_ret)
{
int32_t ret;
uint8_t val;
if (err_ret)
*err_ret = 0;
ret = mmc_io_rw_direct_host(card->host, 0, func_num, addr, 0, &val);
if (ret) {
if (err_ret)
*err_ret = ret;
return 0xFF;
}
return val;
}
/**
* sdio_writeb - write a single byte to a SDIO function
* @func_num: SDIO function to access
* @b: byte to write
* @addr: address to write to
* @err_ret: optional status value from transfer
*
* Writes a single byte to the address space of a given SDIO
* function. @err_ret will contain the status of the actual
* transfer.
*/
void sdio_writeb(struct mmc_card *card, uint32_t func_num, const uint8_t b, uint32_t addr, int32_t *err_ret)
{
int32_t ret;
ret = mmc_io_rw_direct_host(card->host, 1, func_num, addr, b, NULL);
if (err_ret)
*err_ret = ret;
}
/**
* sdio_readw - read a 16 bit integer from a SDIO function
* @func: SDIO function to access
* @addr: address to read
* @err_ret: optional status value from transfer
*
* Reads a 16 bit integer from the address space of a given SDIO
* function. If there is a problem reading the address, 0xffff
* is returned and @err_ret will contain the error code.
*/
uint16_t sdio_readw(struct sdio_func *func, unsigned int addr, int *err_ret)
{
int ret;
if (err_ret)
*err_ret = 0;
ret = sdio_memcpy_fromio(func->card, func->num,func->tmpbuf, addr, 2);
if (ret) {
if (err_ret)
*err_ret = ret;
return 0xFFFF;
}
//return le16_to_cpup((__le16 *)func->tmpbuf);
return le16toh( *((uint16_t *)func->tmpbuf));
}
//EXPORT_SYMBOL_GPL(sdio_readw);
/**
* sdio_writew - write a 16 bit integer to a SDIO function
* @func: SDIO function to access
* @b: integer to write
* @addr: address to write to
* @err_ret: optional status value from transfer
*
* Writes a 16 bit integer to the address space of a given SDIO
* function. @err_ret will contain the status of the actual
* transfer.
*/
void sdio_writew(struct sdio_func *func, uint16_t b, unsigned int addr, int *err_ret)
{
int ret;
//*(__le16 *)func->tmpbuf = cpu_to_le16(b);
*(int16_t *)func->tmpbuf = cpu_to_le16(b);
ret = sdio_memcpy_toio(func->card, func->num, addr, func->tmpbuf, 2);
if (err_ret)
*err_ret = ret;
}
//EXPORT_SYMBOL_GPL(sdio_writew);
/**
* sdio_readl - read a 32 bit integer from a SDIO function
* @func: SDIO function to access
* @addr: address to read
* @err_ret: optional status value from transfer
*
* Reads a 32 bit integer from the address space of a given SDIO
* function. If there is a problem reading the address,
* 0xffffffff is returned and @err_ret will contain the error
* code.
*/
uint32_t sdio_readl(struct sdio_func *func, unsigned int addr, int *err_ret)
{
int ret;
if (err_ret)
*err_ret = 0;
ret = sdio_memcpy_fromio(func->card, func->num,func->tmpbuf, addr, 4);
if (ret) {
if (err_ret)
*err_ret = ret;
return 0xFFFFFFFF;
}
//return le32_to_cpup((__le32 *)func->tmpbuf);
return le32toh(*((uint32_t *)func->tmpbuf));
}
//EXPORT_SYMBOL_GPL(sdio_readl);
/**
* sdio_writel - write a 32 bit integer to a SDIO function
* @func: SDIO function to access
* @b: integer to write
* @addr: address to write to
* @err_ret: optional status value from transfer
*
* Writes a 32 bit integer to the address space of a given SDIO
* function. @err_ret will contain the status of the actual
* transfer.
*/
void sdio_writel(struct sdio_func *func, uint32_t b, unsigned int addr, int *err_ret)
{
int ret;
//*(__le32 *)func->tmpbuf = cpu_to_le32(b);
*(int32_t *)func->tmpbuf = cpu_to_le32(b);
ret = sdio_memcpy_toio(func->card, func->num, addr, func->tmpbuf, 4);
if (err_ret)
*err_ret = ret;
}
//EXPORT_SYMBOL_GPL(sdio_writel);
/**
* sdio_enable_func - enables a SDIO function for usage
* @func: SDIO function to enable
*
* Powers up and activates a SDIO function so that register
* access is possible.
*/
int32_t sdio_enable_func(struct mmc_card *card, uint32_t func_num)
{
uint8_t dat;
mmc_io_rw_direct_host(card->host, 0, FN0, SDIO_CCCR_IOEx, 0, &dat);
dat |= (1 << func_num); /* keep the value of other FN's IO enb state */
mmc_io_rw_direct_host(card->host, 1, FN0, SDIO_CCCR_IOEx, dat, &dat);
if (!(dat & (1 << func_num))) {
SD_LOGE("%s,%d IO%ld Enable failed !!\n", __func__, __LINE__, HAL_PR_SZ_L(func_num));
return -1;
}
SD_LOGD("IO%ld is enabled !!\n", HAL_PR_SZ_L(func_num));
mmc_io_rw_direct_host(card->host, 0, FN0, SDIO_CCCR_IORx, 0, &dat);
if (!(dat & (1 << func_num))) {
SD_LOGD("%s,%d IO%ld is not ready !!\n", __func__, __LINE__, HAL_PR_SZ_L(func_num));
return -1;
}
SD_LOGD("IO%ld is ready !!\n", HAL_PR_SZ_L(func_num));
return 0;
}
/**
* Disable IOx's Function.
* @io_num: 1~7
*/
int32_t sdio_disable_func(struct mmc_card *card, uint32_t func_num)
{
uint8_t dat;
mmc_io_rw_direct_host(card->host, 0, FN0, SDIO_CCCR_IOEx, 0, &dat);
dat &= ~(1 << func_num); /* keep the value of other FN's IO enb state */
mmc_io_rw_direct_host(card->host, 1, FN0, SDIO_CCCR_IOEx, dat, &dat);
if (dat & (1 << func_num)) {
SD_LOGE("%s,%d IO%ld Disable failed !!\n", __func__, __LINE__, HAL_PR_SZ_L(func_num));
return -1;
}
SD_LOGD("IO%ld is Disabled !!\n", HAL_PR_SZ_L(func_num));
return 0;
}
int32_t sdio_set_block_size(struct mmc_card *card, uint32_t fn_num, uint32_t blksz)
{
int32_t ret;
#if 0
if ((blksz == 0) || card->fn_bsize[fn_num] == blksz) {
SD_LOGW("block size has beed set to %d !!\n", blksz);
return -1;
}
#endif
if ((blksz == 0)) {
SD_LOGW("block size has beed set to %ld !!\n", HAL_PR_SZ_L(blksz));
return -1;
}
/* sdio block size set in FN0 CCIA */
sdio_writeb(card, FN0, blksz & 0xff, SDIO_FBR_BASE(fn_num) + SDIO_FBR_BLKSIZE, &ret);
if (ret)
return ret;
sdio_writeb(card, FN0, (blksz >> 8) & 0xff, SDIO_FBR_BASE(fn_num) + SDIO_FBR_BLKSIZE + 1, &ret);
if (ret)
return ret;
card->fn_bsize[fn_num] = blksz;
SD_LOGD("sdio FN%ld set block size to %ld\n", HAL_PR_SZ_L(fn_num), HAL_PR_SZ_L(blksz));
return 0;
}
/*
* Test if the card supports high-speed mode and, if so, switch to it.
*/
static int32_t mmc_sdio_switch_hs(struct mmc_card *card, uint32_t enable)
{
int32_t ret;
uint8_t speed;
if (!(card->host->caps & MMC_CAP_SD_HIGHSPEED))
return 0;
if (!card->cccr.high_speed)
return 0;
ret = mmc_io_rw_direct(card, 0, FN0, SDIO_CCCR_SPEED, 0, &speed);
if (ret)
return ret;
if (!(speed & SDIO_SPEED_SHS)) {
SD_LOGE("%s not support high speed mode!\n", __func__);
return -1;
}
if (enable) {
speed |= SDIO_SPEED_EHS;
} else {
speed &= ~SDIO_SPEED_EHS;
}
ret = mmc_io_rw_direct(card, 1, FN0, SDIO_CCCR_SPEED, speed, NULL);
if(ret)
return ret;
return 1;
}
uint32_t mmc_sdio_get_max_clock(struct mmc_card *card)
{
unsigned max_dtr;
if (mmc_card_highspeed(card)) {
/*
* The SDIO specification doesn't mention how
* the CIS transfer speed register relates to
* high-speed, but it seems that 50 MHz is
* mandatory.
*/
max_dtr = 50000000;
} else {
max_dtr = card->cis.max_dtr;
}
#ifdef CONFIG_USE_SDIO_COMBO
if (card->type == MMC_TYPE_SD_COMBO)
max_dtr = min(max_dtr, mmc_sd_get_max_clock(card));
#endif
return max_dtr;
}
#ifdef CONFIG_SDIO_USE_FUNS
/*
* Allocate and initialise a new SDIO function structure.
*/
struct sdio_func *sdio_alloc_func(struct mmc_card *card)
{
struct sdio_func *func;
func = HAL_Malloc(sizeof(struct sdio_func));
if (!func)
return NULL;
SDC_Memset(func, 0, sizeof(struct sdio_func));
func->card = card;
return func;
}
/*
* Register a new SDIO function with the driver model.
*/
int32_t sdio_add_func(struct sdio_func *func, uint32_t id)
{
// fprintf(func->name, "%s:%d", id, func->num);
sdio_func_set_present(func);
return 0;
}
/*
* Unregister a SDIO function with the driver model, and
* (eventually) free it.
* This function can be called through error paths where sdio_add_func() was
* never executed (because a failure occurred at an earlier point).
*/
void sdio_remove_func(struct sdio_func *func)
{
if (!sdio_func_present(func))
return;
}
static int32_t sdio_init_func(struct mmc_card *card, uint32_t fn)
{
int32_t ret;
struct sdio_func *func;
if (fn > SDIO_MAX_FUNCS) {
SD_LOGE("%s,%d wrong fn:%ld!\n", __func__, __LINE__, HAL_PR_SZ_L(fn));
return -1;
}
func = sdio_alloc_func(card);
if (!func)
return -1;
func->num = fn;
if (!(card->quirks & MMC_QUIRK_NONSTD_SDIO)) {
ret = sdio_read_fbr(func);
if (ret)
goto fail;
ret = sdio_read_func_cis(func);
if (ret)
goto fail;
} else {
func->vendor = func->card->cis.vendor;
func->device = func->card->cis.device;
func->max_blksize = func->card->cis.blksize;
}
card->sdio_func[fn - 1] = func;
printf("func address %p\n",func);
return 0;
fail:
/*
* It is okay to remove the function here even though we hold
* the host lock as we haven't registered the device yet.
*/
sdio_remove_func(func);
return ret;
}
/*
* Host is being removed. Free up the current card.
*/
int mmc_sdio_remove(struct mmc_host *host)
{
int i;
if (!host) {
SD_LOGE_RAW(ROM_ERR_MASK, "%s,%d no host exist!\n", __func__, __LINE__);
return -1;
}
if (!host->card) {
SDC_LOGE("%s,%d no card exist!\n", __func__, __LINE__);
return -1;
}
for (i = 0;i < host->card->sdio_funcs;i++) {
if (host->card->sdio_func[i]) {
sdio_remove_func(host->card->sdio_func[i]);
host->card->sdio_func[i] = NULL;
}
}
//mmc_remove_card(host->card); /* do nothing */
host->card = NULL;
return 0;
}
#endif
static int32_t sdio_read_cccr(struct mmc_card *card, uint32_t ocr)
{
int32_t ret;
int32_t cccr_vsn;
int32_t uhs = ocr & R4_18V_PRESENT;
uint8_t data;
uint8_t speed;
SDC_Memset(&card->cccr, 0, sizeof(struct sdio_cccr));
ret = mmc_io_rw_direct(card, 0, FN0, SDIO_CCCR_CCCR, 0, &data);
if (ret)
goto out;
cccr_vsn = data & 0x0f;
if (cccr_vsn > SDIO_CCCR_REV_3_00) {
SD_LOGW("%s: unrecognised CCCR structure version %ld\n",
__func__, HAL_PR_SZ_L(cccr_vsn));
return -1;
}
card->cccr.sdio_vsn = (data & 0xf0) >> 4;
ret = mmc_io_rw_direct(card, 0, FN0, SDIO_CCCR_CAPS, 0, &data);
if (ret)
goto out;
if (data & SDIO_CCCR_CAP_SMB)
card->cccr.multi_block = 1;
if (data & SDIO_CCCR_CAP_LSC)
card->cccr.low_speed = 1;
if (data & SDIO_CCCR_CAP_4BLS)
card->cccr.wide_bus = 1;
if (cccr_vsn >= SDIO_CCCR_REV_1_10) {
ret = mmc_io_rw_direct(card, 0, FN0, SDIO_CCCR_POWER, 0, &data);
if (ret)
goto out;
if (data & SDIO_POWER_SMPC)
card->cccr.high_power = 1;
}
if (cccr_vsn >= SDIO_CCCR_REV_1_20) {
ret = mmc_io_rw_direct(card, 0, FN0, SDIO_CCCR_SPEED, 0, &speed);
if (ret)
goto out;
card->scr.sda_spec3 = 0;
card->sw_caps.sd3_bus_mode = 0;
card->sw_caps.sd3_drv_type = 0;
if (cccr_vsn >= SDIO_CCCR_REV_3_00 && uhs) {
card->scr.sda_spec3 = 1;
ret = mmc_io_rw_direct(card, 0, FN0, SDIO_CCCR_UHS, 0, &data);
if (ret)
goto out;
if (card->host->caps &
(MMC_CAP_UHS_SDR12 | MMC_CAP_UHS_SDR25 |
MMC_CAP_UHS_SDR50 | MMC_CAP_UHS_SDR104 |
MMC_CAP_UHS_DDR50)) {
if (data & SDIO_UHS_DDR50)
card->sw_caps.sd3_bus_mode |= SD_MODE_UHS_DDR50;
if (data & SDIO_UHS_SDR50)
card->sw_caps.sd3_bus_mode |= SD_MODE_UHS_SDR50;
if (data & SDIO_UHS_SDR104)
card->sw_caps.sd3_bus_mode |= SD_MODE_UHS_SDR104;
}
ret = mmc_io_rw_direct(card, 0, FN0, SDIO_CCCR_DRIVE_STRENGTH, 0, &data);
if (ret)
goto out;
if (data & SDIO_DRIVE_SDTA)
card->sw_caps.sd3_drv_type |= SD_DRIVER_TYPE_A;
if (data & SDIO_DRIVE_SDTC)
card->sw_caps.sd3_drv_type |= SD_DRIVER_TYPE_C;
if (data & SDIO_DRIVE_SDTD)
card->sw_caps.sd3_drv_type |= SD_DRIVER_TYPE_D;
}
/* if no uhs mode ensure we check for high speed */
if (!card->sw_caps.sd3_bus_mode) {
if (speed & SDIO_SPEED_SHS) {
card->cccr.high_speed = 1;
card->sw_caps.hs_max_dtr = 50000000;
} else {
card->cccr.high_speed = 0;
card->sw_caps.hs_max_dtr = 25000000;
}
}
}
out:
SD_LOGD("%s high_speed:%d sda_spec3:%d sd3_drv_type:%lx sd3_bus_mode:%lx\n",
__func__, card->cccr.high_speed, card->scr.sda_spec3,
HAL_PR_SZ_L(card->sw_caps.sd3_drv_type), HAL_PR_SZ_L(card->sw_caps.sd3_bus_mode));
return ret;
}
static int32_t sdio_enable_wide(struct mmc_card *card)
{
int32_t ret;
uint8_t ctrl;
if (!(card->host->caps & MMC_CAP_4_BIT_DATA))
return 0;
if (card->cccr.low_speed && !card->cccr.wide_bus)
return 0;
ret = mmc_io_rw_direct(card, 0, FN0, SDIO_CCCR_IF, 0, &ctrl);
if (ret)
return ret;
ctrl |= SDIO_BUS_WIDTH_4BIT;
ret = mmc_io_rw_direct(card, 1, FN0, SDIO_CCCR_IF, ctrl, NULL);
if (!ret && card->type == MMC_TYPE_SDIO)
card->bus_width = MMC_BUS_WIDTH_4;
return ret;
}
/*
* If desired, disconnect the pull-up resistor on CD/DAT[3] (pin 1)
* of the card. This may be required on certain setups of boards,
* controllers and embedded sdio device which do not need the card's
* pull-up. As a result, card detection is disabled and power is saved.
*/
static int32_t sdio_disable_cd(struct mmc_card *card)
{
int32_t ret;
uint8_t ctrl;
if (!mmc_card_disable_cd(card))
return 0;
ret = mmc_io_rw_direct(card, 0, FN0, SDIO_CCCR_IF, 0, &ctrl);
if (ret)
return ret;
ctrl |= SDIO_BUS_CD_DISABLE;
return mmc_io_rw_direct(card, 1, FN0, SDIO_CCCR_IF, ctrl, NULL);
}
/*
* Devices that remain active during a system suspend are
* put back into 1-bit mode. called by mmc_sdio_suspend(host).
*/
#ifdef CONFIG_SD_PM
static int32_t sdio_disable_wide(struct mmc_card *card)
{
int32_t ret;
uint8_t ctrl;
if (!(card->host->caps & MMC_CAP_4_BIT_DATA))
return 0;
if (card->cccr.low_speed && !card->cccr.wide_bus)
return 0;
ret = mmc_io_rw_direct(card, 0, FN0, SDIO_CCCR_IF, 0, &ctrl);
if (ret)
return ret;
if (!(ctrl & SDIO_BUS_WIDTH_4BIT))
return 0;
ctrl &= ~SDIO_BUS_WIDTH_4BIT;
ctrl |= SDIO_BUS_ASYNC_INT;
ret = mmc_io_rw_direct(card, 1, FN0, SDIO_CCCR_IF, ctrl, NULL);
if (ret)
return ret;
HAL_SDC_Set_BusWidth(card->host, MMC_BUS_WIDTH_1);
return 0;
}
#endif
static int32_t sdio_enable_4bit_bus(struct mmc_card *card)
{
int32_t err = 0;
if (card->type == MMC_TYPE_SDIO)
return sdio_enable_wide(card);
#ifdef CONFIG_USE_SDIO_COMBO
if ((card->host->caps & MMC_CAP_4_BIT_DATA) &&
(card->scr.bus_widths & SD_SCR_BUS_WIDTH_4)) {
err = mmc_app_set_bus_width(card, MMC_BUS_WIDTH_4);
if (err)
return err;
} else
return 0;
err = sdio_enable_wide(card);
if (err <= 0)
mmc_app_set_bus_width(card, MMC_BUS_WIDTH_1);
#endif
return err;
}
/*
* Enable SDIO/combo card's high-speed mode. Return 0/1 if [not]supported.
*/
static int32_t sdio_enable_hs(struct mmc_card *card)
{
int32_t ret;
ret = mmc_sdio_switch_hs(card, 1);
if (ret <= 0 || card->type == MMC_TYPE_SDIO)
return ret;
#ifdef CONFIG_USE_SDIO_COMBO
ret = mmc_sd_switch_hs(card);
if (ret <= 0)
mmc_sdio_switch_hs(card, 0);
#endif
return ret;
}
/*----------------------------------------------------------------------------------------------*\
Function : This function gets the CIS adress present on the SDIO card
Argumennt : pointer to controller structure
Return : 0, -1
\*----------------------------------------------------------------------------------------------*/
/*
static uint32_t sdio_get_cisptr(struct mmc_card *card)
{
uint32_t fn;
uint8_t dat;
for (fn=0; fn<=card->io_num; fn++) {
sdio_ioreg_read(card, FN0, FN_CIS_POINTER_0_REG(fn), &dat);
card->cisptr[fn] = dat;
sdio_ioreg_read(card, FN0, FN_CIS_POINTER_1_REG(fn), &dat);
card->cisptr[fn] |= (uint32_t)dat << 8;
sdio_ioreg_read(card, FN0, FN_CIS_POINTER_2_REG(fn), &dat);
card->cisptr[fn] |= (uint32_t)dat << 16;
SD_LOGD("Card CIS Addr = %x, fn = %d\n", card->cisptr[fn], fn);
}
return 0;
}
*/
#if 0
/*--------------------------------------------------------------*\
@function : uint32_t sdio_read_cisinfo(uint8_t* buf)
@brief : this function read CIS infomation of card
@arguments: buf - pointer to data buffer
@return : 0, -1
\*--------------------------------------------------------------*/
int32_t sdio_read_cisinfo(struct mmc_card *card, uint8_t* buf)
{
uint32_t i;
int32_t ret=0;
/* Read the Tuple Data */
for (i = 0; i < SIZE_OF_TUPLE; i++) {
ret = sdio_ioreg_read(card, FN0, card->cisptr[FN0]+i, buf+i);
if (ret==-1)
return ret;
}
return ret;
}
/*--------------------------------------------------------------*\
@function : uint32_t sdio_read_manfid(uint32_t func_num)
@brief : this function read Manufacturer identification of card
@arguments: func_num - pointer to data buffer
@return : 0, -1
\*--------------------------------------------------------------*/
int32_t sdio_read_manfid(struct mmc_card *card, uint32_t func_num)
{
uint32_t offset = 0;
uint32_t manfid, card_id;
int32_t ret=0;
uint8_t tuple, link, datah, datal;
do {
ret = sdio_ioreg_read(card, func_num, card->cisptr[func_num]+offset, &tuple);
if (ret == -1)
return ret;
if (tuple == CISTPL_MANFID) {
offset += 2;
ret = sdio_ioreg_read(card, func_num, card->cisptr[func_num]+offset, &datal);
if (ret == -1)
return ret;
offset++;
ret = sdio_ioreg_read(card, func_num, card->cisptr[func_num]+offset, &datah);
if (ret == -1)
return ret;
manfid = (uint32_t)datal | (uint32_t)datah << 8;
offset++;
ret = sdio_ioreg_read(card, func_num, card->cisptr[func_num]+offset, &datal);
if (ret == -1)
return ret;
offset++;
ret = sdio_ioreg_read(card, func_num, card->cisptr[func_num]+offset, &datah);
if (ret == -1)
return ret;
card_id = (uint32_t)datal | (uint32_t)datah << 8;
card->manfid = (card_id<<16)|manfid;
SD_LOGD("Card id = %08x manfid = %08x\n", card_id, manfid);
return manfid;
}
ret = sdio_ioreg_read(card, func_num, card->cisptr[func_num]+offset+1, &link);
if (ret == -1)
return ret;
offset += link + 2;
} while(tuple != CISTPL_END);
return 0;
}
int32_t sdio_get_vendor_id(struct mmc_card *card)
{
return (sdio_read_manfid(card, FN0));
}
#endif
int
sdio_memcpy_fromio(struct mmc_card *card, unsigned int func_num, void *dst, unsigned int addr, int count)
{
return sdio_io_rw_ext_helper(card, func_num, 0, addr, 1, dst, count);
}
int
sdio_memcpy_toio(struct mmc_card *card, unsigned int func_num, unsigned int addr, const void *src, int count)
{
return sdio_io_rw_ext_helper(card, func_num, 1, addr, 1, (uint8_t *)src, count);
}
#ifdef CONFIG_SDIO_IRQ_SUPPORT
#if 0
/*-----------------------------------*\
Read IOx's Interrupt Pending
Argument: io_num - 1~7
Return: 1-pending, 0-not pending
\*-----------------------------------*/
int32_t sdio_intx_pend_rd(struct mmc_card *card, uint32_t io_num)
{
uint8_t dat;
//func_num uses default value 0
mmc_io_rw_direct_host(card->host, 0, FN0, INT_PENDING_REG, 0, &dat);
if (dat & INT(io_num)) {
SD_LOGE("IO%x Interrupt is pending !!\n", io_num);
return 0;
}
SD_LOGD("IO%x Interrupt is not pending !!\n", io_num);
return -1;
}
/* IOx's Abort *\
\* io_num: 1~7 */
int32_t sdio_iox_abort(struct mmc_card *card, uint32_t io_num)
{
mmc_io_rw_direct_host(card->host, 0, FN0, IO_ABORT_REG, AS(io_num), NULL);
return 0;
}
/**
* sdio_claim_irq - claim the IRQ for a SDIO function
* @func: SDIO function
* @handler: IRQ handler callback
*
* Claim and activate the IRQ for the given SDIO function. The provided
* handler will be called when that IRQ is asserted. The host is always
* claimed already when the handler is called so the handler must not
* call sdio_claim_host() nor sdio_release_host().
*/
int sdio_claim_irq(struct mmc_card *card, unsigned int func_num, sdio_irq_handler_t *handler)
{
int32_t ret;
uint8_t reg;
if (!card) {
SD_LOGE_RAW(ROM_ERR_MASK, "%s,%d\n", __func__, __LINE__);
return -1;
}
SD_LOGN("SDIO: Enabling IRQ for %d...\n", func_num);
if (card->irq_handler) {
SD_LOGE("SDIO: IRQ for %d already in use.\n", func_num);
return -EBUSY;
}
reg = sdio_readb(card, FN0, SDIO_CCCR_IENx, &ret);
if (ret)
return ret;
reg |= 1 << func_num;
reg |= 1; /* Master interrupt enable */
sdio_writeb(card, FN0, reg, SDIO_CCCR_IENx, &ret);
if (ret)
return ret;
card->irq_handler = handler;
return ret;
}
/**
* sdio_release_irq - release the IRQ for a SDIO function
* @func: SDIO function
*
* Disable and release the IRQ for the given SDIO function.
*/
int sdio_release_irq(struct mmc_card *card, unsigned int func_num)
{
int ret;
uint8_t reg;
if (!card) {
SD_LOGE_RAW(ROM_ERR_MASK, "%s,%d\n", __func__, __LINE__);
return -1;
}
SD_LOGN("SDIO: Disabling IRQ for %d...\n", func_num);
if (card->irq_handler)
card->irq_handler = NULL;
reg = sdio_readb(card, FN0, SDIO_CCCR_IENx, &ret);
if (ret)
return ret;
reg &= ~(1 << func_num);
/* Disable master interrupt with the last function interrupt */
if (!(reg & 0xFE))
reg = 0;
sdio_writeb(card, FN0, reg, SDIO_CCCR_IENx, &ret);
if (ret)
return ret;
return 0;
}
#endif
#endif
/*
* Fetch CID from card.
*/
#ifdef CONFIG_USE_SDIO_COMBO
int32_t mmc_sd_get_cid(struct mmc_host *host, uint32_t ocr, uint32_t *cid, uint32_t *rocr)
{
int32_t err;
/*
* Since we're changing the OCR value, we seem to
* need to tell some cards to go back to the idle
* state. We wait 1ms to give cards time to
* respond.
*/
mmc_go_idle(host);
/*
* If SD_SEND_IF_COND indicates an SD 2.0
* compliant card and we should set bit 30
* of the ocr to indicate that we can handle
* block-addressed SDHC cards.
*/
err = mmc_send_if_cond(host, ocr);
if (!err)
ocr |= SD_OCR_CCS;
/*
* If the host supports one of UHS-I modes, request the card
* to switch to 1.8V signaling level.
*/
if (host->caps & (MMC_CAP_UHS_SDR12 | MMC_CAP_UHS_SDR25 |
MMC_CAP_UHS_SDR50 | MMC_CAP_UHS_SDR104 | MMC_CAP_UHS_DDR50))
ocr |= SD_OCR_S18R;
/* If the host can supply more than 150mA, XPC should be set to 1. */
if (host->caps & (MMC_CAP_SET_XPC_330 | MMC_CAP_SET_XPC_300 |
MMC_CAP_SET_XPC_180))
ocr |= SD_OCR_XPC;
try_again:
err = mmc_send_app_op_cond(host, ocr, rocr);
if (err)
return err;
/*
* In case CCS and S18A in the response is set, start Signal Voltage
* Switch procedure. SPI mode doesn't support CMD11.
*/
if (rocr && ((*rocr & 0x41000000) == 0x41000000)) {
err = mmc_set_signal_voltage(host, MMC_SIGNAL_VOLTAGE_180, true);
if (err) {
ocr &= ~SD_OCR_S18R;
goto try_again;
}
}
err = mmc_all_send_cid(host, cid);
return err;
}
#endif
/*--------------------------------------------------------------*\
@function : uint32_t sdio_enumerate(uint32_t smc_no)
@brief : this function enumerates and initializes SDIO card
@arguments: smc_no - number of the smc channel selected
@return : 0, -1
\*--------------------------------------------------------------*/
int32_t mmc_sdio_init_card(struct mmc_card *card)
{
int32_t err;
//struct mmc_host *host = card->host;
/* The initialization should be done at 3.3 V I/O voltage. */
//mmc_set_signal_voltage();
err = mmc_send_io_op_cond(card, card->ocr.ocr & 0xFF8000, &card->ocr.ocr);
if (err)
return err;
#ifdef CONFIG_USE_SDIO_COMBO
if ((card->ocr.ocr & R4_MEMORY_PRESENT) &&
mmc_sd_get_cid(host, host->ocr & card->ocr.ocr, card->raw_cid, NULL) == 0) {
card->type = MMC_TYPE_SD_COMBO;
SD_LOGW("SDIO Combo Card(With I/O & Memory) !!\n");
/* if with memory in it, allocate memory space for storing memory portion information */
//card->mem_info_p = (SDMMCInfo *)HAL_Malloc(sizeof(SDMMCInfo));
/* relative operations for memory portion */
} else
#endif
{
card->type = MMC_TYPE_SDIO;
SD_LOGD("Standard SDIO Card with IO portion only !!\n");
}
/*
* If the host and card support UHS-I mode request the card
* to switch to 1.8V signaling level. No 1.8v signalling if
* UHS mode is not enabled to maintain compatibilty and some
* systems that claim 1.8v signalling in fact do not support
* it.
*/
#ifdef SD_SUPPORT_VERSION3
if ((card->ocr.ocr & R4_18V_PRESENT) &&
(card->host->caps & (MMC_CAP_UHS_SDR12 | MMC_CAP_UHS_SDR25 |
MMC_CAP_UHS_SDR50 | MMC_CAP_UHS_SDR104 |
MMC_CAP_UHS_DDR50))) {
err = mmc_set_signal_voltage(card->host, MMC_SIGNAL_VOLTAGE_180, true);
if (err) {
card->ocr.ocr &= ~R4_18V_PRESENT;
card->host->ocr &= ~R4_18V_PRESENT;
}
err = 0;
} else {
card->ocr.ocr &= ~R4_18V_PRESENT;
card->host->ocr &= ~R4_18V_PRESENT;
}
#endif
/* CMD3, Ask the card to publish a new Relative Card Address (RCA) */
err = mmc_send_relative_addr(card->host, &card->rca);
if (err) {
SD_LOGW("SD public RCA failed\n");
return err;
}
SD_LOGD("Card RCA %lx\n", HAL_PR_SZ_L(card->rca));
HAL_SDC_Update_Clk(card->host, 25000000);
/*
* Read CSD, before selecting the card
*/
#ifdef CONFIG_USE_SDIO_COMBO
if (card->type == MMC_TYPE_SD_COMBO) {
err = mmc_sd_get_csd(host, card);
if (err)
return err;
mmc_decode_cid(card);
}
#endif
/* CMD7, Select card, as all following commands rely on that. */
err = mmc_select_card(card, 1);
if (err) {
SD_LOGE("Card Select Error!!\n");
return -1;
}
#ifdef CONFIG_USE_MMC_QUIRK
if (card->quirks & MMC_QUIRK_NONSTD_SDIO) {
/*
* This is non-standard SDIO device, meaning it doesn't
* have any CIA (Common I/O area) registers present.
* It's host's responsibility to fill cccr and cis
* structures in init_card().
*/
mmc_set_clock(host, card->cis.max_dtr);
if (card->cccr.high_speed) {
mmc_card_set_highspeed(card);
mmc_set_timing(card->host, MMC_TIMING_SD_HS);
}
goto finish;
}
#endif
/*
* Read the common registers.
*/
err = sdio_read_cccr(card, card->ocr.ocr);
if (err)
goto remove;
/*
* Read the common CIS tuples.
*/
#ifdef CONFIG_SDIO_USE_FUNS
err = sdio_read_common_cis(card);
if (err)
goto remove;
#endif
#ifdef CONFIG_USE_MMC_QUIRK
mmc_fixup_device(card, NULL);
#endif
/*
* If needed, disconnect card detection pull-up resistor.
*/
err = sdio_disable_cd(card);
if (err)
goto remove;
/* Initialization sequence for UHS-I cards */
/* Only if card supports 1.8v and UHS signaling */
#ifdef SD_SUPPORT_VERSION3
if ((card->ocr.ocr & R4_18V_PRESENT) && card->sw_caps.sd3_bus_mode) {
err = mmc_sdio_init_uhs_card(card);
if (err)
goto remove;
/* Card is an ultra-high-speed card */
mmc_card_set_uhs(card);
} else
#endif
{
/*
* Switch to high-speed (if supported).
*/
err = sdio_enable_hs(card);
if (err > 0) {
mmc_card_set_highspeed(card);
SD_LOGN("sdio highspeed \n");
} else if (err)
goto remove;
/*
* Change to the card's maximum speed.
*/
HAL_SDC_Update_Clk(card->host, mmc_sdio_get_max_clock(card));
/*
* Switch to wider bus (if supported).
*/
err = sdio_enable_4bit_bus(card);
if (!err) {
/* sd Host Controller Register SDXC_REG_WIDTH */
HAL_SDC_Set_BusWidth(card->host, MMC_BUS_WIDTH_4);
SD_LOGN("%s bus width type:%d\n", __func__, MMC_BUS_WIDTH_4);
} else if (err)
goto remove;
}
#ifdef CONFIG_USE_MMC_QUIRK
finish:
#endif
card->host->card = card;
return 0;
remove:
card->host->card = NULL;
#ifdef CONFIG_SDIO_USE_FUNS
sdio_free_func_cis((struct sdio_func *)card->sdio_func);
sdio_free_common_cis(card);
#endif
return err;
}
uint32_t sdio_reset(struct mmc_host *host)
{
int32_t ret;
uint8_t abort;
/* SDIO Simplified Specification V2.0, 4.4 Reset for SDIO */
ret = mmc_io_rw_direct_host(host, 0, 0, SDIO_CCCR_ABORT, 0, &abort);
if (ret)
abort = 0x08;
else
abort |= 0x08;
ret = mmc_io_rw_direct_host(host, 1, 0, SDIO_CCCR_ABORT, abort, NULL);
return ret;
}
/**
* sdio_set_host_pm_flags - set wanted host power management capabilities
* @func: SDIO function attached to host
*
* Set a capability bitmask corresponding to wanted host controller
* power management features for the upcoming suspend state.
* This must be called, if needed, each time the suspend method of
* the function driver is called, and must contain only bits that
* were returned by sdio_get_host_pm_caps().
* The host doesn't need to be claimed, nor the function active,
* for this information to be set.
*/
static int32_t sdio_set_host_pm_flags(sdio_t *card, uint32_t flags)
{
#ifdef CONFIG_SD_PM
struct mmc_host *host = card->host;
if (flags & ~host->pm_caps)
return -1;
/* function suspend methods are serialized, hence no lock needed */
host->pm_flags |= flags;
#endif
return 0;
}
int32_t sdio_pm(sdio_t *card, int32_t suspend)
{
int32_t ret = 0;
if (suspend) {
/* Notify SDIO that ALLWINNERTECH will remain powered during suspend */
ret = sdio_set_host_pm_flags(card, MMC_PM_KEEP_POWER);
if (ret)
SD_LOGE("Error setting SDIO pm flags: %ld\n", HAL_PR_SZ_L(ret));
}
return ret;
}
#ifdef CONFIG_SD_PM
/*
* SDIO suspend. We need to suspend all functions separately.
* Therefore all registered functions must have drivers with suspend
* and resume methods. Failing that we simply remove the whole card.
*/
static int mmc_sdio_suspend(struct mmc_host *host)
{
int32_t i, err = 0;
struct mmc_card *card;
card = host->card;
card->suspend = 1;
#ifdef CONFIG_SDIO_USE_FUNS
for (i = 0; i < host->card->sdio_funcs; i++) {
struct sdio_func *func = host->card->sdio_func[i];
if (func && sdio_func_present(func) && func->dev.driver) {
err = sdio_bus_pm_suspend(&func->dev);
sdio_disable_func(host->card, FN1);
if (err)
break;
}
}
while (err && --i >= 0) {
struct sdio_func *func = host->card->sdio_func[i];
if (func && sdio_func_present(func) && func->dev.driver) {
sdio_bus_pm_resume(&func->dev);
}
}
#else
(void)i;
#endif
if (mmc_card_keep_power(host) && mmc_card_wake_sdio_irq(host)) {
mmc_claim_host(host);
sdio_disable_wide(host->card);
mmc_release_host(host);
}
return err;
}
int mmc_sdio_resume(struct mmc_host *host)
{
int32_t i, err = 0;
struct mmc_card *card;
if (!host) {
SDC_LOGE_RAW(ROM_ERR_MASK, "%s,%d no host exist!\n", __func__, __LINE__);
return -1;
}
if (!host->card) {
SDC_LOGE("%s,%d no card exist!\n", __func__, __LINE__);
return -1;
}
card = host->card;
/* Basic card reinitialization. */
mmc_claim_host(host);
/* No need to reinitialize powered-resumed nonremovable cards */
if (!mmc_card_keep_power(host)) {
err = mmc_sdio_init_card(host->card);
} else if (mmc_card_wake_sdio_irq(host)) {
/* We may have switched to 1-bit mode during suspend */
err = sdio_enable_4bit_bus(host->card);
if (!err) {
HAL_SDC_Set_BusWidth(host->card->host, MMC_BUS_WIDTH_4);
SDC_LOGN("%s bus width type:%d\n", __func__, MMC_BUS_WIDTH_4);
err = 0;
}
}
#ifdef CONFIG_SDIO_IRQ_SUPPORT
if (!err && host->sdio_irqs)
wake_up_process(host->sdio_irq_thread);
#endif
mmc_release_host(host);
#ifdef CONFIG_SDIO_USE_FUNS
/*
* If the card looked to be the same as before suspending, then
* we proceed to resume all card functions. If one of them returns
* an error then we simply return that error to the core and the
* card will be redetected as new. It is the responsibility of
* the function driver to perform further tests with the extra
* knowledge it has of the card to confirm the card is indeed the
* same as before suspending (same MAC address for network cards,
* etc.) and return an error otherwise.
*/
for (i = 0; !err && i < host->card->sdio_funcs; i++) {
struct sdio_func *func = host->card->sdio_func[i];
if (func && sdio_func_present(func) && func->dev.driver) {
err = sdio_bus_pm_resume(&func->dev);
sdio_enable_func(host->card, FN1);
}
}
#else
(void)i;
#endif
card->suspend = 0;
return err;
}
static const struct mmc_bus_ops sdio_bus_ops = {
.suspend = mmc_sdio_suspend,
.resume = mmc_sdio_resume,
};
#endif
/*
* Starting point for SDIO card init.
*/
int mmc_attach_sdio(struct mmc_card *card, struct mmc_host *host)
{
int err = -1;
int32_t funcs;
int i;
if (!host) {
SD_LOGE("%s,%d no host exist!\n", __func__, __LINE__);
return -1;
}
/* CMD5 arg=0; get card support Voltage */
err = mmc_send_io_op_cond(card, 0, &card->ocr.ocr);
if (err)
return err;
SD_LOGD("card ocr:%lx\n", HAL_PR_SZ_L(card->ocr.ocr));
/*
* Sanity check the voltages that the card claims to
* support.
*/
if (card->ocr.ocr & 0x7F) {
SD_LOGW("card claims to support voltages below the defined range."
"These will be ignored.\n");
card->ocr.ocr &= ~0x7F;
}
/* Detect and init the card. */
err = mmc_sdio_init_card(card);
if (err)
return err;
funcs = (card->ocr.ocr >> 28) & 0x7;
SD_LOGD("Number of I/O Functions: %02lx\n", HAL_PR_SZ_L(funcs));
/*
* Initialize (but don't add) all present functions.
*/
#ifdef CONFIG_SDIO_USE_FUNS
card->sdio_funcs = 0;
// for (int i = 0; i < card->io_num; i++, card->sdio_funcs++) {
// for (int i = 0; i < funcs; i++, card->sdio_funcs++) {
for (i = 0; i < funcs; i++, card->sdio_funcs++) {
err = sdio_init_func(host->card, i + 1);
if (err)
goto remove;
}
#endif
/*
* First add the card to the driver model...
*/
mmc_release_host(host);
if(host->caps&MMC_CAP_SDIO_IRQ){
int ret = OS_SemaphoreCreateBinary(&host->sdio_irq_signal);
SDC_BUG_ON(ret!=OS_OK);
}
mmc_add_card(host->card);
/*
* ...then the SDIO functions.
*/
#ifdef CONFIG_SDIO_USE_FUNS
// for (int i = 0; i < funcs; i++) {
for (i = 0; i < funcs; i++) {
err = sdio_add_func(host->card->sdio_func[i], i);
if (err)
goto remove_added;
}
#else
(void)funcs;
#endif
card->fn_bsize[1] = 512;
mmc_claim_host(host);
#ifdef CONFIG_SD_PM
if (!card->suspend) {
mmc_attach_bus(host, &sdio_bus_ops);
}
#endif
return 0;
#ifdef CONFIG_SDIO_USE_FUNS
remove_added:
/* Remove without lock if the device has been added. */
mmc_sdio_remove(host);
#endif
card->host->card = NULL;
mmc_claim_host(host);
#ifdef CONFIG_SDIO_USE_FUNS
remove:
/* And with lock if it hasn't been added. */
mmc_release_host(host);
if (host->card) {
mmc_sdio_remove(host);
card->host->card = NULL;
}
mmc_claim_host(host);
#else
card->host->card = NULL;
#endif
SD_LOGE("%s: error %d whilst initialising SDIO card\n", __func__, err);
return err;
}
void mmc_deattach_sdio(struct mmc_card *card, struct mmc_host *host)
{
if (!card) {
SD_LOGE_RAW(ROM_ERR_MASK, "%s,%d\n", __func__, __LINE__);
return ;
}
#ifdef CONFIG_SD_PM
if (!card->suspend) {
mmc_detach_bus(card->host);
}
#endif
if(host->caps&MMC_CAP_SDIO_IRQ){
int ret = OS_SemaphoreDelete(&host->sdio_irq_signal);
SDC_BUG_ON(ret!=OS_OK);
}
}
/**
* sdio_align_size - pads a transfer size to a more optimal value
* @card: SDIO card
* @sz: original transfer size
*
* Pads the original data size with a number of extra bytes in
* order to avoid controller bugs and/or performance hits
* (e.g. some controllers revert to PIO for certain sizes).
*
* If possible, it will also adjust the size so that it can be
* handled in just a single request.
*
* Returns the improved size, which might be unmodified.
*/
//unsigned int sdio_align_size(struct mmc_card *card, unsigned int sz)
unsigned int sdio_align_size(struct sdio_func *func, unsigned int sz)
{
#ifdef CONFIG_SDIO_USE_FUNS
unsigned int orig_sz;
unsigned int blk_sz, byte_sz;
unsigned chunk_sz;
orig_sz = sz;
#endif
/* Do a first check with the controller, in case it
* wants to increase the size up to a point where it
* might need more than one block.
*/
//sz = mmc_align_data_size(card, sz);
sz = mmc_align_data_size(func->card, sz);
#ifdef CONFIG_SDIO_USE_FUNS
/*
* If we can still do this with just a byte transfer, then
* we're done.
*/
if (sz <= sdio_max_byte_size(func))
return sz;
if (func->card->cccr.multi_block) {
/*
* Check if the transfer is already block aligned
*/
if ((sz % func->cur_blksize) == 0) {
return sz;
}
/*
* Realign it so that it can be done with one request,
* and recheck if the controller still likes it.
*/
blk_sz = ((sz + func->cur_blksize - 1) /
func->cur_blksize) * func->cur_blksize;
blk_sz = mmc_align_data_size(func->card, blk_sz);
/*
* This value is only good if it is still just
* one request.
*/
if ((blk_sz % func->cur_blksize) == 0)
return blk_sz;
/*
* We failed to do one request, but at least try to
* pad the remainder properly.
*/
byte_sz = mmc_align_data_size(func->card,
sz % func->cur_blksize);
if (byte_sz <= sdio_max_byte_size(func)) {
blk_sz = sz / func->cur_blksize;
return blk_sz * func->cur_blksize + byte_sz;
}
} else {
/*
* We need multiple requests, so first check that the
* controller can handle the chunk size;
*/
chunk_sz = mmc_align_data_size(func->card,
sdio_max_byte_size(func));
if (chunk_sz == sdio_max_byte_size(func)) {
/*
* Fix up the size of the remainder (if any)
*/
byte_sz = orig_sz % chunk_sz;
if (byte_sz) {
byte_sz = mmc_align_data_size(func->card,
byte_sz);
}
return (orig_sz / chunk_sz) * chunk_sz + byte_sz;
}
}
/* The controller is simply incapable of transferring the size
* we want in decent manner, so just return the original size.
*/
return orig_sz;
#endif
return sz;
}
#ifdef SDIO_EXCLUSIVE_HOST
/**
* sdio_claim_host - exclusively claim a bus for a certain SDIO function
* @card: SDIO that will be accessed
*
* Claim a bus for a set of operations. The SDIO function given
* is used to figure out which bus is relevant.
*/
void sdio_claim_host(struct mmc_card *card)
{
HAL_SDC_Claim_Host(card->host);
}
/**
* sdio_release_host - release a bus for a certain SDIO function
* @card: SDIO that was accessed
*
* Release a bus, allowing others to claim the bus for their
* operations.
*/
void sdio_release_host(struct mmc_card *card)
{
HAL_SDC_Release_Host(card->host);
}
#endif
#endif /* CONFIG_USE_SDIO */
View Git Blame Copy Permalink