[PATCH 0/6] Preparations for ASIC3 support in the TMIO MMC driver

[PATCH 0/6] Preparations for ASIC3 support in the TMIO MMC driver

[Philipp Zabel]

Hi,

this series is really only two parts preparation for ASIC3:
 [PATCH 1/5] MFD,mmc: tmio_mmc: make HCLK configurable
 [PATCH 2/5] mmc: tmio_mmc: add bus_shift support
and three parts cleanup:
 [PATCH 3/5] mmc: tmio_mmc: don't use set_irq_type
 [PATCH 4/5] mmc: tmio_mmc: correct probe return value for num_resources != 3
 [PATCH 5/5] mmc: tmio_mmc: move probe function into __init section

I have still a few remaining differences until tmio_mmc can support ASIC3,
but as patch 2/5 causes changes all over the place, I'd like to get feedback
on that before piling patches on top of it.

I also have a question about the clock divider settings. Currently,
tmio_mmc_set_clock returns the wrong divider setting for new_clock=f_min
(0x40 instead of 0x80). I tried to fix it like below:

+#define TMIO_CARD_CLOCK_ENABLE 0x0100
+#define TMIO_CARD_CLOCK_FOR_SD 0x8000
+
-static void tmio_mmc_set_clock(struct tmio_mmc_host *host, int new_clock)
+static void tmio_mmc_set_clock(struct tmio_mmc_host *host, int new_clock)
 {
        u32 clk = 0, clock;
 
        if (new_clock) {
                for (clock = host->mmc->f_min, clk = 0x100; new_clock >= (clock<<1); ) {
                        clock <<= 1;
                        clk >>= 1;
                }
-               if (clk & 0x1)
-                       clk = 0x20000;
+               /* For fastest speed we disable the divider. */
+               sd_config_write8(host, CNF_SD_CLK_MODE, (clk == 0) ? 0 : 1);
+               clk >>= 1;
 
-               clk >>= 2;
-               sd_config_write8(host, CNF_SD_CLK_MODE, (clk & 0x8000) ? 0 : 1);
-               clk |= 0x100;
+               clk |= host->clock_for_sd | TMIO_CARD_CLOCK_ENABLE;
        }
 
        sd_ctrl_write16(host, CTL_SD_CARD_CLK_CTL, clk);

But the ASIC3 code was handling the 0x8000 bit (called FOR_SD in the ASIC3 headers)
of CTL_SD_CARD_CLK_CTL differently - there it was enabled/disabled based on 1-bit
or 4-bit MMC mode. I have no idea what it is good for - is there any TMIO documentation
available that includes this information?

regards
Philipp

[PATCH 1/5] MFD,mmc: tmio_mmc: make HCLK configurable

[Philipp Zabel]

The Toshiba parts all have a 24 MHz HCLK, but HTC ASIC3 has a 24.576 MHz HCLK
and AMD Imageon w228x's HCLK is 80 MHz. With this patch, the MFD driver
provides the HCLK frequency to tmio_mmc via mfd_cell->driver_data.

Signed-off-by: Philipp Zabel <philipp.zabel@gmail.com>
Cc: Samuel Ortiz <sameo@openedhand.com>
Cc: Pierre Ossman <pierre@ossman.eu>
Cc: Ian Molton <spyro@f2s.com>
---
 drivers/mfd/t7l66xb.c       |    5 +++++
 drivers/mfd/tc6387xb.c      |    5 +++++
 drivers/mfd/tc6393xb.c      |    5 +++++
 drivers/mmc/host/tmio_mmc.c |   22 ++++++++++------------
 include/linux/mfd/tmio.h    |    7 +++++++
 5 files changed, 32 insertions(+), 12 deletions(-)

diff --git a/drivers/mfd/t7l66xb.c b/drivers/mfd/t7l66xb.c
index e9f4323..875f7a8 100644
--- a/drivers/mfd/t7l66xb.c
+++ b/drivers/mfd/t7l66xb.c
@@ -108,6 +108,10 @@ static int t7l66xb_mmc_disable(struct platform_device *mmc)
 
 /*--------------------------------------------------------------------------*/
 
+static const struct tmio_mmc_data t7166xb_mmc_data = {
+	.hclk = 24000000,
+};
+
 static const struct resource t7l66xb_mmc_resources[] = {
 	{
 		.start = 0x800,
@@ -149,6 +153,7 @@ static struct mfd_cell t7l66xb_cells[] = {
 		.name = "tmio-mmc",
 		.enable = t7l66xb_mmc_enable,
 		.disable = t7l66xb_mmc_disable,
+		.driver_data = &t7166xb_mmc_data,
 		.num_resources = ARRAY_SIZE(t7l66xb_mmc_resources),
 		.resources = t7l66xb_mmc_resources,
 	},
diff --git a/drivers/mfd/tc6387xb.c b/drivers/mfd/tc6387xb.c
index 43222c1..c3993ac 100644
--- a/drivers/mfd/tc6387xb.c
+++ b/drivers/mfd/tc6387xb.c
@@ -75,6 +75,10 @@ static int tc6387xb_mmc_disable(struct platform_device *mmc)
 
 /*--------------------------------------------------------------------------*/
 
+const static struct tmio_mmc_data tc6387xb_mmc_data = {
+	.hclk = 24000000,
+};
+
 static struct resource tc6387xb_mmc_resources[] = {
 	{
 		.start = 0x800,
@@ -98,6 +102,7 @@ static struct mfd_cell tc6387xb_cells[] = {
 		.name = "tmio-mmc",
 		.enable = tc6387xb_mmc_enable,
 		.disable = tc6387xb_mmc_disable,
+		.driver_data = &tc6387xb_mmc_data,
 		.num_resources = ARRAY_SIZE(tc6387xb_mmc_resources),
 		.resources = tc6387xb_mmc_resources,
 	},
diff --git a/drivers/mfd/tc6393xb.c b/drivers/mfd/tc6393xb.c
index 77a12fc..9d2abb5 100644
--- a/drivers/mfd/tc6393xb.c
+++ b/drivers/mfd/tc6393xb.c
@@ -136,6 +136,10 @@ static int tc6393xb_nand_enable(struct platform_device *nand)
 	return 0;
 }
 
+const static struct tmio_mmc_data tc6393xb_mmc_data = {
+	.hclk = 24000000,
+};
+
 static struct resource __devinitdata tc6393xb_nand_resources[] = {
 	{
 		.start	= 0x1000,
@@ -351,6 +355,7 @@ static struct mfd_cell __devinitdata tc6393xb_cells[] = {
 	},
 	[TC6393XB_CELL_MMC] = {
 		.name = "tmio-mmc",
+		.driver_data = &tc6393xb_mmc_data,
 		.num_resources = ARRAY_SIZE(tc6393xb_mmc_resources),
 		.resources = tc6393xb_mmc_resources,
 	},
diff --git a/drivers/mmc/host/tmio_mmc.c b/drivers/mmc/host/tmio_mmc.c
index 63fbd5b..9c488a8 100644
--- a/drivers/mmc/host/tmio_mmc.c
+++ b/drivers/mmc/host/tmio_mmc.c
@@ -35,15 +35,6 @@
 
 #include "tmio_mmc.h"
 
-/*
- * Fixme - documentation conflicts on what the clock values are for the
- * various dividers.
- * One document I have says that its a divisor of a 24MHz clock, another 33.
- * This probably depends on HCLK for a given platform, so we may need to
- * require HCLK be passed to us from the MFD core.
- *
- */
-
 static void tmio_mmc_set_clock(struct tmio_mmc_host *host, int new_clock)
 {
 	void __iomem *cnf = host->cnf;
@@ -51,7 +42,7 @@ static void tmio_mmc_set_clock(struct tmio_mmc_host *host, int new_clock)
 	u32 clk = 0, clock;
 
 	if (new_clock) {
-		for (clock = 46875, clk = 0x100; new_clock >= (clock<<1); ) {
+		for (clock = host->mmc->f_min, clk = 0x100; new_clock >= (clock<<1); ) {
 			clock <<= 1;
 			clk >>= 1;
 		}
@@ -545,6 +536,7 @@ out:
 static int __devinit tmio_mmc_probe(struct platform_device *dev)
 {
 	struct mfd_cell	*cell = (struct mfd_cell *)dev->dev.platform_data;
+	struct tmio_mmc_data *pdata;
 	struct resource *res_ctl, *res_cnf;
 	struct tmio_mmc_host *host;
 	struct mmc_host *mmc;
@@ -560,6 +552,12 @@ static int __devinit tmio_mmc_probe(struct platform_device *dev)
 		goto out;
 	}
 
+	pdata = cell->driver_data;
+	if (!pdata || !pdata->hclk) {
+		ret = -EINVAL;
+		goto out;
+	}
+
 	mmc = mmc_alloc_host(sizeof(struct tmio_mmc_host), &dev->dev);
 	if (!mmc)
 		goto out;
@@ -578,8 +576,8 @@ static int __devinit tmio_mmc_probe(struct platform_device *dev)
 
 	mmc->ops = &tmio_mmc_ops;
 	mmc->caps = MMC_CAP_4_BIT_DATA;
-	mmc->f_min = 46875; /* 24000000 / 512 */
-	mmc->f_max = 24000000;
+	mmc->f_max = pdata->hclk;
+	mmc->f_min = mmc->f_max / 512;
 	mmc->ocr_avail = MMC_VDD_32_33 | MMC_VDD_33_34;
 
 	/* Enable the MMC/SD Control registers */
diff --git a/include/linux/mfd/tmio.h b/include/linux/mfd/tmio.h
index 516d955..c377118 100644
--- a/include/linux/mfd/tmio.h
+++ b/include/linux/mfd/tmio.h
@@ -19,6 +19,13 @@
 	} while (0)
 
 /*
+ * data for the MMC controller
+ */
+struct tmio_mmc_data {
+	unsigned int		hclk;
+};
+
+/*
  * data for the NAND controller
  */
 struct tmio_nand_data {
-- 
1.6.3.1

Re: [PATCH 1/5] MFD,mmc: tmio_mmc: make HCLK configurable

[Samuel Ortiz]

On Mon, May 25, 2009 at 09:27:57PM +0200, Philipp Zabel wrote:
> The Toshiba parts all have a 24 MHz HCLK, but HTC ASIC3 has a 24.576 MHz HCLK
> and AMD Imageon w228x's HCLK is 80 MHz. With this patch, the MFD driver
> provides the HCLK frequency to tmio_mmc via mfd_cell->driver_data.
Looks good to me. Ian, are you ok with this one ?

Pierre, are you fine with me pushing the mmc bits of this patch through the
mfd tree ?

Cheers,
Samuel.

 
> Signed-off-by: Philipp Zabel <philipp.zabel@gmail.com>
> Cc: Samuel Ortiz <sameo@openedhand.com>
> Cc: Pierre Ossman <pierre@ossman.eu>
> Cc: Ian Molton <spyro@f2s.com>
> ---
>  drivers/mfd/t7l66xb.c       |    5 +++++
>  drivers/mfd/tc6387xb.c      |    5 +++++
>  drivers/mfd/tc6393xb.c      |    5 +++++
>  drivers/mmc/host/tmio_mmc.c |   22 ++++++++++------------
>  include/linux/mfd/tmio.h    |    7 +++++++
>  5 files changed, 32 insertions(+), 12 deletions(-)
> 
> diff --git a/drivers/mfd/t7l66xb.c b/drivers/mfd/t7l66xb.c
> index e9f4323..875f7a8 100644
> --- a/drivers/mfd/t7l66xb.c
> +++ b/drivers/mfd/t7l66xb.c
> @@ -108,6 +108,10 @@ static int t7l66xb_mmc_disable(struct platform_device *mmc)
>  
>  /*--------------------------------------------------------------------------*/
>  
> +static const struct tmio_mmc_data t7166xb_mmc_data = {
> +	.hclk = 24000000,
> +};
> +
>  static const struct resource t7l66xb_mmc_resources[] = {
>  	{
>  		.start = 0x800,
> @@ -149,6 +153,7 @@ static struct mfd_cell t7l66xb_cells[] = {
>  		.name = "tmio-mmc",
>  		.enable = t7l66xb_mmc_enable,
>  		.disable = t7l66xb_mmc_disable,
> +		.driver_data = &t7166xb_mmc_data,
>  		.num_resources = ARRAY_SIZE(t7l66xb_mmc_resources),
>  		.resources = t7l66xb_mmc_resources,
>  	},
> diff --git a/drivers/mfd/tc6387xb.c b/drivers/mfd/tc6387xb.c
> index 43222c1..c3993ac 100644
> --- a/drivers/mfd/tc6387xb.c
> +++ b/drivers/mfd/tc6387xb.c
> @@ -75,6 +75,10 @@ static int tc6387xb_mmc_disable(struct platform_device *mmc)
>  
>  /*--------------------------------------------------------------------------*/
>  
> +const static struct tmio_mmc_data tc6387xb_mmc_data = {
> +	.hclk = 24000000,
> +};
> +
>  static struct resource tc6387xb_mmc_resources[] = {
>  	{
>  		.start = 0x800,
> @@ -98,6 +102,7 @@ static struct mfd_cell tc6387xb_cells[] = {
>  		.name = "tmio-mmc",
>  		.enable = tc6387xb_mmc_enable,
>  		.disable = tc6387xb_mmc_disable,
> +		.driver_data = &tc6387xb_mmc_data,
>  		.num_resources = ARRAY_SIZE(tc6387xb_mmc_resources),
>  		.resources = tc6387xb_mmc_resources,
>  	},
> diff --git a/drivers/mfd/tc6393xb.c b/drivers/mfd/tc6393xb.c
> index 77a12fc..9d2abb5 100644
> --- a/drivers/mfd/tc6393xb.c
> +++ b/drivers/mfd/tc6393xb.c
> @@ -136,6 +136,10 @@ static int tc6393xb_nand_enable(struct platform_device *nand)
>  	return 0;
>  }
>  
> +const static struct tmio_mmc_data tc6393xb_mmc_data = {
> +	.hclk = 24000000,
> +};
> +
>  static struct resource __devinitdata tc6393xb_nand_resources[] = {
>  	{
>  		.start	= 0x1000,
> @@ -351,6 +355,7 @@ static struct mfd_cell __devinitdata tc6393xb_cells[] = {
>  	},
>  	[TC6393XB_CELL_MMC] = {
>  		.name = "tmio-mmc",
> +		.driver_data = &tc6393xb_mmc_data,
>  		.num_resources = ARRAY_SIZE(tc6393xb_mmc_resources),
>  		.resources = tc6393xb_mmc_resources,
>  	},
> diff --git a/drivers/mmc/host/tmio_mmc.c b/drivers/mmc/host/tmio_mmc.c
> index 63fbd5b..9c488a8 100644
> --- a/drivers/mmc/host/tmio_mmc.c
> +++ b/drivers/mmc/host/tmio_mmc.c
> @@ -35,15 +35,6 @@
>  
>  #include "tmio_mmc.h"
>  
> -/*
> - * Fixme - documentation conflicts on what the clock values are for the
> - * various dividers.
> - * One document I have says that its a divisor of a 24MHz clock, another 33.
> - * This probably depends on HCLK for a given platform, so we may need to
> - * require HCLK be passed to us from the MFD core.
> - *
> - */
> -
>  static void tmio_mmc_set_clock(struct tmio_mmc_host *host, int new_clock)
>  {
>  	void __iomem *cnf = host->cnf;
> @@ -51,7 +42,7 @@ static void tmio_mmc_set_clock(struct tmio_mmc_host *host, int new_clock)
>  	u32 clk = 0, clock;
>  
>  	if (new_clock) {
> -		for (clock = 46875, clk = 0x100; new_clock >= (clock<<1); ) {
> +		for (clock = host->mmc->f_min, clk = 0x100; new_clock >= (clock<<1); ) {
>  			clock <<= 1;
>  			clk >>= 1;
>  		}
> @@ -545,6 +536,7 @@ out:
>  static int __devinit tmio_mmc_probe(struct platform_device *dev)
>  {
>  	struct mfd_cell	*cell = (struct mfd_cell *)dev->dev.platform_data;
> +	struct tmio_mmc_data *pdata;
>  	struct resource *res_ctl, *res_cnf;
>  	struct tmio_mmc_host *host;
>  	struct mmc_host *mmc;
> @@ -560,6 +552,12 @@ static int __devinit tmio_mmc_probe(struct platform_device *dev)
>  		goto out;
>  	}
>  
> +	pdata = cell->driver_data;
> +	if (!pdata || !pdata->hclk) {
> +		ret = -EINVAL;
> +		goto out;
> +	}
> +
>  	mmc = mmc_alloc_host(sizeof(struct tmio_mmc_host), &dev->dev);
>  	if (!mmc)
>  		goto out;
> @@ -578,8 +576,8 @@ static int __devinit tmio_mmc_probe(struct platform_device *dev)
>  
>  	mmc->ops = &tmio_mmc_ops;
>  	mmc->caps = MMC_CAP_4_BIT_DATA;
> -	mmc->f_min = 46875; /* 24000000 / 512 */
> -	mmc->f_max = 24000000;
> +	mmc->f_max = pdata->hclk;
> +	mmc->f_min = mmc->f_max / 512;
>  	mmc->ocr_avail = MMC_VDD_32_33 | MMC_VDD_33_34;
>  
>  	/* Enable the MMC/SD Control registers */
> diff --git a/include/linux/mfd/tmio.h b/include/linux/mfd/tmio.h
> index 516d955..c377118 100644
> --- a/include/linux/mfd/tmio.h
> +++ b/include/linux/mfd/tmio.h
> @@ -19,6 +19,13 @@
>  	} while (0)
>  
>  /*
> + * data for the MMC controller
> + */
> +struct tmio_mmc_data {
> +	unsigned int		hclk;
> +};
> +
> +/*
>   * data for the NAND controller
>   */
>  struct tmio_nand_data {
> -- 
> 1.6.3.1
> 

-- 
Intel Open Source Technology Centre
http://oss.intel.com/

Re: [PATCH 1/5] MFD,mmc: tmio_mmc: make HCLK configurable

[Pierre Ossman]

[-- Attachment #1: Type: text/plain, Size: 795 bytes --]

On Fri, 29 May 2009 13:20:35 +0200
Samuel Ortiz <sameo@openedhand.com> wrote:

> On Mon, May 25, 2009 at 09:27:57PM +0200, Philipp Zabel wrote:
> > The Toshiba parts all have a 24 MHz HCLK, but HTC ASIC3 has a 24.576 MHz HCLK
> > and AMD Imageon w228x's HCLK is 80 MHz. With this patch, the MFD driver
> > provides the HCLK frequency to tmio_mmc via mfd_cell->driver_data.
> Looks good to me. Ian, are you ok with this one ?
> 
> Pierre, are you fine with me pushing the mmc bits of this patch through the
> mfd tree ?

Sure, as long as Ian acks them.

Rgds
-- 
     -- Pierre Ossman

  WARNING: This correspondence is being monitored by the
  Swedish government. Make sure your server uses encryption
  for SMTP traffic and consider using PGP for end-to-end
  encryption.

[-- Attachment #2: signature.asc --]
[-- Type: application/pgp-signature, Size: 198 bytes --]

Re: [PATCH 1/5] MFD,mmc: tmio_mmc: make HCLK configurable

[Ian molton]

Acked-by: Ian Molton <spyro@f2s.com>

However I'd like to see the clk API  weaned of its CPU spcific 
dependencies so that it can be used for this purpose instead.

I consider ASIC3 support in this driver more important and this change 
is pretty noninvasive. Converting to the clk api in future shouldnt be 
any harder with this patch (actually slightly easier).

Philipp Zabel wrote:
> The Toshiba parts all have a 24 MHz HCLK, but HTC ASIC3 has a 24.576 MHz HCLK
> and AMD Imageon w228x's HCLK is 80 MHz. With this patch, the MFD driver
> provides the HCLK frequency to tmio_mmc via mfd_cell->driver_data.
> 
> Signed-off-by: Philipp Zabel <philipp.zabel@gmail.com>
> Cc: Samuel Ortiz <sameo@openedhand.com>
> Cc: Pierre Ossman <pierre@ossman.eu>

Re: [PATCH 1/5] MFD,mmc: tmio_mmc: make HCLK configurable

[pHilipp Zabel]

On Sat, May 30, 2009 at 11:59 AM, Ian molton <spyro@f2s.com> wrote:
>
> Acked-by: Ian Molton <spyro@f2s.com>

Thanks.

> However I'd like to see the clk API  weaned of its CPU spcific dependencies
> so that it can be used for this purpose instead.

Yes, I'm right with you on that.

> I consider ASIC3 support in this driver more important and this change is
> pretty noninvasive. Converting to the clk api in future shouldnt be any
> harder with this patch (actually slightly easier).

I'll try to add ASIC3 clock support in a way that it'll be easy to
convert to a architecture-independent struct clk in the future.

regards
Philipp

> Philipp Zabel wrote:
>>
>> The Toshiba parts all have a 24 MHz HCLK, but HTC ASIC3 has a 24.576 MHz
>> HCLK
>> and AMD Imageon w228x's HCLK is 80 MHz. With this patch, the MFD driver
>> provides the HCLK frequency to tmio_mmc via mfd_cell->driver_data.
>>
>> Signed-off-by: Philipp Zabel <philipp.zabel@gmail.com>
>> Cc: Samuel Ortiz <sameo@openedhand.com>
>> Cc: Pierre Ossman <pierre@ossman.eu>

Re: [PATCH 1/5] MFD,mmc: tmio_mmc: make HCLK configurable

[Ian Molton]

pHilipp Zabel wrote:
> On Sat, May 30, 2009 at 11:59 AM, Ian molton <spyro@f2s.com> wrote:
>> Acked-by: Ian Molton <spyro@f2s.com>
> 
> Thanks.

You're welcome :)

Just noticed that force-of-habit crept in there - thats my old email 
address. Whoever applies this, please use my  current <ian@mnementh.co.uk>

Cheers guys!

[PATCH 2/5] mmc: tmio_mmc: add bus_shift support

[Philipp Zabel]

Some ASIC3 devices in the wild are connected with the address bus shifted
by one line, so that its 16-bit registers appear 32-bit aligned in host
memory space.

Signed-off-by: Philipp Zabel <philipp.zabel@gmail.com>
Cc: Pierre Ossman <pierre@ossman.eu>
Cc: Ian Molton <spyro@f2s.com>
---
 drivers/mmc/host/tmio_mmc.c |  127 +++++++++++++++++++------------------------
 drivers/mmc/host/tmio_mmc.h |   72 +++++++++++++++++++++---
 2 files changed, 118 insertions(+), 81 deletions(-)

diff --git a/drivers/mmc/host/tmio_mmc.c b/drivers/mmc/host/tmio_mmc.c
index 9c488a8..245de05 100644
--- a/drivers/mmc/host/tmio_mmc.c
+++ b/drivers/mmc/host/tmio_mmc.c
@@ -37,8 +37,6 @@
 
 static void tmio_mmc_set_clock(struct tmio_mmc_host *host, int new_clock)
 {
-	void __iomem *cnf = host->cnf;
-	void __iomem *ctl = host->ctl;
 	u32 clk = 0, clock;
 
 	if (new_clock) {
@@ -50,45 +48,39 @@ static void tmio_mmc_set_clock(struct tmio_mmc_host *host, int new_clock)
 			clk = 0x20000;
 
 		clk >>= 2;
-		tmio_iowrite8((clk & 0x8000) ? 0 : 1, cnf + CNF_SD_CLK_MODE);
+		sd_config_write8(host, CNF_SD_CLK_MODE, (clk & 0x8000) ? 0 : 1);
 		clk |= 0x100;
 	}
 
-	tmio_iowrite16(clk, ctl + CTL_SD_CARD_CLK_CTL);
+	sd_ctrl_write16(host, CTL_SD_CARD_CLK_CTL, clk);
 }
 
 static void tmio_mmc_clk_stop(struct tmio_mmc_host *host)
 {
-	void __iomem *ctl = host->ctl;
-
-	tmio_iowrite16(0x0000, ctl + CTL_CLK_AND_WAIT_CTL);
+	sd_ctrl_write16(host, CTL_CLK_AND_WAIT_CTL, 0x0000);
 	msleep(10);
-	tmio_iowrite16(tmio_ioread16(ctl + CTL_SD_CARD_CLK_CTL) & ~0x0100,
-	       ctl + CTL_SD_CARD_CLK_CTL);
+	sd_ctrl_write16(host, CTL_SD_CARD_CLK_CTL, ~0x0100 &
+		sd_ctrl_read16(host, CTL_SD_CARD_CLK_CTL));
 	msleep(10);
 }
 
 static void tmio_mmc_clk_start(struct tmio_mmc_host *host)
 {
-	void __iomem *ctl = host->ctl;
-
-	tmio_iowrite16(tmio_ioread16(ctl + CTL_SD_CARD_CLK_CTL) | 0x0100,
-	       ctl + CTL_SD_CARD_CLK_CTL);
+	sd_ctrl_write16(host, CTL_SD_CARD_CLK_CTL, 0x0100 |
+		sd_ctrl_read16(host, CTL_SD_CARD_CLK_CTL));
 	msleep(10);
-	tmio_iowrite16(0x0100, ctl + CTL_CLK_AND_WAIT_CTL);
+	sd_ctrl_write16(host, CTL_CLK_AND_WAIT_CTL, 0x0100);
 	msleep(10);
 }
 
 static void reset(struct tmio_mmc_host *host)
 {
-	void __iomem *ctl = host->ctl;
-
 	/* FIXME - should we set stop clock reg here */
-	tmio_iowrite16(0x0000, ctl + CTL_RESET_SD);
-	tmio_iowrite16(0x0000, ctl + CTL_RESET_SDIO);
+	sd_ctrl_write16(host, CTL_RESET_SD, 0x0000);
+	sd_ctrl_write16(host, CTL_RESET_SDIO, 0x0000);
 	msleep(10);
-	tmio_iowrite16(0x0001, ctl + CTL_RESET_SD);
-	tmio_iowrite16(0x0001, ctl + CTL_RESET_SDIO);
+	sd_ctrl_write16(host, CTL_RESET_SD, 0x0001);
+	sd_ctrl_write16(host, CTL_RESET_SDIO, 0x0001);
 	msleep(10);
 }
 
@@ -120,13 +112,12 @@ tmio_mmc_finish_request(struct tmio_mmc_host *host)
 static int
 tmio_mmc_start_command(struct tmio_mmc_host *host, struct mmc_command *cmd)
 {
-	void __iomem *ctl = host->ctl;
 	struct mmc_data *data = host->data;
 	int c = cmd->opcode;
 
 	/* Command 12 is handled by hardware */
 	if (cmd->opcode == 12 && !cmd->arg) {
-		tmio_iowrite16(0x001, ctl + CTL_STOP_INTERNAL_ACTION);
+		sd_ctrl_write16(host, CTL_STOP_INTERNAL_ACTION, 0x001);
 		return 0;
 	}
 
@@ -151,18 +142,18 @@ tmio_mmc_start_command(struct tmio_mmc_host *host, struct mmc_command *cmd)
 	if (data) {
 		c |= DATA_PRESENT;
 		if (data->blocks > 1) {
-			tmio_iowrite16(0x100, ctl + CTL_STOP_INTERNAL_ACTION);
+			sd_ctrl_write16(host, CTL_STOP_INTERNAL_ACTION, 0x100);
 			c |= TRANSFER_MULTI;
 		}
 		if (data->flags & MMC_DATA_READ)
 			c |= TRANSFER_READ;
 	}
 
-	enable_mmc_irqs(ctl, TMIO_MASK_CMD);
+	enable_mmc_irqs(host, TMIO_MASK_CMD);
 
 	/* Fire off the command */
-	tmio_iowrite32(cmd->arg, ctl + CTL_ARG_REG);
-	tmio_iowrite16(c, ctl + CTL_SD_CMD);
+	sd_ctrl_write32(host, CTL_ARG_REG, cmd->arg);
+	sd_ctrl_write16(host, CTL_SD_CMD, c);
 
 	return 0;
 }
@@ -174,7 +165,6 @@ tmio_mmc_start_command(struct tmio_mmc_host *host, struct mmc_command *cmd)
  */
 static inline void tmio_mmc_pio_irq(struct tmio_mmc_host *host)
 {
-	void __iomem *ctl = host->ctl;
 	struct mmc_data *data = host->data;
 	unsigned short *buf;
 	unsigned int count;
@@ -197,9 +187,9 @@ static inline void tmio_mmc_pio_irq(struct tmio_mmc_host *host)
 
 	/* Transfer the data */
 	if (data->flags & MMC_DATA_READ)
-		tmio_ioread16_rep(ctl + CTL_SD_DATA_PORT, buf, count >> 1);
+		sd_ctrl_read16_rep(host, CTL_SD_DATA_PORT, buf, count >> 1);
 	else
-		tmio_iowrite16_rep(ctl + CTL_SD_DATA_PORT, buf, count >> 1);
+		sd_ctrl_write16_rep(host, CTL_SD_DATA_PORT, buf, count >> 1);
 
 	host->sg_off += count;
 
@@ -213,7 +203,6 @@ static inline void tmio_mmc_pio_irq(struct tmio_mmc_host *host)
 
 static inline void tmio_mmc_data_irq(struct tmio_mmc_host *host)
 {
-	void __iomem *ctl = host->ctl;
 	struct mmc_data *data = host->data;
 	struct mmc_command *stop;
 
@@ -242,13 +231,13 @@ static inline void tmio_mmc_data_irq(struct tmio_mmc_host *host)
 	 */
 
 	if (data->flags & MMC_DATA_READ)
-		disable_mmc_irqs(ctl, TMIO_MASK_READOP);
+		disable_mmc_irqs(host, TMIO_MASK_READOP);
 	else
-		disable_mmc_irqs(ctl, TMIO_MASK_WRITEOP);
+		disable_mmc_irqs(host, TMIO_MASK_WRITEOP);
 
 	if (stop) {
 		if (stop->opcode == 12 && !stop->arg)
-			tmio_iowrite16(0x000, ctl + CTL_STOP_INTERNAL_ACTION);
+			sd_ctrl_write16(host, CTL_STOP_INTERNAL_ACTION, 0x000);
 		else
 			BUG();
 	}
@@ -259,9 +248,8 @@ static inline void tmio_mmc_data_irq(struct tmio_mmc_host *host)
 static inline void tmio_mmc_cmd_irq(struct tmio_mmc_host *host,
 	unsigned int stat)
 {
-	void __iomem *ctl = host->ctl, *addr;
 	struct mmc_command *cmd = host->cmd;
-	int i;
+	int i, addr;
 
 	if (!host->cmd) {
 		pr_debug("Spurious CMD irq\n");
@@ -275,8 +263,8 @@ static inline void tmio_mmc_cmd_irq(struct tmio_mmc_host *host,
 	 * modify the order of the response for short response command types.
 	 */
 
-	for (i = 3, addr = ctl + CTL_RESPONSE ; i >= 0 ; i--, addr += 4)
-		cmd->resp[i] = tmio_ioread32(addr);
+	for (i = 3, addr = CTL_RESPONSE ; i >= 0 ; i--, addr += 4)
+		cmd->resp[i] = sd_ctrl_read32(host, addr);
 
 	if (cmd->flags &  MMC_RSP_136) {
 		cmd->resp[0] = (cmd->resp[0] << 8) | (cmd->resp[1] >> 24);
@@ -298,9 +286,9 @@ static inline void tmio_mmc_cmd_irq(struct tmio_mmc_host *host,
 	 */
 	if (host->data && !cmd->error) {
 		if (host->data->flags & MMC_DATA_READ)
-			enable_mmc_irqs(ctl, TMIO_MASK_READOP);
+			enable_mmc_irqs(host, TMIO_MASK_READOP);
 		else
-			enable_mmc_irqs(ctl, TMIO_MASK_WRITEOP);
+			enable_mmc_irqs(host, TMIO_MASK_WRITEOP);
 	} else {
 		tmio_mmc_finish_request(host);
 	}
@@ -312,20 +300,19 @@ static inline void tmio_mmc_cmd_irq(struct tmio_mmc_host *host,
 static irqreturn_t tmio_mmc_irq(int irq, void *devid)
 {
 	struct tmio_mmc_host *host = devid;
-	void __iomem *ctl = host->ctl;
 	unsigned int ireg, irq_mask, status;
 
 	pr_debug("MMC IRQ begin\n");
 
-	status = tmio_ioread32(ctl + CTL_STATUS);
-	irq_mask = tmio_ioread32(ctl + CTL_IRQ_MASK);
+	status = sd_ctrl_read32(host, CTL_STATUS);
+	irq_mask = sd_ctrl_read32(host, CTL_IRQ_MASK);
 	ireg = status & TMIO_MASK_IRQ & ~irq_mask;
 
 	pr_debug_status(status);
 	pr_debug_status(ireg);
 
 	if (!ireg) {
-		disable_mmc_irqs(ctl, status & ~irq_mask);
+		disable_mmc_irqs(host, status & ~irq_mask);
 
 		pr_debug("tmio_mmc: Spurious irq, disabling! "
 			"0x%08x 0x%08x 0x%08x\n", status, irq_mask, ireg);
@@ -337,7 +324,7 @@ static irqreturn_t tmio_mmc_irq(int irq, void *devid)
 	while (ireg) {
 		/* Card insert / remove attempts */
 		if (ireg & (TMIO_STAT_CARD_INSERT | TMIO_STAT_CARD_REMOVE)) {
-			ack_mmc_irqs(ctl, TMIO_STAT_CARD_INSERT |
+			ack_mmc_irqs(host, TMIO_STAT_CARD_INSERT |
 				TMIO_STAT_CARD_REMOVE);
 			mmc_detect_change(host->mmc, 0);
 		}
@@ -349,25 +336,25 @@ static irqreturn_t tmio_mmc_irq(int irq, void *devid)
 
 		/* Command completion */
 		if (ireg & TMIO_MASK_CMD) {
-			ack_mmc_irqs(ctl, TMIO_MASK_CMD);
+			ack_mmc_irqs(host, TMIO_MASK_CMD);
 			tmio_mmc_cmd_irq(host, status);
 		}
 
 		/* Data transfer */
 		if (ireg & (TMIO_STAT_RXRDY | TMIO_STAT_TXRQ)) {
-			ack_mmc_irqs(ctl, TMIO_STAT_RXRDY | TMIO_STAT_TXRQ);
+			ack_mmc_irqs(host, TMIO_STAT_RXRDY | TMIO_STAT_TXRQ);
 			tmio_mmc_pio_irq(host);
 		}
 
 		/* Data transfer completion */
 		if (ireg & TMIO_STAT_DATAEND) {
-			ack_mmc_irqs(ctl, TMIO_STAT_DATAEND);
+			ack_mmc_irqs(host, TMIO_STAT_DATAEND);
 			tmio_mmc_data_irq(host);
 		}
 
 		/* Check status - keep going until we've handled it all */
-		status = tmio_ioread32(ctl + CTL_STATUS);
-		irq_mask = tmio_ioread32(ctl + CTL_IRQ_MASK);
+		status = sd_ctrl_read32(host, CTL_STATUS);
+		irq_mask = sd_ctrl_read32(host, CTL_IRQ_MASK);
 		ireg = status & TMIO_MASK_IRQ & ~irq_mask;
 
 		pr_debug("Status at end of loop: %08x\n", status);
@@ -382,8 +369,6 @@ out:
 static int tmio_mmc_start_data(struct tmio_mmc_host *host,
 	struct mmc_data *data)
 {
-	void __iomem *ctl = host->ctl;
-
 	pr_debug("setup data transfer: blocksize %08x  nr_blocks %d\n",
 	    data->blksz, data->blocks);
 
@@ -398,8 +383,8 @@ static int tmio_mmc_start_data(struct tmio_mmc_host *host,
 	host->data = data;
 
 	/* Set transfer length / blocksize */
-	tmio_iowrite16(data->blksz,  ctl + CTL_SD_XFER_LEN);
-	tmio_iowrite16(data->blocks, ctl + CTL_XFER_BLK_COUNT);
+	sd_ctrl_write16(host, CTL_SD_XFER_LEN, data->blksz);
+	sd_ctrl_write16(host, CTL_XFER_BLK_COUNT, data->blocks);
 
 	return 0;
 }
@@ -440,8 +425,6 @@ fail:
 static void tmio_mmc_set_ios(struct mmc_host *mmc, struct mmc_ios *ios)
 {
 	struct tmio_mmc_host *host = mmc_priv(mmc);
-	void __iomem *cnf = host->cnf;
-	void __iomem *ctl = host->ctl;
 
 	if (ios->clock)
 		tmio_mmc_set_clock(host, ios->clock);
@@ -449,12 +432,12 @@ static void tmio_mmc_set_ios(struct mmc_host *mmc, struct mmc_ios *ios)
 	/* Power sequence - OFF -> ON -> UP */
 	switch (ios->power_mode) {
 	case MMC_POWER_OFF: /* power down SD bus */
-		tmio_iowrite8(0x00, cnf + CNF_PWR_CTL_2);
+		sd_config_write8(host, CNF_PWR_CTL_2, 0x00);
 		tmio_mmc_clk_stop(host);
 		break;
 	case MMC_POWER_ON: /* power up SD bus */
 
-		tmio_iowrite8(0x02, cnf + CNF_PWR_CTL_2);
+		sd_config_write8(host, CNF_PWR_CTL_2, 0x02);
 		break;
 	case MMC_POWER_UP: /* start bus clock */
 		tmio_mmc_clk_start(host);
@@ -463,10 +446,10 @@ static void tmio_mmc_set_ios(struct mmc_host *mmc, struct mmc_ios *ios)
 
 	switch (ios->bus_width) {
 	case MMC_BUS_WIDTH_1:
-		tmio_iowrite16(0x80e0, ctl + CTL_SD_MEM_CARD_OPT);
+		sd_ctrl_write16(host, CTL_SD_MEM_CARD_OPT, 0x80e0);
 	break;
 	case MMC_BUS_WIDTH_4:
-		tmio_iowrite16(0x00e0, ctl + CTL_SD_MEM_CARD_OPT);
+		sd_ctrl_write16(host, CTL_SD_MEM_CARD_OPT, 0x00e0);
 	break;
 	}
 
@@ -477,9 +460,8 @@ static void tmio_mmc_set_ios(struct mmc_host *mmc, struct mmc_ios *ios)
 static int tmio_mmc_get_ro(struct mmc_host *mmc)
 {
 	struct tmio_mmc_host *host = mmc_priv(mmc);
-	void __iomem *ctl = host->ctl;
 
-	return (tmio_ioread16(ctl + CTL_STATUS) & TMIO_STAT_WRPROTECT) ? 0 : 1;
+	return (sd_ctrl_read16(host, CTL_STATUS) & TMIO_STAT_WRPROTECT) ? 0 : 1;
 }
 
 static struct mmc_host_ops tmio_mmc_ops = {
@@ -509,12 +491,11 @@ static int tmio_mmc_resume(struct platform_device *dev)
 	struct mfd_cell	*cell = (struct mfd_cell *)dev->dev.platform_data;
 	struct mmc_host *mmc = platform_get_drvdata(dev);
 	struct tmio_mmc_host *host = mmc_priv(mmc);
-	void __iomem *cnf = host->cnf;
 	int ret = 0;
 
 	/* Enable the MMC/SD Control registers */
-	tmio_iowrite16(SDCREN, cnf + CNF_CMD);
-	tmio_iowrite32(dev->resource[0].start & 0xfffe, cnf + CNF_CTL_BASE);
+	sd_config_write16(host, CNF_CMD, SDCREN);
+	sd_config_write32(host, CNF_CTL_BASE, dev->resource[0].start & 0xfffe);
 
 	/* Tell the MFD core we are ready to be enabled */
 	if (cell->enable) {
@@ -566,6 +547,9 @@ static int __devinit tmio_mmc_probe(struct platform_device *dev)
 	host->mmc = mmc;
 	platform_set_drvdata(dev, mmc);
 
+	/* SD control register space size is 0x200, 0x400 for bus_shift=1 */
+	host->bus_shift = resource_size(res_ctl) >> 10;
+
 	host->ctl = ioremap(res_ctl->start, resource_size(res_ctl));
 	if (!host->ctl)
 		goto host_free;
@@ -581,9 +565,8 @@ static int __devinit tmio_mmc_probe(struct platform_device *dev)
 	mmc->ocr_avail = MMC_VDD_32_33 | MMC_VDD_33_34;
 
 	/* Enable the MMC/SD Control registers */
-	tmio_iowrite16(SDCREN, host->cnf + CNF_CMD);
-	tmio_iowrite32(dev->resource[0].start & 0xfffe,
-		host->cnf + CNF_CTL_BASE);
+	sd_config_write16(host, CNF_CMD, SDCREN);
+	sd_config_write32(host, CNF_CTL_BASE, dev->resource[0].start & 0xfffe);
 
 	/* Tell the MFD core we are ready to be enabled */
 	if (cell->enable) {
@@ -593,13 +576,13 @@ static int __devinit tmio_mmc_probe(struct platform_device *dev)
 	}
 
 	/* Disable SD power during suspend */
-	tmio_iowrite8(0x01, host->cnf + CNF_PWR_CTL_3);
+	sd_config_write8(host, CNF_PWR_CTL_3, 0x01);
 
 	/* The below is required but why? FIXME */
-	tmio_iowrite8(0x1f, host->cnf + CNF_STOP_CLK_CTL);
+	sd_config_write8(host, CNF_STOP_CLK_CTL, 0x1f);
 
 	/* Power down SD bus*/
-	tmio_iowrite8(0x0,  host->cnf + CNF_PWR_CTL_2);
+	sd_config_write8(host, CNF_PWR_CTL_2, 0x00);
 
 	tmio_mmc_clk_stop(host);
 	reset(host);
@@ -610,7 +593,7 @@ static int __devinit tmio_mmc_probe(struct platform_device *dev)
 	else
 		goto unmap_cnf;
 
-	disable_mmc_irqs(host->ctl, TMIO_MASK_ALL);
+	disable_mmc_irqs(host, TMIO_MASK_ALL);
 
 	ret = request_irq(host->irq, tmio_mmc_irq, IRQF_DISABLED, "tmio-mmc",
 		host);
@@ -625,7 +608,7 @@ static int __devinit tmio_mmc_probe(struct platform_device *dev)
 	       (unsigned long)host->ctl, host->irq);
 
 	/* Unmask the IRQs we want to know about */
-	enable_mmc_irqs(host->ctl,  TMIO_MASK_IRQ);
+	enable_mmc_irqs(host, TMIO_MASK_IRQ);
 
 	return 0;
 
diff --git a/drivers/mmc/host/tmio_mmc.h b/drivers/mmc/host/tmio_mmc.h
index 9c831ab..9b97afa 100644
--- a/drivers/mmc/host/tmio_mmc.h
+++ b/drivers/mmc/host/tmio_mmc.h
@@ -83,34 +83,36 @@
 		TMIO_STAT_CARD_REMOVE | TMIO_STAT_CARD_INSERT)
 #define TMIO_MASK_IRQ     (TMIO_MASK_READOP | TMIO_MASK_WRITEOP | TMIO_MASK_CMD)
 
-#define enable_mmc_irqs(ctl, i) \
+
+#define enable_mmc_irqs(host, i) \
 	do { \
 		u32 mask;\
-		mask  = tmio_ioread32((ctl) + CTL_IRQ_MASK); \
+		mask  = sd_ctrl_read32((host), CTL_IRQ_MASK); \
 		mask &= ~((i) & TMIO_MASK_IRQ); \
-		tmio_iowrite32(mask, (ctl) + CTL_IRQ_MASK); \
+		sd_ctrl_write32((host), CTL_IRQ_MASK, mask); \
 	} while (0)
 
-#define disable_mmc_irqs(ctl, i) \
+#define disable_mmc_irqs(host, i) \
 	do { \
 		u32 mask;\
-		mask  = tmio_ioread32((ctl) + CTL_IRQ_MASK); \
+		mask  = sd_ctrl_read32((host), CTL_IRQ_MASK); \
 		mask |= ((i) & TMIO_MASK_IRQ); \
-		tmio_iowrite32(mask, (ctl) + CTL_IRQ_MASK); \
+		sd_ctrl_write32((host), CTL_IRQ_MASK, mask); \
 	} while (0)
 
-#define ack_mmc_irqs(ctl, i) \
+#define ack_mmc_irqs(host, i) \
 	do { \
 		u32 mask;\
-		mask  = tmio_ioread32((ctl) + CTL_STATUS); \
+		mask  = sd_ctrl_read32((host), CTL_STATUS); \
 		mask &= ~((i) & TMIO_MASK_IRQ); \
-		tmio_iowrite32(mask, (ctl) + CTL_STATUS); \
+		sd_ctrl_write32((host), CTL_STATUS, mask); \
 	} while (0)
 
 
 struct tmio_mmc_host {
 	void __iomem *cnf;
 	void __iomem *ctl;
+	unsigned long bus_shift;
 	struct mmc_command      *cmd;
 	struct mmc_request      *mrq;
 	struct mmc_data         *data;
@@ -123,6 +125,58 @@ struct tmio_mmc_host {
 	unsigned int            sg_off;
 };
 
+#include <linux/io.h>
+
+static inline u16 sd_ctrl_read16(struct tmio_mmc_host *host, int addr)
+{
+	return readw(host->ctl + (addr << host->bus_shift));
+}
+
+static inline void sd_ctrl_read16_rep(struct tmio_mmc_host *host, int addr,
+		u16 *buf, int count)
+{
+	readsw(host->ctl + (addr << host->bus_shift), buf, count);
+}
+
+static inline u32 sd_ctrl_read32(struct tmio_mmc_host *host, int addr)
+{
+	return readw(host->ctl + (addr << host->bus_shift)) |
+	       readw(host->ctl + ((addr + 2) << host->bus_shift)) << 16;
+}
+
+static inline void sd_ctrl_write16(struct tmio_mmc_host *host, int addr, u16 val)
+{
+	writew(val, host->ctl + (addr << host->bus_shift));
+}
+
+static inline void sd_ctrl_write16_rep(struct tmio_mmc_host *host, int addr,
+		u16 *buf, int count)
+{
+	writesw(host->ctl + (addr << host->bus_shift), buf, count);
+}
+
+static inline void sd_ctrl_write32(struct tmio_mmc_host *host, int addr, u32 val)
+{
+	writew(val, host->ctl + (addr << host->bus_shift));
+	writew(val >> 16, host->ctl + ((addr + 2) << host->bus_shift));
+}
+
+static inline void sd_config_write8(struct tmio_mmc_host *host, int addr, u8 val)
+{
+	writeb(val, host->cnf + (addr << host->bus_shift));
+}
+
+static inline void sd_config_write16(struct tmio_mmc_host *host, int addr, u16 val)
+{
+	writew(val, host->cnf + (addr << host->bus_shift));
+}
+
+static inline void sd_config_write32(struct tmio_mmc_host *host, int addr, u32 val)
+{
+	writew(val, host->cnf + (addr << host->bus_shift));
+	writew(val >> 16, host->cnf + ((addr + 2) << host->bus_shift));
+}
+
 #include <linux/scatterlist.h>
 #include <linux/blkdev.h>
 
-- 
1.6.3.1

Re: [PATCH 2/5] mmc: tmio_mmc: add bus_shift support

[pHilipp Zabel]

On Mon, May 25, 2009 at 9:27 PM, Philipp Zabel <philipp.zabel@gmail.com> wrote:
> Some ASIC3 devices in the wild are connected with the address bus shifted
> by one line, so that its 16-bit registers appear 32-bit aligned in host
> memory space.

This patch has to be amended:

diff --git a/drivers/mmc/host/tmio_mmc.c b/drivers/mmc/host/tmio_mmc.c
index 245de05..8223977 100644
--- a/drivers/mmc/host/tmio_mmc.c
+++ b/drivers/mmc/host/tmio_mmc.c
@@ -495,7 +495,8 @@ static int tmio_mmc_resume(struct platform_device *dev)

        /* Enable the MMC/SD Control registers */
        sd_config_write16(host, CNF_CMD, SDCREN);
-       sd_config_write32(host, CNF_CTL_BASE, dev->resource[0].start & 0xfffe);
+       sd_config_write32(host, CNF_CTL_BASE,
+               (dev->resource[0].start >> host->bus_shift) & 0xfffe);

        /* Tell the MFD core we are ready to be enabled */
        if (cell->enable) {
@@ -566,7 +567,8 @@ static int __devinit tmio_mmc_probe(struct
platform_device *dev)

        /* Enable the MMC/SD Control registers */
        sd_config_write16(host, CNF_CMD, SDCREN);
-       sd_config_write32(host, CNF_CTL_BASE, dev->resource[0].start & 0xfffe);
+       sd_config_write32(host, CNF_CTL_BASE,
+               (dev->resource[0].start >> host->bus_shift) & 0xfffe);

        /* Tell the MFD core we are ready to be enabled */
        if (cell->enable) {

The resources have to be shifted back when configuring the SD control
register space.

regards
Philipp

Re: [PATCH 2/5] mmc: tmio_mmc: add bus_shift support

[Ian molton]

wow. suddenly much interest in tmio_mmc.

I've got some other emails about it to look at so I'll review these in 
the next couple of days.

I'll do a test build then - dmitry, I'll try to test your ac97 patch 
then too.

Thanks guys.

Re: [PATCH 2/5] mmc: tmio_mmc: add bus_shift support

[Ian molton]

pHilipp Zabel wrote:
> On Mon, May 25, 2009 at 9:27 PM, Philipp Zabel <philipp.zabel@gmail.com> wrote:
>> Some ASIC3 devices in the wild are connected with the address bus shifted
>> by one line, so that its 16-bit registers appear 32-bit aligned in host
>> memory space.
> 
> This patch has to be amended:

I have to assume that this works - I have no asic3 hardware, and bus 
shift is zero on TMIO hardware, so this didnt cause issues.

This modification acked too.

Re: [PATCH 2/5] mmc: tmio_mmc: add bus_shift support

[pHilipp Zabel]

On Sat, May 30, 2009 at 12:36 PM, Ian molton <spyro@f2s.com> wrote:
> pHilipp Zabel wrote:
>>
>> On Mon, May 25, 2009 at 9:27 PM, Philipp Zabel <philipp.zabel@gmail.com>
>> wrote:
>>>
>>> Some ASIC3 devices in the wild are connected with the address bus shifted
>>> by one line, so that its 16-bit registers appear 32-bit aligned in host
>>> memory space.
>>
>> This patch has to be amended:
>
> I have to assume that this works - I have no asic3 hardware, and bus shift
> is zero on TMIO hardware, so this didnt cause issues.
>
> This modification acked too.

Thanks. Actually, I only have bus_shift = 0 hardware, too (hx4700 and
blueangel).

According to http://wiki.xda-developers.com/index.php?pagename=ASIC3,
himalaya and the iPAQs h4xxx, h19xx, h39xx and rx37xx have the shift.

regards
Philipp

Re: [PATCH 2/5] mmc: tmio_mmc: add bus_shift support

[Ian molton]

Acked-by: Ian Molton <ian@mnementh.co.uk>

Works fine on the e-series machines, however checkpatch has a few 
warnings about overlength lines. I dont think they are a problem, but 
its not my call - Pierre?

Philipp Zabel wrote:
> Some ASIC3 devices in the wild are connected with the address bus shifted
> by one line, so that its 16-bit registers appear 32-bit aligned in host
> memory space.
> 
> Signed-off-by: Philipp Zabel <philipp.zabel@gmail.com>
> Cc: Pierre Ossman <pierre@ossman.eu>
> Cc: Ian Molton <spyro@f2s.com>
> ---
>  drivers/mmc/host/tmio_mmc.c |  127 +++++++++++++++++++------------------------
>  drivers/mmc/host/tmio_mmc.h |   72 +++++++++++++++++++++---
>  2 files changed, 118 insertions(+), 81 deletions(-)

Re: [PATCH 2/5] mmc: tmio_mmc: add bus_shift support

[pHilipp Zabel]

On Sat, May 30, 2009 at 12:26 PM, Ian molton <spyro@f2s.com> wrote:
> Acked-by: Ian Molton <ian@mnementh.co.uk>
>
> Works fine on the e-series machines, however checkpatch has a few warnings
> about overlength lines. I dont think they are a problem, but its not my call
> - Pierre?

Yes, if you prefer I'll resend with those lines broken up.

regards
Philipp

Re: [PATCH 2/5] mmc: tmio_mmc: add bus_shift support

[Pierre Ossman]

[-- Attachment #1: Type: text/plain, Size: 752 bytes --]

On Sat, 30 May 2009 13:46:06 +0200
pHilipp Zabel <philipp.zabel@gmail.com> wrote:

> On Sat, May 30, 2009 at 12:26 PM, Ian molton <spyro@f2s.com> wrote:
> > Acked-by: Ian Molton <ian@mnementh.co.uk>
> >
> > Works fine on the e-series machines, however checkpatch has a few warnings
> > about overlength lines. I dont think they are a problem, but its not my call
> > - Pierre?
> 
> Yes, if you prefer I'll resend with those lines broken up.
> 

Please do. And included that amended diff at the same time. :)

Rgds
-- 
     -- Pierre Ossman

  WARNING: This correspondence is being monitored by the
  Swedish government. Make sure your server uses encryption
  for SMTP traffic and consider using PGP for end-to-end
  encryption.

[-- Attachment #2: signature.asc --]
[-- Type: application/pgp-signature, Size: 198 bytes --]

[PATCH 3/5] mmc: tmio_mmc: don't use set_irq_type

[Philipp Zabel]

Use an IRQF_TRIGGER_ flag in request_irq instead.

Signed-off-by: Philipp Zabel <philipp.zabel@gmail.com>
Cc: Pierre Ossman <pierre@ossman.eu>
Cc: Ian Molton <spyro@f2s.com>
---
 drivers/mmc/host/tmio_mmc.c |    6 ++----
 1 files changed, 2 insertions(+), 4 deletions(-)

diff --git a/drivers/mmc/host/tmio_mmc.c b/drivers/mmc/host/tmio_mmc.c
index 245de05..9a3dc54 100644
--- a/drivers/mmc/host/tmio_mmc.c
+++ b/drivers/mmc/host/tmio_mmc.c
@@ -595,13 +595,11 @@ static int __devinit tmio_mmc_probe(struct platform_device *dev)
 
 	disable_mmc_irqs(host, TMIO_MASK_ALL);
 
-	ret = request_irq(host->irq, tmio_mmc_irq, IRQF_DISABLED, "tmio-mmc",
-		host);
+	ret = request_irq(host->irq, tmio_mmc_irq, IRQF_DISABLED | IRQF_TRIGGER_FALLING,
+		"tmio-mmc", host);
 	if (ret)
 		goto unmap_cnf;
 
-	set_irq_type(host->irq, IRQ_TYPE_EDGE_FALLING);
-
 	mmc_add_host(mmc);
 
 	printk(KERN_INFO "%s at 0x%08lx irq %d\n", mmc_hostname(host->mmc),
-- 
1.6.3.1

Re: [PATCH 3/5] mmc: tmio_mmc: don't use set_irq_type

[Ian molton]

Acked-by: Ian Molton <ian@mnementh.co.uk>

Again though, lines over 80 characters - but not up to me.

Philipp Zabel wrote:
> Use an IRQF_TRIGGER_ flag in request_irq instead.
> 
> Signed-off-by: Philipp Zabel <philipp.zabel@gmail.com>
> Cc: Pierre Ossman <pierre@ossman.eu>
> Cc: Ian Molton <spyro@f2s.com>

Re: [PATCH 3/5] mmc: tmio_mmc: don't use set_irq_type

[Pierre Ossman]

[-- Attachment #1: Type: text/plain, Size: 426 bytes --]

On Sat, 30 May 2009 11:34:40 +0100
Ian molton <spyro@f2s.com> wrote:

> Acked-by: Ian Molton <ian@mnementh.co.uk>
> 
> Again though, lines over 80 characters - but not up to me.
> 

^ :)

Rgds
-- 
     -- Pierre Ossman

  WARNING: This correspondence is being monitored by the
  Swedish government. Make sure your server uses encryption
  for SMTP traffic and consider using PGP for end-to-end
  encryption.

[-- Attachment #2: signature.asc --]
[-- Type: application/pgp-signature, Size: 198 bytes --]

[PATCH 4/5] mmc: tmio_mmc: correct probe return value for num_resources != 3

[Philipp Zabel]

Signed-off-by: Philipp Zabel <philipp.zabel@gmail.com>
Cc: Pierre Ossman <pierre@ossman.eu>
Cc: Ian Molton <spyro@f2s.com>
---
 drivers/mmc/host/tmio_mmc.c |   12 +++++-------
 1 files changed, 5 insertions(+), 7 deletions(-)

diff --git a/drivers/mmc/host/tmio_mmc.c b/drivers/mmc/host/tmio_mmc.c
index 9a3dc54..b1b4e6c 100644
--- a/drivers/mmc/host/tmio_mmc.c
+++ b/drivers/mmc/host/tmio_mmc.c
@@ -521,23 +521,21 @@ static int __devinit tmio_mmc_probe(struct platform_device *dev)
 	struct resource *res_ctl, *res_cnf;
 	struct tmio_mmc_host *host;
 	struct mmc_host *mmc;
-	int ret = -ENOMEM;
+	int ret = -EINVAL;
 
 	if (dev->num_resources != 3)
 		goto out;
 
 	res_ctl = platform_get_resource(dev, IORESOURCE_MEM, 0);
 	res_cnf = platform_get_resource(dev, IORESOURCE_MEM, 1);
-	if (!res_ctl || !res_cnf) {
-		ret = -EINVAL;
+	if (!res_ctl || !res_cnf)
 		goto out;
-	}
 
 	pdata = cell->driver_data;
-	if (!pdata || !pdata->hclk) {
-		ret = -EINVAL;
+	if (!pdata || !pdata->hclk)
 		goto out;
-	}
+
+	ret = -ENOMEM;
 
 	mmc = mmc_alloc_host(sizeof(struct tmio_mmc_host), &dev->dev);
 	if (!mmc)
-- 
1.6.3.1

Re: [PATCH 4/5] mmc: tmio_mmc: correct probe return value for num_resources != 3

[Ian molton]

Acked-by: Ian Molton <ian@mnementh.co.uk>

Philipp Zabel wrote:
> Signed-off-by: Philipp Zabel <philipp.zabel@gmail.com>
> Cc: Pierre Ossman <pierre@ossman.eu>

[PATCH 5/5] mmc: tmio_mmc: move probe function into __init section

[Philipp Zabel]

As MFD cells are not hotpluggable, this should be safe to do.

Signed-off-by: Philipp Zabel <philipp.zabel@gmail.com>
Cc: Pierre Ossman <pierre@ossman.eu>
Cc: Ian Molton <spyro@f2s.com>
---
 drivers/mmc/host/tmio_mmc.c |    5 ++---
 1 files changed, 2 insertions(+), 3 deletions(-)

diff --git a/drivers/mmc/host/tmio_mmc.c b/drivers/mmc/host/tmio_mmc.c
index b1b4e6c..5858279 100644
--- a/drivers/mmc/host/tmio_mmc.c
+++ b/drivers/mmc/host/tmio_mmc.c
@@ -514,7 +514,7 @@ out:
 #define tmio_mmc_resume NULL
 #endif
 
-static int __devinit tmio_mmc_probe(struct platform_device *dev)
+static int __init tmio_mmc_probe(struct platform_device *dev)
 {
 	struct mfd_cell	*cell = (struct mfd_cell *)dev->dev.platform_data;
 	struct tmio_mmc_data *pdata;
@@ -643,7 +643,6 @@ static struct platform_driver tmio_mmc_driver = {
 		.name = "tmio-mmc",
 		.owner = THIS_MODULE,
 	},
-	.probe = tmio_mmc_probe,
 	.remove = __devexit_p(tmio_mmc_remove),
 	.suspend = tmio_mmc_suspend,
 	.resume = tmio_mmc_resume,
@@ -652,7 +651,7 @@ static struct platform_driver tmio_mmc_driver = {
 
 static int __init tmio_mmc_init(void)
 {
-	return platform_driver_register(&tmio_mmc_driver);
+	return platform_driver_probe(&tmio_mmc_driver, tmio_mmc_probe);
 }
 
 static void __exit tmio_mmc_exit(void)
-- 
1.6.3.1

Re: [PATCH 5/5] mmc: tmio_mmc: move probe function into __init section

[Pierre Ossman]

[-- Attachment #1: Type: text/plain, Size: 615 bytes --]

On Mon, 25 May 2009 21:28:01 +0200
Philipp Zabel <philipp.zabel@gmail.com> wrote:

> As MFD cells are not hotpluggable, this should be safe to do.
> 
> Signed-off-by: Philipp Zabel <philipp.zabel@gmail.com>
> Cc: Pierre Ossman <pierre@ossman.eu>
> Cc: Ian Molton <spyro@f2s.com>
> ---

You can still bind/unbind the driver though, so I don't think this is
inherently safe.

Rgds
-- 
     -- Pierre Ossman

  WARNING: This correspondence is being monitored by the
  Swedish government. Make sure your server uses encryption
  for SMTP traffic and consider using PGP for end-to-end
  encryption.

[-- Attachment #2: signature.asc --]
[-- Type: application/pgp-signature, Size: 198 bytes --]

Re: [PATCH 5/5] mmc: tmio_mmc: move probe function into __init section

[Ian molton]

Philipp Zabel wrote:
> As MFD cells are not hotpluggable, this should be safe to do.

NAK, as per others comments.

Re: [PATCH 5/5] mmc: tmio_mmc: move probe function into __init section

[pHilipp Zabel]

On Sat, May 30, 2009 at 1:36 PM, Ian molton <spyro@f2s.com> wrote:
> Philipp Zabel wrote:
>>
>> As MFD cells are not hotpluggable, this should be safe to do.
>
> NAK, as per others comments.

Ok, dropped. I use mmc as rootfs right now, so I couldn't test that
(unbinding wreaks havoc either way).

regards
Philipp