int mmc_all_send_cid(struct mmc_host *host, u32 *cid)
{
int err;
struct mmc_command cmd = {0};
#ifdef CONFIG_HUAWEI_SDCARD_DSM
char *log_buff;
int buff_len;
#endif
BUG_ON(!host);
BUG_ON(!cid);
cmd.opcode = MMC_ALL_SEND_CID;
cmd.arg = 0;
cmd.flags = MMC_RSP_R2 | MMC_CMD_BCR;
err = mmc_wait_for_cmd(host, &cmd, MMC_CMD_RETRIES);
#ifdef CONFIG_HUAWEI_SDCARD_DSM
if(!strcmp(mmc_hostname(host), "mmc1"))
{
dsm_sdcard_cmd_logs[DSM_SDCARD_CMD2_R0].value = cmd.resp[0];
dsm_sdcard_cmd_logs[DSM_SDCARD_CMD2_R1].value = cmd.resp[1];
dsm_sdcard_cmd_logs[DSM_SDCARD_CMD2_R2].value = cmd.resp[2];
dsm_sdcard_cmd_logs[DSM_SDCARD_CMD2_R3].value = cmd.resp[3];
}
if (err)
{
if(-ENOMEDIUM != err && -ETIMEDOUT != err
&& !strcmp(mmc_hostname(host), "mmc1") && !dsm_client_ocuppy(sdcard_dclient))
{
log_buff = dsm_sdcard_get_log(DSM_SDCARD_CMD2_R3,err);
buff_len = strlen(log_buff);
dsm_client_copy(sdcard_dclient,log_buff,buff_len + 1);
dsm_client_notify(sdcard_dclient, DSM_SDCARD_CMD2_RESP_ERR);
}
if(!strcmp(mmc_hostname(host),"mmc1"))
{
printk(KERN_ERR "%s:send cmd2 fail,err=%d\n",mmc_hostname(host),err);
}
return err;
}
#else
if (err)
{
if(!strcmp(mmc_hostname(host),"mmc1"))
{
printk(KERN_ERR "%s:send cmd2 fail,err=%d\n",mmc_hostname(host),err);
}
return err;
}
#endif
memcpy(cid, cmd.resp, sizeof(u32) * 4);
return 0;
}
//cnotify format: |client name|,|error no|,|contents|
static ssize_t dsm_cnotify_store(struct device *dev,
struct device_attribute *attr, const char *buf, size_t count)
{
char client_name[CLIENT_NAME_LEN]= {0};
int size;
int error_no = 0;
struct dsm_client *client = NULL;
char *strings = NULL;
char *ptr;
DSM_LOG_DEBUG("%s enter\n",__func__);
strings = (char *)kzalloc(count, GFP_KERNEL);
if(!strings) {
DSM_LOG_ERR("dsm write malloc failed\n");
goto out;
}
memcpy(strings, buf, count);
/*get client name*/
ptr = dsm_strtok(strings, ",");
if(ptr) {
size = strlen(ptr);
size = (size < CLIENT_NAME_LEN) ? size : (CLIENT_NAME_LEN - 1);
memcpy(client_name, ptr, size);
}
/*get error no*/
ptr = dsm_strtok(NULL, ",");
if(ptr)
error_no = dsm_atoi(ptr);
/*get notify content*/
ptr = dsm_strtok(NULL, NULL);
DSM_LOG_INFO("client name - %s, error no - %d\n", client_name, error_no);
if(ptr)
DSM_LOG_INFO("content - %s\n", ptr);
client = dsm_find_client(client_name);
if(client && (!dsm_client_ocuppy(client))) {
DSM_LOG_DEBUG("dsm write find client - %s\n", client_name);
if(ptr)
dsm_client_copy(client, ptr, strlen(ptr));
dsm_client_notify(client, error_no);
} else
DSM_LOG_INFO("dsm notify can't find client - %s\n", client_name);
out:
if(strings)
kfree(strings);
DSM_LOG_DEBUG("%s exit\n",__func__);
return count;
}
static int _mmc_select_card(struct mmc_host *host, struct mmc_card *card)
{
int err;
struct mmc_command cmd = {0};
#ifdef CONFIG_HUAWEI_SDCARD_DSM
char *log_buff;
int buff_len;
#endif
BUG_ON(!host);
cmd.opcode = MMC_SELECT_CARD;
if (card) {
cmd.arg = card->rca << 16;
cmd.flags = MMC_RSP_R1 | MMC_CMD_AC;
} else {
cmd.arg = 0;
cmd.flags = MMC_RSP_NONE | MMC_CMD_AC;
}
err = mmc_wait_for_cmd(host, &cmd, MMC_CMD_RETRIES);
#ifdef CONFIG_HUAWEI_SDCARD_DSM
if(!strcmp(mmc_hostname(host), "mmc1"))
{
dsm_sdcard_cmd_logs[DSM_SDCARD_CMD7].value = cmd.resp[0];
}
if (err)
{
if(-ENOMEDIUM != err && -ETIMEDOUT != err
&& !strcmp(mmc_hostname(host), "mmc1") && !dsm_client_ocuppy(sdcard_dclient))
{
log_buff = dsm_sdcard_get_log(DSM_SDCARD_CMD7,err);
buff_len = strlen(log_buff);
dsm_client_copy(sdcard_dclient,log_buff,buff_len + 1);
dsm_client_notify(sdcard_dclient, DSM_SDCARD_CMD7_RESP_ERR);
}
return err;
}
#else
if (err)
return err;
#endif
return 0;
}
static ssize_t dsm_write(struct file *file, const char __user *buf, size_t count, loff_t *ppos)
{
char client_name[CLIENT_NAME_LEN]={0};
int size;
struct dsm_client *client = NULL;
char *buff = NULL;
char *ptr;
DSM_LOG_DEBUG("%s enter\n",__func__);
buff = (char *)kzalloc(count, GFP_KERNEL);
if(!buff){
DSM_LOG_ERR("dsm write malloc failed\n");
goto out;
}
if(copy_from_user(buff, buf, count)){
DSM_LOG_ERR("dsm write copy failed\n");
goto out;
}
ptr = buff;
while(*ptr){
if(*ptr == '\n')
break;
ptr++;
}
if(*ptr == '\n'){
size = ptr - buff;
size = (size < CLIENT_NAME_LEN) ? size : (CLIENT_NAME_LEN - 1);
memcpy(client_name, buff, size);
client = dsm_find_client(client_name);
if(client && (!dsm_client_ocuppy(client))){
DSM_LOG_DEBUG("dsm write find client - %s\n", client_name);
ptr++;//ignore '/n'
size = count - (ptr - buff);
dsm_client_copy(client, ptr, size);
dsm_client_notify(client, 20203);
}else
DSM_LOG_INFO("dsm write can't find client - %s\n", client_name);
}else
DSM_LOG_ERR("dsm write can't find client name\n");
out:
if(buff)
kfree(buff);
DSM_LOG_DEBUG("%s exit\n",__func__);
return count;
}
static ssize_t dsm_write(struct file *file, const char __user *buf, size_t count, loff_t *ppos)
{
char client_name[CLIENT_NAME_LEN]= {'\0'};
int size, error_no = 0;
struct dsm_client *client = NULL;
char *buff = NULL;
char *ptr = NULL;
#ifdef CONFIG_HUAWEI_SDCARD_VOLD
char err_string[20] = {0};
int err;
#endif
DSM_LOG_DEBUG("%s enter\n",__func__);
buff = (char *)kzalloc(count, GFP_KERNEL);
if(!buff) {
DSM_LOG_ERR("dsm write malloc failed\n");
goto out;
}
if(copy_from_user(buff, buf, count)) {
DSM_LOG_ERR("dsm write copy failed\n");
goto out;
}
/*get client name*/
ptr = dsm_strtok(buff, ",");
if(ptr) {
size = strlen(ptr);
size = (size < CLIENT_NAME_LEN) ? size : (CLIENT_NAME_LEN - 1);
memcpy(client_name, ptr, size);
}
/*get error no*/
ptr = dsm_strtok(NULL, ",");
if(ptr) {
error_no = dsm_atoi(ptr);
}
/*get notify content*/
ptr = dsm_strtok(NULL, NULL);
DSM_LOG_INFO("client name - %s, error no - %d\n", client_name, error_no);
if(ptr) {
DSM_LOG_INFO("content - %s\n", ptr);
}
client = dsm_find_client(client_name);
#ifdef CONFIG_HUAWEI_SDCARD_VOLD
if(client && !strncasecmp("sdcard_vold",client_name,size)&&(!dsm_client_ocuppy(client)))
{
DSM_LOG_DEBUG("dsm write find sdcard_vold\n");
ptr++;
while(*ptr) {
if(*ptr == '\n')
break;
ptr++;
}
if(*ptr == '\n')
{
memcpy(err_string,ptr-SDCARD_ERR_LEN,SDCARD_ERR_LEN);
err_string[SDCARD_ERR_LEN] = '\0';
sscanf(err_string,"%d",&err);
dsm_client_copy(client, ptr+1, (count - (ptr+1-buff)));
dsm_client_notify(client, err);
}
}
else if(client && (!dsm_client_ocuppy(client))) {
#else
if(client && (!dsm_client_ocuppy(client))) {
#endif
DSM_LOG_DEBUG("dsm write find client - %s\n", client_name);
if(ptr)
dsm_client_copy(client, ptr, strlen(ptr));
dsm_client_notify(client, error_no);
} else {
DSM_LOG_INFO("dsm notify can't find client - %s\n", client_name);
}
out:
if(buff)
kfree(buff);
DSM_LOG_DEBUG("%s exit\n",__func__);
return count;
}
static unsigned int dsm_poll(struct file *file, poll_table *wait)
{
struct dsm_client *client = file->private_data;
unsigned int mask = 0;
DSM_LOG_DEBUG("%s enter\n",__func__);
if(!client) {
DSM_LOG_ERR("dsm can't poll without client\n");
goto out;
}
DSM_LOG_DEBUG("client name :%s\n", client->client_name);
poll_wait(file, &client->waitq, wait);
if(test_bit(CBUFF_READY_BIT, &client->buff_flag))
mask = POLLIN | POLLRDNORM;
out:
DSM_LOG_DEBUG("%s exit, mask:%d\n",__func__, mask);
return mask;
}
static int dsm_open(struct inode *inode, struct file *file)
{
DSM_LOG_DEBUG("%s enter\n",__func__);
file->private_data = NULL;
DSM_LOG_DEBUG("%s exit\n",__func__);
return 0;
}
/* sysfs write function */
static ssize_t dsm_write(struct file *file, const char __user *buf, size_t count, loff_t *ppos)
{
char client_name[CLIENT_NAME_LEN]={0};
int size;
struct dsm_client *client = NULL;
char *buff = NULL;
char *ptr;
char err_string[20] = {0};
int err;
DSM_LOG_INFO("%s enter\n",__func__);
/* try to get control of the write buffer */
if (down_trylock(&dsm_wbs)) {
/* somebody else has it now;
* if we're non-blocking, then exit...
*/
if (file->f_flags & O_NONBLOCK) {
return -EAGAIN;
}
/* ...or if we want to block, then do so here */
if (down_interruptible(&dsm_wbs)) {
/* something went wrong with wait */
return -ERESTARTSYS;
}
}
buff = (char *)kzalloc(count, GFP_KERNEL);
if(!buff){
DSM_LOG_ERR("dsm write malloc failed\n");
goto out;
}
if(copy_from_user(buff, buf, count)){
DSM_LOG_ERR("dsm write copy failed\n");
goto out;
}
buff[count-1] = '\0';
ptr = buff;
while(*ptr){
if(*ptr == '\n')
break;
ptr++;
}
/* get the client name */
if(*ptr == '\n')
{
size = ptr - buff;
size = (size < CLIENT_NAME_LEN) ? size : (CLIENT_NAME_LEN - 1);
memcpy(client_name, buff, size);
DSM_LOG_INFO( "%s client name is: %s \n", __func__ ,client_name );
client = dsm_find_client(client_name);
if( client )
{
/* found client name */
DSM_LOG_DEBUG("dsm write find client - %s\n", client_name);
ptr++;
while(*ptr)
{
if(*ptr == '\n')
break;
ptr++;
}
/* get error number */
if(*ptr == '\n')
{
memcpy(err_string,ptr-DSM_ERR_LEN,DSM_ERR_LEN);
err_string[DSM_ERR_LEN] = '\0';
sscanf(err_string,"%d",&err);
DSM_LOG_INFO( "%s error number is: %d \n", __func__ ,err );
/* judge if the err number is legal */
if( (err >= DMS_ERR_NUM_MIN ) && (err < DMS_ERR_NUM_MAX) )
{
/* report the error */
dsm_client_copy(client, ptr+1, (count - (ptr+1-buff)));
dsm_client_notify(client, err);
}
else
{
DSM_LOG_ERR("dsm write err number is not legal! err:%d\n", err);
}
}
}
else
{
DSM_LOG_INFO("dsm write can't find client - %s\n", client_name);
}
}
else
{
DSM_LOG_ERR("dsm write can't find client name\n");
}
out:
if(buff)
kfree(buff);
DSM_LOG_DEBUG("%s exit\n", __func__);
/* release the write buffer and wake anyone who's waiting for it */
up(&dsm_wbs);
return count;
}
