openkylin
/
linux
mirror of https://gitee.com/openkylin/linux.git
9
0
Fork 0
Code Issues Projects Releases Wiki Activity

memstick: allow "set_param" method to return an error code 

Some controllers (Jmicron, for instance) can report temporal failure
condition during power-on.  It is desirable to account for this using a
return value of "set_param" device method.  The return value can also be
handy to distinguish between supported and unsupported device parameters
in run time.

[akpm@linux-foundation.org: coding-style fixes]
Signed-off-by: Alex Dubov <oakad@yahoo.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
This commit is contained in:
Alex Dubov 2008-07-25 19:45:00 -07:00 committed by Linus Torvalds
parent 0147600172
commit b77899985b
4 changed files with 71 additions and 33 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

18
drivers/memstick/core/memstick.c
View File

@ -415,10 +415,14 @@ static struct memstick_dev *memstick_alloc_card(struct memstick_host *host)
return NULL; return NULL;
} }
static void memstick_power_on(struct memstick_host *host) static int memstick_power_on(struct memstick_host *host)
{ {
host->set_param(host, MEMSTICK_POWER, MEMSTICK_POWER_ON); int rc = host->set_param(host, MEMSTICK_POWER, MEMSTICK_POWER_ON);
host->set_param(host, MEMSTICK_INTERFACE, MEMSTICK_SERIAL);
if (!rc)
rc = host->set_param(host, MEMSTICK_INTERFACE, MEMSTICK_SERIAL);
return rc;
} }
static void memstick_check(struct work_struct *work) static void memstick_check(struct work_struct *work)
@ -573,11 +577,15 @@ EXPORT_SYMBOL(memstick_suspend_host);
*/ */
void memstick_resume_host(struct memstick_host *host) void memstick_resume_host(struct memstick_host *host)
{ {
int rc = 0;
mutex_lock(&host->lock); mutex_lock(&host->lock);
if (host->card) if (host->card)
memstick_power_on(host); rc = memstick_power_on(host);
mutex_unlock(&host->lock); mutex_unlock(&host->lock);
memstick_detect_change(host);
if (!rc)
memstick_detect_change(host);
} }
EXPORT_SYMBOL(memstick_resume_host); EXPORT_SYMBOL(memstick_resume_host);

67
drivers/memstick/host/jmb38x_ms.c
View File

@ -609,36 +609,68 @@ static void jmb38x_ms_request(struct memstick_host *msh)
spin_unlock_irqrestore(&host->lock, flags); spin_unlock_irqrestore(&host->lock, flags);
} }
static void jmb38x_ms_reset(struct jmb38x_ms_host *host) static int jmb38x_ms_reset(struct jmb38x_ms_host *host)
{ {
unsigned int host_ctl = readl(host->addr + HOST_CONTROL); int cnt;
writel(HOST_CONTROL_RESET_REQ, host->addr + HOST_CONTROL); writel(HOST_CONTROL_RESET_REQ | HOST_CONTROL_CLOCK_EN
| readl(host->addr + HOST_CONTROL),
host->addr + HOST_CONTROL);
mmiowb();
for (cnt = 0; cnt < 20; ++cnt) {
if (!(HOST_CONTROL_RESET_REQ
& readl(host->addr + HOST_CONTROL)))
goto reset_next;
while (HOST_CONTROL_RESET_REQ
& (host_ctl = readl(host->addr + HOST_CONTROL))) {
ndelay(20); ndelay(20);
dev_dbg(&host->chip->pdev->dev, "reset %08x\n", host_ctl);
} }
dev_dbg(&host->chip->pdev->dev, "reset_req timeout\n");
return -EIO;
writel(HOST_CONTROL_RESET, host->addr + HOST_CONTROL); reset_next:
writel(HOST_CONTROL_RESET | HOST_CONTROL_CLOCK_EN
| readl(host->addr + HOST_CONTROL),
host->addr + HOST_CONTROL);
mmiowb();
for (cnt = 0; cnt < 20; ++cnt) {
if (!(HOST_CONTROL_RESET
& readl(host->addr + HOST_CONTROL)))
goto reset_ok;
ndelay(20);
}
dev_dbg(&host->chip->pdev->dev, "reset timeout\n");
return -EIO;
reset_ok:
mmiowb(); mmiowb();
writel(INT_STATUS_ALL, host->addr + INT_SIGNAL_ENABLE); writel(INT_STATUS_ALL, host->addr + INT_SIGNAL_ENABLE);
writel(INT_STATUS_ALL, host->addr + INT_STATUS_ENABLE); writel(INT_STATUS_ALL, host->addr + INT_STATUS_ENABLE);
return 0;
} }
static void jmb38x_ms_set_param(struct memstick_host *msh, static int jmb38x_ms_set_param(struct memstick_host *msh,
enum memstick_param param, enum memstick_param param,
int value) int value)
{ {
struct jmb38x_ms_host *host = memstick_priv(msh); struct jmb38x_ms_host *host = memstick_priv(msh);
unsigned int host_ctl = readl(host->addr + HOST_CONTROL); unsigned int host_ctl = readl(host->addr + HOST_CONTROL);
unsigned int clock_ctl = CLOCK_CONTROL_40MHZ, clock_delay = 0; unsigned int clock_ctl = CLOCK_CONTROL_40MHZ, clock_delay = 0;
int rc = 0;
switch (param) { switch (param) {
case MEMSTICK_POWER: case MEMSTICK_POWER:
if (value == MEMSTICK_POWER_ON) { if (value == MEMSTICK_POWER_ON) {
jmb38x_ms_reset(host); rc = jmb38x_ms_reset(host);
if (rc)
return rc;
host_ctl = 7;
host_ctl |= HOST_CONTROL_POWER_EN
| HOST_CONTROL_CLOCK_EN;
writel(host_ctl, host->addr + HOST_CONTROL);
writel(host->id ? PAD_PU_PD_ON_MS_SOCK1 writel(host->id ? PAD_PU_PD_ON_MS_SOCK1
: PAD_PU_PD_ON_MS_SOCK0, : PAD_PU_PD_ON_MS_SOCK0,
@ -647,11 +679,7 @@ static void jmb38x_ms_set_param(struct memstick_host *msh,
writel(PAD_OUTPUT_ENABLE_MS, writel(PAD_OUTPUT_ENABLE_MS,
host->addr + PAD_OUTPUT_ENABLE); host->addr + PAD_OUTPUT_ENABLE);
host_ctl = 7; msleep(10);
host_ctl |= HOST_CONTROL_POWER_EN
| HOST_CONTROL_CLOCK_EN;
writel(host_ctl, host->addr + HOST_CONTROL);
dev_dbg(&host->chip->pdev->dev, "power on\n"); dev_dbg(&host->chip->pdev->dev, "power on\n");
} else if (value == MEMSTICK_POWER_OFF) { } else if (value == MEMSTICK_POWER_OFF) {
host_ctl &= ~(HOST_CONTROL_POWER_EN host_ctl &= ~(HOST_CONTROL_POWER_EN
@ -660,7 +688,8 @@ static void jmb38x_ms_set_param(struct memstick_host *msh,
writel(0, host->addr + PAD_OUTPUT_ENABLE); writel(0, host->addr + PAD_OUTPUT_ENABLE);
writel(PAD_PU_PD_OFF, host->addr + PAD_PU_PD); writel(PAD_PU_PD_OFF, host->addr + PAD_PU_PD);
dev_dbg(&host->chip->pdev->dev, "power off\n"); dev_dbg(&host->chip->pdev->dev, "power off\n");
} } else
return -EINVAL;
break; break;
case MEMSTICK_INTERFACE: case MEMSTICK_INTERFACE:
host_ctl &= ~(3 << HOST_CONTROL_IF_SHIFT); host_ctl &= ~(3 << HOST_CONTROL_IF_SHIFT);
@ -686,12 +715,14 @@ static void jmb38x_ms_set_param(struct memstick_host *msh,
host_ctl &= ~HOST_CONTROL_REI; host_ctl &= ~HOST_CONTROL_REI;
clock_ctl = CLOCK_CONTROL_60MHZ; clock_ctl = CLOCK_CONTROL_60MHZ;
clock_delay = 0; clock_delay = 0;
} } else
return -EINVAL;
writel(host_ctl, host->addr + HOST_CONTROL); writel(host_ctl, host->addr + HOST_CONTROL);
writel(clock_ctl, host->addr + CLOCK_CONTROL); writel(clock_ctl, host->addr + CLOCK_CONTROL);
writel(clock_delay, host->addr + CLOCK_DELAY); writel(clock_delay, host->addr + CLOCK_DELAY);
break; break;
}; };
return 0;
} }
#ifdef CONFIG_PM #ifdef CONFIG_PM

17
drivers/memstick/host/tifm_ms.c
View File

@ -489,15 +489,12 @@ static void tifm_ms_request(struct memstick_host *msh)
return; return;
} }
static void tifm_ms_set_param(struct memstick_host *msh, static int tifm_ms_set_param(struct memstick_host *msh,
enum memstick_param param, enum memstick_param param,
int value) int value)
{ {
struct tifm_ms *host = memstick_priv(msh); struct tifm_ms *host = memstick_priv(msh);
struct tifm_dev *sock = host->dev; struct tifm_dev *sock = host->dev;
unsigned long flags;
spin_lock_irqsave(&sock->lock, flags);
switch (param) { switch (param) {
case MEMSTICK_POWER: case MEMSTICK_POWER:
@ -512,7 +509,8 @@ static void tifm_ms_set_param(struct memstick_host *msh,
writel(TIFM_MS_SYS_FCLR | TIFM_MS_SYS_INTCLR, writel(TIFM_MS_SYS_FCLR | TIFM_MS_SYS_INTCLR,
sock->addr + SOCK_MS_SYSTEM); sock->addr + SOCK_MS_SYSTEM);
writel(0xffffffff, sock->addr + SOCK_MS_STATUS); writel(0xffffffff, sock->addr + SOCK_MS_STATUS);
} } else
return -EINVAL;
break; break;
case MEMSTICK_INTERFACE: case MEMSTICK_INTERFACE:
if (value == MEMSTICK_SERIAL) { if (value == MEMSTICK_SERIAL) {
@ -525,11 +523,12 @@ static void tifm_ms_set_param(struct memstick_host *msh,
writel(TIFM_CTRL_FAST_CLK writel(TIFM_CTRL_FAST_CLK
| readl(sock->addr + SOCK_CONTROL), | readl(sock->addr + SOCK_CONTROL),
sock->addr + SOCK_CONTROL); sock->addr + SOCK_CONTROL);
} } else
return -EINVAL;
break; break;
}; };
spin_unlock_irqrestore(&sock->lock, flags); return 0;
} }
static void tifm_ms_abort(unsigned long data) static void tifm_ms_abort(unsigned long data)

2
include/linux/memstick.h
View File

@ -284,7 +284,7 @@ struct memstick_host {
/* Notify the host that some requests are pending. */ /* Notify the host that some requests are pending. */
void (*request)(struct memstick_host *host); void (*request)(struct memstick_host *host);
/* Set host IO parameters (power, clock, etc). */ /* Set host IO parameters (power, clock, etc). */
void (*set_param)(struct memstick_host *host, int (*set_param)(struct memstick_host *host,
enum memstick_param param, enum memstick_param param,
int value); int value);
unsigned long private[0] ____cacheline_aligned; unsigned long private[0] ____cacheline_aligned;