* [PATCH v3 1/9] ARM: OMAP2+: gpmc: driver conversion
[not found] <cover.1333640054.git.afzal@ti.com>
2012-04-05 15:45 ` Afzal Mohammed
2012-04-05 15:46 ` Afzal Mohammed
@ 2012-04-05 15:45 ` Afzal Mohammed
2012-04-05 15:46 ` Afzal Mohammed
` (5 subsequent siblings)
8 siblings, 0 replies; 73+ messages in thread
From: Afzal Mohammed @ 2012-04-05 15:45 UTC (permalink / raw)
To: tony, khilman, linux, dwmw2, sameo, grinberg, mike, nm,
artem.bityutskiy, vimal.newwork, dbaryshkov, linux-omap,
linux-arm-kernel, linux-mtd, linux-kernel
Cc: Afzal Mohammed, Vaibhav Hiremath, Jon Hunter
Convert GPMC code to driver. Boards using GPMC should provide driver
with type of configuration, timing, CS, GPMC address space details
(if already configured, driver will retrieve, as is existing).
Platform devices would the be created for each connected peripheral
(details also to be passed by board so that it reaches respective
driver). And GPMC driver would populate memory resource details for
the driver of connected peripheral.
A peripheral connected to GPMC can have multiple address spaces using
different chip select. Hence GPMC driver has been provided capability
to create platform device for peripheral using mutiple CS. The
peripheral that made it necessary was tusb6010. Thanks to Jon Hunter
for his suggesstion on better way to handle this.
Interrupts of GPMC are presented to drivers of connected peripherals
as resource. A fictitious interrupt controller chip handles these
interrupts at GPMC hardware level. Clients can use normal interrupt
APIs. Platforms should inform GPMC driver infrastruture available
for these imaginary client interrupts (like irq number). Platform
information of peripheral passed to GPMC driver should indicate
interrupts to be used via flags.
Final destination for this driver is being investigated. Before moving
to the new location, all existing GPMC users has to be converted to
work with this driver.
NAND driver for NAND used via GPMC is tightly coupled with GPMC
driver (GPMC has few blocks exclusively for NAND), while that is not
the case for most of the other users (they need GPMCs help only for
initial configuration). Currently NAND driver manage using exported
GPMC symbols. This is being planned to remove later & would need
informing NAND driver about GPMC NAND registers. This would help to
have export symbol free GPMC driver, and probably
"mv omap2.c gpmc-nand.c" for OMAP NAND driver.
Thanks to Vaibhav Hiremath for his ideas on this.
Acquiring CS# for NAND is done on a few boards. It means, depending
on bootloader to embed this information. Probably CS# being used can
be set in the Kernel, and acquiring it can be removed. If ever this
capbility is needed, GPMC driver has to be made aware of handling it.
OneNAND - as it may involve reconfiguring GPMC for synchronous may
need a quirk to handle or driver has to be made more intelligent to
handle it.
Code related to GPMC clock may have to continue live in platform
folders (even if the driver is moved to MFD) as input clock is beyond
the control of GPMC and calculating timing for the peripheral may
need other helpers.
Cc: Vaibhav Hiremath <hvaibhav@ti.com>
Cc: Jon Hunter <jon-hunter@ti.com>
Signed-off-by: Afzal Mohammed <afzal@ti.com>
---
arch/arm/mach-omap2/gpmc.c | 518 ++++++++++++++++++++++++++------
arch/arm/plat-omap/include/plat/gpmc.h | 50 ++-
2 files changed, 476 insertions(+), 92 deletions(-)
diff --git a/arch/arm/mach-omap2/gpmc.c b/arch/arm/mach-omap2/gpmc.c
index 00d5108..cf5d8f3 100644
--- a/arch/arm/mach-omap2/gpmc.c
+++ b/arch/arm/mach-omap2/gpmc.c
@@ -14,8 +14,11 @@
*/
#undef DEBUG
+#include <linux/platform_device.h>
+
#include <linux/irq.h>
#include <linux/kernel.h>
+#include <linux/slab.h>
#include <linux/init.h>
#include <linux/err.h>
#include <linux/clk.h>
@@ -64,6 +67,47 @@
#define ENABLE_PREFETCH (0x1 << 7)
#define DMA_MPU_MODE 2
+#define DRIVER_NAME "omap-gpmc"
+
+#define GPMC_NR_IRQ 6
+
+struct gpmc_device {
+ char *name;
+ int id;
+ void *pdata;
+ unsigned pdata_size;
+ struct resource *per_res;
+ unsigned num_per_res;
+ struct resource *gpmc_res;
+ unsigned num_gpmc_res;
+};
+
+struct gpmc_irq {
+ unsigned irq;
+ u32 regval;
+};
+
+struct gpmc {
+ struct device *dev;
+ unsigned long fclk_period;
+ void __iomem *io_base;
+ unsigned long phys_base;
+ u32 memsize;
+ unsigned cs_map;
+ int ecc_used;
+ spinlock_t mem_lock;
+ struct resource mem_root;
+ struct resource cs_mem[GPMC_CS_NUM];
+ /* XXX: Or allocate dynamically ? */
+ struct gpmc_device device[GPMC_CS_NUM];
+ unsigned num_device;
+ unsigned master_irq;
+ unsigned irq_start;
+ unsigned num_irq;
+ struct gpmc_irq irq[GPMC_NR_IRQ];
+ struct irq_chip irq_chip;
+};
+
/* Structure to save gpmc cs context */
struct gpmc_cs_config {
u32 config1;
@@ -91,58 +135,50 @@ struct omap3_gpmc_regs {
struct gpmc_cs_config cs_context[GPMC_CS_NUM];
};
-static struct resource gpmc_mem_root;
-static struct resource gpmc_cs_mem[GPMC_CS_NUM];
-static DEFINE_SPINLOCK(gpmc_mem_lock);
-static unsigned int gpmc_cs_map; /* flag for cs which are initialized */
-static int gpmc_ecc_used = -EINVAL; /* cs using ecc engine */
-
-static void __iomem *gpmc_base;
-
static struct clk *gpmc_l3_clk;
-static irqreturn_t gpmc_handle_irq(int irq, void *dev);
+static struct gpmc *gpmc;
static void gpmc_write_reg(int idx, u32 val)
{
- __raw_writel(val, gpmc_base + idx);
+ writel(val, gpmc->io_base + idx);
}
static u32 gpmc_read_reg(int idx)
{
- return __raw_readl(gpmc_base + idx);
+ return readl(gpmc->io_base + idx);
}
static void gpmc_cs_write_byte(int cs, int idx, u8 val)
{
void __iomem *reg_addr;
- reg_addr = gpmc_base + GPMC_CS0_OFFSET + (cs * GPMC_CS_SIZE) + idx;
- __raw_writeb(val, reg_addr);
+ reg_addr = gpmc->io_base + GPMC_CS0_OFFSET + (cs * GPMC_CS_SIZE) + idx;
+ writeb(val, reg_addr);
}
static u8 gpmc_cs_read_byte(int cs, int idx)
{
void __iomem *reg_addr;
- reg_addr = gpmc_base + GPMC_CS0_OFFSET + (cs * GPMC_CS_SIZE) + idx;
- return __raw_readb(reg_addr);
+ reg_addr = gpmc->io_base + GPMC_CS0_OFFSET + (cs * GPMC_CS_SIZE) + idx;
+ return readb(reg_addr);
}
void gpmc_cs_write_reg(int cs, int idx, u32 val)
{
void __iomem *reg_addr;
- reg_addr = gpmc_base + GPMC_CS0_OFFSET + (cs * GPMC_CS_SIZE) + idx;
- __raw_writel(val, reg_addr);
+ reg_addr = gpmc->io_base + GPMC_CS0_OFFSET + (cs * GPMC_CS_SIZE) + idx;
+ writel(val, reg_addr);
}
u32 gpmc_cs_read_reg(int cs, int idx)
{
void __iomem *reg_addr;
- reg_addr = gpmc_base + GPMC_CS0_OFFSET + (cs * GPMC_CS_SIZE) + idx;
- return __raw_readl(reg_addr);
+ reg_addr = gpmc->io_base + GPMC_CS0_OFFSET + (cs * GPMC_CS_SIZE) + idx;
+ return readl(reg_addr);
}
/* TODO: Add support for gpmc_fck to clock framework and use it */
@@ -332,7 +368,7 @@ static void gpmc_cs_disable_mem(int cs)
gpmc_cs_write_reg(cs, GPMC_CS_CONFIG7, l);
}
-static void gpmc_cs_get_memconf(int cs, u32 *base, u32 *size)
+static __devinit void gpmc_cs_get_memconf(int cs, u32 *base, u32 *size)
{
u32 l;
u32 mask;
@@ -351,23 +387,23 @@ static int gpmc_cs_mem_enabled(int cs)
return l & GPMC_CONFIG7_CSVALID;
}
-int gpmc_cs_set_reserved(int cs, int reserved)
+static int gpmc_cs_set_reserved(int cs, int reserved)
{
if (cs > GPMC_CS_NUM)
return -ENODEV;
- gpmc_cs_map &= ~(1 << cs);
- gpmc_cs_map |= (reserved ? 1 : 0) << cs;
+ gpmc->cs_map &= ~(1 << cs);
+ gpmc->cs_map |= (reserved ? 1 : 0) << cs;
return 0;
}
-int gpmc_cs_reserved(int cs)
+static int gpmc_cs_reserved(int cs)
{
if (cs > GPMC_CS_NUM)
return -ENODEV;
- return gpmc_cs_map & (1 << cs);
+ return gpmc->cs_map & (1 << cs);
}
static unsigned long gpmc_mem_align(unsigned long size)
@@ -384,24 +420,25 @@ static unsigned long gpmc_mem_align(unsigned long size)
return size;
}
-static int gpmc_cs_insert_mem(int cs, unsigned long base, unsigned long size)
+static __devinit
+int gpmc_cs_insert_mem(int cs, unsigned long base, unsigned long size)
{
- struct resource *res = &gpmc_cs_mem[cs];
+ struct resource *res = &gpmc->cs_mem[cs];
int r;
size = gpmc_mem_align(size);
- spin_lock(&gpmc_mem_lock);
+ spin_lock(&gpmc->mem_lock);
res->start = base;
res->end = base + size - 1;
- r = request_resource(&gpmc_mem_root, res);
- spin_unlock(&gpmc_mem_lock);
+ r = request_resource(&gpmc->mem_root, res);
+ spin_unlock(&gpmc->mem_lock);
return r;
}
int gpmc_cs_request(int cs, unsigned long size, unsigned long *base)
{
- struct resource *res = &gpmc_cs_mem[cs];
+ struct resource *res = &gpmc->cs_mem[cs];
int r = -1;
if (cs > GPMC_CS_NUM)
@@ -411,7 +448,7 @@ int gpmc_cs_request(int cs, unsigned long size, unsigned long *base)
if (size > (1 << GPMC_SECTION_SHIFT))
return -ENOMEM;
- spin_lock(&gpmc_mem_lock);
+ spin_lock(&gpmc->mem_lock);
if (gpmc_cs_reserved(cs)) {
r = -EBUSY;
goto out;
@@ -419,7 +456,7 @@ int gpmc_cs_request(int cs, unsigned long size, unsigned long *base)
if (gpmc_cs_mem_enabled(cs))
r = adjust_resource(res, res->start & ~(size - 1), size);
if (r < 0)
- r = allocate_resource(&gpmc_mem_root, res, size, 0, ~0,
+ r = allocate_resource(&gpmc->mem_root, res, size, 0, ~0,
size, NULL, NULL);
if (r < 0)
goto out;
@@ -428,24 +465,24 @@ int gpmc_cs_request(int cs, unsigned long size, unsigned long *base)
*base = res->start;
gpmc_cs_set_reserved(cs, 1);
out:
- spin_unlock(&gpmc_mem_lock);
+ spin_unlock(&gpmc->mem_lock);
return r;
}
EXPORT_SYMBOL(gpmc_cs_request);
void gpmc_cs_free(int cs)
{
- spin_lock(&gpmc_mem_lock);
+ spin_lock(&gpmc->mem_lock);
if (cs >= GPMC_CS_NUM || cs < 0 || !gpmc_cs_reserved(cs)) {
printk(KERN_ERR "Trying to free non-reserved GPMC CS%d\n", cs);
BUG();
- spin_unlock(&gpmc_mem_lock);
+ spin_unlock(&gpmc->mem_lock);
return;
}
gpmc_cs_disable_mem(cs);
- release_resource(&gpmc_cs_mem[cs]);
+ release_resource(&gpmc->cs_mem[cs]);
gpmc_cs_set_reserved(cs, 0);
- spin_unlock(&gpmc_mem_lock);
+ spin_unlock(&gpmc->mem_lock);
}
EXPORT_SYMBOL(gpmc_cs_free);
@@ -546,6 +583,12 @@ int gpmc_cs_configure(int cs, int cmd, int wval)
gpmc_cs_write_reg(cs, GPMC_CS_CONFIG1, regval);
break;
+ case GPMC_CONFIG_WAITPIN:
+ regval = gpmc_cs_read_reg(cs, GPMC_CS_CONFIG1);
+ regval |= GPMC_CONFIG1_WAIT_PIN_SEL(wval);
+ gpmc_cs_write_reg(cs, GPMC_CS_CONFIG1, regval);
+ break;
+
default:
printk(KERN_ERR "gpmc_configure_cs: Not supported\n");
err = -EINVAL;
@@ -668,7 +711,7 @@ int gpmc_prefetch_reset(int cs)
}
EXPORT_SYMBOL(gpmc_prefetch_reset);
-static void __init gpmc_mem_init(void)
+static __devinit void gpmc_mem_init(void)
{
int cs;
unsigned long boot_rom_space = 0;
@@ -680,8 +723,8 @@ static void __init gpmc_mem_init(void)
/* In apollon the CS0 is mapped as 0x0000 0000 */
if (machine_is_omap_apollon())
boot_rom_space = 0;
- gpmc_mem_root.start = GPMC_MEM_START + boot_rom_space;
- gpmc_mem_root.end = GPMC_MEM_END;
+ gpmc->mem_root.start = GPMC_MEM_START + boot_rom_space;
+ gpmc->mem_root.end = GPMC_MEM_END;
/* Reserve all regions that has been set up by bootloader */
for (cs = 0; cs < GPMC_CS_NUM; cs++) {
@@ -697,26 +740,15 @@ static void __init gpmc_mem_init(void)
static int __init gpmc_init(void)
{
- u32 l, irq;
- int cs, ret = -EINVAL;
- int gpmc_irq;
+ int ret = -EINVAL;
char *ck = NULL;
if (cpu_is_omap24xx()) {
ck = "core_l3_ck";
- if (cpu_is_omap2420())
- l = OMAP2420_GPMC_BASE;
- else
- l = OMAP34XX_GPMC_BASE;
- gpmc_irq = INT_34XX_GPMC_IRQ;
} else if (cpu_is_omap34xx()) {
ck = "gpmc_fck";
- l = OMAP34XX_GPMC_BASE;
- gpmc_irq = INT_34XX_GPMC_IRQ;
} else if (cpu_is_omap44xx()) {
ck = "gpmc_ck";
- l = OMAP44XX_GPMC_BASE;
- gpmc_irq = OMAP44XX_IRQ_GPMC;
}
if (WARN_ON(!ck))
@@ -728,54 +760,360 @@ static int __init gpmc_init(void)
BUG();
}
- gpmc_base = ioremap(l, SZ_4K);
- if (!gpmc_base) {
- clk_put(gpmc_l3_clk);
- printk(KERN_ERR "Could not get GPMC register memory\n");
- BUG();
+ clk_enable(gpmc_l3_clk);
+
+ return 0;
+}
+postcore_initcall(gpmc_init);
+
+static __devinit struct resource gpmc_setup_cs_mem(struct gpmc_cs_data *p,
+ struct gpmc_device_pdata *gdp, struct gpmc *gpmc)
+{
+ int i, ret;
+ struct gpmc_config *c;
+ struct resource res;
+ unsigned long start;
+
+ res.flags = 0x0;
+ start = p->mem_start;
+
+ ret = gpmc_cs_request(p->cs, p->mem_size, &start);
+ if (IS_ERR_VALUE(ret)) {
+ dev_err(gpmc->dev, "error: gpmc request on CS: %u\n", p->cs);
+ return res;
}
- clk_enable(gpmc_l3_clk);
+ c = p->config;
+ if (!c)
+ dev_warn(gpmc->dev, "config not present for CS: %u\n", p->cs);
+
+ for (i = 0; i < p->num_config; c++, i++) {
+ /* XXX: check for non-NULL c ? */
+ ret = gpmc_cs_configure(p->cs, c->cmd, c->val);
+ if (IS_ERR_VALUE(ret)) {
+ dev_err(gpmc->dev, "invalid cmd or value on CS: \
+ %u: cmd: %d value: %d\n", p->cs, c->cmd, c->val);
+ return res;
+ }
+ }
- l = gpmc_read_reg(GPMC_REVISION);
- printk(KERN_INFO "GPMC revision %d.%d\n", (l >> 4) & 0x0f, l & 0x0f);
- /* Set smart idle mode and automatic L3 clock gating */
- l = gpmc_read_reg(GPMC_SYSCONFIG);
- l &= 0x03 << 3;
- l |= (0x02 << 3) | (1 << 0);
- gpmc_write_reg(GPMC_SYSCONFIG, l);
- gpmc_mem_init();
+ if (p->timing) {
+ ret = gpmc_cs_set_timings(p->cs, p->timing);
+ if (IS_ERR_VALUE(ret)) {
+ dev_err(gpmc->dev, "error: setting timing on CS: %d\n",
+ p->cs);
+ return res;
+ }
+ } else
+ dev_warn(gpmc->dev, "timing not present for CS: %u\n", p->cs);
- /* initalize the irq_chained */
- irq = OMAP_GPMC_IRQ_BASE;
- for (cs = 0; cs < GPMC_CS_NUM; cs++) {
- irq_set_chip_and_handler(irq, &dummy_irq_chip,
- handle_simple_irq);
- set_irq_flags(irq, IRQF_VALID);
- irq++;
+ res.start = start + p->mem_offset;
+ res.end = res.start + p->mem_size - 1;
+ res.flags = IORESOURCE_MEM;
+
+ dev_info(gpmc->dev, "resource memory 0x%x-0x%x for %s (on CS %d)\n",
+ res.start, res.end, gdp->name, p->cs);
+
+ return res;
+}
+
+static __devinit
+int gpmc_setup_cs_irq(struct gpmc *gpmc, struct gpmc_device_pdata *gdp,
+ struct gpmc_cs_data *cs, struct resource *res)
+{
+ int i, n, val;
+
+ for (i = 0, n = 0; i < gpmc->num_irq; i++)
+ if (gpmc->irq[i].regval & cs->irq_flags) {
+ res[n].start = res[n].end = gpmc->irq[i].irq;
+ res[n].flags = IORESOURCE_IRQ;
+
+ dev_info(gpmc->dev, "resource irq %u for %s "
+ "(on CS %d) [bit: %x]\n", res[n].start,
+ gdp->name, cs->cs, __ffs(gpmc->irq[i].regval));
+
+ switch (gpmc->irq[i].regval) {
+ case GPMC_IRQ_WAIT0EDGEDETECTION:
+ case GPMC_IRQ_WAIT1EDGEDETECTION:
+ case GPMC_IRQ_WAIT2EDGEDETECTION:
+ case GPMC_IRQ_WAIT3EDGEDETECTION:
+ val = __ffs(gpmc->irq[i].regval);
+ val -= __ffs(GPMC_IRQ_WAIT0EDGEDETECTION);
+ gpmc_cs_configure(cs->cs,
+ GPMC_CONFIG_WAITPIN, val);
+ }
+ n++;
+ }
+
+ return n;
+}
+
+static __devinit int gpmc_setup_device(struct gpmc_device_pdata *gdp,
+ struct gpmc_device *dev, struct gpmc *gpmc)
+{
+ int i, j, n;
+ struct gpmc_cs_data *cs;
+
+ for (i = 0, n = 0, cs = gdp->cs_data; i < gdp->num_cs; i++, cs++)
+ n += hweight32(cs->irq_flags & GPMC_IRQ_MASK);
+
+ n += gdp->num_cs;
+
+ dev->gpmc_res = devm_kzalloc(gpmc->dev, sizeof(*dev->gpmc_res) * n,
+ GFP_KERNEL);
+ if (dev->gpmc_res == NULL) {
+ dev_err(gpmc->dev, "error: memory allocation\n");
+ return -ENOMEM;
+ }
+
+ for (i = 0, j = 0, cs = gdp->cs_data; i < gdp->num_cs; cs++, i++) {
+ dev->gpmc_res[j] = gpmc_setup_cs_mem(cs, gdp, gpmc);
+ if (dev->gpmc_res[j++].flags & IORESOURCE_MEM)
+ j += gpmc_setup_cs_irq(gpmc, gdp, cs,
+ dev->gpmc_res + j);
+ else {
+ dev_err(gpmc->dev, "error: setup for %s\n", gdp->name);
+ devm_kfree(gpmc->dev, dev->gpmc_res);
+ dev->gpmc_res = NULL;
+ dev->num_gpmc_res = 0;
+ return -EINVAL;
+ }
}
+ dev->num_gpmc_res = j;
- ret = request_irq(gpmc_irq,
- gpmc_handle_irq, IRQF_SHARED, "gpmc", gpmc_base);
- if (ret)
- pr_err("gpmc: irq-%d could not claim: err %d\n",
- gpmc_irq, ret);
- return ret;
+ dev->name = gdp->name;
+ dev->id = gdp->id;
+ dev->pdata = gdp->pdata;
+ dev->pdata_size = gdp->pdata_size;
+ dev->per_res = gdp->per_res;
+ dev->num_per_res = gdp->num_per_res;
+
+ return 0;
+}
+
+static __devinit
+struct platform_device *gpmc_create_device(struct gpmc_device *p,
+ struct gpmc *gpmc)
+{
+ int num = p->num_per_res + p->num_gpmc_res;
+ struct resource *res;
+ struct platform_device *pdev;
+
+ res = devm_kzalloc(gpmc->dev, sizeof(struct resource) * num,
+ GFP_KERNEL);
+ if (!res) {
+ dev_err(gpmc->dev, "error: allocating memory\n");
+ return NULL;
+ }
+
+ memcpy((char *)res, (const char *) p->gpmc_res,
+ sizeof(struct resource) * p->num_gpmc_res);
+ memcpy((char *)(res + p->num_gpmc_res), (const char *)p->per_res,
+ sizeof(struct resource) * p->num_per_res);
+
+ pdev = platform_device_register_resndata(gpmc->dev, p->name, p->id,
+ res, num, p->pdata, p->pdata_size);
+
+ devm_kfree(gpmc->dev, res);
+
+ return pdev;
}
-postcore_initcall(gpmc_init);
static irqreturn_t gpmc_handle_irq(int irq, void *dev)
{
- u8 cs;
+ int i;
+ u32 regval;
+ struct gpmc *gpmc = dev;
- /* check cs to invoke the irq */
- cs = ((gpmc_read_reg(GPMC_PREFETCH_CONFIG1)) >> CS_NUM_SHIFT) & 0x7;
- if (OMAP_GPMC_IRQ_BASE+cs <= OMAP_GPMC_IRQ_END)
- generic_handle_irq(OMAP_GPMC_IRQ_BASE+cs);
+ regval = gpmc_read_reg(GPMC_IRQSTATUS);
+
+
+ for (i = 0; i < gpmc->num_irq; i++)
+ if (regval & gpmc->irq[i].regval)
+ generic_handle_irq(gpmc->irq[i].irq);
+ gpmc_write_reg(GPMC_IRQSTATUS, regval);
return IRQ_HANDLED;
}
+static int gpmc_irq_endis(struct irq_data *p, bool endis)
+{
+ struct gpmc *gpmc = irq_data_get_irq_chip_data(p);
+ int i;
+ u32 regval;
+
+ for (i = 0; i < gpmc->num_irq; i++)
+ if (p->irq == gpmc->irq[i].irq) {
+ regval = gpmc_read_reg(GPMC_IRQENABLE);
+ if (endis)
+ regval |= gpmc->irq[i].regval;
+ else
+ regval &= ~gpmc->irq[i].regval;
+ gpmc_write_reg(GPMC_IRQENABLE, regval);
+ break;
+ }
+
+ return 0;
+}
+
+static void gpmc_irq_disable(struct irq_data *p)
+{
+ gpmc_irq_endis(p, false);
+}
+
+static void gpmc_irq_enable(struct irq_data *p)
+{
+ gpmc_irq_endis(p, true);
+}
+
+static void gpmc_irq_noop(struct irq_data *data) { }
+
+static unsigned int gpmc_irq_noop_ret(struct irq_data *data) { return 0; }
+
+static __devinit int gpmc_setup_irq(struct gpmc *gpmc)
+{
+ int i;
+ u32 regval;
+
+ if (!gpmc->master_irq)
+ return -EINVAL;
+
+ if (gpmc->num_irq < GPMC_NR_IRQ) {
+ dev_warn(gpmc->dev, "Insufficient interrupts for device\n");
+ return -EINVAL;
+ } else if (gpmc->num_irq > GPMC_NR_IRQ)
+ gpmc->num_irq = GPMC_NR_IRQ;
+
+ gpmc->irq[0].regval = GPMC_IRQ_FIFOEVENT;
+ gpmc->irq[1].regval = GPMC_IRQ_TERMINALCOUNT;
+ gpmc->irq[2].regval = GPMC_IRQ_WAIT0EDGEDETECTION;
+ gpmc->irq[3].regval = GPMC_IRQ_WAIT1EDGEDETECTION;
+ gpmc->irq[4].regval = GPMC_IRQ_WAIT2EDGEDETECTION;
+ gpmc->irq[5].regval = GPMC_IRQ_WAIT3EDGEDETECTION;
+
+ for (i = 0; i < gpmc->num_irq; i++)
+ gpmc->irq[i].irq = gpmc->irq_start + i;
+
+ gpmc->irq_chip.name = "gpmc";
+ gpmc->irq_chip.irq_startup = gpmc_irq_noop_ret;
+ gpmc->irq_chip.irq_enable = gpmc_irq_enable;
+ gpmc->irq_chip.irq_disable = gpmc_irq_disable;
+ gpmc->irq_chip.irq_shutdown = gpmc_irq_noop;
+ gpmc->irq_chip.irq_ack = gpmc_irq_noop;
+ gpmc->irq_chip.irq_mask = gpmc_irq_noop;
+ gpmc->irq_chip.irq_unmask = gpmc_irq_noop;
+
+ for (i = 0; i < gpmc->num_irq; i++) {
+ irq_set_chip_and_handler(gpmc->irq[i].irq,
+ &gpmc->irq_chip, handle_simple_irq);
+ irq_set_chip_data(gpmc->irq[i].irq, gpmc);
+ set_irq_flags(gpmc->irq[i].irq, IRQF_VALID | IRQF_NOAUTOEN);
+ }
+
+ /* clear interrupts */
+ regval = gpmc_read_reg(GPMC_IRQSTATUS);
+ gpmc_write_reg(GPMC_IRQSTATUS, regval);
+
+ return request_irq(gpmc->master_irq, gpmc_handle_irq, IRQF_SHARED,
+ "gpmc", gpmc);
+}
+
+static __devinit int gpmc_probe(struct platform_device *pdev)
+{
+ u32 l;
+ int i;
+ int ret = 0;
+ struct resource *res = NULL;
+ struct gpmc_pdata *gp = dev_get_platdata(&pdev->dev);
+ struct gpmc_device_pdata **gdq = NULL;
+ struct gpmc_device *gd = NULL;
+
+ gpmc = devm_kzalloc(&pdev->dev, sizeof(struct gpmc), GFP_KERNEL);
+ if (gpmc == NULL)
+ return -ENOMEM;
+
+ gpmc->dev = &pdev->dev;
+ gpmc->fclk_period = gp->fclk_period;
+
+ res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+ if (res == NULL)
+ return -ENOENT;
+
+ gpmc->phys_base = res->start;
+ gpmc->memsize = resource_size(res);
+
+ gpmc->io_base = devm_request_and_ioremap(gpmc->dev, res);
+ if (!gpmc->io_base)
+ return -EADDRNOTAVAIL;
+
+ res = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
+ if (res == NULL)
+ dev_warn(gpmc->dev, "Failed to get resource: irq\n");
+ else
+ gpmc->master_irq = res->start;
+
+ gpmc->irq_start = gp->irq_start;
+ gpmc->num_irq = gp->num_irq;
+ gpmc_setup_irq(gpmc);
+
+ gpmc->ecc_used = -EINVAL;
+ spin_lock_init(&gpmc->mem_lock);
+ platform_set_drvdata(pdev, gpmc);
+
+ l = gpmc_read_reg(GPMC_REVISION);
+ dev_info(gpmc->dev, "GPMC revision %d.%d\n", (l >> 4) & 0x0f, l & 0x0f);
+
+ gpmc_mem_init();
+
+ for (gdq = gp->device_pdata, gd = gpmc->device; *gdq; gdq++, i++) {
+ ret = gpmc_setup_device(*gdq, gd, gpmc);
+ if (IS_ERR_VALUE(ret))
+ dev_err(gpmc->dev, "gpmc setup on %s failed\n",
+ (*gdq)->name);
+ else
+ gd++;
+ }
+ gpmc->num_device = gd - gpmc->device;
+
+ for (i = 0, gd = gpmc->device; i < gpmc->num_device; i++, gd++)
+ if (IS_ERR(gpmc_create_device(gd, gpmc)))
+ dev_err(gpmc->dev, "device creation on %s failed\n",
+ gd->name);
+
+ return 0;
+}
+
+static __devexit int gpmc_free_irq(struct gpmc *gpmc)
+{
+ /* TODO: free gpmc irq chip */
+
+ if (gpmc->master_irq)
+ free_irq(gpmc->master_irq, gpmc);
+
+ return 0;
+}
+
+static __devexit int gpmc_remove(struct platform_device *pdev)
+{
+ struct gpmc *gpmc = platform_get_drvdata(pdev);
+
+ platform_set_drvdata(pdev, NULL);
+ gpmc_free_irq(gpmc);
+
+ return 0;
+}
+
+static struct platform_driver gpmc_driver = {
+ .probe = gpmc_probe,
+ .remove = __devexit_p(gpmc_remove),
+ .driver = {
+ .name = DRIVER_NAME,
+ .owner = THIS_MODULE,
+ },
+};
+
+module_platform_driver(gpmc_driver);
+
#ifdef CONFIG_ARCH_OMAP3
static struct omap3_gpmc_regs gpmc_context;
@@ -855,10 +1193,10 @@ int gpmc_enable_hwecc(int cs, int mode, int dev_width, int ecc_size)
unsigned int val;
/* check if ecc module is in used */
- if (gpmc_ecc_used != -EINVAL)
+ if (gpmc->ecc_used != -EINVAL)
return -EINVAL;
- gpmc_ecc_used = cs;
+ gpmc->ecc_used = cs;
/* clear ecc and enable bits */
val = ((0x00000001<<8) | 0x00000001);
@@ -906,7 +1244,7 @@ int gpmc_calculate_ecc(int cs, const u_char *dat, u_char *ecc_code)
{
unsigned int val = 0x0;
- if (gpmc_ecc_used != cs)
+ if (gpmc->ecc_used != cs)
return -EINVAL;
/* read ecc result */
@@ -916,7 +1254,7 @@ int gpmc_calculate_ecc(int cs, const u_char *dat, u_char *ecc_code)
/* P2048o, P1024o, P512o, P256o, P2048e, P1024e, P512e, P256e */
*ecc_code++ = ((val >> 8) & 0x0f) | ((val >> 20) & 0xf0);
- gpmc_ecc_used = -EINVAL;
+ gpmc->ecc_used = -EINVAL;
return 0;
}
EXPORT_SYMBOL_GPL(gpmc_calculate_ecc);
diff --git a/arch/arm/plat-omap/include/plat/gpmc.h b/arch/arm/plat-omap/include/plat/gpmc.h
index 1527929..fa62cdf 100644
--- a/arch/arm/plat-omap/include/plat/gpmc.h
+++ b/arch/arm/plat-omap/include/plat/gpmc.h
@@ -36,6 +36,7 @@
#define GPMC_PREFETCH_FIFO_CNT 0x00000007 /* bytes available in FIFO for r/w */
#define GPMC_PREFETCH_COUNT 0x00000008 /* remaining bytes to be read/write*/
#define GPMC_STATUS_BUFFER 0x00000009 /* 1: buffer is available to write */
+#define GPMC_CONFIG_WAITPIN 0x0000000A
#define GPMC_NAND_COMMAND 0x0000000a
#define GPMC_NAND_ADDRESS 0x0000000b
@@ -83,6 +84,17 @@
#define GPMC_IRQ_FIFOEVENTENABLE 0x01
#define GPMC_IRQ_COUNT_EVENT 0x02
+#define GPMC_IRQ_FIFOEVENT BIT(0)
+#define GPMC_IRQ_TERMINALCOUNT BIT(1)
+#define GPMC_IRQ_WAIT0EDGEDETECTION BIT(8)
+#define GPMC_IRQ_WAIT1EDGEDETECTION BIT(9)
+#define GPMC_IRQ_WAIT2EDGEDETECTION BIT(10)
+#define GPMC_IRQ_WAIT3EDGEDETECTION BIT(11)
+#define GPMC_IRQ_MASK \
+ (GPMC_IRQ_FIFOEVENT | GPMC_IRQ_TERMINALCOUNT | \
+ GPMC_IRQ_WAIT0EDGEDETECTION | GPMC_IRQ_WAIT1EDGEDETECTION | \
+ GPMC_IRQ_WAIT2EDGEDETECTION | GPMC_IRQ_WAIT3EDGEDETECTION)
+
#define PREFETCH_FIFOTHRESHOLD_MAX 0x40
#define PREFETCH_FIFOTHRESHOLD(val) ((val) << 8)
@@ -131,6 +143,42 @@ struct gpmc_timings {
u16 wr_data_mux_bus; /* WRDATAONADMUXBUS */
};
+struct gpmc_config {
+ int cmd;
+ int val;
+};
+
+struct gpmc_cs_data {
+ unsigned cs;
+ unsigned long mem_size;
+ unsigned long mem_start;
+ unsigned long mem_offset;
+ struct gpmc_config *config;
+ unsigned num_config;
+ struct gpmc_timings *timing;
+ unsigned irq_flags;
+};
+
+struct gpmc_device_pdata {
+ char *name;
+ int id;
+ void *pdata;
+ unsigned pdata_size;
+ /* resources configured via GPMC will be created by GPMC driver */
+ struct resource *per_res;
+ unsigned num_per_res;
+ struct gpmc_cs_data *cs_data;
+ unsigned num_cs;
+};
+
+struct gpmc_pdata {
+ /* GPMC_FCLK period in picoseconds */
+ unsigned long fclk_period;
+ struct gpmc_device_pdata **device_pdata;
+ unsigned irq_start;
+ unsigned num_irq;
+};
+
extern unsigned int gpmc_ns_to_ticks(unsigned int time_ns);
extern unsigned int gpmc_ps_to_ticks(unsigned int time_ps);
extern unsigned int gpmc_ticks_to_ns(unsigned int ticks);
@@ -143,8 +191,6 @@ extern int gpmc_cs_calc_divider(int cs, unsigned int sync_clk);
extern int gpmc_cs_set_timings(int cs, const struct gpmc_timings *t);
extern int gpmc_cs_request(int cs, unsigned long size, unsigned long *base);
extern void gpmc_cs_free(int cs);
-extern int gpmc_cs_set_reserved(int cs, int reserved);
-extern int gpmc_cs_reserved(int cs);
extern int gpmc_prefetch_enable(int cs, int fifo_th, int dma_mode,
unsigned int u32_count, int is_write);
extern int gpmc_prefetch_reset(int cs);
--
1.7.9.3
^ permalink raw reply related [flat|nested] 73+ messages in thread
* [PATCH v3 1/9] ARM: OMAP2+: gpmc: driver conversion
@ 2012-04-05 15:45 ` Afzal Mohammed
0 siblings, 0 replies; 73+ messages in thread
From: Afzal Mohammed @ 2012-04-05 15:45 UTC (permalink / raw)
To: tony, khilman, linux, dwmw2, sameo, grinberg, mike, nm,
artem.bityutskiy, vimal.newwork, dbaryshkov, linux-omap,
linux-arm-kernel, linux-mtd, linux-kernel
Cc: Afzal Mohammed, Vaibhav Hiremath, Jon Hunter
Convert GPMC code to driver. Boards using GPMC should provide driver
with type of configuration, timing, CS, GPMC address space details
(if already configured, driver will retrieve, as is existing).
Platform devices would the be created for each connected peripheral
(details also to be passed by board so that it reaches respective
driver). And GPMC driver would populate memory resource details for
the driver of connected peripheral.
A peripheral connected to GPMC can have multiple address spaces using
different chip select. Hence GPMC driver has been provided capability
to create platform device for peripheral using mutiple CS. The
peripheral that made it necessary was tusb6010. Thanks to Jon Hunter
for his suggesstion on better way to handle this.
Interrupts of GPMC are presented to drivers of connected peripherals
as resource. A fictitious interrupt controller chip handles these
interrupts at GPMC hardware level. Clients can use normal interrupt
APIs. Platforms should inform GPMC driver infrastruture available
for these imaginary client interrupts (like irq number). Platform
information of peripheral passed to GPMC driver should indicate
interrupts to be used via flags.
Final destination for this driver is being investigated. Before moving
to the new location, all existing GPMC users has to be converted to
work with this driver.
NAND driver for NAND used via GPMC is tightly coupled with GPMC
driver (GPMC has few blocks exclusively for NAND), while that is not
the case for most of the other users (they need GPMCs help only for
initial configuration). Currently NAND driver manage using exported
GPMC symbols. This is being planned to remove later & would need
informing NAND driver about GPMC NAND registers. This would help to
have export symbol free GPMC driver, and probably
"mv omap2.c gpmc-nand.c" for OMAP NAND driver.
Thanks to Vaibhav Hiremath for his ideas on this.
Acquiring CS# for NAND is done on a few boards. It means, depending
on bootloader to embed this information. Probably CS# being used can
be set in the Kernel, and acquiring it can be removed. If ever this
capbility is needed, GPMC driver has to be made aware of handling it.
OneNAND - as it may involve reconfiguring GPMC for synchronous may
need a quirk to handle or driver has to be made more intelligent to
handle it.
Code related to GPMC clock may have to continue live in platform
folders (even if the driver is moved to MFD) as input clock is beyond
the control of GPMC and calculating timing for the peripheral may
need other helpers.
Cc: Vaibhav Hiremath <hvaibhav@ti.com>
Cc: Jon Hunter <jon-hunter@ti.com>
Signed-off-by: Afzal Mohammed <afzal@ti.com>
---
arch/arm/mach-omap2/gpmc.c | 518 ++++++++++++++++++++++++++------
arch/arm/plat-omap/include/plat/gpmc.h | 50 ++-
2 files changed, 476 insertions(+), 92 deletions(-)
diff --git a/arch/arm/mach-omap2/gpmc.c b/arch/arm/mach-omap2/gpmc.c
index 00d5108..cf5d8f3 100644
--- a/arch/arm/mach-omap2/gpmc.c
+++ b/arch/arm/mach-omap2/gpmc.c
@@ -14,8 +14,11 @@
*/
#undef DEBUG
+#include <linux/platform_device.h>
+
#include <linux/irq.h>
#include <linux/kernel.h>
+#include <linux/slab.h>
#include <linux/init.h>
#include <linux/err.h>
#include <linux/clk.h>
@@ -64,6 +67,47 @@
#define ENABLE_PREFETCH (0x1 << 7)
#define DMA_MPU_MODE 2
+#define DRIVER_NAME "omap-gpmc"
+
+#define GPMC_NR_IRQ 6
+
+struct gpmc_device {
+ char *name;
+ int id;
+ void *pdata;
+ unsigned pdata_size;
+ struct resource *per_res;
+ unsigned num_per_res;
+ struct resource *gpmc_res;
+ unsigned num_gpmc_res;
+};
+
+struct gpmc_irq {
+ unsigned irq;
+ u32 regval;
+};
+
+struct gpmc {
+ struct device *dev;
+ unsigned long fclk_period;
+ void __iomem *io_base;
+ unsigned long phys_base;
+ u32 memsize;
+ unsigned cs_map;
+ int ecc_used;
+ spinlock_t mem_lock;
+ struct resource mem_root;
+ struct resource cs_mem[GPMC_CS_NUM];
+ /* XXX: Or allocate dynamically ? */
+ struct gpmc_device device[GPMC_CS_NUM];
+ unsigned num_device;
+ unsigned master_irq;
+ unsigned irq_start;
+ unsigned num_irq;
+ struct gpmc_irq irq[GPMC_NR_IRQ];
+ struct irq_chip irq_chip;
+};
+
/* Structure to save gpmc cs context */
struct gpmc_cs_config {
u32 config1;
@@ -91,58 +135,50 @@ struct omap3_gpmc_regs {
struct gpmc_cs_config cs_context[GPMC_CS_NUM];
};
-static struct resource gpmc_mem_root;
-static struct resource gpmc_cs_mem[GPMC_CS_NUM];
-static DEFINE_SPINLOCK(gpmc_mem_lock);
-static unsigned int gpmc_cs_map; /* flag for cs which are initialized */
-static int gpmc_ecc_used = -EINVAL; /* cs using ecc engine */
-
-static void __iomem *gpmc_base;
-
static struct clk *gpmc_l3_clk;
-static irqreturn_t gpmc_handle_irq(int irq, void *dev);
+static struct gpmc *gpmc;
static void gpmc_write_reg(int idx, u32 val)
{
- __raw_writel(val, gpmc_base + idx);
+ writel(val, gpmc->io_base + idx);
}
static u32 gpmc_read_reg(int idx)
{
- return __raw_readl(gpmc_base + idx);
+ return readl(gpmc->io_base + idx);
}
static void gpmc_cs_write_byte(int cs, int idx, u8 val)
{
void __iomem *reg_addr;
- reg_addr = gpmc_base + GPMC_CS0_OFFSET + (cs * GPMC_CS_SIZE) + idx;
- __raw_writeb(val, reg_addr);
+ reg_addr = gpmc->io_base + GPMC_CS0_OFFSET + (cs * GPMC_CS_SIZE) + idx;
+ writeb(val, reg_addr);
}
static u8 gpmc_cs_read_byte(int cs, int idx)
{
void __iomem *reg_addr;
- reg_addr = gpmc_base + GPMC_CS0_OFFSET + (cs * GPMC_CS_SIZE) + idx;
- return __raw_readb(reg_addr);
+ reg_addr = gpmc->io_base + GPMC_CS0_OFFSET + (cs * GPMC_CS_SIZE) + idx;
+ return readb(reg_addr);
}
void gpmc_cs_write_reg(int cs, int idx, u32 val)
{
void __iomem *reg_addr;
- reg_addr = gpmc_base + GPMC_CS0_OFFSET + (cs * GPMC_CS_SIZE) + idx;
- __raw_writel(val, reg_addr);
+ reg_addr = gpmc->io_base + GPMC_CS0_OFFSET + (cs * GPMC_CS_SIZE) + idx;
+ writel(val, reg_addr);
}
u32 gpmc_cs_read_reg(int cs, int idx)
{
void __iomem *reg_addr;
- reg_addr = gpmc_base + GPMC_CS0_OFFSET + (cs * GPMC_CS_SIZE) + idx;
- return __raw_readl(reg_addr);
+ reg_addr = gpmc->io_base + GPMC_CS0_OFFSET + (cs * GPMC_CS_SIZE) + idx;
+ return readl(reg_addr);
}
/* TODO: Add support for gpmc_fck to clock framework and use it */
@@ -332,7 +368,7 @@ static void gpmc_cs_disable_mem(int cs)
gpmc_cs_write_reg(cs, GPMC_CS_CONFIG7, l);
}
-static void gpmc_cs_get_memconf(int cs, u32 *base, u32 *size)
+static __devinit void gpmc_cs_get_memconf(int cs, u32 *base, u32 *size)
{
u32 l;
u32 mask;
@@ -351,23 +387,23 @@ static int gpmc_cs_mem_enabled(int cs)
return l & GPMC_CONFIG7_CSVALID;
}
-int gpmc_cs_set_reserved(int cs, int reserved)
+static int gpmc_cs_set_reserved(int cs, int reserved)
{
if (cs > GPMC_CS_NUM)
return -ENODEV;
- gpmc_cs_map &= ~(1 << cs);
- gpmc_cs_map |= (reserved ? 1 : 0) << cs;
+ gpmc->cs_map &= ~(1 << cs);
+ gpmc->cs_map |= (reserved ? 1 : 0) << cs;
return 0;
}
-int gpmc_cs_reserved(int cs)
+static int gpmc_cs_reserved(int cs)
{
if (cs > GPMC_CS_NUM)
return -ENODEV;
- return gpmc_cs_map & (1 << cs);
+ return gpmc->cs_map & (1 << cs);
}
static unsigned long gpmc_mem_align(unsigned long size)
@@ -384,24 +420,25 @@ static unsigned long gpmc_mem_align(unsigned long size)
return size;
}
-static int gpmc_cs_insert_mem(int cs, unsigned long base, unsigned long size)
+static __devinit
+int gpmc_cs_insert_mem(int cs, unsigned long base, unsigned long size)
{
- struct resource *res = &gpmc_cs_mem[cs];
+ struct resource *res = &gpmc->cs_mem[cs];
int r;
size = gpmc_mem_align(size);
- spin_lock(&gpmc_mem_lock);
+ spin_lock(&gpmc->mem_lock);
res->start = base;
res->end = base + size - 1;
- r = request_resource(&gpmc_mem_root, res);
- spin_unlock(&gpmc_mem_lock);
+ r = request_resource(&gpmc->mem_root, res);
+ spin_unlock(&gpmc->mem_lock);
return r;
}
int gpmc_cs_request(int cs, unsigned long size, unsigned long *base)
{
- struct resource *res = &gpmc_cs_mem[cs];
+ struct resource *res = &gpmc->cs_mem[cs];
int r = -1;
if (cs > GPMC_CS_NUM)
@@ -411,7 +448,7 @@ int gpmc_cs_request(int cs, unsigned long size, unsigned long *base)
if (size > (1 << GPMC_SECTION_SHIFT))
return -ENOMEM;
- spin_lock(&gpmc_mem_lock);
+ spin_lock(&gpmc->mem_lock);
if (gpmc_cs_reserved(cs)) {
r = -EBUSY;
goto out;
@@ -419,7 +456,7 @@ int gpmc_cs_request(int cs, unsigned long size, unsigned long *base)
if (gpmc_cs_mem_enabled(cs))
r = adjust_resource(res, res->start & ~(size - 1), size);
if (r < 0)
- r = allocate_resource(&gpmc_mem_root, res, size, 0, ~0,
+ r = allocate_resource(&gpmc->mem_root, res, size, 0, ~0,
size, NULL, NULL);
if (r < 0)
goto out;
@@ -428,24 +465,24 @@ int gpmc_cs_request(int cs, unsigned long size, unsigned long *base)
*base = res->start;
gpmc_cs_set_reserved(cs, 1);
out:
- spin_unlock(&gpmc_mem_lock);
+ spin_unlock(&gpmc->mem_lock);
return r;
}
EXPORT_SYMBOL(gpmc_cs_request);
void gpmc_cs_free(int cs)
{
- spin_lock(&gpmc_mem_lock);
+ spin_lock(&gpmc->mem_lock);
if (cs >= GPMC_CS_NUM || cs < 0 || !gpmc_cs_reserved(cs)) {
printk(KERN_ERR "Trying to free non-reserved GPMC CS%d\n", cs);
BUG();
- spin_unlock(&gpmc_mem_lock);
+ spin_unlock(&gpmc->mem_lock);
return;
}
gpmc_cs_disable_mem(cs);
- release_resource(&gpmc_cs_mem[cs]);
+ release_resource(&gpmc->cs_mem[cs]);
gpmc_cs_set_reserved(cs, 0);
- spin_unlock(&gpmc_mem_lock);
+ spin_unlock(&gpmc->mem_lock);
}
EXPORT_SYMBOL(gpmc_cs_free);
@@ -546,6 +583,12 @@ int gpmc_cs_configure(int cs, int cmd, int wval)
gpmc_cs_write_reg(cs, GPMC_CS_CONFIG1, regval);
break;
+ case GPMC_CONFIG_WAITPIN:
+ regval = gpmc_cs_read_reg(cs, GPMC_CS_CONFIG1);
+ regval |= GPMC_CONFIG1_WAIT_PIN_SEL(wval);
+ gpmc_cs_write_reg(cs, GPMC_CS_CONFIG1, regval);
+ break;
+
default:
printk(KERN_ERR "gpmc_configure_cs: Not supported\n");
err = -EINVAL;
@@ -668,7 +711,7 @@ int gpmc_prefetch_reset(int cs)
}
EXPORT_SYMBOL(gpmc_prefetch_reset);
-static void __init gpmc_mem_init(void)
+static __devinit void gpmc_mem_init(void)
{
int cs;
unsigned long boot_rom_space = 0;
@@ -680,8 +723,8 @@ static void __init gpmc_mem_init(void)
/* In apollon the CS0 is mapped as 0x0000 0000 */
if (machine_is_omap_apollon())
boot_rom_space = 0;
- gpmc_mem_root.start = GPMC_MEM_START + boot_rom_space;
- gpmc_mem_root.end = GPMC_MEM_END;
+ gpmc->mem_root.start = GPMC_MEM_START + boot_rom_space;
+ gpmc->mem_root.end = GPMC_MEM_END;
/* Reserve all regions that has been set up by bootloader */
for (cs = 0; cs < GPMC_CS_NUM; cs++) {
@@ -697,26 +740,15 @@ static void __init gpmc_mem_init(void)
static int __init gpmc_init(void)
{
- u32 l, irq;
- int cs, ret = -EINVAL;
- int gpmc_irq;
+ int ret = -EINVAL;
char *ck = NULL;
if (cpu_is_omap24xx()) {
ck = "core_l3_ck";
- if (cpu_is_omap2420())
- l = OMAP2420_GPMC_BASE;
- else
- l = OMAP34XX_GPMC_BASE;
- gpmc_irq = INT_34XX_GPMC_IRQ;
} else if (cpu_is_omap34xx()) {
ck = "gpmc_fck";
- l = OMAP34XX_GPMC_BASE;
- gpmc_irq = INT_34XX_GPMC_IRQ;
} else if (cpu_is_omap44xx()) {
ck = "gpmc_ck";
- l = OMAP44XX_GPMC_BASE;
- gpmc_irq = OMAP44XX_IRQ_GPMC;
}
if (WARN_ON(!ck))
@@ -728,54 +760,360 @@ static int __init gpmc_init(void)
BUG();
}
- gpmc_base = ioremap(l, SZ_4K);
- if (!gpmc_base) {
- clk_put(gpmc_l3_clk);
- printk(KERN_ERR "Could not get GPMC register memory\n");
- BUG();
+ clk_enable(gpmc_l3_clk);
+
+ return 0;
+}
+postcore_initcall(gpmc_init);
+
+static __devinit struct resource gpmc_setup_cs_mem(struct gpmc_cs_data *p,
+ struct gpmc_device_pdata *gdp, struct gpmc *gpmc)
+{
+ int i, ret;
+ struct gpmc_config *c;
+ struct resource res;
+ unsigned long start;
+
+ res.flags = 0x0;
+ start = p->mem_start;
+
+ ret = gpmc_cs_request(p->cs, p->mem_size, &start);
+ if (IS_ERR_VALUE(ret)) {
+ dev_err(gpmc->dev, "error: gpmc request on CS: %u\n", p->cs);
+ return res;
}
- clk_enable(gpmc_l3_clk);
+ c = p->config;
+ if (!c)
+ dev_warn(gpmc->dev, "config not present for CS: %u\n", p->cs);
+
+ for (i = 0; i < p->num_config; c++, i++) {
+ /* XXX: check for non-NULL c ? */
+ ret = gpmc_cs_configure(p->cs, c->cmd, c->val);
+ if (IS_ERR_VALUE(ret)) {
+ dev_err(gpmc->dev, "invalid cmd or value on CS: \
+ %u: cmd: %d value: %d\n", p->cs, c->cmd, c->val);
+ return res;
+ }
+ }
- l = gpmc_read_reg(GPMC_REVISION);
- printk(KERN_INFO "GPMC revision %d.%d\n", (l >> 4) & 0x0f, l & 0x0f);
- /* Set smart idle mode and automatic L3 clock gating */
- l = gpmc_read_reg(GPMC_SYSCONFIG);
- l &= 0x03 << 3;
- l |= (0x02 << 3) | (1 << 0);
- gpmc_write_reg(GPMC_SYSCONFIG, l);
- gpmc_mem_init();
+ if (p->timing) {
+ ret = gpmc_cs_set_timings(p->cs, p->timing);
+ if (IS_ERR_VALUE(ret)) {
+ dev_err(gpmc->dev, "error: setting timing on CS: %d\n",
+ p->cs);
+ return res;
+ }
+ } else
+ dev_warn(gpmc->dev, "timing not present for CS: %u\n", p->cs);
- /* initalize the irq_chained */
- irq = OMAP_GPMC_IRQ_BASE;
- for (cs = 0; cs < GPMC_CS_NUM; cs++) {
- irq_set_chip_and_handler(irq, &dummy_irq_chip,
- handle_simple_irq);
- set_irq_flags(irq, IRQF_VALID);
- irq++;
+ res.start = start + p->mem_offset;
+ res.end = res.start + p->mem_size - 1;
+ res.flags = IORESOURCE_MEM;
+
+ dev_info(gpmc->dev, "resource memory 0x%x-0x%x for %s (on CS %d)\n",
+ res.start, res.end, gdp->name, p->cs);
+
+ return res;
+}
+
+static __devinit
+int gpmc_setup_cs_irq(struct gpmc *gpmc, struct gpmc_device_pdata *gdp,
+ struct gpmc_cs_data *cs, struct resource *res)
+{
+ int i, n, val;
+
+ for (i = 0, n = 0; i < gpmc->num_irq; i++)
+ if (gpmc->irq[i].regval & cs->irq_flags) {
+ res[n].start = res[n].end = gpmc->irq[i].irq;
+ res[n].flags = IORESOURCE_IRQ;
+
+ dev_info(gpmc->dev, "resource irq %u for %s "
+ "(on CS %d) [bit: %x]\n", res[n].start,
+ gdp->name, cs->cs, __ffs(gpmc->irq[i].regval));
+
+ switch (gpmc->irq[i].regval) {
+ case GPMC_IRQ_WAIT0EDGEDETECTION:
+ case GPMC_IRQ_WAIT1EDGEDETECTION:
+ case GPMC_IRQ_WAIT2EDGEDETECTION:
+ case GPMC_IRQ_WAIT3EDGEDETECTION:
+ val = __ffs(gpmc->irq[i].regval);
+ val -= __ffs(GPMC_IRQ_WAIT0EDGEDETECTION);
+ gpmc_cs_configure(cs->cs,
+ GPMC_CONFIG_WAITPIN, val);
+ }
+ n++;
+ }
+
+ return n;
+}
+
+static __devinit int gpmc_setup_device(struct gpmc_device_pdata *gdp,
+ struct gpmc_device *dev, struct gpmc *gpmc)
+{
+ int i, j, n;
+ struct gpmc_cs_data *cs;
+
+ for (i = 0, n = 0, cs = gdp->cs_data; i < gdp->num_cs; i++, cs++)
+ n += hweight32(cs->irq_flags & GPMC_IRQ_MASK);
+
+ n += gdp->num_cs;
+
+ dev->gpmc_res = devm_kzalloc(gpmc->dev, sizeof(*dev->gpmc_res) * n,
+ GFP_KERNEL);
+ if (dev->gpmc_res == NULL) {
+ dev_err(gpmc->dev, "error: memory allocation\n");
+ return -ENOMEM;
+ }
+
+ for (i = 0, j = 0, cs = gdp->cs_data; i < gdp->num_cs; cs++, i++) {
+ dev->gpmc_res[j] = gpmc_setup_cs_mem(cs, gdp, gpmc);
+ if (dev->gpmc_res[j++].flags & IORESOURCE_MEM)
+ j += gpmc_setup_cs_irq(gpmc, gdp, cs,
+ dev->gpmc_res + j);
+ else {
+ dev_err(gpmc->dev, "error: setup for %s\n", gdp->name);
+ devm_kfree(gpmc->dev, dev->gpmc_res);
+ dev->gpmc_res = NULL;
+ dev->num_gpmc_res = 0;
+ return -EINVAL;
+ }
}
+ dev->num_gpmc_res = j;
- ret = request_irq(gpmc_irq,
- gpmc_handle_irq, IRQF_SHARED, "gpmc", gpmc_base);
- if (ret)
- pr_err("gpmc: irq-%d could not claim: err %d\n",
- gpmc_irq, ret);
- return ret;
+ dev->name = gdp->name;
+ dev->id = gdp->id;
+ dev->pdata = gdp->pdata;
+ dev->pdata_size = gdp->pdata_size;
+ dev->per_res = gdp->per_res;
+ dev->num_per_res = gdp->num_per_res;
+
+ return 0;
+}
+
+static __devinit
+struct platform_device *gpmc_create_device(struct gpmc_device *p,
+ struct gpmc *gpmc)
+{
+ int num = p->num_per_res + p->num_gpmc_res;
+ struct resource *res;
+ struct platform_device *pdev;
+
+ res = devm_kzalloc(gpmc->dev, sizeof(struct resource) * num,
+ GFP_KERNEL);
+ if (!res) {
+ dev_err(gpmc->dev, "error: allocating memory\n");
+ return NULL;
+ }
+
+ memcpy((char *)res, (const char *) p->gpmc_res,
+ sizeof(struct resource) * p->num_gpmc_res);
+ memcpy((char *)(res + p->num_gpmc_res), (const char *)p->per_res,
+ sizeof(struct resource) * p->num_per_res);
+
+ pdev = platform_device_register_resndata(gpmc->dev, p->name, p->id,
+ res, num, p->pdata, p->pdata_size);
+
+ devm_kfree(gpmc->dev, res);
+
+ return pdev;
}
-postcore_initcall(gpmc_init);
static irqreturn_t gpmc_handle_irq(int irq, void *dev)
{
- u8 cs;
+ int i;
+ u32 regval;
+ struct gpmc *gpmc = dev;
- /* check cs to invoke the irq */
- cs = ((gpmc_read_reg(GPMC_PREFETCH_CONFIG1)) >> CS_NUM_SHIFT) & 0x7;
- if (OMAP_GPMC_IRQ_BASE+cs <= OMAP_GPMC_IRQ_END)
- generic_handle_irq(OMAP_GPMC_IRQ_BASE+cs);
+ regval = gpmc_read_reg(GPMC_IRQSTATUS);
+
+
+ for (i = 0; i < gpmc->num_irq; i++)
+ if (regval & gpmc->irq[i].regval)
+ generic_handle_irq(gpmc->irq[i].irq);
+ gpmc_write_reg(GPMC_IRQSTATUS, regval);
return IRQ_HANDLED;
}
+static int gpmc_irq_endis(struct irq_data *p, bool endis)
+{
+ struct gpmc *gpmc = irq_data_get_irq_chip_data(p);
+ int i;
+ u32 regval;
+
+ for (i = 0; i < gpmc->num_irq; i++)
+ if (p->irq == gpmc->irq[i].irq) {
+ regval = gpmc_read_reg(GPMC_IRQENABLE);
+ if (endis)
+ regval |= gpmc->irq[i].regval;
+ else
+ regval &= ~gpmc->irq[i].regval;
+ gpmc_write_reg(GPMC_IRQENABLE, regval);
+ break;
+ }
+
+ return 0;
+}
+
+static void gpmc_irq_disable(struct irq_data *p)
+{
+ gpmc_irq_endis(p, false);
+}
+
+static void gpmc_irq_enable(struct irq_data *p)
+{
+ gpmc_irq_endis(p, true);
+}
+
+static void gpmc_irq_noop(struct irq_data *data) { }
+
+static unsigned int gpmc_irq_noop_ret(struct irq_data *data) { return 0; }
+
+static __devinit int gpmc_setup_irq(struct gpmc *gpmc)
+{
+ int i;
+ u32 regval;
+
+ if (!gpmc->master_irq)
+ return -EINVAL;
+
+ if (gpmc->num_irq < GPMC_NR_IRQ) {
+ dev_warn(gpmc->dev, "Insufficient interrupts for device\n");
+ return -EINVAL;
+ } else if (gpmc->num_irq > GPMC_NR_IRQ)
+ gpmc->num_irq = GPMC_NR_IRQ;
+
+ gpmc->irq[0].regval = GPMC_IRQ_FIFOEVENT;
+ gpmc->irq[1].regval = GPMC_IRQ_TERMINALCOUNT;
+ gpmc->irq[2].regval = GPMC_IRQ_WAIT0EDGEDETECTION;
+ gpmc->irq[3].regval = GPMC_IRQ_WAIT1EDGEDETECTION;
+ gpmc->irq[4].regval = GPMC_IRQ_WAIT2EDGEDETECTION;
+ gpmc->irq[5].regval = GPMC_IRQ_WAIT3EDGEDETECTION;
+
+ for (i = 0; i < gpmc->num_irq; i++)
+ gpmc->irq[i].irq = gpmc->irq_start + i;
+
+ gpmc->irq_chip.name = "gpmc";
+ gpmc->irq_chip.irq_startup = gpmc_irq_noop_ret;
+ gpmc->irq_chip.irq_enable = gpmc_irq_enable;
+ gpmc->irq_chip.irq_disable = gpmc_irq_disable;
+ gpmc->irq_chip.irq_shutdown = gpmc_irq_noop;
+ gpmc->irq_chip.irq_ack = gpmc_irq_noop;
+ gpmc->irq_chip.irq_mask = gpmc_irq_noop;
+ gpmc->irq_chip.irq_unmask = gpmc_irq_noop;
+
+ for (i = 0; i < gpmc->num_irq; i++) {
+ irq_set_chip_and_handler(gpmc->irq[i].irq,
+ &gpmc->irq_chip, handle_simple_irq);
+ irq_set_chip_data(gpmc->irq[i].irq, gpmc);
+ set_irq_flags(gpmc->irq[i].irq, IRQF_VALID | IRQF_NOAUTOEN);
+ }
+
+ /* clear interrupts */
+ regval = gpmc_read_reg(GPMC_IRQSTATUS);
+ gpmc_write_reg(GPMC_IRQSTATUS, regval);
+
+ return request_irq(gpmc->master_irq, gpmc_handle_irq, IRQF_SHARED,
+ "gpmc", gpmc);
+}
+
+static __devinit int gpmc_probe(struct platform_device *pdev)
+{
+ u32 l;
+ int i;
+ int ret = 0;
+ struct resource *res = NULL;
+ struct gpmc_pdata *gp = dev_get_platdata(&pdev->dev);
+ struct gpmc_device_pdata **gdq = NULL;
+ struct gpmc_device *gd = NULL;
+
+ gpmc = devm_kzalloc(&pdev->dev, sizeof(struct gpmc), GFP_KERNEL);
+ if (gpmc == NULL)
+ return -ENOMEM;
+
+ gpmc->dev = &pdev->dev;
+ gpmc->fclk_period = gp->fclk_period;
+
+ res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+ if (res == NULL)
+ return -ENOENT;
+
+ gpmc->phys_base = res->start;
+ gpmc->memsize = resource_size(res);
+
+ gpmc->io_base = devm_request_and_ioremap(gpmc->dev, res);
+ if (!gpmc->io_base)
+ return -EADDRNOTAVAIL;
+
+ res = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
+ if (res == NULL)
+ dev_warn(gpmc->dev, "Failed to get resource: irq\n");
+ else
+ gpmc->master_irq = res->start;
+
+ gpmc->irq_start = gp->irq_start;
+ gpmc->num_irq = gp->num_irq;
+ gpmc_setup_irq(gpmc);
+
+ gpmc->ecc_used = -EINVAL;
+ spin_lock_init(&gpmc->mem_lock);
+ platform_set_drvdata(pdev, gpmc);
+
+ l = gpmc_read_reg(GPMC_REVISION);
+ dev_info(gpmc->dev, "GPMC revision %d.%d\n", (l >> 4) & 0x0f, l & 0x0f);
+
+ gpmc_mem_init();
+
+ for (gdq = gp->device_pdata, gd = gpmc->device; *gdq; gdq++, i++) {
+ ret = gpmc_setup_device(*gdq, gd, gpmc);
+ if (IS_ERR_VALUE(ret))
+ dev_err(gpmc->dev, "gpmc setup on %s failed\n",
+ (*gdq)->name);
+ else
+ gd++;
+ }
+ gpmc->num_device = gd - gpmc->device;
+
+ for (i = 0, gd = gpmc->device; i < gpmc->num_device; i++, gd++)
+ if (IS_ERR(gpmc_create_device(gd, gpmc)))
+ dev_err(gpmc->dev, "device creation on %s failed\n",
+ gd->name);
+
+ return 0;
+}
+
+static __devexit int gpmc_free_irq(struct gpmc *gpmc)
+{
+ /* TODO: free gpmc irq chip */
+
+ if (gpmc->master_irq)
+ free_irq(gpmc->master_irq, gpmc);
+
+ return 0;
+}
+
+static __devexit int gpmc_remove(struct platform_device *pdev)
+{
+ struct gpmc *gpmc = platform_get_drvdata(pdev);
+
+ platform_set_drvdata(pdev, NULL);
+ gpmc_free_irq(gpmc);
+
+ return 0;
+}
+
+static struct platform_driver gpmc_driver = {
+ .probe = gpmc_probe,
+ .remove = __devexit_p(gpmc_remove),
+ .driver = {
+ .name = DRIVER_NAME,
+ .owner = THIS_MODULE,
+ },
+};
+
+module_platform_driver(gpmc_driver);
+
#ifdef CONFIG_ARCH_OMAP3
static struct omap3_gpmc_regs gpmc_context;
@@ -855,10 +1193,10 @@ int gpmc_enable_hwecc(int cs, int mode, int dev_width, int ecc_size)
unsigned int val;
/* check if ecc module is in used */
- if (gpmc_ecc_used != -EINVAL)
+ if (gpmc->ecc_used != -EINVAL)
return -EINVAL;
- gpmc_ecc_used = cs;
+ gpmc->ecc_used = cs;
/* clear ecc and enable bits */
val = ((0x00000001<<8) | 0x00000001);
@@ -906,7 +1244,7 @@ int gpmc_calculate_ecc(int cs, const u_char *dat, u_char *ecc_code)
{
unsigned int val = 0x0;
- if (gpmc_ecc_used != cs)
+ if (gpmc->ecc_used != cs)
return -EINVAL;
/* read ecc result */
@@ -916,7 +1254,7 @@ int gpmc_calculate_ecc(int cs, const u_char *dat, u_char *ecc_code)
/* P2048o, P1024o, P512o, P256o, P2048e, P1024e, P512e, P256e */
*ecc_code++ = ((val >> 8) & 0x0f) | ((val >> 20) & 0xf0);
- gpmc_ecc_used = -EINVAL;
+ gpmc->ecc_used = -EINVAL;
return 0;
}
EXPORT_SYMBOL_GPL(gpmc_calculate_ecc);
diff --git a/arch/arm/plat-omap/include/plat/gpmc.h b/arch/arm/plat-omap/include/plat/gpmc.h
index 1527929..fa62cdf 100644
--- a/arch/arm/plat-omap/include/plat/gpmc.h
+++ b/arch/arm/plat-omap/include/plat/gpmc.h
@@ -36,6 +36,7 @@
#define GPMC_PREFETCH_FIFO_CNT 0x00000007 /* bytes available in FIFO for r/w */
#define GPMC_PREFETCH_COUNT 0x00000008 /* remaining bytes to be read/write*/
#define GPMC_STATUS_BUFFER 0x00000009 /* 1: buffer is available to write */
+#define GPMC_CONFIG_WAITPIN 0x0000000A
#define GPMC_NAND_COMMAND 0x0000000a
#define GPMC_NAND_ADDRESS 0x0000000b
@@ -83,6 +84,17 @@
#define GPMC_IRQ_FIFOEVENTENABLE 0x01
#define GPMC_IRQ_COUNT_EVENT 0x02
+#define GPMC_IRQ_FIFOEVENT BIT(0)
+#define GPMC_IRQ_TERMINALCOUNT BIT(1)
+#define GPMC_IRQ_WAIT0EDGEDETECTION BIT(8)
+#define GPMC_IRQ_WAIT1EDGEDETECTION BIT(9)
+#define GPMC_IRQ_WAIT2EDGEDETECTION BIT(10)
+#define GPMC_IRQ_WAIT3EDGEDETECTION BIT(11)
+#define GPMC_IRQ_MASK \
+ (GPMC_IRQ_FIFOEVENT | GPMC_IRQ_TERMINALCOUNT | \
+ GPMC_IRQ_WAIT0EDGEDETECTION | GPMC_IRQ_WAIT1EDGEDETECTION | \
+ GPMC_IRQ_WAIT2EDGEDETECTION | GPMC_IRQ_WAIT3EDGEDETECTION)
+
#define PREFETCH_FIFOTHRESHOLD_MAX 0x40
#define PREFETCH_FIFOTHRESHOLD(val) ((val) << 8)
@@ -131,6 +143,42 @@ struct gpmc_timings {
u16 wr_data_mux_bus; /* WRDATAONADMUXBUS */
};
+struct gpmc_config {
+ int cmd;
+ int val;
+};
+
+struct gpmc_cs_data {
+ unsigned cs;
+ unsigned long mem_size;
+ unsigned long mem_start;
+ unsigned long mem_offset;
+ struct gpmc_config *config;
+ unsigned num_config;
+ struct gpmc_timings *timing;
+ unsigned irq_flags;
+};
+
+struct gpmc_device_pdata {
+ char *name;
+ int id;
+ void *pdata;
+ unsigned pdata_size;
+ /* resources configured via GPMC will be created by GPMC driver */
+ struct resource *per_res;
+ unsigned num_per_res;
+ struct gpmc_cs_data *cs_data;
+ unsigned num_cs;
+};
+
+struct gpmc_pdata {
+ /* GPMC_FCLK period in picoseconds */
+ unsigned long fclk_period;
+ struct gpmc_device_pdata **device_pdata;
+ unsigned irq_start;
+ unsigned num_irq;
+};
+
extern unsigned int gpmc_ns_to_ticks(unsigned int time_ns);
extern unsigned int gpmc_ps_to_ticks(unsigned int time_ps);
extern unsigned int gpmc_ticks_to_ns(unsigned int ticks);
@@ -143,8 +191,6 @@ extern int gpmc_cs_calc_divider(int cs, unsigned int sync_clk);
extern int gpmc_cs_set_timings(int cs, const struct gpmc_timings *t);
extern int gpmc_cs_request(int cs, unsigned long size, unsigned long *base);
extern void gpmc_cs_free(int cs);
-extern int gpmc_cs_set_reserved(int cs, int reserved);
-extern int gpmc_cs_reserved(int cs);
extern int gpmc_prefetch_enable(int cs, int fifo_th, int dma_mode,
unsigned int u32_count, int is_write);
extern int gpmc_prefetch_reset(int cs);
--
1.7.9.3
^ permalink raw reply related [flat|nested] 73+ messages in thread
* [PATCH v3 1/9] ARM: OMAP2+: gpmc: driver conversion
@ 2012-04-05 15:45 ` Afzal Mohammed
0 siblings, 0 replies; 73+ messages in thread
From: Afzal Mohammed @ 2012-04-05 15:45 UTC (permalink / raw)
To: tony, khilman, linux, dwmw2, sameo, grinberg, mike, nm,
artem.bityutskiy, vimal.newwork, dbaryshkov, linux-omap,
linux-arm-kernel, linux-mtd, linux-kernel
Cc: Afzal Mohammed, Jon Hunter, Vaibhav Hiremath
Convert GPMC code to driver. Boards using GPMC should provide driver
with type of configuration, timing, CS, GPMC address space details
(if already configured, driver will retrieve, as is existing).
Platform devices would the be created for each connected peripheral
(details also to be passed by board so that it reaches respective
driver). And GPMC driver would populate memory resource details for
the driver of connected peripheral.
A peripheral connected to GPMC can have multiple address spaces using
different chip select. Hence GPMC driver has been provided capability
to create platform device for peripheral using mutiple CS. The
peripheral that made it necessary was tusb6010. Thanks to Jon Hunter
for his suggesstion on better way to handle this.
Interrupts of GPMC are presented to drivers of connected peripherals
as resource. A fictitious interrupt controller chip handles these
interrupts at GPMC hardware level. Clients can use normal interrupt
APIs. Platforms should inform GPMC driver infrastruture available
for these imaginary client interrupts (like irq number). Platform
information of peripheral passed to GPMC driver should indicate
interrupts to be used via flags.
Final destination for this driver is being investigated. Before moving
to the new location, all existing GPMC users has to be converted to
work with this driver.
NAND driver for NAND used via GPMC is tightly coupled with GPMC
driver (GPMC has few blocks exclusively for NAND), while that is not
the case for most of the other users (they need GPMCs help only for
initial configuration). Currently NAND driver manage using exported
GPMC symbols. This is being planned to remove later & would need
informing NAND driver about GPMC NAND registers. This would help to
have export symbol free GPMC driver, and probably
"mv omap2.c gpmc-nand.c" for OMAP NAND driver.
Thanks to Vaibhav Hiremath for his ideas on this.
Acquiring CS# for NAND is done on a few boards. It means, depending
on bootloader to embed this information. Probably CS# being used can
be set in the Kernel, and acquiring it can be removed. If ever this
capbility is needed, GPMC driver has to be made aware of handling it.
OneNAND - as it may involve reconfiguring GPMC for synchronous may
need a quirk to handle or driver has to be made more intelligent to
handle it.
Code related to GPMC clock may have to continue live in platform
folders (even if the driver is moved to MFD) as input clock is beyond
the control of GPMC and calculating timing for the peripheral may
need other helpers.
Cc: Vaibhav Hiremath <hvaibhav@ti.com>
Cc: Jon Hunter <jon-hunter@ti.com>
Signed-off-by: Afzal Mohammed <afzal@ti.com>
---
arch/arm/mach-omap2/gpmc.c | 518 ++++++++++++++++++++++++++------
arch/arm/plat-omap/include/plat/gpmc.h | 50 ++-
2 files changed, 476 insertions(+), 92 deletions(-)
diff --git a/arch/arm/mach-omap2/gpmc.c b/arch/arm/mach-omap2/gpmc.c
index 00d5108..cf5d8f3 100644
--- a/arch/arm/mach-omap2/gpmc.c
+++ b/arch/arm/mach-omap2/gpmc.c
@@ -14,8 +14,11 @@
*/
#undef DEBUG
+#include <linux/platform_device.h>
+
#include <linux/irq.h>
#include <linux/kernel.h>
+#include <linux/slab.h>
#include <linux/init.h>
#include <linux/err.h>
#include <linux/clk.h>
@@ -64,6 +67,47 @@
#define ENABLE_PREFETCH (0x1 << 7)
#define DMA_MPU_MODE 2
+#define DRIVER_NAME "omap-gpmc"
+
+#define GPMC_NR_IRQ 6
+
+struct gpmc_device {
+ char *name;
+ int id;
+ void *pdata;
+ unsigned pdata_size;
+ struct resource *per_res;
+ unsigned num_per_res;
+ struct resource *gpmc_res;
+ unsigned num_gpmc_res;
+};
+
+struct gpmc_irq {
+ unsigned irq;
+ u32 regval;
+};
+
+struct gpmc {
+ struct device *dev;
+ unsigned long fclk_period;
+ void __iomem *io_base;
+ unsigned long phys_base;
+ u32 memsize;
+ unsigned cs_map;
+ int ecc_used;
+ spinlock_t mem_lock;
+ struct resource mem_root;
+ struct resource cs_mem[GPMC_CS_NUM];
+ /* XXX: Or allocate dynamically ? */
+ struct gpmc_device device[GPMC_CS_NUM];
+ unsigned num_device;
+ unsigned master_irq;
+ unsigned irq_start;
+ unsigned num_irq;
+ struct gpmc_irq irq[GPMC_NR_IRQ];
+ struct irq_chip irq_chip;
+};
+
/* Structure to save gpmc cs context */
struct gpmc_cs_config {
u32 config1;
@@ -91,58 +135,50 @@ struct omap3_gpmc_regs {
struct gpmc_cs_config cs_context[GPMC_CS_NUM];
};
-static struct resource gpmc_mem_root;
-static struct resource gpmc_cs_mem[GPMC_CS_NUM];
-static DEFINE_SPINLOCK(gpmc_mem_lock);
-static unsigned int gpmc_cs_map; /* flag for cs which are initialized */
-static int gpmc_ecc_used = -EINVAL; /* cs using ecc engine */
-
-static void __iomem *gpmc_base;
-
static struct clk *gpmc_l3_clk;
-static irqreturn_t gpmc_handle_irq(int irq, void *dev);
+static struct gpmc *gpmc;
static void gpmc_write_reg(int idx, u32 val)
{
- __raw_writel(val, gpmc_base + idx);
+ writel(val, gpmc->io_base + idx);
}
static u32 gpmc_read_reg(int idx)
{
- return __raw_readl(gpmc_base + idx);
+ return readl(gpmc->io_base + idx);
}
static void gpmc_cs_write_byte(int cs, int idx, u8 val)
{
void __iomem *reg_addr;
- reg_addr = gpmc_base + GPMC_CS0_OFFSET + (cs * GPMC_CS_SIZE) + idx;
- __raw_writeb(val, reg_addr);
+ reg_addr = gpmc->io_base + GPMC_CS0_OFFSET + (cs * GPMC_CS_SIZE) + idx;
+ writeb(val, reg_addr);
}
static u8 gpmc_cs_read_byte(int cs, int idx)
{
void __iomem *reg_addr;
- reg_addr = gpmc_base + GPMC_CS0_OFFSET + (cs * GPMC_CS_SIZE) + idx;
- return __raw_readb(reg_addr);
+ reg_addr = gpmc->io_base + GPMC_CS0_OFFSET + (cs * GPMC_CS_SIZE) + idx;
+ return readb(reg_addr);
}
void gpmc_cs_write_reg(int cs, int idx, u32 val)
{
void __iomem *reg_addr;
- reg_addr = gpmc_base + GPMC_CS0_OFFSET + (cs * GPMC_CS_SIZE) + idx;
- __raw_writel(val, reg_addr);
+ reg_addr = gpmc->io_base + GPMC_CS0_OFFSET + (cs * GPMC_CS_SIZE) + idx;
+ writel(val, reg_addr);
}
u32 gpmc_cs_read_reg(int cs, int idx)
{
void __iomem *reg_addr;
- reg_addr = gpmc_base + GPMC_CS0_OFFSET + (cs * GPMC_CS_SIZE) + idx;
- return __raw_readl(reg_addr);
+ reg_addr = gpmc->io_base + GPMC_CS0_OFFSET + (cs * GPMC_CS_SIZE) + idx;
+ return readl(reg_addr);
}
/* TODO: Add support for gpmc_fck to clock framework and use it */
@@ -332,7 +368,7 @@ static void gpmc_cs_disable_mem(int cs)
gpmc_cs_write_reg(cs, GPMC_CS_CONFIG7, l);
}
-static void gpmc_cs_get_memconf(int cs, u32 *base, u32 *size)
+static __devinit void gpmc_cs_get_memconf(int cs, u32 *base, u32 *size)
{
u32 l;
u32 mask;
@@ -351,23 +387,23 @@ static int gpmc_cs_mem_enabled(int cs)
return l & GPMC_CONFIG7_CSVALID;
}
-int gpmc_cs_set_reserved(int cs, int reserved)
+static int gpmc_cs_set_reserved(int cs, int reserved)
{
if (cs > GPMC_CS_NUM)
return -ENODEV;
- gpmc_cs_map &= ~(1 << cs);
- gpmc_cs_map |= (reserved ? 1 : 0) << cs;
+ gpmc->cs_map &= ~(1 << cs);
+ gpmc->cs_map |= (reserved ? 1 : 0) << cs;
return 0;
}
-int gpmc_cs_reserved(int cs)
+static int gpmc_cs_reserved(int cs)
{
if (cs > GPMC_CS_NUM)
return -ENODEV;
- return gpmc_cs_map & (1 << cs);
+ return gpmc->cs_map & (1 << cs);
}
static unsigned long gpmc_mem_align(unsigned long size)
@@ -384,24 +420,25 @@ static unsigned long gpmc_mem_align(unsigned long size)
return size;
}
-static int gpmc_cs_insert_mem(int cs, unsigned long base, unsigned long size)
+static __devinit
+int gpmc_cs_insert_mem(int cs, unsigned long base, unsigned long size)
{
- struct resource *res = &gpmc_cs_mem[cs];
+ struct resource *res = &gpmc->cs_mem[cs];
int r;
size = gpmc_mem_align(size);
- spin_lock(&gpmc_mem_lock);
+ spin_lock(&gpmc->mem_lock);
res->start = base;
res->end = base + size - 1;
- r = request_resource(&gpmc_mem_root, res);
- spin_unlock(&gpmc_mem_lock);
+ r = request_resource(&gpmc->mem_root, res);
+ spin_unlock(&gpmc->mem_lock);
return r;
}
int gpmc_cs_request(int cs, unsigned long size, unsigned long *base)
{
- struct resource *res = &gpmc_cs_mem[cs];
+ struct resource *res = &gpmc->cs_mem[cs];
int r = -1;
if (cs > GPMC_CS_NUM)
@@ -411,7 +448,7 @@ int gpmc_cs_request(int cs, unsigned long size, unsigned long *base)
if (size > (1 << GPMC_SECTION_SHIFT))
return -ENOMEM;
- spin_lock(&gpmc_mem_lock);
+ spin_lock(&gpmc->mem_lock);
if (gpmc_cs_reserved(cs)) {
r = -EBUSY;
goto out;
@@ -419,7 +456,7 @@ int gpmc_cs_request(int cs, unsigned long size, unsigned long *base)
if (gpmc_cs_mem_enabled(cs))
r = adjust_resource(res, res->start & ~(size - 1), size);
if (r < 0)
- r = allocate_resource(&gpmc_mem_root, res, size, 0, ~0,
+ r = allocate_resource(&gpmc->mem_root, res, size, 0, ~0,
size, NULL, NULL);
if (r < 0)
goto out;
@@ -428,24 +465,24 @@ int gpmc_cs_request(int cs, unsigned long size, unsigned long *base)
*base = res->start;
gpmc_cs_set_reserved(cs, 1);
out:
- spin_unlock(&gpmc_mem_lock);
+ spin_unlock(&gpmc->mem_lock);
return r;
}
EXPORT_SYMBOL(gpmc_cs_request);
void gpmc_cs_free(int cs)
{
- spin_lock(&gpmc_mem_lock);
+ spin_lock(&gpmc->mem_lock);
if (cs >= GPMC_CS_NUM || cs < 0 || !gpmc_cs_reserved(cs)) {
printk(KERN_ERR "Trying to free non-reserved GPMC CS%d\n", cs);
BUG();
- spin_unlock(&gpmc_mem_lock);
+ spin_unlock(&gpmc->mem_lock);
return;
}
gpmc_cs_disable_mem(cs);
- release_resource(&gpmc_cs_mem[cs]);
+ release_resource(&gpmc->cs_mem[cs]);
gpmc_cs_set_reserved(cs, 0);
- spin_unlock(&gpmc_mem_lock);
+ spin_unlock(&gpmc->mem_lock);
}
EXPORT_SYMBOL(gpmc_cs_free);
@@ -546,6 +583,12 @@ int gpmc_cs_configure(int cs, int cmd, int wval)
gpmc_cs_write_reg(cs, GPMC_CS_CONFIG1, regval);
break;
+ case GPMC_CONFIG_WAITPIN:
+ regval = gpmc_cs_read_reg(cs, GPMC_CS_CONFIG1);
+ regval |= GPMC_CONFIG1_WAIT_PIN_SEL(wval);
+ gpmc_cs_write_reg(cs, GPMC_CS_CONFIG1, regval);
+ break;
+
default:
printk(KERN_ERR "gpmc_configure_cs: Not supported\n");
err = -EINVAL;
@@ -668,7 +711,7 @@ int gpmc_prefetch_reset(int cs)
}
EXPORT_SYMBOL(gpmc_prefetch_reset);
-static void __init gpmc_mem_init(void)
+static __devinit void gpmc_mem_init(void)
{
int cs;
unsigned long boot_rom_space = 0;
@@ -680,8 +723,8 @@ static void __init gpmc_mem_init(void)
/* In apollon the CS0 is mapped as 0x0000 0000 */
if (machine_is_omap_apollon())
boot_rom_space = 0;
- gpmc_mem_root.start = GPMC_MEM_START + boot_rom_space;
- gpmc_mem_root.end = GPMC_MEM_END;
+ gpmc->mem_root.start = GPMC_MEM_START + boot_rom_space;
+ gpmc->mem_root.end = GPMC_MEM_END;
/* Reserve all regions that has been set up by bootloader */
for (cs = 0; cs < GPMC_CS_NUM; cs++) {
@@ -697,26 +740,15 @@ static void __init gpmc_mem_init(void)
static int __init gpmc_init(void)
{
- u32 l, irq;
- int cs, ret = -EINVAL;
- int gpmc_irq;
+ int ret = -EINVAL;
char *ck = NULL;
if (cpu_is_omap24xx()) {
ck = "core_l3_ck";
- if (cpu_is_omap2420())
- l = OMAP2420_GPMC_BASE;
- else
- l = OMAP34XX_GPMC_BASE;
- gpmc_irq = INT_34XX_GPMC_IRQ;
} else if (cpu_is_omap34xx()) {
ck = "gpmc_fck";
- l = OMAP34XX_GPMC_BASE;
- gpmc_irq = INT_34XX_GPMC_IRQ;
} else if (cpu_is_omap44xx()) {
ck = "gpmc_ck";
- l = OMAP44XX_GPMC_BASE;
- gpmc_irq = OMAP44XX_IRQ_GPMC;
}
if (WARN_ON(!ck))
@@ -728,54 +760,360 @@ static int __init gpmc_init(void)
BUG();
}
- gpmc_base = ioremap(l, SZ_4K);
- if (!gpmc_base) {
- clk_put(gpmc_l3_clk);
- printk(KERN_ERR "Could not get GPMC register memory\n");
- BUG();
+ clk_enable(gpmc_l3_clk);
+
+ return 0;
+}
+postcore_initcall(gpmc_init);
+
+static __devinit struct resource gpmc_setup_cs_mem(struct gpmc_cs_data *p,
+ struct gpmc_device_pdata *gdp, struct gpmc *gpmc)
+{
+ int i, ret;
+ struct gpmc_config *c;
+ struct resource res;
+ unsigned long start;
+
+ res.flags = 0x0;
+ start = p->mem_start;
+
+ ret = gpmc_cs_request(p->cs, p->mem_size, &start);
+ if (IS_ERR_VALUE(ret)) {
+ dev_err(gpmc->dev, "error: gpmc request on CS: %u\n", p->cs);
+ return res;
}
- clk_enable(gpmc_l3_clk);
+ c = p->config;
+ if (!c)
+ dev_warn(gpmc->dev, "config not present for CS: %u\n", p->cs);
+
+ for (i = 0; i < p->num_config; c++, i++) {
+ /* XXX: check for non-NULL c ? */
+ ret = gpmc_cs_configure(p->cs, c->cmd, c->val);
+ if (IS_ERR_VALUE(ret)) {
+ dev_err(gpmc->dev, "invalid cmd or value on CS: \
+ %u: cmd: %d value: %d\n", p->cs, c->cmd, c->val);
+ return res;
+ }
+ }
- l = gpmc_read_reg(GPMC_REVISION);
- printk(KERN_INFO "GPMC revision %d.%d\n", (l >> 4) & 0x0f, l & 0x0f);
- /* Set smart idle mode and automatic L3 clock gating */
- l = gpmc_read_reg(GPMC_SYSCONFIG);
- l &= 0x03 << 3;
- l |= (0x02 << 3) | (1 << 0);
- gpmc_write_reg(GPMC_SYSCONFIG, l);
- gpmc_mem_init();
+ if (p->timing) {
+ ret = gpmc_cs_set_timings(p->cs, p->timing);
+ if (IS_ERR_VALUE(ret)) {
+ dev_err(gpmc->dev, "error: setting timing on CS: %d\n",
+ p->cs);
+ return res;
+ }
+ } else
+ dev_warn(gpmc->dev, "timing not present for CS: %u\n", p->cs);
- /* initalize the irq_chained */
- irq = OMAP_GPMC_IRQ_BASE;
- for (cs = 0; cs < GPMC_CS_NUM; cs++) {
- irq_set_chip_and_handler(irq, &dummy_irq_chip,
- handle_simple_irq);
- set_irq_flags(irq, IRQF_VALID);
- irq++;
+ res.start = start + p->mem_offset;
+ res.end = res.start + p->mem_size - 1;
+ res.flags = IORESOURCE_MEM;
+
+ dev_info(gpmc->dev, "resource memory 0x%x-0x%x for %s (on CS %d)\n",
+ res.start, res.end, gdp->name, p->cs);
+
+ return res;
+}
+
+static __devinit
+int gpmc_setup_cs_irq(struct gpmc *gpmc, struct gpmc_device_pdata *gdp,
+ struct gpmc_cs_data *cs, struct resource *res)
+{
+ int i, n, val;
+
+ for (i = 0, n = 0; i < gpmc->num_irq; i++)
+ if (gpmc->irq[i].regval & cs->irq_flags) {
+ res[n].start = res[n].end = gpmc->irq[i].irq;
+ res[n].flags = IORESOURCE_IRQ;
+
+ dev_info(gpmc->dev, "resource irq %u for %s "
+ "(on CS %d) [bit: %x]\n", res[n].start,
+ gdp->name, cs->cs, __ffs(gpmc->irq[i].regval));
+
+ switch (gpmc->irq[i].regval) {
+ case GPMC_IRQ_WAIT0EDGEDETECTION:
+ case GPMC_IRQ_WAIT1EDGEDETECTION:
+ case GPMC_IRQ_WAIT2EDGEDETECTION:
+ case GPMC_IRQ_WAIT3EDGEDETECTION:
+ val = __ffs(gpmc->irq[i].regval);
+ val -= __ffs(GPMC_IRQ_WAIT0EDGEDETECTION);
+ gpmc_cs_configure(cs->cs,
+ GPMC_CONFIG_WAITPIN, val);
+ }
+ n++;
+ }
+
+ return n;
+}
+
+static __devinit int gpmc_setup_device(struct gpmc_device_pdata *gdp,
+ struct gpmc_device *dev, struct gpmc *gpmc)
+{
+ int i, j, n;
+ struct gpmc_cs_data *cs;
+
+ for (i = 0, n = 0, cs = gdp->cs_data; i < gdp->num_cs; i++, cs++)
+ n += hweight32(cs->irq_flags & GPMC_IRQ_MASK);
+
+ n += gdp->num_cs;
+
+ dev->gpmc_res = devm_kzalloc(gpmc->dev, sizeof(*dev->gpmc_res) * n,
+ GFP_KERNEL);
+ if (dev->gpmc_res == NULL) {
+ dev_err(gpmc->dev, "error: memory allocation\n");
+ return -ENOMEM;
+ }
+
+ for (i = 0, j = 0, cs = gdp->cs_data; i < gdp->num_cs; cs++, i++) {
+ dev->gpmc_res[j] = gpmc_setup_cs_mem(cs, gdp, gpmc);
+ if (dev->gpmc_res[j++].flags & IORESOURCE_MEM)
+ j += gpmc_setup_cs_irq(gpmc, gdp, cs,
+ dev->gpmc_res + j);
+ else {
+ dev_err(gpmc->dev, "error: setup for %s\n", gdp->name);
+ devm_kfree(gpmc->dev, dev->gpmc_res);
+ dev->gpmc_res = NULL;
+ dev->num_gpmc_res = 0;
+ return -EINVAL;
+ }
}
+ dev->num_gpmc_res = j;
- ret = request_irq(gpmc_irq,
- gpmc_handle_irq, IRQF_SHARED, "gpmc", gpmc_base);
- if (ret)
- pr_err("gpmc: irq-%d could not claim: err %d\n",
- gpmc_irq, ret);
- return ret;
+ dev->name = gdp->name;
+ dev->id = gdp->id;
+ dev->pdata = gdp->pdata;
+ dev->pdata_size = gdp->pdata_size;
+ dev->per_res = gdp->per_res;
+ dev->num_per_res = gdp->num_per_res;
+
+ return 0;
+}
+
+static __devinit
+struct platform_device *gpmc_create_device(struct gpmc_device *p,
+ struct gpmc *gpmc)
+{
+ int num = p->num_per_res + p->num_gpmc_res;
+ struct resource *res;
+ struct platform_device *pdev;
+
+ res = devm_kzalloc(gpmc->dev, sizeof(struct resource) * num,
+ GFP_KERNEL);
+ if (!res) {
+ dev_err(gpmc->dev, "error: allocating memory\n");
+ return NULL;
+ }
+
+ memcpy((char *)res, (const char *) p->gpmc_res,
+ sizeof(struct resource) * p->num_gpmc_res);
+ memcpy((char *)(res + p->num_gpmc_res), (const char *)p->per_res,
+ sizeof(struct resource) * p->num_per_res);
+
+ pdev = platform_device_register_resndata(gpmc->dev, p->name, p->id,
+ res, num, p->pdata, p->pdata_size);
+
+ devm_kfree(gpmc->dev, res);
+
+ return pdev;
}
-postcore_initcall(gpmc_init);
static irqreturn_t gpmc_handle_irq(int irq, void *dev)
{
- u8 cs;
+ int i;
+ u32 regval;
+ struct gpmc *gpmc = dev;
- /* check cs to invoke the irq */
- cs = ((gpmc_read_reg(GPMC_PREFETCH_CONFIG1)) >> CS_NUM_SHIFT) & 0x7;
- if (OMAP_GPMC_IRQ_BASE+cs <= OMAP_GPMC_IRQ_END)
- generic_handle_irq(OMAP_GPMC_IRQ_BASE+cs);
+ regval = gpmc_read_reg(GPMC_IRQSTATUS);
+
+
+ for (i = 0; i < gpmc->num_irq; i++)
+ if (regval & gpmc->irq[i].regval)
+ generic_handle_irq(gpmc->irq[i].irq);
+ gpmc_write_reg(GPMC_IRQSTATUS, regval);
return IRQ_HANDLED;
}
+static int gpmc_irq_endis(struct irq_data *p, bool endis)
+{
+ struct gpmc *gpmc = irq_data_get_irq_chip_data(p);
+ int i;
+ u32 regval;
+
+ for (i = 0; i < gpmc->num_irq; i++)
+ if (p->irq == gpmc->irq[i].irq) {
+ regval = gpmc_read_reg(GPMC_IRQENABLE);
+ if (endis)
+ regval |= gpmc->irq[i].regval;
+ else
+ regval &= ~gpmc->irq[i].regval;
+ gpmc_write_reg(GPMC_IRQENABLE, regval);
+ break;
+ }
+
+ return 0;
+}
+
+static void gpmc_irq_disable(struct irq_data *p)
+{
+ gpmc_irq_endis(p, false);
+}
+
+static void gpmc_irq_enable(struct irq_data *p)
+{
+ gpmc_irq_endis(p, true);
+}
+
+static void gpmc_irq_noop(struct irq_data *data) { }
+
+static unsigned int gpmc_irq_noop_ret(struct irq_data *data) { return 0; }
+
+static __devinit int gpmc_setup_irq(struct gpmc *gpmc)
+{
+ int i;
+ u32 regval;
+
+ if (!gpmc->master_irq)
+ return -EINVAL;
+
+ if (gpmc->num_irq < GPMC_NR_IRQ) {
+ dev_warn(gpmc->dev, "Insufficient interrupts for device\n");
+ return -EINVAL;
+ } else if (gpmc->num_irq > GPMC_NR_IRQ)
+ gpmc->num_irq = GPMC_NR_IRQ;
+
+ gpmc->irq[0].regval = GPMC_IRQ_FIFOEVENT;
+ gpmc->irq[1].regval = GPMC_IRQ_TERMINALCOUNT;
+ gpmc->irq[2].regval = GPMC_IRQ_WAIT0EDGEDETECTION;
+ gpmc->irq[3].regval = GPMC_IRQ_WAIT1EDGEDETECTION;
+ gpmc->irq[4].regval = GPMC_IRQ_WAIT2EDGEDETECTION;
+ gpmc->irq[5].regval = GPMC_IRQ_WAIT3EDGEDETECTION;
+
+ for (i = 0; i < gpmc->num_irq; i++)
+ gpmc->irq[i].irq = gpmc->irq_start + i;
+
+ gpmc->irq_chip.name = "gpmc";
+ gpmc->irq_chip.irq_startup = gpmc_irq_noop_ret;
+ gpmc->irq_chip.irq_enable = gpmc_irq_enable;
+ gpmc->irq_chip.irq_disable = gpmc_irq_disable;
+ gpmc->irq_chip.irq_shutdown = gpmc_irq_noop;
+ gpmc->irq_chip.irq_ack = gpmc_irq_noop;
+ gpmc->irq_chip.irq_mask = gpmc_irq_noop;
+ gpmc->irq_chip.irq_unmask = gpmc_irq_noop;
+
+ for (i = 0; i < gpmc->num_irq; i++) {
+ irq_set_chip_and_handler(gpmc->irq[i].irq,
+ &gpmc->irq_chip, handle_simple_irq);
+ irq_set_chip_data(gpmc->irq[i].irq, gpmc);
+ set_irq_flags(gpmc->irq[i].irq, IRQF_VALID | IRQF_NOAUTOEN);
+ }
+
+ /* clear interrupts */
+ regval = gpmc_read_reg(GPMC_IRQSTATUS);
+ gpmc_write_reg(GPMC_IRQSTATUS, regval);
+
+ return request_irq(gpmc->master_irq, gpmc_handle_irq, IRQF_SHARED,
+ "gpmc", gpmc);
+}
+
+static __devinit int gpmc_probe(struct platform_device *pdev)
+{
+ u32 l;
+ int i;
+ int ret = 0;
+ struct resource *res = NULL;
+ struct gpmc_pdata *gp = dev_get_platdata(&pdev->dev);
+ struct gpmc_device_pdata **gdq = NULL;
+ struct gpmc_device *gd = NULL;
+
+ gpmc = devm_kzalloc(&pdev->dev, sizeof(struct gpmc), GFP_KERNEL);
+ if (gpmc == NULL)
+ return -ENOMEM;
+
+ gpmc->dev = &pdev->dev;
+ gpmc->fclk_period = gp->fclk_period;
+
+ res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+ if (res == NULL)
+ return -ENOENT;
+
+ gpmc->phys_base = res->start;
+ gpmc->memsize = resource_size(res);
+
+ gpmc->io_base = devm_request_and_ioremap(gpmc->dev, res);
+ if (!gpmc->io_base)
+ return -EADDRNOTAVAIL;
+
+ res = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
+ if (res == NULL)
+ dev_warn(gpmc->dev, "Failed to get resource: irq\n");
+ else
+ gpmc->master_irq = res->start;
+
+ gpmc->irq_start = gp->irq_start;
+ gpmc->num_irq = gp->num_irq;
+ gpmc_setup_irq(gpmc);
+
+ gpmc->ecc_used = -EINVAL;
+ spin_lock_init(&gpmc->mem_lock);
+ platform_set_drvdata(pdev, gpmc);
+
+ l = gpmc_read_reg(GPMC_REVISION);
+ dev_info(gpmc->dev, "GPMC revision %d.%d\n", (l >> 4) & 0x0f, l & 0x0f);
+
+ gpmc_mem_init();
+
+ for (gdq = gp->device_pdata, gd = gpmc->device; *gdq; gdq++, i++) {
+ ret = gpmc_setup_device(*gdq, gd, gpmc);
+ if (IS_ERR_VALUE(ret))
+ dev_err(gpmc->dev, "gpmc setup on %s failed\n",
+ (*gdq)->name);
+ else
+ gd++;
+ }
+ gpmc->num_device = gd - gpmc->device;
+
+ for (i = 0, gd = gpmc->device; i < gpmc->num_device; i++, gd++)
+ if (IS_ERR(gpmc_create_device(gd, gpmc)))
+ dev_err(gpmc->dev, "device creation on %s failed\n",
+ gd->name);
+
+ return 0;
+}
+
+static __devexit int gpmc_free_irq(struct gpmc *gpmc)
+{
+ /* TODO: free gpmc irq chip */
+
+ if (gpmc->master_irq)
+ free_irq(gpmc->master_irq, gpmc);
+
+ return 0;
+}
+
+static __devexit int gpmc_remove(struct platform_device *pdev)
+{
+ struct gpmc *gpmc = platform_get_drvdata(pdev);
+
+ platform_set_drvdata(pdev, NULL);
+ gpmc_free_irq(gpmc);
+
+ return 0;
+}
+
+static struct platform_driver gpmc_driver = {
+ .probe = gpmc_probe,
+ .remove = __devexit_p(gpmc_remove),
+ .driver = {
+ .name = DRIVER_NAME,
+ .owner = THIS_MODULE,
+ },
+};
+
+module_platform_driver(gpmc_driver);
+
#ifdef CONFIG_ARCH_OMAP3
static struct omap3_gpmc_regs gpmc_context;
@@ -855,10 +1193,10 @@ int gpmc_enable_hwecc(int cs, int mode, int dev_width, int ecc_size)
unsigned int val;
/* check if ecc module is in used */
- if (gpmc_ecc_used != -EINVAL)
+ if (gpmc->ecc_used != -EINVAL)
return -EINVAL;
- gpmc_ecc_used = cs;
+ gpmc->ecc_used = cs;
/* clear ecc and enable bits */
val = ((0x00000001<<8) | 0x00000001);
@@ -906,7 +1244,7 @@ int gpmc_calculate_ecc(int cs, const u_char *dat, u_char *ecc_code)
{
unsigned int val = 0x0;
- if (gpmc_ecc_used != cs)
+ if (gpmc->ecc_used != cs)
return -EINVAL;
/* read ecc result */
@@ -916,7 +1254,7 @@ int gpmc_calculate_ecc(int cs, const u_char *dat, u_char *ecc_code)
/* P2048o, P1024o, P512o, P256o, P2048e, P1024e, P512e, P256e */
*ecc_code++ = ((val >> 8) & 0x0f) | ((val >> 20) & 0xf0);
- gpmc_ecc_used = -EINVAL;
+ gpmc->ecc_used = -EINVAL;
return 0;
}
EXPORT_SYMBOL_GPL(gpmc_calculate_ecc);
diff --git a/arch/arm/plat-omap/include/plat/gpmc.h b/arch/arm/plat-omap/include/plat/gpmc.h
index 1527929..fa62cdf 100644
--- a/arch/arm/plat-omap/include/plat/gpmc.h
+++ b/arch/arm/plat-omap/include/plat/gpmc.h
@@ -36,6 +36,7 @@
#define GPMC_PREFETCH_FIFO_CNT 0x00000007 /* bytes available in FIFO for r/w */
#define GPMC_PREFETCH_COUNT 0x00000008 /* remaining bytes to be read/write*/
#define GPMC_STATUS_BUFFER 0x00000009 /* 1: buffer is available to write */
+#define GPMC_CONFIG_WAITPIN 0x0000000A
#define GPMC_NAND_COMMAND 0x0000000a
#define GPMC_NAND_ADDRESS 0x0000000b
@@ -83,6 +84,17 @@
#define GPMC_IRQ_FIFOEVENTENABLE 0x01
#define GPMC_IRQ_COUNT_EVENT 0x02
+#define GPMC_IRQ_FIFOEVENT BIT(0)
+#define GPMC_IRQ_TERMINALCOUNT BIT(1)
+#define GPMC_IRQ_WAIT0EDGEDETECTION BIT(8)
+#define GPMC_IRQ_WAIT1EDGEDETECTION BIT(9)
+#define GPMC_IRQ_WAIT2EDGEDETECTION BIT(10)
+#define GPMC_IRQ_WAIT3EDGEDETECTION BIT(11)
+#define GPMC_IRQ_MASK \
+ (GPMC_IRQ_FIFOEVENT | GPMC_IRQ_TERMINALCOUNT | \
+ GPMC_IRQ_WAIT0EDGEDETECTION | GPMC_IRQ_WAIT1EDGEDETECTION | \
+ GPMC_IRQ_WAIT2EDGEDETECTION | GPMC_IRQ_WAIT3EDGEDETECTION)
+
#define PREFETCH_FIFOTHRESHOLD_MAX 0x40
#define PREFETCH_FIFOTHRESHOLD(val) ((val) << 8)
@@ -131,6 +143,42 @@ struct gpmc_timings {
u16 wr_data_mux_bus; /* WRDATAONADMUXBUS */
};
+struct gpmc_config {
+ int cmd;
+ int val;
+};
+
+struct gpmc_cs_data {
+ unsigned cs;
+ unsigned long mem_size;
+ unsigned long mem_start;
+ unsigned long mem_offset;
+ struct gpmc_config *config;
+ unsigned num_config;
+ struct gpmc_timings *timing;
+ unsigned irq_flags;
+};
+
+struct gpmc_device_pdata {
+ char *name;
+ int id;
+ void *pdata;
+ unsigned pdata_size;
+ /* resources configured via GPMC will be created by GPMC driver */
+ struct resource *per_res;
+ unsigned num_per_res;
+ struct gpmc_cs_data *cs_data;
+ unsigned num_cs;
+};
+
+struct gpmc_pdata {
+ /* GPMC_FCLK period in picoseconds */
+ unsigned long fclk_period;
+ struct gpmc_device_pdata **device_pdata;
+ unsigned irq_start;
+ unsigned num_irq;
+};
+
extern unsigned int gpmc_ns_to_ticks(unsigned int time_ns);
extern unsigned int gpmc_ps_to_ticks(unsigned int time_ps);
extern unsigned int gpmc_ticks_to_ns(unsigned int ticks);
@@ -143,8 +191,6 @@ extern int gpmc_cs_calc_divider(int cs, unsigned int sync_clk);
extern int gpmc_cs_set_timings(int cs, const struct gpmc_timings *t);
extern int gpmc_cs_request(int cs, unsigned long size, unsigned long *base);
extern void gpmc_cs_free(int cs);
-extern int gpmc_cs_set_reserved(int cs, int reserved);
-extern int gpmc_cs_reserved(int cs);
extern int gpmc_prefetch_enable(int cs, int fifo_th, int dma_mode,
unsigned int u32_count, int is_write);
extern int gpmc_prefetch_reset(int cs);
--
1.7.9.3
^ permalink raw reply related [flat|nested] 73+ messages in thread
* [PATCH v3 1/9] ARM: OMAP2+: gpmc: driver conversion
@ 2012-04-05 15:45 ` Afzal Mohammed
0 siblings, 0 replies; 73+ messages in thread
From: Afzal Mohammed @ 2012-04-05 15:45 UTC (permalink / raw)
To: linux-arm-kernel
Convert GPMC code to driver. Boards using GPMC should provide driver
with type of configuration, timing, CS, GPMC address space details
(if already configured, driver will retrieve, as is existing).
Platform devices would the be created for each connected peripheral
(details also to be passed by board so that it reaches respective
driver). And GPMC driver would populate memory resource details for
the driver of connected peripheral.
A peripheral connected to GPMC can have multiple address spaces using
different chip select. Hence GPMC driver has been provided capability
to create platform device for peripheral using mutiple CS. The
peripheral that made it necessary was tusb6010. Thanks to Jon Hunter
for his suggesstion on better way to handle this.
Interrupts of GPMC are presented to drivers of connected peripherals
as resource. A fictitious interrupt controller chip handles these
interrupts at GPMC hardware level. Clients can use normal interrupt
APIs. Platforms should inform GPMC driver infrastruture available
for these imaginary client interrupts (like irq number). Platform
information of peripheral passed to GPMC driver should indicate
interrupts to be used via flags.
Final destination for this driver is being investigated. Before moving
to the new location, all existing GPMC users has to be converted to
work with this driver.
NAND driver for NAND used via GPMC is tightly coupled with GPMC
driver (GPMC has few blocks exclusively for NAND), while that is not
the case for most of the other users (they need GPMCs help only for
initial configuration). Currently NAND driver manage using exported
GPMC symbols. This is being planned to remove later & would need
informing NAND driver about GPMC NAND registers. This would help to
have export symbol free GPMC driver, and probably
"mv omap2.c gpmc-nand.c" for OMAP NAND driver.
Thanks to Vaibhav Hiremath for his ideas on this.
Acquiring CS# for NAND is done on a few boards. It means, depending
on bootloader to embed this information. Probably CS# being used can
be set in the Kernel, and acquiring it can be removed. If ever this
capbility is needed, GPMC driver has to be made aware of handling it.
OneNAND - as it may involve reconfiguring GPMC for synchronous may
need a quirk to handle or driver has to be made more intelligent to
handle it.
Code related to GPMC clock may have to continue live in platform
folders (even if the driver is moved to MFD) as input clock is beyond
the control of GPMC and calculating timing for the peripheral may
need other helpers.
Cc: Vaibhav Hiremath <hvaibhav@ti.com>
Cc: Jon Hunter <jon-hunter@ti.com>
Signed-off-by: Afzal Mohammed <afzal@ti.com>
---
arch/arm/mach-omap2/gpmc.c | 518 ++++++++++++++++++++++++++------
arch/arm/plat-omap/include/plat/gpmc.h | 50 ++-
2 files changed, 476 insertions(+), 92 deletions(-)
diff --git a/arch/arm/mach-omap2/gpmc.c b/arch/arm/mach-omap2/gpmc.c
index 00d5108..cf5d8f3 100644
--- a/arch/arm/mach-omap2/gpmc.c
+++ b/arch/arm/mach-omap2/gpmc.c
@@ -14,8 +14,11 @@
*/
#undef DEBUG
+#include <linux/platform_device.h>
+
#include <linux/irq.h>
#include <linux/kernel.h>
+#include <linux/slab.h>
#include <linux/init.h>
#include <linux/err.h>
#include <linux/clk.h>
@@ -64,6 +67,47 @@
#define ENABLE_PREFETCH (0x1 << 7)
#define DMA_MPU_MODE 2
+#define DRIVER_NAME "omap-gpmc"
+
+#define GPMC_NR_IRQ 6
+
+struct gpmc_device {
+ char *name;
+ int id;
+ void *pdata;
+ unsigned pdata_size;
+ struct resource *per_res;
+ unsigned num_per_res;
+ struct resource *gpmc_res;
+ unsigned num_gpmc_res;
+};
+
+struct gpmc_irq {
+ unsigned irq;
+ u32 regval;
+};
+
+struct gpmc {
+ struct device *dev;
+ unsigned long fclk_period;
+ void __iomem *io_base;
+ unsigned long phys_base;
+ u32 memsize;
+ unsigned cs_map;
+ int ecc_used;
+ spinlock_t mem_lock;
+ struct resource mem_root;
+ struct resource cs_mem[GPMC_CS_NUM];
+ /* XXX: Or allocate dynamically ? */
+ struct gpmc_device device[GPMC_CS_NUM];
+ unsigned num_device;
+ unsigned master_irq;
+ unsigned irq_start;
+ unsigned num_irq;
+ struct gpmc_irq irq[GPMC_NR_IRQ];
+ struct irq_chip irq_chip;
+};
+
/* Structure to save gpmc cs context */
struct gpmc_cs_config {
u32 config1;
@@ -91,58 +135,50 @@ struct omap3_gpmc_regs {
struct gpmc_cs_config cs_context[GPMC_CS_NUM];
};
-static struct resource gpmc_mem_root;
-static struct resource gpmc_cs_mem[GPMC_CS_NUM];
-static DEFINE_SPINLOCK(gpmc_mem_lock);
-static unsigned int gpmc_cs_map; /* flag for cs which are initialized */
-static int gpmc_ecc_used = -EINVAL; /* cs using ecc engine */
-
-static void __iomem *gpmc_base;
-
static struct clk *gpmc_l3_clk;
-static irqreturn_t gpmc_handle_irq(int irq, void *dev);
+static struct gpmc *gpmc;
static void gpmc_write_reg(int idx, u32 val)
{
- __raw_writel(val, gpmc_base + idx);
+ writel(val, gpmc->io_base + idx);
}
static u32 gpmc_read_reg(int idx)
{
- return __raw_readl(gpmc_base + idx);
+ return readl(gpmc->io_base + idx);
}
static void gpmc_cs_write_byte(int cs, int idx, u8 val)
{
void __iomem *reg_addr;
- reg_addr = gpmc_base + GPMC_CS0_OFFSET + (cs * GPMC_CS_SIZE) + idx;
- __raw_writeb(val, reg_addr);
+ reg_addr = gpmc->io_base + GPMC_CS0_OFFSET + (cs * GPMC_CS_SIZE) + idx;
+ writeb(val, reg_addr);
}
static u8 gpmc_cs_read_byte(int cs, int idx)
{
void __iomem *reg_addr;
- reg_addr = gpmc_base + GPMC_CS0_OFFSET + (cs * GPMC_CS_SIZE) + idx;
- return __raw_readb(reg_addr);
+ reg_addr = gpmc->io_base + GPMC_CS0_OFFSET + (cs * GPMC_CS_SIZE) + idx;
+ return readb(reg_addr);
}
void gpmc_cs_write_reg(int cs, int idx, u32 val)
{
void __iomem *reg_addr;
- reg_addr = gpmc_base + GPMC_CS0_OFFSET + (cs * GPMC_CS_SIZE) + idx;
- __raw_writel(val, reg_addr);
+ reg_addr = gpmc->io_base + GPMC_CS0_OFFSET + (cs * GPMC_CS_SIZE) + idx;
+ writel(val, reg_addr);
}
u32 gpmc_cs_read_reg(int cs, int idx)
{
void __iomem *reg_addr;
- reg_addr = gpmc_base + GPMC_CS0_OFFSET + (cs * GPMC_CS_SIZE) + idx;
- return __raw_readl(reg_addr);
+ reg_addr = gpmc->io_base + GPMC_CS0_OFFSET + (cs * GPMC_CS_SIZE) + idx;
+ return readl(reg_addr);
}
/* TODO: Add support for gpmc_fck to clock framework and use it */
@@ -332,7 +368,7 @@ static void gpmc_cs_disable_mem(int cs)
gpmc_cs_write_reg(cs, GPMC_CS_CONFIG7, l);
}
-static void gpmc_cs_get_memconf(int cs, u32 *base, u32 *size)
+static __devinit void gpmc_cs_get_memconf(int cs, u32 *base, u32 *size)
{
u32 l;
u32 mask;
@@ -351,23 +387,23 @@ static int gpmc_cs_mem_enabled(int cs)
return l & GPMC_CONFIG7_CSVALID;
}
-int gpmc_cs_set_reserved(int cs, int reserved)
+static int gpmc_cs_set_reserved(int cs, int reserved)
{
if (cs > GPMC_CS_NUM)
return -ENODEV;
- gpmc_cs_map &= ~(1 << cs);
- gpmc_cs_map |= (reserved ? 1 : 0) << cs;
+ gpmc->cs_map &= ~(1 << cs);
+ gpmc->cs_map |= (reserved ? 1 : 0) << cs;
return 0;
}
-int gpmc_cs_reserved(int cs)
+static int gpmc_cs_reserved(int cs)
{
if (cs > GPMC_CS_NUM)
return -ENODEV;
- return gpmc_cs_map & (1 << cs);
+ return gpmc->cs_map & (1 << cs);
}
static unsigned long gpmc_mem_align(unsigned long size)
@@ -384,24 +420,25 @@ static unsigned long gpmc_mem_align(unsigned long size)
return size;
}
-static int gpmc_cs_insert_mem(int cs, unsigned long base, unsigned long size)
+static __devinit
+int gpmc_cs_insert_mem(int cs, unsigned long base, unsigned long size)
{
- struct resource *res = &gpmc_cs_mem[cs];
+ struct resource *res = &gpmc->cs_mem[cs];
int r;
size = gpmc_mem_align(size);
- spin_lock(&gpmc_mem_lock);
+ spin_lock(&gpmc->mem_lock);
res->start = base;
res->end = base + size - 1;
- r = request_resource(&gpmc_mem_root, res);
- spin_unlock(&gpmc_mem_lock);
+ r = request_resource(&gpmc->mem_root, res);
+ spin_unlock(&gpmc->mem_lock);
return r;
}
int gpmc_cs_request(int cs, unsigned long size, unsigned long *base)
{
- struct resource *res = &gpmc_cs_mem[cs];
+ struct resource *res = &gpmc->cs_mem[cs];
int r = -1;
if (cs > GPMC_CS_NUM)
@@ -411,7 +448,7 @@ int gpmc_cs_request(int cs, unsigned long size, unsigned long *base)
if (size > (1 << GPMC_SECTION_SHIFT))
return -ENOMEM;
- spin_lock(&gpmc_mem_lock);
+ spin_lock(&gpmc->mem_lock);
if (gpmc_cs_reserved(cs)) {
r = -EBUSY;
goto out;
@@ -419,7 +456,7 @@ int gpmc_cs_request(int cs, unsigned long size, unsigned long *base)
if (gpmc_cs_mem_enabled(cs))
r = adjust_resource(res, res->start & ~(size - 1), size);
if (r < 0)
- r = allocate_resource(&gpmc_mem_root, res, size, 0, ~0,
+ r = allocate_resource(&gpmc->mem_root, res, size, 0, ~0,
size, NULL, NULL);
if (r < 0)
goto out;
@@ -428,24 +465,24 @@ int gpmc_cs_request(int cs, unsigned long size, unsigned long *base)
*base = res->start;
gpmc_cs_set_reserved(cs, 1);
out:
- spin_unlock(&gpmc_mem_lock);
+ spin_unlock(&gpmc->mem_lock);
return r;
}
EXPORT_SYMBOL(gpmc_cs_request);
void gpmc_cs_free(int cs)
{
- spin_lock(&gpmc_mem_lock);
+ spin_lock(&gpmc->mem_lock);
if (cs >= GPMC_CS_NUM || cs < 0 || !gpmc_cs_reserved(cs)) {
printk(KERN_ERR "Trying to free non-reserved GPMC CS%d\n", cs);
BUG();
- spin_unlock(&gpmc_mem_lock);
+ spin_unlock(&gpmc->mem_lock);
return;
}
gpmc_cs_disable_mem(cs);
- release_resource(&gpmc_cs_mem[cs]);
+ release_resource(&gpmc->cs_mem[cs]);
gpmc_cs_set_reserved(cs, 0);
- spin_unlock(&gpmc_mem_lock);
+ spin_unlock(&gpmc->mem_lock);
}
EXPORT_SYMBOL(gpmc_cs_free);
@@ -546,6 +583,12 @@ int gpmc_cs_configure(int cs, int cmd, int wval)
gpmc_cs_write_reg(cs, GPMC_CS_CONFIG1, regval);
break;
+ case GPMC_CONFIG_WAITPIN:
+ regval = gpmc_cs_read_reg(cs, GPMC_CS_CONFIG1);
+ regval |= GPMC_CONFIG1_WAIT_PIN_SEL(wval);
+ gpmc_cs_write_reg(cs, GPMC_CS_CONFIG1, regval);
+ break;
+
default:
printk(KERN_ERR "gpmc_configure_cs: Not supported\n");
err = -EINVAL;
@@ -668,7 +711,7 @@ int gpmc_prefetch_reset(int cs)
}
EXPORT_SYMBOL(gpmc_prefetch_reset);
-static void __init gpmc_mem_init(void)
+static __devinit void gpmc_mem_init(void)
{
int cs;
unsigned long boot_rom_space = 0;
@@ -680,8 +723,8 @@ static void __init gpmc_mem_init(void)
/* In apollon the CS0 is mapped as 0x0000 0000 */
if (machine_is_omap_apollon())
boot_rom_space = 0;
- gpmc_mem_root.start = GPMC_MEM_START + boot_rom_space;
- gpmc_mem_root.end = GPMC_MEM_END;
+ gpmc->mem_root.start = GPMC_MEM_START + boot_rom_space;
+ gpmc->mem_root.end = GPMC_MEM_END;
/* Reserve all regions that has been set up by bootloader */
for (cs = 0; cs < GPMC_CS_NUM; cs++) {
@@ -697,26 +740,15 @@ static void __init gpmc_mem_init(void)
static int __init gpmc_init(void)
{
- u32 l, irq;
- int cs, ret = -EINVAL;
- int gpmc_irq;
+ int ret = -EINVAL;
char *ck = NULL;
if (cpu_is_omap24xx()) {
ck = "core_l3_ck";
- if (cpu_is_omap2420())
- l = OMAP2420_GPMC_BASE;
- else
- l = OMAP34XX_GPMC_BASE;
- gpmc_irq = INT_34XX_GPMC_IRQ;
} else if (cpu_is_omap34xx()) {
ck = "gpmc_fck";
- l = OMAP34XX_GPMC_BASE;
- gpmc_irq = INT_34XX_GPMC_IRQ;
} else if (cpu_is_omap44xx()) {
ck = "gpmc_ck";
- l = OMAP44XX_GPMC_BASE;
- gpmc_irq = OMAP44XX_IRQ_GPMC;
}
if (WARN_ON(!ck))
@@ -728,54 +760,360 @@ static int __init gpmc_init(void)
BUG();
}
- gpmc_base = ioremap(l, SZ_4K);
- if (!gpmc_base) {
- clk_put(gpmc_l3_clk);
- printk(KERN_ERR "Could not get GPMC register memory\n");
- BUG();
+ clk_enable(gpmc_l3_clk);
+
+ return 0;
+}
+postcore_initcall(gpmc_init);
+
+static __devinit struct resource gpmc_setup_cs_mem(struct gpmc_cs_data *p,
+ struct gpmc_device_pdata *gdp, struct gpmc *gpmc)
+{
+ int i, ret;
+ struct gpmc_config *c;
+ struct resource res;
+ unsigned long start;
+
+ res.flags = 0x0;
+ start = p->mem_start;
+
+ ret = gpmc_cs_request(p->cs, p->mem_size, &start);
+ if (IS_ERR_VALUE(ret)) {
+ dev_err(gpmc->dev, "error: gpmc request on CS: %u\n", p->cs);
+ return res;
}
- clk_enable(gpmc_l3_clk);
+ c = p->config;
+ if (!c)
+ dev_warn(gpmc->dev, "config not present for CS: %u\n", p->cs);
+
+ for (i = 0; i < p->num_config; c++, i++) {
+ /* XXX: check for non-NULL c ? */
+ ret = gpmc_cs_configure(p->cs, c->cmd, c->val);
+ if (IS_ERR_VALUE(ret)) {
+ dev_err(gpmc->dev, "invalid cmd or value on CS: \
+ %u: cmd: %d value: %d\n", p->cs, c->cmd, c->val);
+ return res;
+ }
+ }
- l = gpmc_read_reg(GPMC_REVISION);
- printk(KERN_INFO "GPMC revision %d.%d\n", (l >> 4) & 0x0f, l & 0x0f);
- /* Set smart idle mode and automatic L3 clock gating */
- l = gpmc_read_reg(GPMC_SYSCONFIG);
- l &= 0x03 << 3;
- l |= (0x02 << 3) | (1 << 0);
- gpmc_write_reg(GPMC_SYSCONFIG, l);
- gpmc_mem_init();
+ if (p->timing) {
+ ret = gpmc_cs_set_timings(p->cs, p->timing);
+ if (IS_ERR_VALUE(ret)) {
+ dev_err(gpmc->dev, "error: setting timing on CS: %d\n",
+ p->cs);
+ return res;
+ }
+ } else
+ dev_warn(gpmc->dev, "timing not present for CS: %u\n", p->cs);
- /* initalize the irq_chained */
- irq = OMAP_GPMC_IRQ_BASE;
- for (cs = 0; cs < GPMC_CS_NUM; cs++) {
- irq_set_chip_and_handler(irq, &dummy_irq_chip,
- handle_simple_irq);
- set_irq_flags(irq, IRQF_VALID);
- irq++;
+ res.start = start + p->mem_offset;
+ res.end = res.start + p->mem_size - 1;
+ res.flags = IORESOURCE_MEM;
+
+ dev_info(gpmc->dev, "resource memory 0x%x-0x%x for %s (on CS %d)\n",
+ res.start, res.end, gdp->name, p->cs);
+
+ return res;
+}
+
+static __devinit
+int gpmc_setup_cs_irq(struct gpmc *gpmc, struct gpmc_device_pdata *gdp,
+ struct gpmc_cs_data *cs, struct resource *res)
+{
+ int i, n, val;
+
+ for (i = 0, n = 0; i < gpmc->num_irq; i++)
+ if (gpmc->irq[i].regval & cs->irq_flags) {
+ res[n].start = res[n].end = gpmc->irq[i].irq;
+ res[n].flags = IORESOURCE_IRQ;
+
+ dev_info(gpmc->dev, "resource irq %u for %s "
+ "(on CS %d) [bit: %x]\n", res[n].start,
+ gdp->name, cs->cs, __ffs(gpmc->irq[i].regval));
+
+ switch (gpmc->irq[i].regval) {
+ case GPMC_IRQ_WAIT0EDGEDETECTION:
+ case GPMC_IRQ_WAIT1EDGEDETECTION:
+ case GPMC_IRQ_WAIT2EDGEDETECTION:
+ case GPMC_IRQ_WAIT3EDGEDETECTION:
+ val = __ffs(gpmc->irq[i].regval);
+ val -= __ffs(GPMC_IRQ_WAIT0EDGEDETECTION);
+ gpmc_cs_configure(cs->cs,
+ GPMC_CONFIG_WAITPIN, val);
+ }
+ n++;
+ }
+
+ return n;
+}
+
+static __devinit int gpmc_setup_device(struct gpmc_device_pdata *gdp,
+ struct gpmc_device *dev, struct gpmc *gpmc)
+{
+ int i, j, n;
+ struct gpmc_cs_data *cs;
+
+ for (i = 0, n = 0, cs = gdp->cs_data; i < gdp->num_cs; i++, cs++)
+ n += hweight32(cs->irq_flags & GPMC_IRQ_MASK);
+
+ n += gdp->num_cs;
+
+ dev->gpmc_res = devm_kzalloc(gpmc->dev, sizeof(*dev->gpmc_res) * n,
+ GFP_KERNEL);
+ if (dev->gpmc_res == NULL) {
+ dev_err(gpmc->dev, "error: memory allocation\n");
+ return -ENOMEM;
+ }
+
+ for (i = 0, j = 0, cs = gdp->cs_data; i < gdp->num_cs; cs++, i++) {
+ dev->gpmc_res[j] = gpmc_setup_cs_mem(cs, gdp, gpmc);
+ if (dev->gpmc_res[j++].flags & IORESOURCE_MEM)
+ j += gpmc_setup_cs_irq(gpmc, gdp, cs,
+ dev->gpmc_res + j);
+ else {
+ dev_err(gpmc->dev, "error: setup for %s\n", gdp->name);
+ devm_kfree(gpmc->dev, dev->gpmc_res);
+ dev->gpmc_res = NULL;
+ dev->num_gpmc_res = 0;
+ return -EINVAL;
+ }
}
+ dev->num_gpmc_res = j;
- ret = request_irq(gpmc_irq,
- gpmc_handle_irq, IRQF_SHARED, "gpmc", gpmc_base);
- if (ret)
- pr_err("gpmc: irq-%d could not claim: err %d\n",
- gpmc_irq, ret);
- return ret;
+ dev->name = gdp->name;
+ dev->id = gdp->id;
+ dev->pdata = gdp->pdata;
+ dev->pdata_size = gdp->pdata_size;
+ dev->per_res = gdp->per_res;
+ dev->num_per_res = gdp->num_per_res;
+
+ return 0;
+}
+
+static __devinit
+struct platform_device *gpmc_create_device(struct gpmc_device *p,
+ struct gpmc *gpmc)
+{
+ int num = p->num_per_res + p->num_gpmc_res;
+ struct resource *res;
+ struct platform_device *pdev;
+
+ res = devm_kzalloc(gpmc->dev, sizeof(struct resource) * num,
+ GFP_KERNEL);
+ if (!res) {
+ dev_err(gpmc->dev, "error: allocating memory\n");
+ return NULL;
+ }
+
+ memcpy((char *)res, (const char *) p->gpmc_res,
+ sizeof(struct resource) * p->num_gpmc_res);
+ memcpy((char *)(res + p->num_gpmc_res), (const char *)p->per_res,
+ sizeof(struct resource) * p->num_per_res);
+
+ pdev = platform_device_register_resndata(gpmc->dev, p->name, p->id,
+ res, num, p->pdata, p->pdata_size);
+
+ devm_kfree(gpmc->dev, res);
+
+ return pdev;
}
-postcore_initcall(gpmc_init);
static irqreturn_t gpmc_handle_irq(int irq, void *dev)
{
- u8 cs;
+ int i;
+ u32 regval;
+ struct gpmc *gpmc = dev;
- /* check cs to invoke the irq */
- cs = ((gpmc_read_reg(GPMC_PREFETCH_CONFIG1)) >> CS_NUM_SHIFT) & 0x7;
- if (OMAP_GPMC_IRQ_BASE+cs <= OMAP_GPMC_IRQ_END)
- generic_handle_irq(OMAP_GPMC_IRQ_BASE+cs);
+ regval = gpmc_read_reg(GPMC_IRQSTATUS);
+
+
+ for (i = 0; i < gpmc->num_irq; i++)
+ if (regval & gpmc->irq[i].regval)
+ generic_handle_irq(gpmc->irq[i].irq);
+ gpmc_write_reg(GPMC_IRQSTATUS, regval);
return IRQ_HANDLED;
}
+static int gpmc_irq_endis(struct irq_data *p, bool endis)
+{
+ struct gpmc *gpmc = irq_data_get_irq_chip_data(p);
+ int i;
+ u32 regval;
+
+ for (i = 0; i < gpmc->num_irq; i++)
+ if (p->irq == gpmc->irq[i].irq) {
+ regval = gpmc_read_reg(GPMC_IRQENABLE);
+ if (endis)
+ regval |= gpmc->irq[i].regval;
+ else
+ regval &= ~gpmc->irq[i].regval;
+ gpmc_write_reg(GPMC_IRQENABLE, regval);
+ break;
+ }
+
+ return 0;
+}
+
+static void gpmc_irq_disable(struct irq_data *p)
+{
+ gpmc_irq_endis(p, false);
+}
+
+static void gpmc_irq_enable(struct irq_data *p)
+{
+ gpmc_irq_endis(p, true);
+}
+
+static void gpmc_irq_noop(struct irq_data *data) { }
+
+static unsigned int gpmc_irq_noop_ret(struct irq_data *data) { return 0; }
+
+static __devinit int gpmc_setup_irq(struct gpmc *gpmc)
+{
+ int i;
+ u32 regval;
+
+ if (!gpmc->master_irq)
+ return -EINVAL;
+
+ if (gpmc->num_irq < GPMC_NR_IRQ) {
+ dev_warn(gpmc->dev, "Insufficient interrupts for device\n");
+ return -EINVAL;
+ } else if (gpmc->num_irq > GPMC_NR_IRQ)
+ gpmc->num_irq = GPMC_NR_IRQ;
+
+ gpmc->irq[0].regval = GPMC_IRQ_FIFOEVENT;
+ gpmc->irq[1].regval = GPMC_IRQ_TERMINALCOUNT;
+ gpmc->irq[2].regval = GPMC_IRQ_WAIT0EDGEDETECTION;
+ gpmc->irq[3].regval = GPMC_IRQ_WAIT1EDGEDETECTION;
+ gpmc->irq[4].regval = GPMC_IRQ_WAIT2EDGEDETECTION;
+ gpmc->irq[5].regval = GPMC_IRQ_WAIT3EDGEDETECTION;
+
+ for (i = 0; i < gpmc->num_irq; i++)
+ gpmc->irq[i].irq = gpmc->irq_start + i;
+
+ gpmc->irq_chip.name = "gpmc";
+ gpmc->irq_chip.irq_startup = gpmc_irq_noop_ret;
+ gpmc->irq_chip.irq_enable = gpmc_irq_enable;
+ gpmc->irq_chip.irq_disable = gpmc_irq_disable;
+ gpmc->irq_chip.irq_shutdown = gpmc_irq_noop;
+ gpmc->irq_chip.irq_ack = gpmc_irq_noop;
+ gpmc->irq_chip.irq_mask = gpmc_irq_noop;
+ gpmc->irq_chip.irq_unmask = gpmc_irq_noop;
+
+ for (i = 0; i < gpmc->num_irq; i++) {
+ irq_set_chip_and_handler(gpmc->irq[i].irq,
+ &gpmc->irq_chip, handle_simple_irq);
+ irq_set_chip_data(gpmc->irq[i].irq, gpmc);
+ set_irq_flags(gpmc->irq[i].irq, IRQF_VALID | IRQF_NOAUTOEN);
+ }
+
+ /* clear interrupts */
+ regval = gpmc_read_reg(GPMC_IRQSTATUS);
+ gpmc_write_reg(GPMC_IRQSTATUS, regval);
+
+ return request_irq(gpmc->master_irq, gpmc_handle_irq, IRQF_SHARED,
+ "gpmc", gpmc);
+}
+
+static __devinit int gpmc_probe(struct platform_device *pdev)
+{
+ u32 l;
+ int i;
+ int ret = 0;
+ struct resource *res = NULL;
+ struct gpmc_pdata *gp = dev_get_platdata(&pdev->dev);
+ struct gpmc_device_pdata **gdq = NULL;
+ struct gpmc_device *gd = NULL;
+
+ gpmc = devm_kzalloc(&pdev->dev, sizeof(struct gpmc), GFP_KERNEL);
+ if (gpmc == NULL)
+ return -ENOMEM;
+
+ gpmc->dev = &pdev->dev;
+ gpmc->fclk_period = gp->fclk_period;
+
+ res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+ if (res == NULL)
+ return -ENOENT;
+
+ gpmc->phys_base = res->start;
+ gpmc->memsize = resource_size(res);
+
+ gpmc->io_base = devm_request_and_ioremap(gpmc->dev, res);
+ if (!gpmc->io_base)
+ return -EADDRNOTAVAIL;
+
+ res = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
+ if (res == NULL)
+ dev_warn(gpmc->dev, "Failed to get resource: irq\n");
+ else
+ gpmc->master_irq = res->start;
+
+ gpmc->irq_start = gp->irq_start;
+ gpmc->num_irq = gp->num_irq;
+ gpmc_setup_irq(gpmc);
+
+ gpmc->ecc_used = -EINVAL;
+ spin_lock_init(&gpmc->mem_lock);
+ platform_set_drvdata(pdev, gpmc);
+
+ l = gpmc_read_reg(GPMC_REVISION);
+ dev_info(gpmc->dev, "GPMC revision %d.%d\n", (l >> 4) & 0x0f, l & 0x0f);
+
+ gpmc_mem_init();
+
+ for (gdq = gp->device_pdata, gd = gpmc->device; *gdq; gdq++, i++) {
+ ret = gpmc_setup_device(*gdq, gd, gpmc);
+ if (IS_ERR_VALUE(ret))
+ dev_err(gpmc->dev, "gpmc setup on %s failed\n",
+ (*gdq)->name);
+ else
+ gd++;
+ }
+ gpmc->num_device = gd - gpmc->device;
+
+ for (i = 0, gd = gpmc->device; i < gpmc->num_device; i++, gd++)
+ if (IS_ERR(gpmc_create_device(gd, gpmc)))
+ dev_err(gpmc->dev, "device creation on %s failed\n",
+ gd->name);
+
+ return 0;
+}
+
+static __devexit int gpmc_free_irq(struct gpmc *gpmc)
+{
+ /* TODO: free gpmc irq chip */
+
+ if (gpmc->master_irq)
+ free_irq(gpmc->master_irq, gpmc);
+
+ return 0;
+}
+
+static __devexit int gpmc_remove(struct platform_device *pdev)
+{
+ struct gpmc *gpmc = platform_get_drvdata(pdev);
+
+ platform_set_drvdata(pdev, NULL);
+ gpmc_free_irq(gpmc);
+
+ return 0;
+}
+
+static struct platform_driver gpmc_driver = {
+ .probe = gpmc_probe,
+ .remove = __devexit_p(gpmc_remove),
+ .driver = {
+ .name = DRIVER_NAME,
+ .owner = THIS_MODULE,
+ },
+};
+
+module_platform_driver(gpmc_driver);
+
#ifdef CONFIG_ARCH_OMAP3
static struct omap3_gpmc_regs gpmc_context;
@@ -855,10 +1193,10 @@ int gpmc_enable_hwecc(int cs, int mode, int dev_width, int ecc_size)
unsigned int val;
/* check if ecc module is in used */
- if (gpmc_ecc_used != -EINVAL)
+ if (gpmc->ecc_used != -EINVAL)
return -EINVAL;
- gpmc_ecc_used = cs;
+ gpmc->ecc_used = cs;
/* clear ecc and enable bits */
val = ((0x00000001<<8) | 0x00000001);
@@ -906,7 +1244,7 @@ int gpmc_calculate_ecc(int cs, const u_char *dat, u_char *ecc_code)
{
unsigned int val = 0x0;
- if (gpmc_ecc_used != cs)
+ if (gpmc->ecc_used != cs)
return -EINVAL;
/* read ecc result */
@@ -916,7 +1254,7 @@ int gpmc_calculate_ecc(int cs, const u_char *dat, u_char *ecc_code)
/* P2048o, P1024o, P512o, P256o, P2048e, P1024e, P512e, P256e */
*ecc_code++ = ((val >> 8) & 0x0f) | ((val >> 20) & 0xf0);
- gpmc_ecc_used = -EINVAL;
+ gpmc->ecc_used = -EINVAL;
return 0;
}
EXPORT_SYMBOL_GPL(gpmc_calculate_ecc);
diff --git a/arch/arm/plat-omap/include/plat/gpmc.h b/arch/arm/plat-omap/include/plat/gpmc.h
index 1527929..fa62cdf 100644
--- a/arch/arm/plat-omap/include/plat/gpmc.h
+++ b/arch/arm/plat-omap/include/plat/gpmc.h
@@ -36,6 +36,7 @@
#define GPMC_PREFETCH_FIFO_CNT 0x00000007 /* bytes available in FIFO for r/w */
#define GPMC_PREFETCH_COUNT 0x00000008 /* remaining bytes to be read/write*/
#define GPMC_STATUS_BUFFER 0x00000009 /* 1: buffer is available to write */
+#define GPMC_CONFIG_WAITPIN 0x0000000A
#define GPMC_NAND_COMMAND 0x0000000a
#define GPMC_NAND_ADDRESS 0x0000000b
@@ -83,6 +84,17 @@
#define GPMC_IRQ_FIFOEVENTENABLE 0x01
#define GPMC_IRQ_COUNT_EVENT 0x02
+#define GPMC_IRQ_FIFOEVENT BIT(0)
+#define GPMC_IRQ_TERMINALCOUNT BIT(1)
+#define GPMC_IRQ_WAIT0EDGEDETECTION BIT(8)
+#define GPMC_IRQ_WAIT1EDGEDETECTION BIT(9)
+#define GPMC_IRQ_WAIT2EDGEDETECTION BIT(10)
+#define GPMC_IRQ_WAIT3EDGEDETECTION BIT(11)
+#define GPMC_IRQ_MASK \
+ (GPMC_IRQ_FIFOEVENT | GPMC_IRQ_TERMINALCOUNT | \
+ GPMC_IRQ_WAIT0EDGEDETECTION | GPMC_IRQ_WAIT1EDGEDETECTION | \
+ GPMC_IRQ_WAIT2EDGEDETECTION | GPMC_IRQ_WAIT3EDGEDETECTION)
+
#define PREFETCH_FIFOTHRESHOLD_MAX 0x40
#define PREFETCH_FIFOTHRESHOLD(val) ((val) << 8)
@@ -131,6 +143,42 @@ struct gpmc_timings {
u16 wr_data_mux_bus; /* WRDATAONADMUXBUS */
};
+struct gpmc_config {
+ int cmd;
+ int val;
+};
+
+struct gpmc_cs_data {
+ unsigned cs;
+ unsigned long mem_size;
+ unsigned long mem_start;
+ unsigned long mem_offset;
+ struct gpmc_config *config;
+ unsigned num_config;
+ struct gpmc_timings *timing;
+ unsigned irq_flags;
+};
+
+struct gpmc_device_pdata {
+ char *name;
+ int id;
+ void *pdata;
+ unsigned pdata_size;
+ /* resources configured via GPMC will be created by GPMC driver */
+ struct resource *per_res;
+ unsigned num_per_res;
+ struct gpmc_cs_data *cs_data;
+ unsigned num_cs;
+};
+
+struct gpmc_pdata {
+ /* GPMC_FCLK period in picoseconds */
+ unsigned long fclk_period;
+ struct gpmc_device_pdata **device_pdata;
+ unsigned irq_start;
+ unsigned num_irq;
+};
+
extern unsigned int gpmc_ns_to_ticks(unsigned int time_ns);
extern unsigned int gpmc_ps_to_ticks(unsigned int time_ps);
extern unsigned int gpmc_ticks_to_ns(unsigned int ticks);
@@ -143,8 +191,6 @@ extern int gpmc_cs_calc_divider(int cs, unsigned int sync_clk);
extern int gpmc_cs_set_timings(int cs, const struct gpmc_timings *t);
extern int gpmc_cs_request(int cs, unsigned long size, unsigned long *base);
extern void gpmc_cs_free(int cs);
-extern int gpmc_cs_set_reserved(int cs, int reserved);
-extern int gpmc_cs_reserved(int cs);
extern int gpmc_prefetch_enable(int cs, int fifo_th, int dma_mode,
unsigned int u32_count, int is_write);
extern int gpmc_prefetch_reset(int cs);
--
1.7.9.3
^ permalink raw reply related [flat|nested] 73+ messages in thread
* [PATCH v3 2/9] ARM: OMAP2+: gpmc: registers for nand driver
[not found] <cover.1333640054.git.afzal@ti.com>
2012-04-05 15:45 ` Afzal Mohammed
@ 2012-04-05 15:46 ` Afzal Mohammed
2012-04-05 15:46 ` Afzal Mohammed
` (6 subsequent siblings)
8 siblings, 0 replies; 73+ messages in thread
From: Afzal Mohammed @ 2012-04-05 15:46 UTC (permalink / raw)
To: tony, khilman, linux, dwmw2, sameo, grinberg, mike, nm,
artem.bityutskiy, vimal.newwork, dbaryshkov, linux-omap,
linux-arm-kernel, linux-mtd, linux-kernel
Cc: Afzal Mohammed
If peripheral connected is NAND, update NAND drivers platform data
with NAND related register addresses so that NAND driver can handle
GPMC NAND operations by itself
Signed-off-by: Afzal Mohammed <afzal@ti.com>
---
arch/arm/mach-omap2/gpmc.c | 25 +++++++++++++++++++++++++
arch/arm/plat-omap/include/plat/gpmc.h | 16 ++++++++++++++++
arch/arm/plat-omap/include/plat/nand.h | 1 +
3 files changed, 42 insertions(+)
diff --git a/arch/arm/mach-omap2/gpmc.c b/arch/arm/mach-omap2/gpmc.c
index cf5d8f3..ca7fa83 100644
--- a/arch/arm/mach-omap2/gpmc.c
+++ b/arch/arm/mach-omap2/gpmc.c
@@ -30,6 +30,7 @@
#include <asm/mach-types.h>
#include <plat/gpmc.h>
+#include <plat/nand.h>
#include <plat/sdrc.h>
@@ -766,6 +767,28 @@ static int __init gpmc_init(void)
}
postcore_initcall(gpmc_init);
+static __devinit void gpmc_update_nand_reg(struct gpmc *gpmc,
+ struct omap_nand_platform_data *nand)
+{
+ int cs = nand->cs;
+
+ nand->reg.gpmc_status = gpmc->io_base + GPMC_STATUS;
+ nand->reg.gpmc_nand_command = gpmc->io_base + GPMC_CS0_OFFSET +
+ GPMC_CS_NAND_COMMAND + GPMC_CS_SIZE * cs;
+ nand->reg.gpmc_nand_address = gpmc->io_base + GPMC_CS0_OFFSET +
+ GPMC_CS_NAND_ADDRESS + GPMC_CS_SIZE * cs;
+ nand->reg.gpmc_nand_data = gpmc->io_base + GPMC_CS0_OFFSET +
+ GPMC_CS_NAND_DATA + GPMC_CS_SIZE * cs;
+ nand->reg.gpmc_prefetch_config1 = gpmc->io_base + GPMC_PREFETCH_CONFIG1;
+ nand->reg.gpmc_prefetch_config2 = gpmc->io_base + GPMC_PREFETCH_CONFIG2;
+ nand->reg.gpmc_prefetch_control = gpmc->io_base + GPMC_PREFETCH_CONTROL;
+ nand->reg.gpmc_prefetch_status = gpmc->io_base + GPMC_PREFETCH_STATUS;
+ nand->reg.gpmc_ecc_config = gpmc->io_base + GPMC_ECC_CONFIG;
+ nand->reg.gpmc_ecc_control = gpmc->io_base + GPMC_ECC_CONTROL;
+ nand->reg.gpmc_ecc_size_config = gpmc->io_base + GPMC_ECC_SIZE_CONFIG;
+ nand->reg.gpmc_ecc1_result = gpmc->io_base + GPMC_ECC1_RESULT;
+}
+
static __devinit struct resource gpmc_setup_cs_mem(struct gpmc_cs_data *p,
struct gpmc_device_pdata *gdp, struct gpmc *gpmc)
{
@@ -1066,6 +1089,8 @@ static __devinit int gpmc_probe(struct platform_device *pdev)
gpmc_mem_init();
for (gdq = gp->device_pdata, gd = gpmc->device; *gdq; gdq++, i++) {
+ if ((*gdq)->is_nand)
+ gpmc_update_nand_reg(gpmc, (*gdq)->pdata);
ret = gpmc_setup_device(*gdq, gd, gpmc);
if (IS_ERR_VALUE(ret))
dev_err(gpmc->dev, "gpmc setup on %s failed\n",
diff --git a/arch/arm/plat-omap/include/plat/gpmc.h b/arch/arm/plat-omap/include/plat/gpmc.h
index fa62cdf..a320e71 100644
--- a/arch/arm/plat-omap/include/plat/gpmc.h
+++ b/arch/arm/plat-omap/include/plat/gpmc.h
@@ -169,6 +169,7 @@ struct gpmc_device_pdata {
unsigned num_per_res;
struct gpmc_cs_data *cs_data;
unsigned num_cs;
+ bool is_nand;
};
struct gpmc_pdata {
@@ -179,6 +180,21 @@ struct gpmc_pdata {
unsigned num_irq;
};
+struct gpmc_nand_regs {
+ void __iomem *gpmc_status;
+ void __iomem *gpmc_nand_command;
+ void __iomem *gpmc_nand_address;
+ void __iomem *gpmc_nand_data;
+ void __iomem *gpmc_prefetch_config1;
+ void __iomem *gpmc_prefetch_config2;
+ void __iomem *gpmc_prefetch_control;
+ void __iomem *gpmc_prefetch_status;
+ void __iomem *gpmc_ecc_config;
+ void __iomem *gpmc_ecc_control;
+ void __iomem *gpmc_ecc_size_config;
+ void __iomem *gpmc_ecc1_result;
+};
+
extern unsigned int gpmc_ns_to_ticks(unsigned int time_ns);
extern unsigned int gpmc_ps_to_ticks(unsigned int time_ps);
extern unsigned int gpmc_ticks_to_ns(unsigned int ticks);
diff --git a/arch/arm/plat-omap/include/plat/nand.h b/arch/arm/plat-omap/include/plat/nand.h
index 67fc506..86e4d9c 100644
--- a/arch/arm/plat-omap/include/plat/nand.h
+++ b/arch/arm/plat-omap/include/plat/nand.h
@@ -29,6 +29,7 @@ struct omap_nand_platform_data {
unsigned long phys_base;
int devsize;
enum omap_ecc ecc_opt;
+ struct gpmc_nand_regs reg;
};
/* minimum size for IO mapping */
--
1.7.9.3
^ permalink raw reply related [flat|nested] 73+ messages in thread
* [PATCH v3 2/9] ARM: OMAP2+: gpmc: registers for nand driver
@ 2012-04-05 15:46 ` Afzal Mohammed
0 siblings, 0 replies; 73+ messages in thread
From: Afzal Mohammed @ 2012-04-05 15:46 UTC (permalink / raw)
To: tony, khilman, linux, dwmw2, sameo, grinberg, mike, nm,
artem.bityutskiy, vimal.newwork, dbaryshkov, linux-omap,
linux-arm-kernel, linux-mtd, linux-kernel
Cc: Afzal Mohammed
If peripheral connected is NAND, update NAND drivers platform data
with NAND related register addresses so that NAND driver can handle
GPMC NAND operations by itself
Signed-off-by: Afzal Mohammed <afzal@ti.com>
---
arch/arm/mach-omap2/gpmc.c | 25 +++++++++++++++++++++++++
arch/arm/plat-omap/include/plat/gpmc.h | 16 ++++++++++++++++
arch/arm/plat-omap/include/plat/nand.h | 1 +
3 files changed, 42 insertions(+)
diff --git a/arch/arm/mach-omap2/gpmc.c b/arch/arm/mach-omap2/gpmc.c
index cf5d8f3..ca7fa83 100644
--- a/arch/arm/mach-omap2/gpmc.c
+++ b/arch/arm/mach-omap2/gpmc.c
@@ -30,6 +30,7 @@
#include <asm/mach-types.h>
#include <plat/gpmc.h>
+#include <plat/nand.h>
#include <plat/sdrc.h>
@@ -766,6 +767,28 @@ static int __init gpmc_init(void)
}
postcore_initcall(gpmc_init);
+static __devinit void gpmc_update_nand_reg(struct gpmc *gpmc,
+ struct omap_nand_platform_data *nand)
+{
+ int cs = nand->cs;
+
+ nand->reg.gpmc_status = gpmc->io_base + GPMC_STATUS;
+ nand->reg.gpmc_nand_command = gpmc->io_base + GPMC_CS0_OFFSET +
+ GPMC_CS_NAND_COMMAND + GPMC_CS_SIZE * cs;
+ nand->reg.gpmc_nand_address = gpmc->io_base + GPMC_CS0_OFFSET +
+ GPMC_CS_NAND_ADDRESS + GPMC_CS_SIZE * cs;
+ nand->reg.gpmc_nand_data = gpmc->io_base + GPMC_CS0_OFFSET +
+ GPMC_CS_NAND_DATA + GPMC_CS_SIZE * cs;
+ nand->reg.gpmc_prefetch_config1 = gpmc->io_base + GPMC_PREFETCH_CONFIG1;
+ nand->reg.gpmc_prefetch_config2 = gpmc->io_base + GPMC_PREFETCH_CONFIG2;
+ nand->reg.gpmc_prefetch_control = gpmc->io_base + GPMC_PREFETCH_CONTROL;
+ nand->reg.gpmc_prefetch_status = gpmc->io_base + GPMC_PREFETCH_STATUS;
+ nand->reg.gpmc_ecc_config = gpmc->io_base + GPMC_ECC_CONFIG;
+ nand->reg.gpmc_ecc_control = gpmc->io_base + GPMC_ECC_CONTROL;
+ nand->reg.gpmc_ecc_size_config = gpmc->io_base + GPMC_ECC_SIZE_CONFIG;
+ nand->reg.gpmc_ecc1_result = gpmc->io_base + GPMC_ECC1_RESULT;
+}
+
static __devinit struct resource gpmc_setup_cs_mem(struct gpmc_cs_data *p,
struct gpmc_device_pdata *gdp, struct gpmc *gpmc)
{
@@ -1066,6 +1089,8 @@ static __devinit int gpmc_probe(struct platform_device *pdev)
gpmc_mem_init();
for (gdq = gp->device_pdata, gd = gpmc->device; *gdq; gdq++, i++) {
+ if ((*gdq)->is_nand)
+ gpmc_update_nand_reg(gpmc, (*gdq)->pdata);
ret = gpmc_setup_device(*gdq, gd, gpmc);
if (IS_ERR_VALUE(ret))
dev_err(gpmc->dev, "gpmc setup on %s failed\n",
diff --git a/arch/arm/plat-omap/include/plat/gpmc.h b/arch/arm/plat-omap/include/plat/gpmc.h
index fa62cdf..a320e71 100644
--- a/arch/arm/plat-omap/include/plat/gpmc.h
+++ b/arch/arm/plat-omap/include/plat/gpmc.h
@@ -169,6 +169,7 @@ struct gpmc_device_pdata {
unsigned num_per_res;
struct gpmc_cs_data *cs_data;
unsigned num_cs;
+ bool is_nand;
};
struct gpmc_pdata {
@@ -179,6 +180,21 @@ struct gpmc_pdata {
unsigned num_irq;
};
+struct gpmc_nand_regs {
+ void __iomem *gpmc_status;
+ void __iomem *gpmc_nand_command;
+ void __iomem *gpmc_nand_address;
+ void __iomem *gpmc_nand_data;
+ void __iomem *gpmc_prefetch_config1;
+ void __iomem *gpmc_prefetch_config2;
+ void __iomem *gpmc_prefetch_control;
+ void __iomem *gpmc_prefetch_status;
+ void __iomem *gpmc_ecc_config;
+ void __iomem *gpmc_ecc_control;
+ void __iomem *gpmc_ecc_size_config;
+ void __iomem *gpmc_ecc1_result;
+};
+
extern unsigned int gpmc_ns_to_ticks(unsigned int time_ns);
extern unsigned int gpmc_ps_to_ticks(unsigned int time_ps);
extern unsigned int gpmc_ticks_to_ns(unsigned int ticks);
diff --git a/arch/arm/plat-omap/include/plat/nand.h b/arch/arm/plat-omap/include/plat/nand.h
index 67fc506..86e4d9c 100644
--- a/arch/arm/plat-omap/include/plat/nand.h
+++ b/arch/arm/plat-omap/include/plat/nand.h
@@ -29,6 +29,7 @@ struct omap_nand_platform_data {
unsigned long phys_base;
int devsize;
enum omap_ecc ecc_opt;
+ struct gpmc_nand_regs reg;
};
/* minimum size for IO mapping */
--
1.7.9.3
^ permalink raw reply related [flat|nested] 73+ messages in thread
* [PATCH v3 2/9] ARM: OMAP2+: gpmc: registers for nand driver
@ 2012-04-05 15:46 ` Afzal Mohammed
0 siblings, 0 replies; 73+ messages in thread
From: Afzal Mohammed @ 2012-04-05 15:46 UTC (permalink / raw)
To: linux-arm-kernel
If peripheral connected is NAND, update NAND drivers platform data
with NAND related register addresses so that NAND driver can handle
GPMC NAND operations by itself
Signed-off-by: Afzal Mohammed <afzal@ti.com>
---
arch/arm/mach-omap2/gpmc.c | 25 +++++++++++++++++++++++++
arch/arm/plat-omap/include/plat/gpmc.h | 16 ++++++++++++++++
arch/arm/plat-omap/include/plat/nand.h | 1 +
3 files changed, 42 insertions(+)
diff --git a/arch/arm/mach-omap2/gpmc.c b/arch/arm/mach-omap2/gpmc.c
index cf5d8f3..ca7fa83 100644
--- a/arch/arm/mach-omap2/gpmc.c
+++ b/arch/arm/mach-omap2/gpmc.c
@@ -30,6 +30,7 @@
#include <asm/mach-types.h>
#include <plat/gpmc.h>
+#include <plat/nand.h>
#include <plat/sdrc.h>
@@ -766,6 +767,28 @@ static int __init gpmc_init(void)
}
postcore_initcall(gpmc_init);
+static __devinit void gpmc_update_nand_reg(struct gpmc *gpmc,
+ struct omap_nand_platform_data *nand)
+{
+ int cs = nand->cs;
+
+ nand->reg.gpmc_status = gpmc->io_base + GPMC_STATUS;
+ nand->reg.gpmc_nand_command = gpmc->io_base + GPMC_CS0_OFFSET +
+ GPMC_CS_NAND_COMMAND + GPMC_CS_SIZE * cs;
+ nand->reg.gpmc_nand_address = gpmc->io_base + GPMC_CS0_OFFSET +
+ GPMC_CS_NAND_ADDRESS + GPMC_CS_SIZE * cs;
+ nand->reg.gpmc_nand_data = gpmc->io_base + GPMC_CS0_OFFSET +
+ GPMC_CS_NAND_DATA + GPMC_CS_SIZE * cs;
+ nand->reg.gpmc_prefetch_config1 = gpmc->io_base + GPMC_PREFETCH_CONFIG1;
+ nand->reg.gpmc_prefetch_config2 = gpmc->io_base + GPMC_PREFETCH_CONFIG2;
+ nand->reg.gpmc_prefetch_control = gpmc->io_base + GPMC_PREFETCH_CONTROL;
+ nand->reg.gpmc_prefetch_status = gpmc->io_base + GPMC_PREFETCH_STATUS;
+ nand->reg.gpmc_ecc_config = gpmc->io_base + GPMC_ECC_CONFIG;
+ nand->reg.gpmc_ecc_control = gpmc->io_base + GPMC_ECC_CONTROL;
+ nand->reg.gpmc_ecc_size_config = gpmc->io_base + GPMC_ECC_SIZE_CONFIG;
+ nand->reg.gpmc_ecc1_result = gpmc->io_base + GPMC_ECC1_RESULT;
+}
+
static __devinit struct resource gpmc_setup_cs_mem(struct gpmc_cs_data *p,
struct gpmc_device_pdata *gdp, struct gpmc *gpmc)
{
@@ -1066,6 +1089,8 @@ static __devinit int gpmc_probe(struct platform_device *pdev)
gpmc_mem_init();
for (gdq = gp->device_pdata, gd = gpmc->device; *gdq; gdq++, i++) {
+ if ((*gdq)->is_nand)
+ gpmc_update_nand_reg(gpmc, (*gdq)->pdata);
ret = gpmc_setup_device(*gdq, gd, gpmc);
if (IS_ERR_VALUE(ret))
dev_err(gpmc->dev, "gpmc setup on %s failed\n",
diff --git a/arch/arm/plat-omap/include/plat/gpmc.h b/arch/arm/plat-omap/include/plat/gpmc.h
index fa62cdf..a320e71 100644
--- a/arch/arm/plat-omap/include/plat/gpmc.h
+++ b/arch/arm/plat-omap/include/plat/gpmc.h
@@ -169,6 +169,7 @@ struct gpmc_device_pdata {
unsigned num_per_res;
struct gpmc_cs_data *cs_data;
unsigned num_cs;
+ bool is_nand;
};
struct gpmc_pdata {
@@ -179,6 +180,21 @@ struct gpmc_pdata {
unsigned num_irq;
};
+struct gpmc_nand_regs {
+ void __iomem *gpmc_status;
+ void __iomem *gpmc_nand_command;
+ void __iomem *gpmc_nand_address;
+ void __iomem *gpmc_nand_data;
+ void __iomem *gpmc_prefetch_config1;
+ void __iomem *gpmc_prefetch_config2;
+ void __iomem *gpmc_prefetch_control;
+ void __iomem *gpmc_prefetch_status;
+ void __iomem *gpmc_ecc_config;
+ void __iomem *gpmc_ecc_control;
+ void __iomem *gpmc_ecc_size_config;
+ void __iomem *gpmc_ecc1_result;
+};
+
extern unsigned int gpmc_ns_to_ticks(unsigned int time_ns);
extern unsigned int gpmc_ps_to_ticks(unsigned int time_ps);
extern unsigned int gpmc_ticks_to_ns(unsigned int ticks);
diff --git a/arch/arm/plat-omap/include/plat/nand.h b/arch/arm/plat-omap/include/plat/nand.h
index 67fc506..86e4d9c 100644
--- a/arch/arm/plat-omap/include/plat/nand.h
+++ b/arch/arm/plat-omap/include/plat/nand.h
@@ -29,6 +29,7 @@ struct omap_nand_platform_data {
unsigned long phys_base;
int devsize;
enum omap_ecc ecc_opt;
+ struct gpmc_nand_regs reg;
};
/* minimum size for IO mapping */
--
1.7.9.3
^ permalink raw reply related [flat|nested] 73+ messages in thread
* [PATCH v3 3/9] ARM: OMAP2+: nand: create platform data structure
[not found] <cover.1333640054.git.afzal@ti.com>
2012-04-05 15:45 ` Afzal Mohammed
@ 2012-04-05 15:46 ` Afzal Mohammed
2012-04-05 15:46 ` Afzal Mohammed
` (6 subsequent siblings)
8 siblings, 0 replies; 73+ messages in thread
From: Afzal Mohammed @ 2012-04-05 15:46 UTC (permalink / raw)
To: tony, khilman, linux, dwmw2, sameo, grinberg, mike, nm,
artem.bityutskiy, vimal.newwork, dbaryshkov, linux-omap,
linux-arm-kernel, linux-mtd, linux-kernel
Cc: Afzal Mohammed
New API for updating nand platform data. This has
been created by unifying the two existing ones and
taking out gpmc hardware handling.
>From now on, platforms can call omap_nand_init to
initialize platform nand structures, it's fields.
Or can statically create the same.
Acquiring gpmc CS has been removed. Acquiring CS
probably should be avoided, if ever required, do
in GPMC driver.
Signed-off-by: Afzal Mohammed <afzal@ti.com>
---
arch/arm/mach-omap2/board-devkit8000.c | 6 ++-
arch/arm/mach-omap2/board-flash.c | 63 ++++++++++++++--------------
arch/arm/mach-omap2/board-flash.h | 13 ++++--
arch/arm/mach-omap2/board-ldp.c | 4 +-
arch/arm/mach-omap2/board-omap3beagle.c | 6 ++-
arch/arm/mach-omap2/board-omap3touchbook.c | 6 ++-
arch/arm/mach-omap2/board-overo.c | 5 ++-
arch/arm/mach-omap2/board-zoom.c | 5 ++-
arch/arm/mach-omap2/common-board-devices.c | 46 --------------------
arch/arm/mach-omap2/common-board-devices.h | 1 -
10 files changed, 61 insertions(+), 94 deletions(-)
diff --git a/arch/arm/mach-omap2/board-devkit8000.c b/arch/arm/mach-omap2/board-devkit8000.c
index a2010f0..adfcfc1 100644
--- a/arch/arm/mach-omap2/board-devkit8000.c
+++ b/arch/arm/mach-omap2/board-devkit8000.c
@@ -59,6 +59,7 @@
#include "mux.h"
#include "hsmmc.h"
+#include "board-flash.h"
#include "common-board-devices.h"
#define OMAP_DM9000_GPIO_IRQ 25
@@ -648,8 +649,9 @@ static void __init devkit8000_init(void)
usb_musb_init(NULL);
usbhs_init(&usbhs_bdata);
- omap_nand_flash_init(NAND_BUSWIDTH_16, devkit8000_nand_partitions,
- ARRAY_SIZE(devkit8000_nand_partitions));
+ omap_nand_init(devkit8000_nand_partitions,
+ ARRAY_SIZE(devkit8000_nand_partitions), GPMC_CS_NUM + 1,
+ NAND_BUSWIDTH_16, NULL);
/* Ensure SDRC pins are mux'd for self-refresh */
omap_mux_init_signal("sdrc_cke0", OMAP_PIN_OUTPUT);
diff --git a/arch/arm/mach-omap2/board-flash.c b/arch/arm/mach-omap2/board-flash.c
index 0349fd2..26c70b8 100644
--- a/arch/arm/mach-omap2/board-flash.c
+++ b/arch/arm/mach-omap2/board-flash.c
@@ -108,45 +108,45 @@ __init board_onenand_init(struct mtd_partition *nor_parts, u8 nr_parts, u8 cs)
defined(CONFIG_MTD_NAND_OMAP2_MODULE)
/* Note that all values in this struct are in nanoseconds */
-static struct gpmc_timings nand_timings = {
+struct gpmc_timings nand_default_timings[1] = {
+ {
+ .sync_clk = 0,
- .sync_clk = 0,
+ .cs_on = 0,
+ .cs_rd_off = 36,
+ .cs_wr_off = 36,
- .cs_on = 0,
- .cs_rd_off = 36,
- .cs_wr_off = 36,
+ .adv_on = 6,
+ .adv_rd_off = 24,
+ .adv_wr_off = 36,
- .adv_on = 6,
- .adv_rd_off = 24,
- .adv_wr_off = 36,
+ .we_off = 30,
+ .oe_off = 48,
- .we_off = 30,
- .oe_off = 48,
+ .access = 54,
+ .rd_cycle = 72,
+ .wr_cycle = 72,
- .access = 54,
- .rd_cycle = 72,
- .wr_cycle = 72,
-
- .wr_access = 30,
- .wr_data_mux_bus = 0,
+ .wr_access = 30,
+ .wr_data_mux_bus = 0,
+ },
};
-static struct omap_nand_platform_data board_nand_data = {
- .gpmc_t = &nand_timings,
+static struct omap_nand_platform_data omap_nand_data = {
+ .gpmc_t = nand_default_timings,
};
-void
-__init board_nand_init(struct mtd_partition *nand_parts,
- u8 nr_parts, u8 cs, int nand_type)
+struct omap_nand_platform_data *
+__init omap_nand_init(struct mtd_partition *nand_parts, u8 nr_parts, u8 cs,
+ int nand_type, struct gpmc_timings *gpmc_t)
{
- board_nand_data.cs = cs;
- board_nand_data.parts = nand_parts;
- board_nand_data.nr_parts = nr_parts;
- board_nand_data.devsize = nand_type;
-
- board_nand_data.ecc_opt = OMAP_ECC_HAMMING_CODE_DEFAULT;
- board_nand_data.gpmc_irq = OMAP_GPMC_IRQ_BASE + cs;
- gpmc_nand_init(&board_nand_data);
+ omap_nand_data.cs = cs;
+ omap_nand_data.parts = nand_parts;
+ omap_nand_data.nr_parts = nr_parts;
+ omap_nand_data.devsize = nand_type;
+ omap_nand_data.gpmc_t = gpmc_t;
+
+ return &omap_nand_data;
}
#endif /* CONFIG_MTD_NAND_OMAP2 || CONFIG_MTD_NAND_OMAP2_MODULE */
@@ -242,6 +242,7 @@ void __init board_flash_init(struct flash_partitions partition_info[],
if (nandcs > GPMC_CS_NUM)
pr_err("NAND: Unable to find configuration in GPMC\n");
else
- board_nand_init(partition_info[2].parts,
- partition_info[2].nr_parts, nandcs, nand_type);
+ omap_nand_init(partition_info[2].parts,
+ partition_info[2].nr_parts, nandcs,
+ nand_type, nand_default_timings);
}
diff --git a/arch/arm/mach-omap2/board-flash.h b/arch/arm/mach-omap2/board-flash.h
index d25503a..1d3f039 100644
--- a/arch/arm/mach-omap2/board-flash.h
+++ b/arch/arm/mach-omap2/board-flash.h
@@ -39,11 +39,16 @@ static inline void board_flash_init(struct flash_partitions part[],
#if defined(CONFIG_MTD_NAND_OMAP2) || \
defined(CONFIG_MTD_NAND_OMAP2_MODULE)
-extern void board_nand_init(struct mtd_partition *nand_parts,
- u8 nr_parts, u8 cs, int nand_type);
+extern struct gpmc_timings nand_default_timings[];
+extern struct omap_nand_platform_data *
+__init omap_nand_init(struct mtd_partition *nand_parts, u8 nr_parts, u8 cs,
+ int nand_type, struct gpmc_timings *gpmc_t);
#else
-static inline void board_nand_init(struct mtd_partition *nand_parts,
- u8 nr_parts, u8 cs, int nand_type)
+#define nand_default_timings NULL
+static inline struct omap_nand_platform_data *
+omap_nand_init(struct mtd_partition *nand_parts,
+ u8 nr_parts, u8 cs, int nand_type, struct gpmc_timings *gpmc_t)
{
+ return NULL;
}
#endif
diff --git a/arch/arm/mach-omap2/board-ldp.c b/arch/arm/mach-omap2/board-ldp.c
index 1b60495..a2510b2 100644
--- a/arch/arm/mach-omap2/board-ldp.c
+++ b/arch/arm/mach-omap2/board-ldp.c
@@ -427,8 +427,8 @@ static void __init omap_ldp_init(void)
omap_serial_init();
omap_sdrc_init(NULL, NULL);
usb_musb_init(NULL);
- board_nand_init(ldp_nand_partitions,
- ARRAY_SIZE(ldp_nand_partitions), ZOOM_NAND_CS, 0);
+ omap_nand_init(ldp_nand_partitions, ARRAY_SIZE(ldp_nand_partitions),
+ ZOOM_NAND_CS, 0, nand_default_timings);
omap_hsmmc_init(mmc);
ldp_display_init();
diff --git a/arch/arm/mach-omap2/board-omap3beagle.c b/arch/arm/mach-omap2/board-omap3beagle.c
index 7be8d65..f9beece 100644
--- a/arch/arm/mach-omap2/board-omap3beagle.c
+++ b/arch/arm/mach-omap2/board-omap3beagle.c
@@ -51,6 +51,7 @@
#include "mux.h"
#include "hsmmc.h"
#include "pm.h"
+#include "board-flash.h"
#include "common-board-devices.h"
/*
@@ -542,8 +543,9 @@ static void __init omap3_beagle_init(void)
usb_musb_init(NULL);
usbhs_init(&usbhs_bdata);
- omap_nand_flash_init(NAND_BUSWIDTH_16, omap3beagle_nand_partitions,
- ARRAY_SIZE(omap3beagle_nand_partitions));
+ omap_nand_init(omap3beagle_nand_partitions,
+ ARRAY_SIZE(omap3beagle_nand_partitions), GPMC_CS_NUM + 1,
+ NAND_BUSWIDTH_16, NULL);
/* Ensure msecure is mux'd to be able to set the RTC. */
omap_mux_init_signal("sys_drm_msecure", OMAP_PIN_OFF_OUTPUT_HIGH);
diff --git a/arch/arm/mach-omap2/board-omap3touchbook.c b/arch/arm/mach-omap2/board-omap3touchbook.c
index ae2251f..dd917ca 100644
--- a/arch/arm/mach-omap2/board-omap3touchbook.c
+++ b/arch/arm/mach-omap2/board-omap3touchbook.c
@@ -52,6 +52,7 @@
#include "mux.h"
#include "hsmmc.h"
+#include "board-flash.h"
#include "common-board-devices.h"
#include <asm/setup.h>
@@ -370,8 +371,9 @@ static void __init omap3_touchbook_init(void)
omap_ads7846_init(4, OMAP3_TS_GPIO, 310, &ads7846_pdata);
usb_musb_init(NULL);
usbhs_init(&usbhs_bdata);
- omap_nand_flash_init(NAND_BUSWIDTH_16, omap3touchbook_nand_partitions,
- ARRAY_SIZE(omap3touchbook_nand_partitions));
+ omap_nand_init(omap3touchbook_nand_partitions,
+ ARRAY_SIZE(omap3touchbook_nand_partitions), GPMC_CS_NUM + 1,
+ NAND_BUSWIDTH_16, NULL);
/* Ensure SDRC pins are mux'd for self-refresh */
omap_mux_init_signal("sdrc_cke0", OMAP_PIN_OUTPUT);
diff --git a/arch/arm/mach-omap2/board-overo.c b/arch/arm/mach-omap2/board-overo.c
index 33aa391..4b70a31 100644
--- a/arch/arm/mach-omap2/board-overo.c
+++ b/arch/arm/mach-omap2/board-overo.c
@@ -57,6 +57,7 @@
#include "mux.h"
#include "sdram-micron-mt46h32m32lf-6.h"
#include "hsmmc.h"
+#include "board-flash.h"
#include "common-board-devices.h"
#define OVERO_GPIO_BT_XGATE 15
@@ -517,8 +518,8 @@ static void __init overo_init(void)
omap_serial_init();
omap_sdrc_init(mt46h32m32lf6_sdrc_params,
mt46h32m32lf6_sdrc_params);
- omap_nand_flash_init(0, overo_nand_partitions,
- ARRAY_SIZE(overo_nand_partitions));
+ omap_nand_init(overo_nand_partitions,
+ ARRAY_SIZE(overo_nand_partitions), GPMC_CS_NUM + 1, 0, NULL);
usb_musb_init(NULL);
usbhs_init(&usbhs_bdata);
overo_spi_init();
diff --git a/arch/arm/mach-omap2/board-zoom.c b/arch/arm/mach-omap2/board-zoom.c
index 5c20bcc..0faef81 100644
--- a/arch/arm/mach-omap2/board-zoom.c
+++ b/arch/arm/mach-omap2/board-zoom.c
@@ -114,8 +114,9 @@ static void __init omap_zoom_init(void)
usbhs_init(&usbhs_bdata);
}
- board_nand_init(zoom_nand_partitions, ARRAY_SIZE(zoom_nand_partitions),
- ZOOM_NAND_CS, NAND_BUSWIDTH_16);
+ omap_nand_init(zoom_nand_partitions,
+ ARRAY_SIZE(zoom_nand_partitions), ZOOM_NAND_CS,
+ NAND_BUSWIDTH_16, nand_default_timings);
zoom_debugboard_init();
zoom_peripherals_init();
diff --git a/arch/arm/mach-omap2/common-board-devices.c b/arch/arm/mach-omap2/common-board-devices.c
index 1706ebc..0fd35a4 100644
--- a/arch/arm/mach-omap2/common-board-devices.c
+++ b/arch/arm/mach-omap2/common-board-devices.c
@@ -93,49 +93,3 @@ void __init omap_ads7846_init(int bus_num, int gpio_pendown, int gpio_debounce,
{
}
#endif
-
-#if defined(CONFIG_MTD_NAND_OMAP2) || defined(CONFIG_MTD_NAND_OMAP2_MODULE)
-static struct omap_nand_platform_data nand_data;
-
-void __init omap_nand_flash_init(int options, struct mtd_partition *parts,
- int nr_parts)
-{
- u8 cs = 0;
- u8 nandcs = GPMC_CS_NUM + 1;
-
- /* find out the chip-select on which NAND exists */
- while (cs < GPMC_CS_NUM) {
- u32 ret = 0;
- ret = gpmc_cs_read_reg(cs, GPMC_CS_CONFIG1);
-
- if ((ret & 0xC00) == 0x800) {
- printk(KERN_INFO "Found NAND on CS%d\n", cs);
- if (nandcs > GPMC_CS_NUM)
- nandcs = cs;
- }
- cs++;
- }
-
- if (nandcs > GPMC_CS_NUM) {
- printk(KERN_INFO "NAND: Unable to find configuration "
- "in GPMC\n ");
- return;
- }
-
- if (nandcs < GPMC_CS_NUM) {
- nand_data.cs = nandcs;
- nand_data.parts = parts;
- nand_data.nr_parts = nr_parts;
- nand_data.devsize = options;
-
- printk(KERN_INFO "Registering NAND on CS%d\n", nandcs);
- if (gpmc_nand_init(&nand_data) < 0)
- printk(KERN_ERR "Unable to register NAND device\n");
- }
-}
-#else
-void __init omap_nand_flash_init(int options, struct mtd_partition *parts,
- int nr_parts)
-{
-}
-#endif
diff --git a/arch/arm/mach-omap2/common-board-devices.h b/arch/arm/mach-omap2/common-board-devices.h
index a0b4a428..72bb41b 100644
--- a/arch/arm/mach-omap2/common-board-devices.h
+++ b/arch/arm/mach-omap2/common-board-devices.h
@@ -10,6 +10,5 @@ struct ads7846_platform_data;
void omap_ads7846_init(int bus_num, int gpio_pendown, int gpio_debounce,
struct ads7846_platform_data *board_pdata);
-void omap_nand_flash_init(int opts, struct mtd_partition *parts, int n_parts);
#endif /* __OMAP_COMMON_BOARD_DEVICES__ */
--
1.7.9.3
^ permalink raw reply related [flat|nested] 73+ messages in thread
* [PATCH v3 3/9] ARM: OMAP2+: nand: create platform data structure
@ 2012-04-05 15:46 ` Afzal Mohammed
0 siblings, 0 replies; 73+ messages in thread
From: Afzal Mohammed @ 2012-04-05 15:46 UTC (permalink / raw)
To: tony, khilman, linux, dwmw2, sameo, grinberg, mike, nm,
artem.bityutskiy, vimal.newwork, dbaryshkov, linux-omap,
linux-arm-kernel, linux-mtd, linux-kernel
Cc: Afzal Mohammed
New API for updating nand platform data. This has
been created by unifying the two existing ones and
taking out gpmc hardware handling.
>From now on, platforms can call omap_nand_init to
initialize platform nand structures, it's fields.
Or can statically create the same.
Acquiring gpmc CS has been removed. Acquiring CS
probably should be avoided, if ever required, do
in GPMC driver.
Signed-off-by: Afzal Mohammed <afzal@ti.com>
---
arch/arm/mach-omap2/board-devkit8000.c | 6 ++-
arch/arm/mach-omap2/board-flash.c | 63 ++++++++++++++--------------
arch/arm/mach-omap2/board-flash.h | 13 ++++--
arch/arm/mach-omap2/board-ldp.c | 4 +-
arch/arm/mach-omap2/board-omap3beagle.c | 6 ++-
arch/arm/mach-omap2/board-omap3touchbook.c | 6 ++-
arch/arm/mach-omap2/board-overo.c | 5 ++-
arch/arm/mach-omap2/board-zoom.c | 5 ++-
arch/arm/mach-omap2/common-board-devices.c | 46 --------------------
arch/arm/mach-omap2/common-board-devices.h | 1 -
10 files changed, 61 insertions(+), 94 deletions(-)
diff --git a/arch/arm/mach-omap2/board-devkit8000.c b/arch/arm/mach-omap2/board-devkit8000.c
index a2010f0..adfcfc1 100644
--- a/arch/arm/mach-omap2/board-devkit8000.c
+++ b/arch/arm/mach-omap2/board-devkit8000.c
@@ -59,6 +59,7 @@
#include "mux.h"
#include "hsmmc.h"
+#include "board-flash.h"
#include "common-board-devices.h"
#define OMAP_DM9000_GPIO_IRQ 25
@@ -648,8 +649,9 @@ static void __init devkit8000_init(void)
usb_musb_init(NULL);
usbhs_init(&usbhs_bdata);
- omap_nand_flash_init(NAND_BUSWIDTH_16, devkit8000_nand_partitions,
- ARRAY_SIZE(devkit8000_nand_partitions));
+ omap_nand_init(devkit8000_nand_partitions,
+ ARRAY_SIZE(devkit8000_nand_partitions), GPMC_CS_NUM + 1,
+ NAND_BUSWIDTH_16, NULL);
/* Ensure SDRC pins are mux'd for self-refresh */
omap_mux_init_signal("sdrc_cke0", OMAP_PIN_OUTPUT);
diff --git a/arch/arm/mach-omap2/board-flash.c b/arch/arm/mach-omap2/board-flash.c
index 0349fd2..26c70b8 100644
--- a/arch/arm/mach-omap2/board-flash.c
+++ b/arch/arm/mach-omap2/board-flash.c
@@ -108,45 +108,45 @@ __init board_onenand_init(struct mtd_partition *nor_parts, u8 nr_parts, u8 cs)
defined(CONFIG_MTD_NAND_OMAP2_MODULE)
/* Note that all values in this struct are in nanoseconds */
-static struct gpmc_timings nand_timings = {
+struct gpmc_timings nand_default_timings[1] = {
+ {
+ .sync_clk = 0,
- .sync_clk = 0,
+ .cs_on = 0,
+ .cs_rd_off = 36,
+ .cs_wr_off = 36,
- .cs_on = 0,
- .cs_rd_off = 36,
- .cs_wr_off = 36,
+ .adv_on = 6,
+ .adv_rd_off = 24,
+ .adv_wr_off = 36,
- .adv_on = 6,
- .adv_rd_off = 24,
- .adv_wr_off = 36,
+ .we_off = 30,
+ .oe_off = 48,
- .we_off = 30,
- .oe_off = 48,
+ .access = 54,
+ .rd_cycle = 72,
+ .wr_cycle = 72,
- .access = 54,
- .rd_cycle = 72,
- .wr_cycle = 72,
-
- .wr_access = 30,
- .wr_data_mux_bus = 0,
+ .wr_access = 30,
+ .wr_data_mux_bus = 0,
+ },
};
-static struct omap_nand_platform_data board_nand_data = {
- .gpmc_t = &nand_timings,
+static struct omap_nand_platform_data omap_nand_data = {
+ .gpmc_t = nand_default_timings,
};
-void
-__init board_nand_init(struct mtd_partition *nand_parts,
- u8 nr_parts, u8 cs, int nand_type)
+struct omap_nand_platform_data *
+__init omap_nand_init(struct mtd_partition *nand_parts, u8 nr_parts, u8 cs,
+ int nand_type, struct gpmc_timings *gpmc_t)
{
- board_nand_data.cs = cs;
- board_nand_data.parts = nand_parts;
- board_nand_data.nr_parts = nr_parts;
- board_nand_data.devsize = nand_type;
-
- board_nand_data.ecc_opt = OMAP_ECC_HAMMING_CODE_DEFAULT;
- board_nand_data.gpmc_irq = OMAP_GPMC_IRQ_BASE + cs;
- gpmc_nand_init(&board_nand_data);
+ omap_nand_data.cs = cs;
+ omap_nand_data.parts = nand_parts;
+ omap_nand_data.nr_parts = nr_parts;
+ omap_nand_data.devsize = nand_type;
+ omap_nand_data.gpmc_t = gpmc_t;
+
+ return &omap_nand_data;
}
#endif /* CONFIG_MTD_NAND_OMAP2 || CONFIG_MTD_NAND_OMAP2_MODULE */
@@ -242,6 +242,7 @@ void __init board_flash_init(struct flash_partitions partition_info[],
if (nandcs > GPMC_CS_NUM)
pr_err("NAND: Unable to find configuration in GPMC\n");
else
- board_nand_init(partition_info[2].parts,
- partition_info[2].nr_parts, nandcs, nand_type);
+ omap_nand_init(partition_info[2].parts,
+ partition_info[2].nr_parts, nandcs,
+ nand_type, nand_default_timings);
}
diff --git a/arch/arm/mach-omap2/board-flash.h b/arch/arm/mach-omap2/board-flash.h
index d25503a..1d3f039 100644
--- a/arch/arm/mach-omap2/board-flash.h
+++ b/arch/arm/mach-omap2/board-flash.h
@@ -39,11 +39,16 @@ static inline void board_flash_init(struct flash_partitions part[],
#if defined(CONFIG_MTD_NAND_OMAP2) || \
defined(CONFIG_MTD_NAND_OMAP2_MODULE)
-extern void board_nand_init(struct mtd_partition *nand_parts,
- u8 nr_parts, u8 cs, int nand_type);
+extern struct gpmc_timings nand_default_timings[];
+extern struct omap_nand_platform_data *
+__init omap_nand_init(struct mtd_partition *nand_parts, u8 nr_parts, u8 cs,
+ int nand_type, struct gpmc_timings *gpmc_t);
#else
-static inline void board_nand_init(struct mtd_partition *nand_parts,
- u8 nr_parts, u8 cs, int nand_type)
+#define nand_default_timings NULL
+static inline struct omap_nand_platform_data *
+omap_nand_init(struct mtd_partition *nand_parts,
+ u8 nr_parts, u8 cs, int nand_type, struct gpmc_timings *gpmc_t)
{
+ return NULL;
}
#endif
diff --git a/arch/arm/mach-omap2/board-ldp.c b/arch/arm/mach-omap2/board-ldp.c
index 1b60495..a2510b2 100644
--- a/arch/arm/mach-omap2/board-ldp.c
+++ b/arch/arm/mach-omap2/board-ldp.c
@@ -427,8 +427,8 @@ static void __init omap_ldp_init(void)
omap_serial_init();
omap_sdrc_init(NULL, NULL);
usb_musb_init(NULL);
- board_nand_init(ldp_nand_partitions,
- ARRAY_SIZE(ldp_nand_partitions), ZOOM_NAND_CS, 0);
+ omap_nand_init(ldp_nand_partitions, ARRAY_SIZE(ldp_nand_partitions),
+ ZOOM_NAND_CS, 0, nand_default_timings);
omap_hsmmc_init(mmc);
ldp_display_init();
diff --git a/arch/arm/mach-omap2/board-omap3beagle.c b/arch/arm/mach-omap2/board-omap3beagle.c
index 7be8d65..f9beece 100644
--- a/arch/arm/mach-omap2/board-omap3beagle.c
+++ b/arch/arm/mach-omap2/board-omap3beagle.c
@@ -51,6 +51,7 @@
#include "mux.h"
#include "hsmmc.h"
#include "pm.h"
+#include "board-flash.h"
#include "common-board-devices.h"
/*
@@ -542,8 +543,9 @@ static void __init omap3_beagle_init(void)
usb_musb_init(NULL);
usbhs_init(&usbhs_bdata);
- omap_nand_flash_init(NAND_BUSWIDTH_16, omap3beagle_nand_partitions,
- ARRAY_SIZE(omap3beagle_nand_partitions));
+ omap_nand_init(omap3beagle_nand_partitions,
+ ARRAY_SIZE(omap3beagle_nand_partitions), GPMC_CS_NUM + 1,
+ NAND_BUSWIDTH_16, NULL);
/* Ensure msecure is mux'd to be able to set the RTC. */
omap_mux_init_signal("sys_drm_msecure", OMAP_PIN_OFF_OUTPUT_HIGH);
diff --git a/arch/arm/mach-omap2/board-omap3touchbook.c b/arch/arm/mach-omap2/board-omap3touchbook.c
index ae2251f..dd917ca 100644
--- a/arch/arm/mach-omap2/board-omap3touchbook.c
+++ b/arch/arm/mach-omap2/board-omap3touchbook.c
@@ -52,6 +52,7 @@
#include "mux.h"
#include "hsmmc.h"
+#include "board-flash.h"
#include "common-board-devices.h"
#include <asm/setup.h>
@@ -370,8 +371,9 @@ static void __init omap3_touchbook_init(void)
omap_ads7846_init(4, OMAP3_TS_GPIO, 310, &ads7846_pdata);
usb_musb_init(NULL);
usbhs_init(&usbhs_bdata);
- omap_nand_flash_init(NAND_BUSWIDTH_16, omap3touchbook_nand_partitions,
- ARRAY_SIZE(omap3touchbook_nand_partitions));
+ omap_nand_init(omap3touchbook_nand_partitions,
+ ARRAY_SIZE(omap3touchbook_nand_partitions), GPMC_CS_NUM + 1,
+ NAND_BUSWIDTH_16, NULL);
/* Ensure SDRC pins are mux'd for self-refresh */
omap_mux_init_signal("sdrc_cke0", OMAP_PIN_OUTPUT);
diff --git a/arch/arm/mach-omap2/board-overo.c b/arch/arm/mach-omap2/board-overo.c
index 33aa391..4b70a31 100644
--- a/arch/arm/mach-omap2/board-overo.c
+++ b/arch/arm/mach-omap2/board-overo.c
@@ -57,6 +57,7 @@
#include "mux.h"
#include "sdram-micron-mt46h32m32lf-6.h"
#include "hsmmc.h"
+#include "board-flash.h"
#include "common-board-devices.h"
#define OVERO_GPIO_BT_XGATE 15
@@ -517,8 +518,8 @@ static void __init overo_init(void)
omap_serial_init();
omap_sdrc_init(mt46h32m32lf6_sdrc_params,
mt46h32m32lf6_sdrc_params);
- omap_nand_flash_init(0, overo_nand_partitions,
- ARRAY_SIZE(overo_nand_partitions));
+ omap_nand_init(overo_nand_partitions,
+ ARRAY_SIZE(overo_nand_partitions), GPMC_CS_NUM + 1, 0, NULL);
usb_musb_init(NULL);
usbhs_init(&usbhs_bdata);
overo_spi_init();
diff --git a/arch/arm/mach-omap2/board-zoom.c b/arch/arm/mach-omap2/board-zoom.c
index 5c20bcc..0faef81 100644
--- a/arch/arm/mach-omap2/board-zoom.c
+++ b/arch/arm/mach-omap2/board-zoom.c
@@ -114,8 +114,9 @@ static void __init omap_zoom_init(void)
usbhs_init(&usbhs_bdata);
}
- board_nand_init(zoom_nand_partitions, ARRAY_SIZE(zoom_nand_partitions),
- ZOOM_NAND_CS, NAND_BUSWIDTH_16);
+ omap_nand_init(zoom_nand_partitions,
+ ARRAY_SIZE(zoom_nand_partitions), ZOOM_NAND_CS,
+ NAND_BUSWIDTH_16, nand_default_timings);
zoom_debugboard_init();
zoom_peripherals_init();
diff --git a/arch/arm/mach-omap2/common-board-devices.c b/arch/arm/mach-omap2/common-board-devices.c
index 1706ebc..0fd35a4 100644
--- a/arch/arm/mach-omap2/common-board-devices.c
+++ b/arch/arm/mach-omap2/common-board-devices.c
@@ -93,49 +93,3 @@ void __init omap_ads7846_init(int bus_num, int gpio_pendown, int gpio_debounce,
{
}
#endif
-
-#if defined(CONFIG_MTD_NAND_OMAP2) || defined(CONFIG_MTD_NAND_OMAP2_MODULE)
-static struct omap_nand_platform_data nand_data;
-
-void __init omap_nand_flash_init(int options, struct mtd_partition *parts,
- int nr_parts)
-{
- u8 cs = 0;
- u8 nandcs = GPMC_CS_NUM + 1;
-
- /* find out the chip-select on which NAND exists */
- while (cs < GPMC_CS_NUM) {
- u32 ret = 0;
- ret = gpmc_cs_read_reg(cs, GPMC_CS_CONFIG1);
-
- if ((ret & 0xC00) == 0x800) {
- printk(KERN_INFO "Found NAND on CS%d\n", cs);
- if (nandcs > GPMC_CS_NUM)
- nandcs = cs;
- }
- cs++;
- }
-
- if (nandcs > GPMC_CS_NUM) {
- printk(KERN_INFO "NAND: Unable to find configuration "
- "in GPMC\n ");
- return;
- }
-
- if (nandcs < GPMC_CS_NUM) {
- nand_data.cs = nandcs;
- nand_data.parts = parts;
- nand_data.nr_parts = nr_parts;
- nand_data.devsize = options;
-
- printk(KERN_INFO "Registering NAND on CS%d\n", nandcs);
- if (gpmc_nand_init(&nand_data) < 0)
- printk(KERN_ERR "Unable to register NAND device\n");
- }
-}
-#else
-void __init omap_nand_flash_init(int options, struct mtd_partition *parts,
- int nr_parts)
-{
-}
-#endif
diff --git a/arch/arm/mach-omap2/common-board-devices.h b/arch/arm/mach-omap2/common-board-devices.h
index a0b4a428..72bb41b 100644
--- a/arch/arm/mach-omap2/common-board-devices.h
+++ b/arch/arm/mach-omap2/common-board-devices.h
@@ -10,6 +10,5 @@ struct ads7846_platform_data;
void omap_ads7846_init(int bus_num, int gpio_pendown, int gpio_debounce,
struct ads7846_platform_data *board_pdata);
-void omap_nand_flash_init(int opts, struct mtd_partition *parts, int n_parts);
#endif /* __OMAP_COMMON_BOARD_DEVICES__ */
--
1.7.9.3
^ permalink raw reply related [flat|nested] 73+ messages in thread
* [PATCH v3 3/9] ARM: OMAP2+: nand: create platform data structure
@ 2012-04-05 15:46 ` Afzal Mohammed
0 siblings, 0 replies; 73+ messages in thread
From: Afzal Mohammed @ 2012-04-05 15:46 UTC (permalink / raw)
To: linux-arm-kernel
New API for updating nand platform data. This has
been created by unifying the two existing ones and
taking out gpmc hardware handling.
>From now on, platforms can call omap_nand_init to
initialize platform nand structures, it's fields.
Or can statically create the same.
Acquiring gpmc CS has been removed. Acquiring CS
probably should be avoided, if ever required, do
in GPMC driver.
Signed-off-by: Afzal Mohammed <afzal@ti.com>
---
arch/arm/mach-omap2/board-devkit8000.c | 6 ++-
arch/arm/mach-omap2/board-flash.c | 63 ++++++++++++++--------------
arch/arm/mach-omap2/board-flash.h | 13 ++++--
arch/arm/mach-omap2/board-ldp.c | 4 +-
arch/arm/mach-omap2/board-omap3beagle.c | 6 ++-
arch/arm/mach-omap2/board-omap3touchbook.c | 6 ++-
arch/arm/mach-omap2/board-overo.c | 5 ++-
arch/arm/mach-omap2/board-zoom.c | 5 ++-
arch/arm/mach-omap2/common-board-devices.c | 46 --------------------
arch/arm/mach-omap2/common-board-devices.h | 1 -
10 files changed, 61 insertions(+), 94 deletions(-)
diff --git a/arch/arm/mach-omap2/board-devkit8000.c b/arch/arm/mach-omap2/board-devkit8000.c
index a2010f0..adfcfc1 100644
--- a/arch/arm/mach-omap2/board-devkit8000.c
+++ b/arch/arm/mach-omap2/board-devkit8000.c
@@ -59,6 +59,7 @@
#include "mux.h"
#include "hsmmc.h"
+#include "board-flash.h"
#include "common-board-devices.h"
#define OMAP_DM9000_GPIO_IRQ 25
@@ -648,8 +649,9 @@ static void __init devkit8000_init(void)
usb_musb_init(NULL);
usbhs_init(&usbhs_bdata);
- omap_nand_flash_init(NAND_BUSWIDTH_16, devkit8000_nand_partitions,
- ARRAY_SIZE(devkit8000_nand_partitions));
+ omap_nand_init(devkit8000_nand_partitions,
+ ARRAY_SIZE(devkit8000_nand_partitions), GPMC_CS_NUM + 1,
+ NAND_BUSWIDTH_16, NULL);
/* Ensure SDRC pins are mux'd for self-refresh */
omap_mux_init_signal("sdrc_cke0", OMAP_PIN_OUTPUT);
diff --git a/arch/arm/mach-omap2/board-flash.c b/arch/arm/mach-omap2/board-flash.c
index 0349fd2..26c70b8 100644
--- a/arch/arm/mach-omap2/board-flash.c
+++ b/arch/arm/mach-omap2/board-flash.c
@@ -108,45 +108,45 @@ __init board_onenand_init(struct mtd_partition *nor_parts, u8 nr_parts, u8 cs)
defined(CONFIG_MTD_NAND_OMAP2_MODULE)
/* Note that all values in this struct are in nanoseconds */
-static struct gpmc_timings nand_timings = {
+struct gpmc_timings nand_default_timings[1] = {
+ {
+ .sync_clk = 0,
- .sync_clk = 0,
+ .cs_on = 0,
+ .cs_rd_off = 36,
+ .cs_wr_off = 36,
- .cs_on = 0,
- .cs_rd_off = 36,
- .cs_wr_off = 36,
+ .adv_on = 6,
+ .adv_rd_off = 24,
+ .adv_wr_off = 36,
- .adv_on = 6,
- .adv_rd_off = 24,
- .adv_wr_off = 36,
+ .we_off = 30,
+ .oe_off = 48,
- .we_off = 30,
- .oe_off = 48,
+ .access = 54,
+ .rd_cycle = 72,
+ .wr_cycle = 72,
- .access = 54,
- .rd_cycle = 72,
- .wr_cycle = 72,
-
- .wr_access = 30,
- .wr_data_mux_bus = 0,
+ .wr_access = 30,
+ .wr_data_mux_bus = 0,
+ },
};
-static struct omap_nand_platform_data board_nand_data = {
- .gpmc_t = &nand_timings,
+static struct omap_nand_platform_data omap_nand_data = {
+ .gpmc_t = nand_default_timings,
};
-void
-__init board_nand_init(struct mtd_partition *nand_parts,
- u8 nr_parts, u8 cs, int nand_type)
+struct omap_nand_platform_data *
+__init omap_nand_init(struct mtd_partition *nand_parts, u8 nr_parts, u8 cs,
+ int nand_type, struct gpmc_timings *gpmc_t)
{
- board_nand_data.cs = cs;
- board_nand_data.parts = nand_parts;
- board_nand_data.nr_parts = nr_parts;
- board_nand_data.devsize = nand_type;
-
- board_nand_data.ecc_opt = OMAP_ECC_HAMMING_CODE_DEFAULT;
- board_nand_data.gpmc_irq = OMAP_GPMC_IRQ_BASE + cs;
- gpmc_nand_init(&board_nand_data);
+ omap_nand_data.cs = cs;
+ omap_nand_data.parts = nand_parts;
+ omap_nand_data.nr_parts = nr_parts;
+ omap_nand_data.devsize = nand_type;
+ omap_nand_data.gpmc_t = gpmc_t;
+
+ return &omap_nand_data;
}
#endif /* CONFIG_MTD_NAND_OMAP2 || CONFIG_MTD_NAND_OMAP2_MODULE */
@@ -242,6 +242,7 @@ void __init board_flash_init(struct flash_partitions partition_info[],
if (nandcs > GPMC_CS_NUM)
pr_err("NAND: Unable to find configuration in GPMC\n");
else
- board_nand_init(partition_info[2].parts,
- partition_info[2].nr_parts, nandcs, nand_type);
+ omap_nand_init(partition_info[2].parts,
+ partition_info[2].nr_parts, nandcs,
+ nand_type, nand_default_timings);
}
diff --git a/arch/arm/mach-omap2/board-flash.h b/arch/arm/mach-omap2/board-flash.h
index d25503a..1d3f039 100644
--- a/arch/arm/mach-omap2/board-flash.h
+++ b/arch/arm/mach-omap2/board-flash.h
@@ -39,11 +39,16 @@ static inline void board_flash_init(struct flash_partitions part[],
#if defined(CONFIG_MTD_NAND_OMAP2) || \
defined(CONFIG_MTD_NAND_OMAP2_MODULE)
-extern void board_nand_init(struct mtd_partition *nand_parts,
- u8 nr_parts, u8 cs, int nand_type);
+extern struct gpmc_timings nand_default_timings[];
+extern struct omap_nand_platform_data *
+__init omap_nand_init(struct mtd_partition *nand_parts, u8 nr_parts, u8 cs,
+ int nand_type, struct gpmc_timings *gpmc_t);
#else
-static inline void board_nand_init(struct mtd_partition *nand_parts,
- u8 nr_parts, u8 cs, int nand_type)
+#define nand_default_timings NULL
+static inline struct omap_nand_platform_data *
+omap_nand_init(struct mtd_partition *nand_parts,
+ u8 nr_parts, u8 cs, int nand_type, struct gpmc_timings *gpmc_t)
{
+ return NULL;
}
#endif
diff --git a/arch/arm/mach-omap2/board-ldp.c b/arch/arm/mach-omap2/board-ldp.c
index 1b60495..a2510b2 100644
--- a/arch/arm/mach-omap2/board-ldp.c
+++ b/arch/arm/mach-omap2/board-ldp.c
@@ -427,8 +427,8 @@ static void __init omap_ldp_init(void)
omap_serial_init();
omap_sdrc_init(NULL, NULL);
usb_musb_init(NULL);
- board_nand_init(ldp_nand_partitions,
- ARRAY_SIZE(ldp_nand_partitions), ZOOM_NAND_CS, 0);
+ omap_nand_init(ldp_nand_partitions, ARRAY_SIZE(ldp_nand_partitions),
+ ZOOM_NAND_CS, 0, nand_default_timings);
omap_hsmmc_init(mmc);
ldp_display_init();
diff --git a/arch/arm/mach-omap2/board-omap3beagle.c b/arch/arm/mach-omap2/board-omap3beagle.c
index 7be8d65..f9beece 100644
--- a/arch/arm/mach-omap2/board-omap3beagle.c
+++ b/arch/arm/mach-omap2/board-omap3beagle.c
@@ -51,6 +51,7 @@
#include "mux.h"
#include "hsmmc.h"
#include "pm.h"
+#include "board-flash.h"
#include "common-board-devices.h"
/*
@@ -542,8 +543,9 @@ static void __init omap3_beagle_init(void)
usb_musb_init(NULL);
usbhs_init(&usbhs_bdata);
- omap_nand_flash_init(NAND_BUSWIDTH_16, omap3beagle_nand_partitions,
- ARRAY_SIZE(omap3beagle_nand_partitions));
+ omap_nand_init(omap3beagle_nand_partitions,
+ ARRAY_SIZE(omap3beagle_nand_partitions), GPMC_CS_NUM + 1,
+ NAND_BUSWIDTH_16, NULL);
/* Ensure msecure is mux'd to be able to set the RTC. */
omap_mux_init_signal("sys_drm_msecure", OMAP_PIN_OFF_OUTPUT_HIGH);
diff --git a/arch/arm/mach-omap2/board-omap3touchbook.c b/arch/arm/mach-omap2/board-omap3touchbook.c
index ae2251f..dd917ca 100644
--- a/arch/arm/mach-omap2/board-omap3touchbook.c
+++ b/arch/arm/mach-omap2/board-omap3touchbook.c
@@ -52,6 +52,7 @@
#include "mux.h"
#include "hsmmc.h"
+#include "board-flash.h"
#include "common-board-devices.h"
#include <asm/setup.h>
@@ -370,8 +371,9 @@ static void __init omap3_touchbook_init(void)
omap_ads7846_init(4, OMAP3_TS_GPIO, 310, &ads7846_pdata);
usb_musb_init(NULL);
usbhs_init(&usbhs_bdata);
- omap_nand_flash_init(NAND_BUSWIDTH_16, omap3touchbook_nand_partitions,
- ARRAY_SIZE(omap3touchbook_nand_partitions));
+ omap_nand_init(omap3touchbook_nand_partitions,
+ ARRAY_SIZE(omap3touchbook_nand_partitions), GPMC_CS_NUM + 1,
+ NAND_BUSWIDTH_16, NULL);
/* Ensure SDRC pins are mux'd for self-refresh */
omap_mux_init_signal("sdrc_cke0", OMAP_PIN_OUTPUT);
diff --git a/arch/arm/mach-omap2/board-overo.c b/arch/arm/mach-omap2/board-overo.c
index 33aa391..4b70a31 100644
--- a/arch/arm/mach-omap2/board-overo.c
+++ b/arch/arm/mach-omap2/board-overo.c
@@ -57,6 +57,7 @@
#include "mux.h"
#include "sdram-micron-mt46h32m32lf-6.h"
#include "hsmmc.h"
+#include "board-flash.h"
#include "common-board-devices.h"
#define OVERO_GPIO_BT_XGATE 15
@@ -517,8 +518,8 @@ static void __init overo_init(void)
omap_serial_init();
omap_sdrc_init(mt46h32m32lf6_sdrc_params,
mt46h32m32lf6_sdrc_params);
- omap_nand_flash_init(0, overo_nand_partitions,
- ARRAY_SIZE(overo_nand_partitions));
+ omap_nand_init(overo_nand_partitions,
+ ARRAY_SIZE(overo_nand_partitions), GPMC_CS_NUM + 1, 0, NULL);
usb_musb_init(NULL);
usbhs_init(&usbhs_bdata);
overo_spi_init();
diff --git a/arch/arm/mach-omap2/board-zoom.c b/arch/arm/mach-omap2/board-zoom.c
index 5c20bcc..0faef81 100644
--- a/arch/arm/mach-omap2/board-zoom.c
+++ b/arch/arm/mach-omap2/board-zoom.c
@@ -114,8 +114,9 @@ static void __init omap_zoom_init(void)
usbhs_init(&usbhs_bdata);
}
- board_nand_init(zoom_nand_partitions, ARRAY_SIZE(zoom_nand_partitions),
- ZOOM_NAND_CS, NAND_BUSWIDTH_16);
+ omap_nand_init(zoom_nand_partitions,
+ ARRAY_SIZE(zoom_nand_partitions), ZOOM_NAND_CS,
+ NAND_BUSWIDTH_16, nand_default_timings);
zoom_debugboard_init();
zoom_peripherals_init();
diff --git a/arch/arm/mach-omap2/common-board-devices.c b/arch/arm/mach-omap2/common-board-devices.c
index 1706ebc..0fd35a4 100644
--- a/arch/arm/mach-omap2/common-board-devices.c
+++ b/arch/arm/mach-omap2/common-board-devices.c
@@ -93,49 +93,3 @@ void __init omap_ads7846_init(int bus_num, int gpio_pendown, int gpio_debounce,
{
}
#endif
-
-#if defined(CONFIG_MTD_NAND_OMAP2) || defined(CONFIG_MTD_NAND_OMAP2_MODULE)
-static struct omap_nand_platform_data nand_data;
-
-void __init omap_nand_flash_init(int options, struct mtd_partition *parts,
- int nr_parts)
-{
- u8 cs = 0;
- u8 nandcs = GPMC_CS_NUM + 1;
-
- /* find out the chip-select on which NAND exists */
- while (cs < GPMC_CS_NUM) {
- u32 ret = 0;
- ret = gpmc_cs_read_reg(cs, GPMC_CS_CONFIG1);
-
- if ((ret & 0xC00) == 0x800) {
- printk(KERN_INFO "Found NAND on CS%d\n", cs);
- if (nandcs > GPMC_CS_NUM)
- nandcs = cs;
- }
- cs++;
- }
-
- if (nandcs > GPMC_CS_NUM) {
- printk(KERN_INFO "NAND: Unable to find configuration "
- "in GPMC\n ");
- return;
- }
-
- if (nandcs < GPMC_CS_NUM) {
- nand_data.cs = nandcs;
- nand_data.parts = parts;
- nand_data.nr_parts = nr_parts;
- nand_data.devsize = options;
-
- printk(KERN_INFO "Registering NAND on CS%d\n", nandcs);
- if (gpmc_nand_init(&nand_data) < 0)
- printk(KERN_ERR "Unable to register NAND device\n");
- }
-}
-#else
-void __init omap_nand_flash_init(int options, struct mtd_partition *parts,
- int nr_parts)
-{
-}
-#endif
diff --git a/arch/arm/mach-omap2/common-board-devices.h b/arch/arm/mach-omap2/common-board-devices.h
index a0b4a428..72bb41b 100644
--- a/arch/arm/mach-omap2/common-board-devices.h
+++ b/arch/arm/mach-omap2/common-board-devices.h
@@ -10,6 +10,5 @@ struct ads7846_platform_data;
void omap_ads7846_init(int bus_num, int gpio_pendown, int gpio_debounce,
struct ads7846_platform_data *board_pdata);
-void omap_nand_flash_init(int opts, struct mtd_partition *parts, int n_parts);
#endif /* __OMAP_COMMON_BOARD_DEVICES__ */
--
1.7.9.3
^ permalink raw reply related [flat|nested] 73+ messages in thread
* [PATCH v3 4/9] ARM: OMAP2+: gpmc-nand: populate gpmc configs
[not found] <cover.1333640054.git.afzal@ti.com>
2012-04-05 15:45 ` Afzal Mohammed
@ 2012-04-05 15:46 ` Afzal Mohammed
2012-04-05 15:46 ` Afzal Mohammed
` (6 subsequent siblings)
8 siblings, 0 replies; 73+ messages in thread
From: Afzal Mohammed @ 2012-04-05 15:46 UTC (permalink / raw)
To: tony, khilman, linux, dwmw2, sameo, grinberg, mike, nm,
artem.bityutskiy, vimal.newwork, dbaryshkov, linux-omap,
linux-arm-kernel, linux-mtd, linux-kernel
Cc: Afzal Mohammed
Currently gpmc is configured in platform for nand.
As configuring gpmc has been moved to gpmc driver,
populate details needed for the driver to configure
gpmc. gpmc driver would configure based on this
information.
Signed-off-by: Afzal Mohammed <afzal@ti.com>
---
arch/arm/mach-omap2/gpmc-nand.c | 97 ++++++++++++++------------------
arch/arm/plat-omap/include/plat/nand.h | 8 ++-
2 files changed, 48 insertions(+), 57 deletions(-)
diff --git a/arch/arm/mach-omap2/gpmc-nand.c b/arch/arm/mach-omap2/gpmc-nand.c
index 386dec8..85de31f 100644
--- a/arch/arm/mach-omap2/gpmc-nand.c
+++ b/arch/arm/mach-omap2/gpmc-nand.c
@@ -21,24 +21,38 @@
#include <plat/board.h>
#include <plat/gpmc.h>
-static struct resource gpmc_nand_resource = {
- .flags = IORESOURCE_MEM,
+
+#define GPMC_NAND_CONFIG_NUM 4
+#define IDX_DEV_SIZE 2
+#define IDX_RDY_BSY 3
+
+static struct gpmc_config gpmc_nand_config[GPMC_NAND_CONFIG_NUM] = {
+ { GPMC_CONFIG_DEV_TYPE, GPMC_DEVICETYPE_NAND},
+ { GPMC_CONFIG_WP, 0},
};
-static struct platform_device gpmc_nand_device = {
+static struct gpmc_cs_data gpmc_nand_cs_info = {
+ .config = gpmc_nand_config,
+ .num_config = ARRAY_SIZE(gpmc_nand_config),
+ .irq_flags = GPMC_IRQ_FIFOEVENT | GPMC_IRQ_TERMINALCOUNT,
+};
+
+static struct gpmc_device_pdata gpmc_nand_info = {
.name = "omap2-nand",
.id = 0,
- .num_resources = 1,
- .resource = &gpmc_nand_resource,
+ .cs_data = &gpmc_nand_cs_info,
+ .num_cs = 1,
};
-static int omap2_nand_gpmc_retime(struct omap_nand_platform_data *gpmc_nand_data)
-{
- struct gpmc_timings t;
- int err;
+static struct gpmc_timings t;
- if (!gpmc_nand_data->gpmc_t)
+static struct gpmc_timings *
+gpmc_nand_retime(struct omap_nand_platform_data *gpmc_nand_data)
+{
+ if (!gpmc_nand_data->gpmc_t) {
+ pr_warn("gpmc timings not provided\n");
return 0;
+ }
memset(&t, 0, sizeof(t));
t.sync_clk = gpmc_nand_data->gpmc_t->sync_clk;
@@ -68,56 +82,31 @@ static int omap2_nand_gpmc_retime(struct omap_nand_platform_data *gpmc_nand_data
t.cs_wr_off = gpmc_round_ns_to_ticks(gpmc_nand_data->gpmc_t->cs_wr_off);
t.wr_cycle = gpmc_round_ns_to_ticks(gpmc_nand_data->gpmc_t->wr_cycle);
- /* Configure GPMC */
- if (gpmc_nand_data->devsize == NAND_BUSWIDTH_16)
- gpmc_cs_configure(gpmc_nand_data->cs, GPMC_CONFIG_DEV_SIZE, 1);
- else
- gpmc_cs_configure(gpmc_nand_data->cs, GPMC_CONFIG_DEV_SIZE, 0);
- gpmc_cs_configure(gpmc_nand_data->cs,
- GPMC_CONFIG_DEV_TYPE, GPMC_DEVICETYPE_NAND);
- err = gpmc_cs_set_timings(gpmc_nand_data->cs, &t);
- if (err)
- return err;
-
- return 0;
+ return &t;
}
-int __init gpmc_nand_init(struct omap_nand_platform_data *gpmc_nand_data)
+struct gpmc_device_pdata *
+__init gpmc_nand_init(struct omap_nand_platform_data *gpmc_nand_data)
{
- int err = 0;
- struct device *dev = &gpmc_nand_device.dev;
+ gpmc_nand_info.pdata = gpmc_nand_data;
+ gpmc_nand_info.pdata_size = sizeof(*gpmc_nand_data);
- gpmc_nand_device.dev.platform_data = gpmc_nand_data;
+ gpmc_nand_cs_info.cs = gpmc_nand_data->cs;
+ gpmc_nand_cs_info.mem_size = NAND_IO_SIZE;
- err = gpmc_cs_request(gpmc_nand_data->cs, NAND_IO_SIZE,
- &gpmc_nand_data->phys_base);
- if (err < 0) {
- dev_err(dev, "Cannot request GPMC CS\n");
- return err;
- }
+ gpmc_nand_cs_info.timing = gpmc_nand_retime(gpmc_nand_data);
- /* Set timings in GPMC */
- err = omap2_nand_gpmc_retime(gpmc_nand_data);
- if (err < 0) {
- dev_err(dev, "Unable to set gpmc timings: %d\n", err);
- return err;
- }
-
- /* Enable RD PIN Monitoring Reg */
- if (gpmc_nand_data->dev_ready) {
- gpmc_cs_configure(gpmc_nand_data->cs, GPMC_CONFIG_RDY_BSY, 1);
- }
-
- err = platform_device_register(&gpmc_nand_device);
- if (err < 0) {
- dev_err(dev, "Unable to register NAND device\n");
- goto out_free_cs;
- }
-
- return 0;
+ gpmc_nand_config[IDX_DEV_SIZE].cmd = GPMC_CONFIG_DEV_SIZE;
+ if (gpmc_nand_data->devsize == NAND_BUSWIDTH_16)
+ gpmc_nand_config[IDX_DEV_SIZE].val = 1;
+ else
+ gpmc_nand_config[IDX_DEV_SIZE].val = 0;
-out_free_cs:
- gpmc_cs_free(gpmc_nand_data->cs);
+ gpmc_nand_config[IDX_RDY_BSY].cmd = GPMC_CONFIG_RDY_BSY;
+ if (gpmc_nand_data->dev_ready)
+ gpmc_nand_config[IDX_RDY_BSY].val = 1;
+ else
+ gpmc_nand_config[IDX_RDY_BSY].val = 0;
- return err;
+ return &gpmc_nand_info;
}
diff --git a/arch/arm/plat-omap/include/plat/nand.h b/arch/arm/plat-omap/include/plat/nand.h
index 86e4d9c..30c61c9 100644
--- a/arch/arm/plat-omap/include/plat/nand.h
+++ b/arch/arm/plat-omap/include/plat/nand.h
@@ -36,10 +36,12 @@ struct omap_nand_platform_data {
#define NAND_IO_SIZE 4
#if defined(CONFIG_MTD_NAND_OMAP2) || defined(CONFIG_MTD_NAND_OMAP2_MODULE)
-extern int gpmc_nand_init(struct omap_nand_platform_data *d);
+extern struct gpmc_device_pdata *
+gpmc_nand_init(struct omap_nand_platform_data *d);
#else
-static inline int gpmc_nand_init(struct omap_nand_platform_data *d)
+static inline struct gpmc_device_pdata *
+gpmc_nand_init(struct omap_nand_platform_data *d)
{
- return 0;
+ return NULL;
}
#endif
--
1.7.9.3
^ permalink raw reply related [flat|nested] 73+ messages in thread
* [PATCH v3 4/9] ARM: OMAP2+: gpmc-nand: populate gpmc configs
@ 2012-04-05 15:46 ` Afzal Mohammed
0 siblings, 0 replies; 73+ messages in thread
From: Afzal Mohammed @ 2012-04-05 15:46 UTC (permalink / raw)
To: tony, khilman, linux, dwmw2, sameo, grinberg, mike, nm,
artem.bityutskiy, vimal.newwork, dbaryshkov, linux-omap,
linux-arm-kernel, linux-mtd, linux-kernel
Cc: Afzal Mohammed
Currently gpmc is configured in platform for nand.
As configuring gpmc has been moved to gpmc driver,
populate details needed for the driver to configure
gpmc. gpmc driver would configure based on this
information.
Signed-off-by: Afzal Mohammed <afzal@ti.com>
---
arch/arm/mach-omap2/gpmc-nand.c | 97 ++++++++++++++------------------
arch/arm/plat-omap/include/plat/nand.h | 8 ++-
2 files changed, 48 insertions(+), 57 deletions(-)
diff --git a/arch/arm/mach-omap2/gpmc-nand.c b/arch/arm/mach-omap2/gpmc-nand.c
index 386dec8..85de31f 100644
--- a/arch/arm/mach-omap2/gpmc-nand.c
+++ b/arch/arm/mach-omap2/gpmc-nand.c
@@ -21,24 +21,38 @@
#include <plat/board.h>
#include <plat/gpmc.h>
-static struct resource gpmc_nand_resource = {
- .flags = IORESOURCE_MEM,
+
+#define GPMC_NAND_CONFIG_NUM 4
+#define IDX_DEV_SIZE 2
+#define IDX_RDY_BSY 3
+
+static struct gpmc_config gpmc_nand_config[GPMC_NAND_CONFIG_NUM] = {
+ { GPMC_CONFIG_DEV_TYPE, GPMC_DEVICETYPE_NAND},
+ { GPMC_CONFIG_WP, 0},
};
-static struct platform_device gpmc_nand_device = {
+static struct gpmc_cs_data gpmc_nand_cs_info = {
+ .config = gpmc_nand_config,
+ .num_config = ARRAY_SIZE(gpmc_nand_config),
+ .irq_flags = GPMC_IRQ_FIFOEVENT | GPMC_IRQ_TERMINALCOUNT,
+};
+
+static struct gpmc_device_pdata gpmc_nand_info = {
.name = "omap2-nand",
.id = 0,
- .num_resources = 1,
- .resource = &gpmc_nand_resource,
+ .cs_data = &gpmc_nand_cs_info,
+ .num_cs = 1,
};
-static int omap2_nand_gpmc_retime(struct omap_nand_platform_data *gpmc_nand_data)
-{
- struct gpmc_timings t;
- int err;
+static struct gpmc_timings t;
- if (!gpmc_nand_data->gpmc_t)
+static struct gpmc_timings *
+gpmc_nand_retime(struct omap_nand_platform_data *gpmc_nand_data)
+{
+ if (!gpmc_nand_data->gpmc_t) {
+ pr_warn("gpmc timings not provided\n");
return 0;
+ }
memset(&t, 0, sizeof(t));
t.sync_clk = gpmc_nand_data->gpmc_t->sync_clk;
@@ -68,56 +82,31 @@ static int omap2_nand_gpmc_retime(struct omap_nand_platform_data *gpmc_nand_data
t.cs_wr_off = gpmc_round_ns_to_ticks(gpmc_nand_data->gpmc_t->cs_wr_off);
t.wr_cycle = gpmc_round_ns_to_ticks(gpmc_nand_data->gpmc_t->wr_cycle);
- /* Configure GPMC */
- if (gpmc_nand_data->devsize == NAND_BUSWIDTH_16)
- gpmc_cs_configure(gpmc_nand_data->cs, GPMC_CONFIG_DEV_SIZE, 1);
- else
- gpmc_cs_configure(gpmc_nand_data->cs, GPMC_CONFIG_DEV_SIZE, 0);
- gpmc_cs_configure(gpmc_nand_data->cs,
- GPMC_CONFIG_DEV_TYPE, GPMC_DEVICETYPE_NAND);
- err = gpmc_cs_set_timings(gpmc_nand_data->cs, &t);
- if (err)
- return err;
-
- return 0;
+ return &t;
}
-int __init gpmc_nand_init(struct omap_nand_platform_data *gpmc_nand_data)
+struct gpmc_device_pdata *
+__init gpmc_nand_init(struct omap_nand_platform_data *gpmc_nand_data)
{
- int err = 0;
- struct device *dev = &gpmc_nand_device.dev;
+ gpmc_nand_info.pdata = gpmc_nand_data;
+ gpmc_nand_info.pdata_size = sizeof(*gpmc_nand_data);
- gpmc_nand_device.dev.platform_data = gpmc_nand_data;
+ gpmc_nand_cs_info.cs = gpmc_nand_data->cs;
+ gpmc_nand_cs_info.mem_size = NAND_IO_SIZE;
- err = gpmc_cs_request(gpmc_nand_data->cs, NAND_IO_SIZE,
- &gpmc_nand_data->phys_base);
- if (err < 0) {
- dev_err(dev, "Cannot request GPMC CS\n");
- return err;
- }
+ gpmc_nand_cs_info.timing = gpmc_nand_retime(gpmc_nand_data);
- /* Set timings in GPMC */
- err = omap2_nand_gpmc_retime(gpmc_nand_data);
- if (err < 0) {
- dev_err(dev, "Unable to set gpmc timings: %d\n", err);
- return err;
- }
-
- /* Enable RD PIN Monitoring Reg */
- if (gpmc_nand_data->dev_ready) {
- gpmc_cs_configure(gpmc_nand_data->cs, GPMC_CONFIG_RDY_BSY, 1);
- }
-
- err = platform_device_register(&gpmc_nand_device);
- if (err < 0) {
- dev_err(dev, "Unable to register NAND device\n");
- goto out_free_cs;
- }
-
- return 0;
+ gpmc_nand_config[IDX_DEV_SIZE].cmd = GPMC_CONFIG_DEV_SIZE;
+ if (gpmc_nand_data->devsize == NAND_BUSWIDTH_16)
+ gpmc_nand_config[IDX_DEV_SIZE].val = 1;
+ else
+ gpmc_nand_config[IDX_DEV_SIZE].val = 0;
-out_free_cs:
- gpmc_cs_free(gpmc_nand_data->cs);
+ gpmc_nand_config[IDX_RDY_BSY].cmd = GPMC_CONFIG_RDY_BSY;
+ if (gpmc_nand_data->dev_ready)
+ gpmc_nand_config[IDX_RDY_BSY].val = 1;
+ else
+ gpmc_nand_config[IDX_RDY_BSY].val = 0;
- return err;
+ return &gpmc_nand_info;
}
diff --git a/arch/arm/plat-omap/include/plat/nand.h b/arch/arm/plat-omap/include/plat/nand.h
index 86e4d9c..30c61c9 100644
--- a/arch/arm/plat-omap/include/plat/nand.h
+++ b/arch/arm/plat-omap/include/plat/nand.h
@@ -36,10 +36,12 @@ struct omap_nand_platform_data {
#define NAND_IO_SIZE 4
#if defined(CONFIG_MTD_NAND_OMAP2) || defined(CONFIG_MTD_NAND_OMAP2_MODULE)
-extern int gpmc_nand_init(struct omap_nand_platform_data *d);
+extern struct gpmc_device_pdata *
+gpmc_nand_init(struct omap_nand_platform_data *d);
#else
-static inline int gpmc_nand_init(struct omap_nand_platform_data *d)
+static inline struct gpmc_device_pdata *
+gpmc_nand_init(struct omap_nand_platform_data *d)
{
- return 0;
+ return NULL;
}
#endif
--
1.7.9.3
______________________________________________________
Linux MTD discussion mailing list
http://lists.infradead.org/mailman/listinfo/linux-mtd/
^ permalink raw reply related [flat|nested] 73+ messages in thread
* [PATCH v3 4/9] ARM: OMAP2+: gpmc-nand: populate gpmc configs
@ 2012-04-05 15:46 ` Afzal Mohammed
0 siblings, 0 replies; 73+ messages in thread
From: Afzal Mohammed @ 2012-04-05 15:46 UTC (permalink / raw)
To: linux-arm-kernel
Currently gpmc is configured in platform for nand.
As configuring gpmc has been moved to gpmc driver,
populate details needed for the driver to configure
gpmc. gpmc driver would configure based on this
information.
Signed-off-by: Afzal Mohammed <afzal@ti.com>
---
arch/arm/mach-omap2/gpmc-nand.c | 97 ++++++++++++++------------------
arch/arm/plat-omap/include/plat/nand.h | 8 ++-
2 files changed, 48 insertions(+), 57 deletions(-)
diff --git a/arch/arm/mach-omap2/gpmc-nand.c b/arch/arm/mach-omap2/gpmc-nand.c
index 386dec8..85de31f 100644
--- a/arch/arm/mach-omap2/gpmc-nand.c
+++ b/arch/arm/mach-omap2/gpmc-nand.c
@@ -21,24 +21,38 @@
#include <plat/board.h>
#include <plat/gpmc.h>
-static struct resource gpmc_nand_resource = {
- .flags = IORESOURCE_MEM,
+
+#define GPMC_NAND_CONFIG_NUM 4
+#define IDX_DEV_SIZE 2
+#define IDX_RDY_BSY 3
+
+static struct gpmc_config gpmc_nand_config[GPMC_NAND_CONFIG_NUM] = {
+ { GPMC_CONFIG_DEV_TYPE, GPMC_DEVICETYPE_NAND},
+ { GPMC_CONFIG_WP, 0},
};
-static struct platform_device gpmc_nand_device = {
+static struct gpmc_cs_data gpmc_nand_cs_info = {
+ .config = gpmc_nand_config,
+ .num_config = ARRAY_SIZE(gpmc_nand_config),
+ .irq_flags = GPMC_IRQ_FIFOEVENT | GPMC_IRQ_TERMINALCOUNT,
+};
+
+static struct gpmc_device_pdata gpmc_nand_info = {
.name = "omap2-nand",
.id = 0,
- .num_resources = 1,
- .resource = &gpmc_nand_resource,
+ .cs_data = &gpmc_nand_cs_info,
+ .num_cs = 1,
};
-static int omap2_nand_gpmc_retime(struct omap_nand_platform_data *gpmc_nand_data)
-{
- struct gpmc_timings t;
- int err;
+static struct gpmc_timings t;
- if (!gpmc_nand_data->gpmc_t)
+static struct gpmc_timings *
+gpmc_nand_retime(struct omap_nand_platform_data *gpmc_nand_data)
+{
+ if (!gpmc_nand_data->gpmc_t) {
+ pr_warn("gpmc timings not provided\n");
return 0;
+ }
memset(&t, 0, sizeof(t));
t.sync_clk = gpmc_nand_data->gpmc_t->sync_clk;
@@ -68,56 +82,31 @@ static int omap2_nand_gpmc_retime(struct omap_nand_platform_data *gpmc_nand_data
t.cs_wr_off = gpmc_round_ns_to_ticks(gpmc_nand_data->gpmc_t->cs_wr_off);
t.wr_cycle = gpmc_round_ns_to_ticks(gpmc_nand_data->gpmc_t->wr_cycle);
- /* Configure GPMC */
- if (gpmc_nand_data->devsize == NAND_BUSWIDTH_16)
- gpmc_cs_configure(gpmc_nand_data->cs, GPMC_CONFIG_DEV_SIZE, 1);
- else
- gpmc_cs_configure(gpmc_nand_data->cs, GPMC_CONFIG_DEV_SIZE, 0);
- gpmc_cs_configure(gpmc_nand_data->cs,
- GPMC_CONFIG_DEV_TYPE, GPMC_DEVICETYPE_NAND);
- err = gpmc_cs_set_timings(gpmc_nand_data->cs, &t);
- if (err)
- return err;
-
- return 0;
+ return &t;
}
-int __init gpmc_nand_init(struct omap_nand_platform_data *gpmc_nand_data)
+struct gpmc_device_pdata *
+__init gpmc_nand_init(struct omap_nand_platform_data *gpmc_nand_data)
{
- int err = 0;
- struct device *dev = &gpmc_nand_device.dev;
+ gpmc_nand_info.pdata = gpmc_nand_data;
+ gpmc_nand_info.pdata_size = sizeof(*gpmc_nand_data);
- gpmc_nand_device.dev.platform_data = gpmc_nand_data;
+ gpmc_nand_cs_info.cs = gpmc_nand_data->cs;
+ gpmc_nand_cs_info.mem_size = NAND_IO_SIZE;
- err = gpmc_cs_request(gpmc_nand_data->cs, NAND_IO_SIZE,
- &gpmc_nand_data->phys_base);
- if (err < 0) {
- dev_err(dev, "Cannot request GPMC CS\n");
- return err;
- }
+ gpmc_nand_cs_info.timing = gpmc_nand_retime(gpmc_nand_data);
- /* Set timings in GPMC */
- err = omap2_nand_gpmc_retime(gpmc_nand_data);
- if (err < 0) {
- dev_err(dev, "Unable to set gpmc timings: %d\n", err);
- return err;
- }
-
- /* Enable RD PIN Monitoring Reg */
- if (gpmc_nand_data->dev_ready) {
- gpmc_cs_configure(gpmc_nand_data->cs, GPMC_CONFIG_RDY_BSY, 1);
- }
-
- err = platform_device_register(&gpmc_nand_device);
- if (err < 0) {
- dev_err(dev, "Unable to register NAND device\n");
- goto out_free_cs;
- }
-
- return 0;
+ gpmc_nand_config[IDX_DEV_SIZE].cmd = GPMC_CONFIG_DEV_SIZE;
+ if (gpmc_nand_data->devsize == NAND_BUSWIDTH_16)
+ gpmc_nand_config[IDX_DEV_SIZE].val = 1;
+ else
+ gpmc_nand_config[IDX_DEV_SIZE].val = 0;
-out_free_cs:
- gpmc_cs_free(gpmc_nand_data->cs);
+ gpmc_nand_config[IDX_RDY_BSY].cmd = GPMC_CONFIG_RDY_BSY;
+ if (gpmc_nand_data->dev_ready)
+ gpmc_nand_config[IDX_RDY_BSY].val = 1;
+ else
+ gpmc_nand_config[IDX_RDY_BSY].val = 0;
- return err;
+ return &gpmc_nand_info;
}
diff --git a/arch/arm/plat-omap/include/plat/nand.h b/arch/arm/plat-omap/include/plat/nand.h
index 86e4d9c..30c61c9 100644
--- a/arch/arm/plat-omap/include/plat/nand.h
+++ b/arch/arm/plat-omap/include/plat/nand.h
@@ -36,10 +36,12 @@ struct omap_nand_platform_data {
#define NAND_IO_SIZE 4
#if defined(CONFIG_MTD_NAND_OMAP2) || defined(CONFIG_MTD_NAND_OMAP2_MODULE)
-extern int gpmc_nand_init(struct omap_nand_platform_data *d);
+extern struct gpmc_device_pdata *
+gpmc_nand_init(struct omap_nand_platform_data *d);
#else
-static inline int gpmc_nand_init(struct omap_nand_platform_data *d)
+static inline struct gpmc_device_pdata *
+gpmc_nand_init(struct omap_nand_platform_data *d)
{
- return 0;
+ return NULL;
}
#endif
--
1.7.9.3
^ permalink raw reply related [flat|nested] 73+ messages in thread
* [PATCH v3 5/9] ARM: OMAP2+: gpmc-smsc911x: gpmc driver information
[not found] <cover.1333640054.git.afzal@ti.com>
2012-04-05 15:45 ` Afzal Mohammed
@ 2012-04-05 15:46 ` Afzal Mohammed
2012-04-05 15:46 ` Afzal Mohammed
` (6 subsequent siblings)
8 siblings, 0 replies; 73+ messages in thread
From: Afzal Mohammed @ 2012-04-05 15:46 UTC (permalink / raw)
To: tony, khilman, linux, dwmw2, sameo, grinberg, mike, nm,
artem.bityutskiy, vimal.newwork, dbaryshkov, linux-omap,
linux-arm-kernel, linux-mtd, linux-kernel
Cc: Afzal Mohammed
gpmc has been converted to driver. And all gpmc related
configuration would be done by gpmc driver. Provide
gpmc driver with sufficient information so that it can
configure.
Signed-off-by: Afzal Mohammed <afzal@ti.com>
---
arch/arm/mach-omap2/gpmc-smsc911x.c | 59 ++++++++++++-----------
arch/arm/plat-omap/include/plat/gpmc-smsc911x.h | 9 +++-
2 files changed, 39 insertions(+), 29 deletions(-)
diff --git a/arch/arm/mach-omap2/gpmc-smsc911x.c b/arch/arm/mach-omap2/gpmc-smsc911x.c
index b6c77be..52192a9 100644
--- a/arch/arm/mach-omap2/gpmc-smsc911x.c
+++ b/arch/arm/mach-omap2/gpmc-smsc911x.c
@@ -24,13 +24,8 @@
#include <plat/gpmc.h>
#include <plat/gpmc-smsc911x.h>
-static struct resource gpmc_smsc911x_resources[] = {
- [0] = {
- .flags = IORESOURCE_MEM,
- },
- [1] = {
- .flags = IORESOURCE_IRQ | IORESOURCE_IRQ_LOWLEVEL,
- },
+static struct resource gpmc_smsc911x_resources = {
+ .flags = IORESOURCE_IRQ | IORESOURCE_IRQ_LOWLEVEL,
};
static struct smsc911x_platform_config gpmc_smsc911x_config = {
@@ -44,26 +39,42 @@ static struct smsc911x_platform_config gpmc_smsc911x_config = {
* assume that pin multiplexing is done in the board-*.c file,
* or in the bootloader.
*/
-void __init gpmc_smsc911x_init(struct omap_smsc911x_platform_data *gpmc_cfg)
+__init struct gpmc_device_pdata *
+gpmc_smsc911x_init(struct omap_smsc911x_platform_data *gpmc_cfg)
{
- struct platform_device *pdev;
- unsigned long cs_mem_base;
int ret;
+ struct gpmc_device_pdata *gpmc_pdev;
+ struct gpmc_cs_data *gpmc_cs;
- if (gpmc_cs_request(gpmc_cfg->cs, SZ_16M, &cs_mem_base) < 0) {
- pr_err("Failed to request GPMC mem region\n");
- return;
+ gpmc_pdev = kzalloc(sizeof(*gpmc_pdev), GFP_KERNEL);
+ if (gpmc_pdev == NULL)
+ return gpmc_pdev;
+
+ gpmc_cs = kzalloc(sizeof(*gpmc_cs), GFP_KERNEL);
+ if (gpmc_pdev == NULL) {
+ kfree(gpmc_pdev);
+ return NULL;
}
- gpmc_smsc911x_resources[0].start = cs_mem_base + 0x0;
- gpmc_smsc911x_resources[0].end = cs_mem_base + 0xff;
+ gpmc_pdev->cs_data = gpmc_cs;
+ gpmc_pdev->num_cs = 1;
+ gpmc_pdev->name = "smsc911x";
+ gpmc_pdev->id = gpmc_cfg->id;
+ gpmc_pdev->pdata = &gpmc_smsc911x_config;
+ gpmc_pdev->pdata_size = sizeof(gpmc_smsc911x_config);
+
+ gpmc_cs->cs = gpmc_cfg->cs;
+ gpmc_cs->mem_size = 0xff;
+
+ gpmc_pdev->per_res = &gpmc_smsc911x_resources;
+ gpmc_pdev->num_per_res = 1;
if (gpio_request_one(gpmc_cfg->gpio_irq, GPIOF_IN, "smsc911x irq")) {
pr_err("Failed to request IRQ GPIO%d\n", gpmc_cfg->gpio_irq);
goto free1;
}
- gpmc_smsc911x_resources[1].start = gpio_to_irq(gpmc_cfg->gpio_irq);
+ gpmc_smsc911x_resources.start = gpio_to_irq(gpmc_cfg->gpio_irq);
if (gpio_is_valid(gpmc_cfg->gpio_reset)) {
ret = gpio_request_one(gpmc_cfg->gpio_reset,
@@ -81,21 +92,15 @@ void __init gpmc_smsc911x_init(struct omap_smsc911x_platform_data *gpmc_cfg)
gpmc_smsc911x_config.flags = gpmc_cfg->flags ? : SMSC911X_USE_16BIT;
- pdev = platform_device_register_resndata(NULL, "smsc911x", gpmc_cfg->id,
- gpmc_smsc911x_resources, ARRAY_SIZE(gpmc_smsc911x_resources),
- &gpmc_smsc911x_config, sizeof(gpmc_smsc911x_config));
- if (!pdev) {
- pr_err("Unable to register platform device\n");
- gpio_free(gpmc_cfg->gpio_reset);
- goto free2;
- }
-
- return;
+ return gpmc_pdev;
free2:
gpio_free(gpmc_cfg->gpio_irq);
free1:
- gpmc_cs_free(gpmc_cfg->cs);
+ kfree(gpmc_cs);
+ kfree(gpmc_pdev);
pr_err("Could not initialize smsc911x device\n");
+
+ return NULL;
}
diff --git a/arch/arm/plat-omap/include/plat/gpmc-smsc911x.h b/arch/arm/plat-omap/include/plat/gpmc-smsc911x.h
index ea6c9c8..66dc7f1 100644
--- a/arch/arm/plat-omap/include/plat/gpmc-smsc911x.h
+++ b/arch/arm/plat-omap/include/plat/gpmc-smsc911x.h
@@ -11,6 +11,8 @@
* published by the Free Software Foundation.
*/
+#include<plat/gpmc.h>
+
#ifndef __ASM_ARCH_OMAP_GPMC_SMSC911X_H__
struct omap_smsc911x_platform_data {
@@ -23,12 +25,15 @@ struct omap_smsc911x_platform_data {
#if defined(CONFIG_SMSC911X) || defined(CONFIG_SMSC911X_MODULE)
-extern void gpmc_smsc911x_init(struct omap_smsc911x_platform_data *d);
+extern struct gpmc_device_pdata *
+gpmc_smsc911x_init(struct omap_smsc911x_platform_data *d);
#else
-static inline void gpmc_smsc911x_init(struct omap_smsc911x_platform_data *d)
+static inline struct gpmc_device_pdata *
+gpmc_smsc911x_init(struct omap_smsc911x_platform_data *d)
{
+ return NULL;
}
#endif
--
1.7.9.3
^ permalink raw reply related [flat|nested] 73+ messages in thread
* [PATCH v3 5/9] ARM: OMAP2+: gpmc-smsc911x: gpmc driver information
@ 2012-04-05 15:46 ` Afzal Mohammed
0 siblings, 0 replies; 73+ messages in thread
From: Afzal Mohammed @ 2012-04-05 15:46 UTC (permalink / raw)
To: tony, khilman, linux, dwmw2, sameo, grinberg, mike, nm,
artem.bityutskiy, vimal.newwork, dbaryshkov, linux-omap,
linux-arm-kernel, linux-mtd, linux-kernel
Cc: Afzal Mohammed
gpmc has been converted to driver. And all gpmc related
configuration would be done by gpmc driver. Provide
gpmc driver with sufficient information so that it can
configure.
Signed-off-by: Afzal Mohammed <afzal@ti.com>
---
arch/arm/mach-omap2/gpmc-smsc911x.c | 59 ++++++++++++-----------
arch/arm/plat-omap/include/plat/gpmc-smsc911x.h | 9 +++-
2 files changed, 39 insertions(+), 29 deletions(-)
diff --git a/arch/arm/mach-omap2/gpmc-smsc911x.c b/arch/arm/mach-omap2/gpmc-smsc911x.c
index b6c77be..52192a9 100644
--- a/arch/arm/mach-omap2/gpmc-smsc911x.c
+++ b/arch/arm/mach-omap2/gpmc-smsc911x.c
@@ -24,13 +24,8 @@
#include <plat/gpmc.h>
#include <plat/gpmc-smsc911x.h>
-static struct resource gpmc_smsc911x_resources[] = {
- [0] = {
- .flags = IORESOURCE_MEM,
- },
- [1] = {
- .flags = IORESOURCE_IRQ | IORESOURCE_IRQ_LOWLEVEL,
- },
+static struct resource gpmc_smsc911x_resources = {
+ .flags = IORESOURCE_IRQ | IORESOURCE_IRQ_LOWLEVEL,
};
static struct smsc911x_platform_config gpmc_smsc911x_config = {
@@ -44,26 +39,42 @@ static struct smsc911x_platform_config gpmc_smsc911x_config = {
* assume that pin multiplexing is done in the board-*.c file,
* or in the bootloader.
*/
-void __init gpmc_smsc911x_init(struct omap_smsc911x_platform_data *gpmc_cfg)
+__init struct gpmc_device_pdata *
+gpmc_smsc911x_init(struct omap_smsc911x_platform_data *gpmc_cfg)
{
- struct platform_device *pdev;
- unsigned long cs_mem_base;
int ret;
+ struct gpmc_device_pdata *gpmc_pdev;
+ struct gpmc_cs_data *gpmc_cs;
- if (gpmc_cs_request(gpmc_cfg->cs, SZ_16M, &cs_mem_base) < 0) {
- pr_err("Failed to request GPMC mem region\n");
- return;
+ gpmc_pdev = kzalloc(sizeof(*gpmc_pdev), GFP_KERNEL);
+ if (gpmc_pdev == NULL)
+ return gpmc_pdev;
+
+ gpmc_cs = kzalloc(sizeof(*gpmc_cs), GFP_KERNEL);
+ if (gpmc_pdev == NULL) {
+ kfree(gpmc_pdev);
+ return NULL;
}
- gpmc_smsc911x_resources[0].start = cs_mem_base + 0x0;
- gpmc_smsc911x_resources[0].end = cs_mem_base + 0xff;
+ gpmc_pdev->cs_data = gpmc_cs;
+ gpmc_pdev->num_cs = 1;
+ gpmc_pdev->name = "smsc911x";
+ gpmc_pdev->id = gpmc_cfg->id;
+ gpmc_pdev->pdata = &gpmc_smsc911x_config;
+ gpmc_pdev->pdata_size = sizeof(gpmc_smsc911x_config);
+
+ gpmc_cs->cs = gpmc_cfg->cs;
+ gpmc_cs->mem_size = 0xff;
+
+ gpmc_pdev->per_res = &gpmc_smsc911x_resources;
+ gpmc_pdev->num_per_res = 1;
if (gpio_request_one(gpmc_cfg->gpio_irq, GPIOF_IN, "smsc911x irq")) {
pr_err("Failed to request IRQ GPIO%d\n", gpmc_cfg->gpio_irq);
goto free1;
}
- gpmc_smsc911x_resources[1].start = gpio_to_irq(gpmc_cfg->gpio_irq);
+ gpmc_smsc911x_resources.start = gpio_to_irq(gpmc_cfg->gpio_irq);
if (gpio_is_valid(gpmc_cfg->gpio_reset)) {
ret = gpio_request_one(gpmc_cfg->gpio_reset,
@@ -81,21 +92,15 @@ void __init gpmc_smsc911x_init(struct omap_smsc911x_platform_data *gpmc_cfg)
gpmc_smsc911x_config.flags = gpmc_cfg->flags ? : SMSC911X_USE_16BIT;
- pdev = platform_device_register_resndata(NULL, "smsc911x", gpmc_cfg->id,
- gpmc_smsc911x_resources, ARRAY_SIZE(gpmc_smsc911x_resources),
- &gpmc_smsc911x_config, sizeof(gpmc_smsc911x_config));
- if (!pdev) {
- pr_err("Unable to register platform device\n");
- gpio_free(gpmc_cfg->gpio_reset);
- goto free2;
- }
-
- return;
+ return gpmc_pdev;
free2:
gpio_free(gpmc_cfg->gpio_irq);
free1:
- gpmc_cs_free(gpmc_cfg->cs);
+ kfree(gpmc_cs);
+ kfree(gpmc_pdev);
pr_err("Could not initialize smsc911x device\n");
+
+ return NULL;
}
diff --git a/arch/arm/plat-omap/include/plat/gpmc-smsc911x.h b/arch/arm/plat-omap/include/plat/gpmc-smsc911x.h
index ea6c9c8..66dc7f1 100644
--- a/arch/arm/plat-omap/include/plat/gpmc-smsc911x.h
+++ b/arch/arm/plat-omap/include/plat/gpmc-smsc911x.h
@@ -11,6 +11,8 @@
* published by the Free Software Foundation.
*/
+#include<plat/gpmc.h>
+
#ifndef __ASM_ARCH_OMAP_GPMC_SMSC911X_H__
struct omap_smsc911x_platform_data {
@@ -23,12 +25,15 @@ struct omap_smsc911x_platform_data {
#if defined(CONFIG_SMSC911X) || defined(CONFIG_SMSC911X_MODULE)
-extern void gpmc_smsc911x_init(struct omap_smsc911x_platform_data *d);
+extern struct gpmc_device_pdata *
+gpmc_smsc911x_init(struct omap_smsc911x_platform_data *d);
#else
-static inline void gpmc_smsc911x_init(struct omap_smsc911x_platform_data *d)
+static inline struct gpmc_device_pdata *
+gpmc_smsc911x_init(struct omap_smsc911x_platform_data *d)
{
+ return NULL;
}
#endif
--
1.7.9.3
^ permalink raw reply related [flat|nested] 73+ messages in thread
* [PATCH v3 5/9] ARM: OMAP2+: gpmc-smsc911x: gpmc driver information
@ 2012-04-05 15:46 ` Afzal Mohammed
0 siblings, 0 replies; 73+ messages in thread
From: Afzal Mohammed @ 2012-04-05 15:46 UTC (permalink / raw)
To: linux-arm-kernel
gpmc has been converted to driver. And all gpmc related
configuration would be done by gpmc driver. Provide
gpmc driver with sufficient information so that it can
configure.
Signed-off-by: Afzal Mohammed <afzal@ti.com>
---
arch/arm/mach-omap2/gpmc-smsc911x.c | 59 ++++++++++++-----------
arch/arm/plat-omap/include/plat/gpmc-smsc911x.h | 9 +++-
2 files changed, 39 insertions(+), 29 deletions(-)
diff --git a/arch/arm/mach-omap2/gpmc-smsc911x.c b/arch/arm/mach-omap2/gpmc-smsc911x.c
index b6c77be..52192a9 100644
--- a/arch/arm/mach-omap2/gpmc-smsc911x.c
+++ b/arch/arm/mach-omap2/gpmc-smsc911x.c
@@ -24,13 +24,8 @@
#include <plat/gpmc.h>
#include <plat/gpmc-smsc911x.h>
-static struct resource gpmc_smsc911x_resources[] = {
- [0] = {
- .flags = IORESOURCE_MEM,
- },
- [1] = {
- .flags = IORESOURCE_IRQ | IORESOURCE_IRQ_LOWLEVEL,
- },
+static struct resource gpmc_smsc911x_resources = {
+ .flags = IORESOURCE_IRQ | IORESOURCE_IRQ_LOWLEVEL,
};
static struct smsc911x_platform_config gpmc_smsc911x_config = {
@@ -44,26 +39,42 @@ static struct smsc911x_platform_config gpmc_smsc911x_config = {
* assume that pin multiplexing is done in the board-*.c file,
* or in the bootloader.
*/
-void __init gpmc_smsc911x_init(struct omap_smsc911x_platform_data *gpmc_cfg)
+__init struct gpmc_device_pdata *
+gpmc_smsc911x_init(struct omap_smsc911x_platform_data *gpmc_cfg)
{
- struct platform_device *pdev;
- unsigned long cs_mem_base;
int ret;
+ struct gpmc_device_pdata *gpmc_pdev;
+ struct gpmc_cs_data *gpmc_cs;
- if (gpmc_cs_request(gpmc_cfg->cs, SZ_16M, &cs_mem_base) < 0) {
- pr_err("Failed to request GPMC mem region\n");
- return;
+ gpmc_pdev = kzalloc(sizeof(*gpmc_pdev), GFP_KERNEL);
+ if (gpmc_pdev == NULL)
+ return gpmc_pdev;
+
+ gpmc_cs = kzalloc(sizeof(*gpmc_cs), GFP_KERNEL);
+ if (gpmc_pdev == NULL) {
+ kfree(gpmc_pdev);
+ return NULL;
}
- gpmc_smsc911x_resources[0].start = cs_mem_base + 0x0;
- gpmc_smsc911x_resources[0].end = cs_mem_base + 0xff;
+ gpmc_pdev->cs_data = gpmc_cs;
+ gpmc_pdev->num_cs = 1;
+ gpmc_pdev->name = "smsc911x";
+ gpmc_pdev->id = gpmc_cfg->id;
+ gpmc_pdev->pdata = &gpmc_smsc911x_config;
+ gpmc_pdev->pdata_size = sizeof(gpmc_smsc911x_config);
+
+ gpmc_cs->cs = gpmc_cfg->cs;
+ gpmc_cs->mem_size = 0xff;
+
+ gpmc_pdev->per_res = &gpmc_smsc911x_resources;
+ gpmc_pdev->num_per_res = 1;
if (gpio_request_one(gpmc_cfg->gpio_irq, GPIOF_IN, "smsc911x irq")) {
pr_err("Failed to request IRQ GPIO%d\n", gpmc_cfg->gpio_irq);
goto free1;
}
- gpmc_smsc911x_resources[1].start = gpio_to_irq(gpmc_cfg->gpio_irq);
+ gpmc_smsc911x_resources.start = gpio_to_irq(gpmc_cfg->gpio_irq);
if (gpio_is_valid(gpmc_cfg->gpio_reset)) {
ret = gpio_request_one(gpmc_cfg->gpio_reset,
@@ -81,21 +92,15 @@ void __init gpmc_smsc911x_init(struct omap_smsc911x_platform_data *gpmc_cfg)
gpmc_smsc911x_config.flags = gpmc_cfg->flags ? : SMSC911X_USE_16BIT;
- pdev = platform_device_register_resndata(NULL, "smsc911x", gpmc_cfg->id,
- gpmc_smsc911x_resources, ARRAY_SIZE(gpmc_smsc911x_resources),
- &gpmc_smsc911x_config, sizeof(gpmc_smsc911x_config));
- if (!pdev) {
- pr_err("Unable to register platform device\n");
- gpio_free(gpmc_cfg->gpio_reset);
- goto free2;
- }
-
- return;
+ return gpmc_pdev;
free2:
gpio_free(gpmc_cfg->gpio_irq);
free1:
- gpmc_cs_free(gpmc_cfg->cs);
+ kfree(gpmc_cs);
+ kfree(gpmc_pdev);
pr_err("Could not initialize smsc911x device\n");
+
+ return NULL;
}
diff --git a/arch/arm/plat-omap/include/plat/gpmc-smsc911x.h b/arch/arm/plat-omap/include/plat/gpmc-smsc911x.h
index ea6c9c8..66dc7f1 100644
--- a/arch/arm/plat-omap/include/plat/gpmc-smsc911x.h
+++ b/arch/arm/plat-omap/include/plat/gpmc-smsc911x.h
@@ -11,6 +11,8 @@
* published by the Free Software Foundation.
*/
+#include<plat/gpmc.h>
+
#ifndef __ASM_ARCH_OMAP_GPMC_SMSC911X_H__
struct omap_smsc911x_platform_data {
@@ -23,12 +25,15 @@ struct omap_smsc911x_platform_data {
#if defined(CONFIG_SMSC911X) || defined(CONFIG_SMSC911X_MODULE)
-extern void gpmc_smsc911x_init(struct omap_smsc911x_platform_data *d);
+extern struct gpmc_device_pdata *
+gpmc_smsc911x_init(struct omap_smsc911x_platform_data *d);
#else
-static inline void gpmc_smsc911x_init(struct omap_smsc911x_platform_data *d)
+static inline struct gpmc_device_pdata *
+gpmc_smsc911x_init(struct omap_smsc911x_platform_data *d)
{
+ return NULL;
}
#endif
--
1.7.9.3
^ permalink raw reply related [flat|nested] 73+ messages in thread
* [PATCH v3 6/9] mtd: nand: omap2: obtain memory from resource
[not found] <cover.1333640054.git.afzal@ti.com>
2012-04-05 15:45 ` Afzal Mohammed
@ 2012-04-05 15:46 ` Afzal Mohammed
2012-04-05 15:46 ` Afzal Mohammed
` (6 subsequent siblings)
8 siblings, 0 replies; 73+ messages in thread
From: Afzal Mohammed @ 2012-04-05 15:46 UTC (permalink / raw)
To: tony, khilman, linux, dwmw2, sameo, grinberg, mike, nm,
artem.bityutskiy, vimal.newwork, dbaryshkov, linux-omap,
linux-arm-kernel, linux-mtd, linux-kernel
Cc: Afzal Mohammed
gpmc being converted to driver, provides drivers
of peripheral connected memory space used by the
peripheral as memory resource.
Modify nand omap driver to obtain memory detials
from resource structure.
Signed-off-by: Afzal Mohammed <afzal@ti.com>
---
arch/arm/plat-omap/include/plat/nand.h | 1 -
drivers/mtd/nand/omap2.c | 20 ++++++++++++++------
2 files changed, 14 insertions(+), 7 deletions(-)
diff --git a/arch/arm/plat-omap/include/plat/nand.h b/arch/arm/plat-omap/include/plat/nand.h
index 30c61c9..570c4f4 100644
--- a/arch/arm/plat-omap/include/plat/nand.h
+++ b/arch/arm/plat-omap/include/plat/nand.h
@@ -26,7 +26,6 @@ struct omap_nand_platform_data {
bool dev_ready;
int gpmc_irq;
enum nand_io xfer_type;
- unsigned long phys_base;
int devsize;
enum omap_ecc ecc_opt;
struct gpmc_nand_regs reg;
diff --git a/drivers/mtd/nand/omap2.c b/drivers/mtd/nand/omap2.c
index c2b0bba..be4b321 100644
--- a/drivers/mtd/nand/omap2.c
+++ b/drivers/mtd/nand/omap2.c
@@ -118,6 +118,7 @@ struct omap_nand_info {
int gpmc_cs;
unsigned long phys_base;
+ unsigned long mem_size;
struct completion comp;
int dma_ch;
int gpmc_irq;
@@ -931,6 +932,7 @@ static int __devinit omap_nand_probe(struct platform_device *pdev)
struct omap_nand_platform_data *pdata;
int err;
int i, offset;
+ struct resource *res;
pdata = pdev->dev.platform_data;
if (pdata == NULL) {
@@ -950,7 +952,6 @@ static int __devinit omap_nand_probe(struct platform_device *pdev)
info->pdev = pdev;
info->gpmc_cs = pdata->cs;
- info->phys_base = pdata->phys_base;
info->mtd.priv = &info->nand;
info->mtd.name = dev_name(&pdev->dev);
@@ -959,16 +960,23 @@ static int __devinit omap_nand_probe(struct platform_device *pdev)
info->nand.options = pdata->devsize;
info->nand.options |= NAND_SKIP_BBTSCAN;
- /* NAND write protect off */
- gpmc_cs_configure(info->gpmc_cs, GPMC_CONFIG_WP, 0);
+ res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+ if (res == NULL) {
+ err = -EINVAL;
+ dev_err(&pdev->dev, "error getting memory resource\n");
+ goto out_free_info;
+ }
+
+ info->phys_base = res->start;
+ info->mem_size = resource_size(res);
- if (!request_mem_region(info->phys_base, NAND_IO_SIZE,
+ if (!request_mem_region(info->phys_base, info->mem_size,
pdev->dev.driver->name)) {
err = -EBUSY;
goto out_free_info;
}
- info->nand.IO_ADDR_R = ioremap(info->phys_base, NAND_IO_SIZE);
+ info->nand.IO_ADDR_R = ioremap(info->phys_base, info->mem_size);
if (!info->nand.IO_ADDR_R) {
err = -ENOMEM;
goto out_release_mem_region;
@@ -1110,7 +1118,7 @@ static int __devinit omap_nand_probe(struct platform_device *pdev)
return 0;
out_release_mem_region:
- release_mem_region(info->phys_base, NAND_IO_SIZE);
+ release_mem_region(info->phys_base, info->mem_size);
out_free_info:
kfree(info);
--
1.7.9.3
^ permalink raw reply related [flat|nested] 73+ messages in thread
* [PATCH v3 6/9] mtd: nand: omap2: obtain memory from resource
@ 2012-04-05 15:46 ` Afzal Mohammed
0 siblings, 0 replies; 73+ messages in thread
From: Afzal Mohammed @ 2012-04-05 15:46 UTC (permalink / raw)
To: tony, khilman, linux, dwmw2, sameo, grinberg, mike, nm,
artem.bityutskiy, vimal.newwork, dbaryshkov, linux-omap,
linux-arm-kernel, linux-mtd, linux-kernel
Cc: Afzal Mohammed
gpmc being converted to driver, provides drivers
of peripheral connected memory space used by the
peripheral as memory resource.
Modify nand omap driver to obtain memory detials
from resource structure.
Signed-off-by: Afzal Mohammed <afzal@ti.com>
---
arch/arm/plat-omap/include/plat/nand.h | 1 -
drivers/mtd/nand/omap2.c | 20 ++++++++++++++------
2 files changed, 14 insertions(+), 7 deletions(-)
diff --git a/arch/arm/plat-omap/include/plat/nand.h b/arch/arm/plat-omap/include/plat/nand.h
index 30c61c9..570c4f4 100644
--- a/arch/arm/plat-omap/include/plat/nand.h
+++ b/arch/arm/plat-omap/include/plat/nand.h
@@ -26,7 +26,6 @@ struct omap_nand_platform_data {
bool dev_ready;
int gpmc_irq;
enum nand_io xfer_type;
- unsigned long phys_base;
int devsize;
enum omap_ecc ecc_opt;
struct gpmc_nand_regs reg;
diff --git a/drivers/mtd/nand/omap2.c b/drivers/mtd/nand/omap2.c
index c2b0bba..be4b321 100644
--- a/drivers/mtd/nand/omap2.c
+++ b/drivers/mtd/nand/omap2.c
@@ -118,6 +118,7 @@ struct omap_nand_info {
int gpmc_cs;
unsigned long phys_base;
+ unsigned long mem_size;
struct completion comp;
int dma_ch;
int gpmc_irq;
@@ -931,6 +932,7 @@ static int __devinit omap_nand_probe(struct platform_device *pdev)
struct omap_nand_platform_data *pdata;
int err;
int i, offset;
+ struct resource *res;
pdata = pdev->dev.platform_data;
if (pdata == NULL) {
@@ -950,7 +952,6 @@ static int __devinit omap_nand_probe(struct platform_device *pdev)
info->pdev = pdev;
info->gpmc_cs = pdata->cs;
- info->phys_base = pdata->phys_base;
info->mtd.priv = &info->nand;
info->mtd.name = dev_name(&pdev->dev);
@@ -959,16 +960,23 @@ static int __devinit omap_nand_probe(struct platform_device *pdev)
info->nand.options = pdata->devsize;
info->nand.options |= NAND_SKIP_BBTSCAN;
- /* NAND write protect off */
- gpmc_cs_configure(info->gpmc_cs, GPMC_CONFIG_WP, 0);
+ res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+ if (res == NULL) {
+ err = -EINVAL;
+ dev_err(&pdev->dev, "error getting memory resource\n");
+ goto out_free_info;
+ }
+
+ info->phys_base = res->start;
+ info->mem_size = resource_size(res);
- if (!request_mem_region(info->phys_base, NAND_IO_SIZE,
+ if (!request_mem_region(info->phys_base, info->mem_size,
pdev->dev.driver->name)) {
err = -EBUSY;
goto out_free_info;
}
- info->nand.IO_ADDR_R = ioremap(info->phys_base, NAND_IO_SIZE);
+ info->nand.IO_ADDR_R = ioremap(info->phys_base, info->mem_size);
if (!info->nand.IO_ADDR_R) {
err = -ENOMEM;
goto out_release_mem_region;
@@ -1110,7 +1118,7 @@ static int __devinit omap_nand_probe(struct platform_device *pdev)
return 0;
out_release_mem_region:
- release_mem_region(info->phys_base, NAND_IO_SIZE);
+ release_mem_region(info->phys_base, info->mem_size);
out_free_info:
kfree(info);
--
1.7.9.3
^ permalink raw reply related [flat|nested] 73+ messages in thread
* [PATCH v3 6/9] mtd: nand: omap2: obtain memory from resource
@ 2012-04-05 15:46 ` Afzal Mohammed
0 siblings, 0 replies; 73+ messages in thread
From: Afzal Mohammed @ 2012-04-05 15:46 UTC (permalink / raw)
To: linux-arm-kernel
gpmc being converted to driver, provides drivers
of peripheral connected memory space used by the
peripheral as memory resource.
Modify nand omap driver to obtain memory detials
from resource structure.
Signed-off-by: Afzal Mohammed <afzal@ti.com>
---
arch/arm/plat-omap/include/plat/nand.h | 1 -
drivers/mtd/nand/omap2.c | 20 ++++++++++++++------
2 files changed, 14 insertions(+), 7 deletions(-)
diff --git a/arch/arm/plat-omap/include/plat/nand.h b/arch/arm/plat-omap/include/plat/nand.h
index 30c61c9..570c4f4 100644
--- a/arch/arm/plat-omap/include/plat/nand.h
+++ b/arch/arm/plat-omap/include/plat/nand.h
@@ -26,7 +26,6 @@ struct omap_nand_platform_data {
bool dev_ready;
int gpmc_irq;
enum nand_io xfer_type;
- unsigned long phys_base;
int devsize;
enum omap_ecc ecc_opt;
struct gpmc_nand_regs reg;
diff --git a/drivers/mtd/nand/omap2.c b/drivers/mtd/nand/omap2.c
index c2b0bba..be4b321 100644
--- a/drivers/mtd/nand/omap2.c
+++ b/drivers/mtd/nand/omap2.c
@@ -118,6 +118,7 @@ struct omap_nand_info {
int gpmc_cs;
unsigned long phys_base;
+ unsigned long mem_size;
struct completion comp;
int dma_ch;
int gpmc_irq;
@@ -931,6 +932,7 @@ static int __devinit omap_nand_probe(struct platform_device *pdev)
struct omap_nand_platform_data *pdata;
int err;
int i, offset;
+ struct resource *res;
pdata = pdev->dev.platform_data;
if (pdata == NULL) {
@@ -950,7 +952,6 @@ static int __devinit omap_nand_probe(struct platform_device *pdev)
info->pdev = pdev;
info->gpmc_cs = pdata->cs;
- info->phys_base = pdata->phys_base;
info->mtd.priv = &info->nand;
info->mtd.name = dev_name(&pdev->dev);
@@ -959,16 +960,23 @@ static int __devinit omap_nand_probe(struct platform_device *pdev)
info->nand.options = pdata->devsize;
info->nand.options |= NAND_SKIP_BBTSCAN;
- /* NAND write protect off */
- gpmc_cs_configure(info->gpmc_cs, GPMC_CONFIG_WP, 0);
+ res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+ if (res == NULL) {
+ err = -EINVAL;
+ dev_err(&pdev->dev, "error getting memory resource\n");
+ goto out_free_info;
+ }
+
+ info->phys_base = res->start;
+ info->mem_size = resource_size(res);
- if (!request_mem_region(info->phys_base, NAND_IO_SIZE,
+ if (!request_mem_region(info->phys_base, info->mem_size,
pdev->dev.driver->name)) {
err = -EBUSY;
goto out_free_info;
}
- info->nand.IO_ADDR_R = ioremap(info->phys_base, NAND_IO_SIZE);
+ info->nand.IO_ADDR_R = ioremap(info->phys_base, info->mem_size);
if (!info->nand.IO_ADDR_R) {
err = -ENOMEM;
goto out_release_mem_region;
@@ -1110,7 +1118,7 @@ static int __devinit omap_nand_probe(struct platform_device *pdev)
return 0;
out_release_mem_region:
- release_mem_region(info->phys_base, NAND_IO_SIZE);
+ release_mem_region(info->phys_base, info->mem_size);
out_free_info:
kfree(info);
--
1.7.9.3
^ permalink raw reply related [flat|nested] 73+ messages in thread
* [PATCH v3 7/9] mtd: nand: omap2: use gpmc provided irqs
[not found] <cover.1333640054.git.afzal@ti.com>
2012-04-05 15:45 ` Afzal Mohammed
@ 2012-04-05 15:47 ` Afzal Mohammed
2012-04-05 15:46 ` Afzal Mohammed
` (6 subsequent siblings)
8 siblings, 0 replies; 73+ messages in thread
From: Afzal Mohammed @ 2012-04-05 15:47 UTC (permalink / raw)
To: tony, khilman, linux, dwmw2, sameo, grinberg, mike, nm,
artem.bityutskiy, vimal.newwork, dbaryshkov, linux-omap,
linux-arm-kernel, linux-mtd, linux-kernel
Cc: Afzal Mohammed
GPMC driver provides it's clientsd with interrupts that can be used
through struct resource. Make use of it for irq mode functionality.
Signed-off-by: Afzal Mohammed <afzal@ti.com>
---
drivers/mtd/nand/omap2.c | 67 +++++++++++++++++++++++++++++-----------------
1 file changed, 42 insertions(+), 25 deletions(-)
diff --git a/drivers/mtd/nand/omap2.c b/drivers/mtd/nand/omap2.c
index be4b321..440536b 100644
--- a/drivers/mtd/nand/omap2.c
+++ b/drivers/mtd/nand/omap2.c
@@ -121,7 +121,8 @@ struct omap_nand_info {
unsigned long mem_size;
struct completion comp;
int dma_ch;
- int gpmc_irq;
+ int gpmc_irq_fifo;
+ int gpmc_irq_count;
enum {
OMAP_NAND_IO_READ = 0, /* read */
OMAP_NAND_IO_WRITE, /* write */
@@ -472,13 +473,11 @@ static irqreturn_t omap_nand_irq(int this_irq, void *dev)
{
struct omap_nand_info *info = (struct omap_nand_info *) dev;
u32 bytes;
- u32 irq_stat;
- irq_stat = gpmc_read_status(GPMC_GET_IRQ_STATUS);
bytes = gpmc_read_status(GPMC_PREFETCH_FIFO_CNT);
bytes = bytes & 0xFFFC; /* io in multiple of 4 bytes */
if (info->iomode == OMAP_NAND_IO_WRITE) { /* checks for write io */
- if (irq_stat & 0x2)
+ if (this_irq == info->gpmc_irq_count)
goto done;
if (info->buf_len && (info->buf_len < bytes))
@@ -495,20 +494,17 @@ static irqreturn_t omap_nand_irq(int this_irq, void *dev)
(u32 *)info->buf, bytes >> 2);
info->buf = info->buf + bytes;
- if (irq_stat & 0x2)
+ if (this_irq == info->gpmc_irq_count)
goto done;
}
- gpmc_cs_configure(info->gpmc_cs, GPMC_SET_IRQ_STATUS, irq_stat);
return IRQ_HANDLED;
done:
complete(&info->comp);
- /* disable irq */
- gpmc_cs_configure(info->gpmc_cs, GPMC_ENABLE_IRQ, 0);
- /* clear status */
- gpmc_cs_configure(info->gpmc_cs, GPMC_SET_IRQ_STATUS, irq_stat);
+ disable_irq_nosync(info->gpmc_irq_fifo);
+ disable_irq_nosync(info->gpmc_irq_count);
return IRQ_HANDLED;
}
@@ -542,9 +538,9 @@ static void omap_read_buf_irq_pref(struct mtd_info *mtd, u_char *buf, int len)
goto out_copy;
info->buf_len = len;
- /* enable irq */
- gpmc_cs_configure(info->gpmc_cs, GPMC_ENABLE_IRQ,
- (GPMC_IRQ_FIFOEVENTENABLE | GPMC_IRQ_COUNT_EVENT));
+
+ enable_irq(info->gpmc_irq_count);
+ enable_irq(info->gpmc_irq_fifo);
/* waiting for read to complete */
wait_for_completion(&info->comp);
@@ -591,12 +587,13 @@ static void omap_write_buf_irq_pref(struct mtd_info *mtd,
goto out_copy;
info->buf_len = len;
- /* enable irq */
- gpmc_cs_configure(info->gpmc_cs, GPMC_ENABLE_IRQ,
- (GPMC_IRQ_FIFOEVENTENABLE | GPMC_IRQ_COUNT_EVENT));
+
+ enable_irq(info->gpmc_irq_count);
+ enable_irq(info->gpmc_irq_fifo);
/* waiting for write to complete */
wait_for_completion(&info->comp);
+
/* wait for data to flushed-out before reset the prefetch */
tim = 0;
limit = (loops_per_jiffy * msecs_to_jiffies(OMAP_NAND_TIMEOUT_MS));
@@ -982,6 +979,14 @@ static int __devinit omap_nand_probe(struct platform_device *pdev)
goto out_release_mem_region;
}
+ info->gpmc_irq_fifo = platform_get_irq(pdev, 0);
+ if (info->gpmc_irq_fifo == -ENXIO)
+ dev_warn(&pdev->dev, "error getting FIFO IRQ\n");
+
+ info->gpmc_irq_count = platform_get_irq(pdev, 1);
+ if (info->gpmc_irq_fifo == -ENXIO)
+ dev_warn(&pdev->dev, "error getting TERMINALCOUNT IRQ\n");
+
info->nand.controller = &info->controller;
info->nand.IO_ADDR_W = info->nand.IO_ADDR_R;
@@ -1037,17 +1042,24 @@ static int __devinit omap_nand_probe(struct platform_device *pdev)
break;
case NAND_OMAP_PREFETCH_IRQ:
- err = request_irq(pdata->gpmc_irq,
- omap_nand_irq, IRQF_SHARED, "gpmc-nand", info);
+ err = request_irq(info->gpmc_irq_fifo, omap_nand_irq,
+ IRQF_SHARED, "gpmc-nand-fifo", info);
if (err) {
dev_err(&pdev->dev, "requesting irq(%d) error:%d",
- pdata->gpmc_irq, err);
+ info->gpmc_irq_fifo, err);
goto out_release_mem_region;
- } else {
- info->gpmc_irq = pdata->gpmc_irq;
- info->nand.read_buf = omap_read_buf_irq_pref;
- info->nand.write_buf = omap_write_buf_irq_pref;
}
+ err = request_irq(info->gpmc_irq_count, omap_nand_irq,
+ IRQF_SHARED, "gpmc-nand-count", info);
+ if (err) {
+ dev_err(&pdev->dev, "requesting irq(%d) error:%d",
+ info->gpmc_irq_count, err);
+ goto out_free_irq_gpmc_fifo;
+ }
+
+ info->nand.read_buf = omap_read_buf_irq_pref;
+ info->nand.write_buf = omap_write_buf_irq_pref;
+
break;
default:
@@ -1117,6 +1129,8 @@ static int __devinit omap_nand_probe(struct platform_device *pdev)
return 0;
+out_free_irq_gpmc_fifo:
+ free_irq(info->gpmc_irq_fifo, info);
out_release_mem_region:
release_mem_region(info->phys_base, info->mem_size);
out_free_info:
@@ -1135,8 +1149,11 @@ static int omap_nand_remove(struct platform_device *pdev)
if (info->dma_ch != -1)
omap_free_dma(info->dma_ch);
- if (info->gpmc_irq)
- free_irq(info->gpmc_irq, info);
+ if (info->gpmc_irq_fifo > 0)
+ free_irq(info->gpmc_irq_fifo, info);
+
+ if (info->gpmc_irq_count > 0)
+ free_irq(info->gpmc_irq_count, info);
/* Release NAND device, its internal structures and partitions */
nand_release(&info->mtd);
--
1.7.9.3
^ permalink raw reply related [flat|nested] 73+ messages in thread
* [PATCH v3 7/9] mtd: nand: omap2: use gpmc provided irqs
@ 2012-04-05 15:47 ` Afzal Mohammed
0 siblings, 0 replies; 73+ messages in thread
From: Afzal Mohammed @ 2012-04-05 15:47 UTC (permalink / raw)
To: tony, khilman, linux, dwmw2, sameo, grinberg, mike, nm,
artem.bityutskiy, vimal.newwork, dbaryshkov, linux-omap,
linux-arm-kernel, linux-mtd, linux-kernel
Cc: Afzal Mohammed
GPMC driver provides it's clientsd with interrupts that can be used
through struct resource. Make use of it for irq mode functionality.
Signed-off-by: Afzal Mohammed <afzal@ti.com>
---
drivers/mtd/nand/omap2.c | 67 +++++++++++++++++++++++++++++-----------------
1 file changed, 42 insertions(+), 25 deletions(-)
diff --git a/drivers/mtd/nand/omap2.c b/drivers/mtd/nand/omap2.c
index be4b321..440536b 100644
--- a/drivers/mtd/nand/omap2.c
+++ b/drivers/mtd/nand/omap2.c
@@ -121,7 +121,8 @@ struct omap_nand_info {
unsigned long mem_size;
struct completion comp;
int dma_ch;
- int gpmc_irq;
+ int gpmc_irq_fifo;
+ int gpmc_irq_count;
enum {
OMAP_NAND_IO_READ = 0, /* read */
OMAP_NAND_IO_WRITE, /* write */
@@ -472,13 +473,11 @@ static irqreturn_t omap_nand_irq(int this_irq, void *dev)
{
struct omap_nand_info *info = (struct omap_nand_info *) dev;
u32 bytes;
- u32 irq_stat;
- irq_stat = gpmc_read_status(GPMC_GET_IRQ_STATUS);
bytes = gpmc_read_status(GPMC_PREFETCH_FIFO_CNT);
bytes = bytes & 0xFFFC; /* io in multiple of 4 bytes */
if (info->iomode == OMAP_NAND_IO_WRITE) { /* checks for write io */
- if (irq_stat & 0x2)
+ if (this_irq == info->gpmc_irq_count)
goto done;
if (info->buf_len && (info->buf_len < bytes))
@@ -495,20 +494,17 @@ static irqreturn_t omap_nand_irq(int this_irq, void *dev)
(u32 *)info->buf, bytes >> 2);
info->buf = info->buf + bytes;
- if (irq_stat & 0x2)
+ if (this_irq == info->gpmc_irq_count)
goto done;
}
- gpmc_cs_configure(info->gpmc_cs, GPMC_SET_IRQ_STATUS, irq_stat);
return IRQ_HANDLED;
done:
complete(&info->comp);
- /* disable irq */
- gpmc_cs_configure(info->gpmc_cs, GPMC_ENABLE_IRQ, 0);
- /* clear status */
- gpmc_cs_configure(info->gpmc_cs, GPMC_SET_IRQ_STATUS, irq_stat);
+ disable_irq_nosync(info->gpmc_irq_fifo);
+ disable_irq_nosync(info->gpmc_irq_count);
return IRQ_HANDLED;
}
@@ -542,9 +538,9 @@ static void omap_read_buf_irq_pref(struct mtd_info *mtd, u_char *buf, int len)
goto out_copy;
info->buf_len = len;
- /* enable irq */
- gpmc_cs_configure(info->gpmc_cs, GPMC_ENABLE_IRQ,
- (GPMC_IRQ_FIFOEVENTENABLE | GPMC_IRQ_COUNT_EVENT));
+
+ enable_irq(info->gpmc_irq_count);
+ enable_irq(info->gpmc_irq_fifo);
/* waiting for read to complete */
wait_for_completion(&info->comp);
@@ -591,12 +587,13 @@ static void omap_write_buf_irq_pref(struct mtd_info *mtd,
goto out_copy;
info->buf_len = len;
- /* enable irq */
- gpmc_cs_configure(info->gpmc_cs, GPMC_ENABLE_IRQ,
- (GPMC_IRQ_FIFOEVENTENABLE | GPMC_IRQ_COUNT_EVENT));
+
+ enable_irq(info->gpmc_irq_count);
+ enable_irq(info->gpmc_irq_fifo);
/* waiting for write to complete */
wait_for_completion(&info->comp);
+
/* wait for data to flushed-out before reset the prefetch */
tim = 0;
limit = (loops_per_jiffy * msecs_to_jiffies(OMAP_NAND_TIMEOUT_MS));
@@ -982,6 +979,14 @@ static int __devinit omap_nand_probe(struct platform_device *pdev)
goto out_release_mem_region;
}
+ info->gpmc_irq_fifo = platform_get_irq(pdev, 0);
+ if (info->gpmc_irq_fifo == -ENXIO)
+ dev_warn(&pdev->dev, "error getting FIFO IRQ\n");
+
+ info->gpmc_irq_count = platform_get_irq(pdev, 1);
+ if (info->gpmc_irq_fifo == -ENXIO)
+ dev_warn(&pdev->dev, "error getting TERMINALCOUNT IRQ\n");
+
info->nand.controller = &info->controller;
info->nand.IO_ADDR_W = info->nand.IO_ADDR_R;
@@ -1037,17 +1042,24 @@ static int __devinit omap_nand_probe(struct platform_device *pdev)
break;
case NAND_OMAP_PREFETCH_IRQ:
- err = request_irq(pdata->gpmc_irq,
- omap_nand_irq, IRQF_SHARED, "gpmc-nand", info);
+ err = request_irq(info->gpmc_irq_fifo, omap_nand_irq,
+ IRQF_SHARED, "gpmc-nand-fifo", info);
if (err) {
dev_err(&pdev->dev, "requesting irq(%d) error:%d",
- pdata->gpmc_irq, err);
+ info->gpmc_irq_fifo, err);
goto out_release_mem_region;
- } else {
- info->gpmc_irq = pdata->gpmc_irq;
- info->nand.read_buf = omap_read_buf_irq_pref;
- info->nand.write_buf = omap_write_buf_irq_pref;
}
+ err = request_irq(info->gpmc_irq_count, omap_nand_irq,
+ IRQF_SHARED, "gpmc-nand-count", info);
+ if (err) {
+ dev_err(&pdev->dev, "requesting irq(%d) error:%d",
+ info->gpmc_irq_count, err);
+ goto out_free_irq_gpmc_fifo;
+ }
+
+ info->nand.read_buf = omap_read_buf_irq_pref;
+ info->nand.write_buf = omap_write_buf_irq_pref;
+
break;
default:
@@ -1117,6 +1129,8 @@ static int __devinit omap_nand_probe(struct platform_device *pdev)
return 0;
+out_free_irq_gpmc_fifo:
+ free_irq(info->gpmc_irq_fifo, info);
out_release_mem_region:
release_mem_region(info->phys_base, info->mem_size);
out_free_info:
@@ -1135,8 +1149,11 @@ static int omap_nand_remove(struct platform_device *pdev)
if (info->dma_ch != -1)
omap_free_dma(info->dma_ch);
- if (info->gpmc_irq)
- free_irq(info->gpmc_irq, info);
+ if (info->gpmc_irq_fifo > 0)
+ free_irq(info->gpmc_irq_fifo, info);
+
+ if (info->gpmc_irq_count > 0)
+ free_irq(info->gpmc_irq_count, info);
/* Release NAND device, its internal structures and partitions */
nand_release(&info->mtd);
--
1.7.9.3
^ permalink raw reply related [flat|nested] 73+ messages in thread
* [PATCH v3 7/9] mtd: nand: omap2: use gpmc provided irqs
@ 2012-04-05 15:47 ` Afzal Mohammed
0 siblings, 0 replies; 73+ messages in thread
From: Afzal Mohammed @ 2012-04-05 15:47 UTC (permalink / raw)
To: linux-arm-kernel
GPMC driver provides it's clientsd with interrupts that can be used
through struct resource. Make use of it for irq mode functionality.
Signed-off-by: Afzal Mohammed <afzal@ti.com>
---
drivers/mtd/nand/omap2.c | 67 +++++++++++++++++++++++++++++-----------------
1 file changed, 42 insertions(+), 25 deletions(-)
diff --git a/drivers/mtd/nand/omap2.c b/drivers/mtd/nand/omap2.c
index be4b321..440536b 100644
--- a/drivers/mtd/nand/omap2.c
+++ b/drivers/mtd/nand/omap2.c
@@ -121,7 +121,8 @@ struct omap_nand_info {
unsigned long mem_size;
struct completion comp;
int dma_ch;
- int gpmc_irq;
+ int gpmc_irq_fifo;
+ int gpmc_irq_count;
enum {
OMAP_NAND_IO_READ = 0, /* read */
OMAP_NAND_IO_WRITE, /* write */
@@ -472,13 +473,11 @@ static irqreturn_t omap_nand_irq(int this_irq, void *dev)
{
struct omap_nand_info *info = (struct omap_nand_info *) dev;
u32 bytes;
- u32 irq_stat;
- irq_stat = gpmc_read_status(GPMC_GET_IRQ_STATUS);
bytes = gpmc_read_status(GPMC_PREFETCH_FIFO_CNT);
bytes = bytes & 0xFFFC; /* io in multiple of 4 bytes */
if (info->iomode == OMAP_NAND_IO_WRITE) { /* checks for write io */
- if (irq_stat & 0x2)
+ if (this_irq == info->gpmc_irq_count)
goto done;
if (info->buf_len && (info->buf_len < bytes))
@@ -495,20 +494,17 @@ static irqreturn_t omap_nand_irq(int this_irq, void *dev)
(u32 *)info->buf, bytes >> 2);
info->buf = info->buf + bytes;
- if (irq_stat & 0x2)
+ if (this_irq == info->gpmc_irq_count)
goto done;
}
- gpmc_cs_configure(info->gpmc_cs, GPMC_SET_IRQ_STATUS, irq_stat);
return IRQ_HANDLED;
done:
complete(&info->comp);
- /* disable irq */
- gpmc_cs_configure(info->gpmc_cs, GPMC_ENABLE_IRQ, 0);
- /* clear status */
- gpmc_cs_configure(info->gpmc_cs, GPMC_SET_IRQ_STATUS, irq_stat);
+ disable_irq_nosync(info->gpmc_irq_fifo);
+ disable_irq_nosync(info->gpmc_irq_count);
return IRQ_HANDLED;
}
@@ -542,9 +538,9 @@ static void omap_read_buf_irq_pref(struct mtd_info *mtd, u_char *buf, int len)
goto out_copy;
info->buf_len = len;
- /* enable irq */
- gpmc_cs_configure(info->gpmc_cs, GPMC_ENABLE_IRQ,
- (GPMC_IRQ_FIFOEVENTENABLE | GPMC_IRQ_COUNT_EVENT));
+
+ enable_irq(info->gpmc_irq_count);
+ enable_irq(info->gpmc_irq_fifo);
/* waiting for read to complete */
wait_for_completion(&info->comp);
@@ -591,12 +587,13 @@ static void omap_write_buf_irq_pref(struct mtd_info *mtd,
goto out_copy;
info->buf_len = len;
- /* enable irq */
- gpmc_cs_configure(info->gpmc_cs, GPMC_ENABLE_IRQ,
- (GPMC_IRQ_FIFOEVENTENABLE | GPMC_IRQ_COUNT_EVENT));
+
+ enable_irq(info->gpmc_irq_count);
+ enable_irq(info->gpmc_irq_fifo);
/* waiting for write to complete */
wait_for_completion(&info->comp);
+
/* wait for data to flushed-out before reset the prefetch */
tim = 0;
limit = (loops_per_jiffy * msecs_to_jiffies(OMAP_NAND_TIMEOUT_MS));
@@ -982,6 +979,14 @@ static int __devinit omap_nand_probe(struct platform_device *pdev)
goto out_release_mem_region;
}
+ info->gpmc_irq_fifo = platform_get_irq(pdev, 0);
+ if (info->gpmc_irq_fifo == -ENXIO)
+ dev_warn(&pdev->dev, "error getting FIFO IRQ\n");
+
+ info->gpmc_irq_count = platform_get_irq(pdev, 1);
+ if (info->gpmc_irq_fifo == -ENXIO)
+ dev_warn(&pdev->dev, "error getting TERMINALCOUNT IRQ\n");
+
info->nand.controller = &info->controller;
info->nand.IO_ADDR_W = info->nand.IO_ADDR_R;
@@ -1037,17 +1042,24 @@ static int __devinit omap_nand_probe(struct platform_device *pdev)
break;
case NAND_OMAP_PREFETCH_IRQ:
- err = request_irq(pdata->gpmc_irq,
- omap_nand_irq, IRQF_SHARED, "gpmc-nand", info);
+ err = request_irq(info->gpmc_irq_fifo, omap_nand_irq,
+ IRQF_SHARED, "gpmc-nand-fifo", info);
if (err) {
dev_err(&pdev->dev, "requesting irq(%d) error:%d",
- pdata->gpmc_irq, err);
+ info->gpmc_irq_fifo, err);
goto out_release_mem_region;
- } else {
- info->gpmc_irq = pdata->gpmc_irq;
- info->nand.read_buf = omap_read_buf_irq_pref;
- info->nand.write_buf = omap_write_buf_irq_pref;
}
+ err = request_irq(info->gpmc_irq_count, omap_nand_irq,
+ IRQF_SHARED, "gpmc-nand-count", info);
+ if (err) {
+ dev_err(&pdev->dev, "requesting irq(%d) error:%d",
+ info->gpmc_irq_count, err);
+ goto out_free_irq_gpmc_fifo;
+ }
+
+ info->nand.read_buf = omap_read_buf_irq_pref;
+ info->nand.write_buf = omap_write_buf_irq_pref;
+
break;
default:
@@ -1117,6 +1129,8 @@ static int __devinit omap_nand_probe(struct platform_device *pdev)
return 0;
+out_free_irq_gpmc_fifo:
+ free_irq(info->gpmc_irq_fifo, info);
out_release_mem_region:
release_mem_region(info->phys_base, info->mem_size);
out_free_info:
@@ -1135,8 +1149,11 @@ static int omap_nand_remove(struct platform_device *pdev)
if (info->dma_ch != -1)
omap_free_dma(info->dma_ch);
- if (info->gpmc_irq)
- free_irq(info->gpmc_irq, info);
+ if (info->gpmc_irq_fifo > 0)
+ free_irq(info->gpmc_irq_fifo, info);
+
+ if (info->gpmc_irq_count > 0)
+ free_irq(info->gpmc_irq_count, info);
/* Release NAND device, its internal structures and partitions */
nand_release(&info->mtd);
--
1.7.9.3
^ permalink raw reply related [flat|nested] 73+ messages in thread
* [PATCH v3 8/9] mtd: nand: omap2: handle nand on gpmc
[not found] <cover.1333640054.git.afzal@ti.com>
2012-04-05 15:45 ` Afzal Mohammed
@ 2012-04-05 15:47 ` Afzal Mohammed
2012-04-05 15:46 ` Afzal Mohammed
` (6 subsequent siblings)
8 siblings, 0 replies; 73+ messages in thread
From: Afzal Mohammed @ 2012-04-05 15:47 UTC (permalink / raw)
To: tony, khilman, linux, dwmw2, sameo, grinberg, mike, nm,
artem.bityutskiy, vimal.newwork, dbaryshkov, linux-omap,
linux-arm-kernel, linux-mtd, linux-kernel
Cc: Afzal Mohammed
GPMC driver has been modified to fill NAND platform data with GPMC
NAND register details. As these registers are accessible in NAND
driver itself, configure NAND in GPMC by itself.
Note: Verfying that other CS have not yet enabled for prefetch & ecc
has to be incorporated. Currently this causes no issues as there are
no boards that use NAND on multiple CS. With GPMC modifications,
perhaps it would be better to consider NAND connected on multiple CS
as a single peripheral using multiple CS. This would make handling
multiple CS issues easier.
Signed-off-by: Afzal Mohammed <afzal@ti.com>
---
drivers/mtd/nand/omap2.c | 209 ++++++++++++++++++++++++++++++++++++----------
1 file changed, 165 insertions(+), 44 deletions(-)
diff --git a/drivers/mtd/nand/omap2.c b/drivers/mtd/nand/omap2.c
index 440536b..34fb726 100644
--- a/drivers/mtd/nand/omap2.c
+++ b/drivers/mtd/nand/omap2.c
@@ -129,8 +129,79 @@ struct omap_nand_info {
} iomode;
u_char *buf;
int buf_len;
+ struct gpmc_nand_regs reg;
};
+#define PREFETCH_CONFIG1_CS_SHIFT 24
+#define ECC_CONFIG_CS_SHIFT 1
+#define CS_MASK 0x7
+#define ENABLE_PREFETCH (0x1 << 7)
+#define DMA_MPU_MODE_SHIFT 2
+#define ECCSIZE1_SHIFT 22
+#define ECC1RESULTSIZE 0x1
+#define ECC_CLEAR_SHIFT 8
+#define ECC1 0x1
+
+/**
+ * omap_prefetch_enable - configures and starts prefetch transfer
+ * @cs: cs (chip select) number
+ * @fifo_th: fifo threshold to be used for read/ write
+ * @dma_mode: dma mode enable (1) or disable (0)
+ * @u32_count: number of bytes to be transferred
+ * @is_write: prefetch read(0) or write post(1) mode
+ */
+static int omap_prefetch_enable(int cs, int fifo_th, int dma_mode,
+ unsigned int u32_count, int is_write, struct omap_nand_info *info)
+{
+ u32 val;
+
+ if (fifo_th > PREFETCH_FIFOTHRESHOLD_MAX) {
+ pr_err("gpmc: fifo threshold is not supported\n");
+ return -1;
+ } else if (!(readl(info->reg.gpmc_prefetch_control))) {
+ /* Set the amount of bytes to be prefetched */
+ writel(u32_count, info->reg.gpmc_prefetch_config2);
+
+ /* Set dma/mpu mode, the prefetch read / post write and
+ * enable the engine. Set which cs is has requested for.
+ */
+ val = ((cs << PREFETCH_CONFIG1_CS_SHIFT) |
+ PREFETCH_FIFOTHRESHOLD(fifo_th) |
+ ENABLE_PREFETCH |
+ (dma_mode << DMA_MPU_MODE_SHIFT) |
+ (0x1 & is_write));
+ writel(val, info->reg.gpmc_prefetch_config1);
+
+ /* Start the prefetch engine */
+ writel(0x1, info->reg.gpmc_prefetch_control);
+ } else {
+ return -EBUSY;
+ }
+
+ return 0;
+}
+
+/**
+ * omap_prefetch_reset - disables and stops the prefetch engine
+ */
+static int omap_prefetch_reset(int cs, struct omap_nand_info *info)
+{
+ u32 config1;
+
+ /* check if the same module/cs is trying to reset */
+ config1 = readl(info->reg.gpmc_prefetch_config1);
+ if (((config1 >> PREFETCH_CONFIG1_CS_SHIFT) & CS_MASK) != cs)
+ return -EINVAL;
+
+ /* Stop the PFPW engine */
+ writel(0x0, info->reg.gpmc_prefetch_control);
+
+ /* Reset/disable the PFPW engine */
+ writel(0x0, info->reg.gpmc_prefetch_config1);
+
+ return 0;
+}
+
/**
* omap_hwcontrol - hardware specific access to control-lines
* @mtd: MTD device structure
@@ -149,13 +220,13 @@ static void omap_hwcontrol(struct mtd_info *mtd, int cmd, unsigned int ctrl)
if (cmd != NAND_CMD_NONE) {
if (ctrl & NAND_CLE)
- gpmc_nand_write(info->gpmc_cs, GPMC_NAND_COMMAND, cmd);
+ writeb(cmd, info->reg.gpmc_nand_command);
else if (ctrl & NAND_ALE)
- gpmc_nand_write(info->gpmc_cs, GPMC_NAND_ADDRESS, cmd);
+ writeb(cmd, info->reg.gpmc_nand_address);
else /* NAND_NCE */
- gpmc_nand_write(info->gpmc_cs, GPMC_NAND_DATA, cmd);
+ writeb(cmd, info->reg.gpmc_nand_data);
}
}
@@ -189,7 +260,8 @@ static void omap_write_buf8(struct mtd_info *mtd, const u_char *buf, int len)
iowrite8(*p++, info->nand.IO_ADDR_W);
/* wait until buffer is available for write */
do {
- status = gpmc_read_status(GPMC_STATUS_BUFFER);
+ status = readl(info->reg.gpmc_status) &
+ GPMC_STATUS_BUFF_EMPTY;
} while (!status);
}
}
@@ -226,7 +298,8 @@ static void omap_write_buf16(struct mtd_info *mtd, const u_char * buf, int len)
iowrite16(*p++, info->nand.IO_ADDR_W);
/* wait until buffer is available for write */
do {
- status = gpmc_read_status(GPMC_STATUS_BUFFER);
+ status = readl(info->reg.gpmc_status) &
+ GPMC_STATUS_BUFF_EMPTY;
} while (!status);
}
}
@@ -256,8 +329,8 @@ static void omap_read_buf_pref(struct mtd_info *mtd, u_char *buf, int len)
}
/* configure and start prefetch transfer */
- ret = gpmc_prefetch_enable(info->gpmc_cs,
- PREFETCH_FIFOTHRESHOLD_MAX, 0x0, len, 0x0);
+ ret = omap_prefetch_enable(info->gpmc_cs,
+ PREFETCH_FIFOTHRESHOLD_MAX, 0x0, len, 0x0, info);
if (ret) {
/* PFPW engine is busy, use cpu copy method */
if (info->nand.options & NAND_BUSWIDTH_16)
@@ -266,14 +339,15 @@ static void omap_read_buf_pref(struct mtd_info *mtd, u_char *buf, int len)
omap_read_buf8(mtd, (u_char *)p, len);
} else {
do {
- r_count = gpmc_read_status(GPMC_PREFETCH_FIFO_CNT);
+ r_count = readl(info->reg.gpmc_prefetch_status);
+ r_count = GPMC_PREFETCH_STATUS_FIFO_CNT(r_count);
r_count = r_count >> 2;
ioread32_rep(info->nand.IO_ADDR_R, p, r_count);
p += r_count;
len -= r_count << 2;
} while (len);
/* disable and stop the PFPW engine */
- gpmc_prefetch_reset(info->gpmc_cs);
+ omap_prefetch_reset(info->gpmc_cs, info);
}
}
@@ -292,6 +366,7 @@ static void omap_write_buf_pref(struct mtd_info *mtd,
int i = 0, ret = 0;
u16 *p = (u16 *)buf;
unsigned long tim, limit;
+ u32 val;
/* take care of subpage writes */
if (len % 2 != 0) {
@@ -301,8 +376,8 @@ static void omap_write_buf_pref(struct mtd_info *mtd,
}
/* configure and start prefetch transfer */
- ret = gpmc_prefetch_enable(info->gpmc_cs,
- PREFETCH_FIFOTHRESHOLD_MAX, 0x0, len, 0x1);
+ ret = omap_prefetch_enable(info->gpmc_cs,
+ PREFETCH_FIFOTHRESHOLD_MAX, 0x0, len, 0x1, info);
if (ret) {
/* PFPW engine is busy, use cpu copy method */
if (info->nand.options & NAND_BUSWIDTH_16)
@@ -311,7 +386,8 @@ static void omap_write_buf_pref(struct mtd_info *mtd,
omap_write_buf8(mtd, (u_char *)p, len);
} else {
while (len) {
- w_count = gpmc_read_status(GPMC_PREFETCH_FIFO_CNT);
+ w_count = readl(info->reg.gpmc_prefetch_status);
+ w_count = GPMC_PREFETCH_STATUS_FIFO_CNT(w_count);
w_count = w_count >> 1;
for (i = 0; (i < w_count) && len; i++, len -= 2)
iowrite16(*p++, info->nand.IO_ADDR_W);
@@ -320,11 +396,14 @@ static void omap_write_buf_pref(struct mtd_info *mtd,
tim = 0;
limit = (loops_per_jiffy *
msecs_to_jiffies(OMAP_NAND_TIMEOUT_MS));
- while (gpmc_read_status(GPMC_PREFETCH_COUNT) && (tim++ < limit))
+ do {
cpu_relax();
+ val = readl(info->reg.gpmc_prefetch_status);
+ val = GPMC_PREFETCH_STATUS_COUNT(val);
+ } while (val && (tim++ < limit));
/* disable and stop the PFPW engine */
- gpmc_prefetch_reset(info->gpmc_cs);
+ omap_prefetch_reset(info->gpmc_cs, info);
}
}
@@ -356,6 +435,7 @@ static inline int omap_nand_dma_transfer(struct mtd_info *mtd, void *addr,
dma_addr_t dma_addr;
int ret;
unsigned long tim, limit;
+ u32 val;
/* The fifo depth is 64 bytes max.
* But configure the FIFO-threahold to 32 to get a sync at each frame
@@ -400,8 +480,8 @@ static inline int omap_nand_dma_transfer(struct mtd_info *mtd, void *addr,
OMAP24XX_DMA_GPMC, OMAP_DMA_SRC_SYNC);
}
/* configure and start prefetch transfer */
- ret = gpmc_prefetch_enable(info->gpmc_cs,
- PREFETCH_FIFOTHRESHOLD_MAX, 0x1, len, is_write);
+ ret = omap_prefetch_enable(info->gpmc_cs,
+ PREFETCH_FIFOTHRESHOLD_MAX, 0x1, len, is_write, info);
if (ret)
/* PFPW engine is busy, use cpu copy method */
goto out_copy;
@@ -414,11 +494,15 @@ static inline int omap_nand_dma_transfer(struct mtd_info *mtd, void *addr,
wait_for_completion(&info->comp);
tim = 0;
limit = (loops_per_jiffy * msecs_to_jiffies(OMAP_NAND_TIMEOUT_MS));
- while (gpmc_read_status(GPMC_PREFETCH_COUNT) && (tim++ < limit))
+
+ do {
cpu_relax();
+ val = readl(info->reg.gpmc_prefetch_status);
+ val = GPMC_PREFETCH_STATUS_COUNT(val);
+ } while (val && (tim++ < limit));
/* disable and stop the PFPW engine */
- gpmc_prefetch_reset(info->gpmc_cs);
+ omap_prefetch_reset(info->gpmc_cs, info);
dma_unmap_single(&info->pdev->dev, dma_addr, len, dir);
return 0;
@@ -474,7 +558,8 @@ static irqreturn_t omap_nand_irq(int this_irq, void *dev)
struct omap_nand_info *info = (struct omap_nand_info *) dev;
u32 bytes;
- bytes = gpmc_read_status(GPMC_PREFETCH_FIFO_CNT);
+ bytes = readl(info->reg.gpmc_prefetch_status);
+ bytes = GPMC_PREFETCH_STATUS_FIFO_CNT(bytes);
bytes = bytes & 0xFFFC; /* io in multiple of 4 bytes */
if (info->iomode == OMAP_NAND_IO_WRITE) { /* checks for write io */
if (this_irq == info->gpmc_irq_count)
@@ -531,8 +616,8 @@ static void omap_read_buf_irq_pref(struct mtd_info *mtd, u_char *buf, int len)
init_completion(&info->comp);
/* configure and start prefetch transfer */
- ret = gpmc_prefetch_enable(info->gpmc_cs,
- PREFETCH_FIFOTHRESHOLD_MAX/2, 0x0, len, 0x0);
+ ret = omap_prefetch_enable(info->gpmc_cs,
+ PREFETCH_FIFOTHRESHOLD_MAX/2, 0x0, len, 0x0, info);
if (ret)
/* PFPW engine is busy, use cpu copy method */
goto out_copy;
@@ -546,7 +631,7 @@ static void omap_read_buf_irq_pref(struct mtd_info *mtd, u_char *buf, int len)
wait_for_completion(&info->comp);
/* disable and stop the PFPW engine */
- gpmc_prefetch_reset(info->gpmc_cs);
+ omap_prefetch_reset(info->gpmc_cs, info);
return;
out_copy:
@@ -569,6 +654,7 @@ static void omap_write_buf_irq_pref(struct mtd_info *mtd,
struct omap_nand_info, mtd);
int ret = 0;
unsigned long tim, limit;
+ u32 val;
if (len <= mtd->oobsize) {
omap_write_buf_pref(mtd, buf, len);
@@ -580,8 +666,8 @@ static void omap_write_buf_irq_pref(struct mtd_info *mtd,
init_completion(&info->comp);
/* configure and start prefetch transfer : size=24 */
- ret = gpmc_prefetch_enable(info->gpmc_cs,
- (PREFETCH_FIFOTHRESHOLD_MAX * 3) / 8, 0x0, len, 0x1);
+ ret = omap_prefetch_enable(info->gpmc_cs,
+ (PREFETCH_FIFOTHRESHOLD_MAX * 3) / 8, 0x0, len, 0x1, info);
if (ret)
/* PFPW engine is busy, use cpu copy method */
goto out_copy;
@@ -597,11 +683,14 @@ static void omap_write_buf_irq_pref(struct mtd_info *mtd,
/* wait for data to flushed-out before reset the prefetch */
tim = 0;
limit = (loops_per_jiffy * msecs_to_jiffies(OMAP_NAND_TIMEOUT_MS));
- while (gpmc_read_status(GPMC_PREFETCH_COUNT) && (tim++ < limit))
+ do {
+ val = readl(info->reg.gpmc_prefetch_status);
+ val = GPMC_PREFETCH_STATUS_COUNT(val);
cpu_relax();
+ } while (val && (tim++ < limit));
/* disable and stop the PFPW engine */
- gpmc_prefetch_reset(info->gpmc_cs);
+ omap_prefetch_reset(info->gpmc_cs, info);
return;
out_copy:
@@ -841,7 +930,20 @@ static int omap_calculate_ecc(struct mtd_info *mtd, const u_char *dat,
{
struct omap_nand_info *info = container_of(mtd, struct omap_nand_info,
mtd);
- return gpmc_calculate_ecc(info->gpmc_cs, dat, ecc_code);
+ u32 val;
+
+ val = readl(info->reg.gpmc_ecc_config);
+ if (((val >> ECC_CONFIG_CS_SHIFT) & ~CS_MASK) != info->gpmc_cs)
+ return -EINVAL;
+
+ /* read ecc result */
+ val = readl(info->reg.gpmc_ecc1_result);
+ *ecc_code++ = val; /* P128e, ..., P1e */
+ *ecc_code++ = val >> 16; /* P128o, ..., P1o */
+ /* P2048o, P1024o, P512o, P256o, P2048e, P1024e, P512e, P256e */
+ *ecc_code++ = ((val >> 8) & 0x0f) | ((val >> 20) & 0xf0);
+
+ return 0;
}
/**
@@ -855,8 +957,36 @@ static void omap_enable_hwecc(struct mtd_info *mtd, int mode)
mtd);
struct nand_chip *chip = mtd->priv;
unsigned int dev_width = (chip->options & NAND_BUSWIDTH_16) ? 1 : 0;
+ u32 val;
+
+ /* clear ecc and enable bits */
+ val = ((0x1 << ECC_CLEAR_SHIFT) | ECC1);
+ writel(val, info->reg.gpmc_ecc_control);
+
+ /* program ecc and result sizes */
+ val = ((((info->nand.ecc.size >> 1) - 1) << ECCSIZE1_SHIFT) |
+ ECC1RESULTSIZE);
+ writel(val, info->reg.gpmc_ecc_size_config);
+
+ switch (mode) {
+ case NAND_ECC_READ:
+ writel(0x101, info->reg.gpmc_ecc_control);
+ break;
+ case NAND_ECC_READSYN:
+ writel(0x100, info->reg.gpmc_ecc_control);
+ break;
+ case NAND_ECC_WRITE:
+ writel(0x101, info->reg.gpmc_ecc_control);
+ break;
+ default:
+ dev_info(&info->pdev->dev,
+ "error: unrecognized Mode[%d]!\n", mode);
+ break;
+ }
- gpmc_enable_hwecc(info->gpmc_cs, mode, dev_width, info->nand.ecc.size);
+ /* (ECC 16 or 8 bit col) | ( CS ) | ECC Enable */
+ val = (dev_width << 7) | (info->gpmc_cs << 1) | (0x1);
+ writel(val, info->reg.gpmc_ecc_config);
}
/**
@@ -884,10 +1014,9 @@ static int omap_wait(struct mtd_info *mtd, struct nand_chip *chip)
else
timeo += (HZ * 20) / 1000;
- gpmc_nand_write(info->gpmc_cs,
- GPMC_NAND_COMMAND, (NAND_CMD_STATUS & 0xFF));
+ writeb(NAND_CMD_STATUS & 0xFF, info->reg.gpmc_nand_command);
while (time_before(jiffies, timeo)) {
- status = gpmc_nand_read(info->gpmc_cs, GPMC_NAND_DATA);
+ status = readb(info->reg.gpmc_nand_data);
if (status & NAND_STATUS_READY)
break;
cond_resched();
@@ -905,22 +1034,13 @@ static int omap_dev_ready(struct mtd_info *mtd)
struct omap_nand_info *info = container_of(mtd, struct omap_nand_info,
mtd);
- val = gpmc_read_status(GPMC_GET_IRQ_STATUS);
+ val = readl(info->reg.gpmc_status);
+
if ((val & 0x100) == 0x100) {
- /* Clear IRQ Interrupt */
- val |= 0x100;
- val &= ~(0x0);
- gpmc_cs_configure(info->gpmc_cs, GPMC_SET_IRQ_STATUS, val);
+ return 1;
} else {
- unsigned int cnt = 0;
- while (cnt++ < 0x1FF) {
- if ((val & 0x100) == 0x100)
- return 0;
- val = gpmc_read_status(GPMC_GET_IRQ_STATUS);
- }
+ return 0;
}
-
- return 1;
}
static int __devinit omap_nand_probe(struct platform_device *pdev)
@@ -949,6 +1069,7 @@ static int __devinit omap_nand_probe(struct platform_device *pdev)
info->pdev = pdev;
info->gpmc_cs = pdata->cs;
+ info->reg = pdata->reg;
info->mtd.priv = &info->nand;
info->mtd.name = dev_name(&pdev->dev);
--
1.7.9.3
^ permalink raw reply related [flat|nested] 73+ messages in thread
* [PATCH v3 8/9] mtd: nand: omap2: handle nand on gpmc
@ 2012-04-05 15:47 ` Afzal Mohammed
0 siblings, 0 replies; 73+ messages in thread
From: Afzal Mohammed @ 2012-04-05 15:47 UTC (permalink / raw)
To: tony, khilman, linux, dwmw2, sameo, grinberg, mike, nm,
artem.bityutskiy, vimal.newwork, dbaryshkov, linux-omap,
linux-arm-kernel, linux-mtd, linux-kernel
Cc: Afzal Mohammed
GPMC driver has been modified to fill NAND platform data with GPMC
NAND register details. As these registers are accessible in NAND
driver itself, configure NAND in GPMC by itself.
Note: Verfying that other CS have not yet enabled for prefetch & ecc
has to be incorporated. Currently this causes no issues as there are
no boards that use NAND on multiple CS. With GPMC modifications,
perhaps it would be better to consider NAND connected on multiple CS
as a single peripheral using multiple CS. This would make handling
multiple CS issues easier.
Signed-off-by: Afzal Mohammed <afzal@ti.com>
---
drivers/mtd/nand/omap2.c | 209 ++++++++++++++++++++++++++++++++++++----------
1 file changed, 165 insertions(+), 44 deletions(-)
diff --git a/drivers/mtd/nand/omap2.c b/drivers/mtd/nand/omap2.c
index 440536b..34fb726 100644
--- a/drivers/mtd/nand/omap2.c
+++ b/drivers/mtd/nand/omap2.c
@@ -129,8 +129,79 @@ struct omap_nand_info {
} iomode;
u_char *buf;
int buf_len;
+ struct gpmc_nand_regs reg;
};
+#define PREFETCH_CONFIG1_CS_SHIFT 24
+#define ECC_CONFIG_CS_SHIFT 1
+#define CS_MASK 0x7
+#define ENABLE_PREFETCH (0x1 << 7)
+#define DMA_MPU_MODE_SHIFT 2
+#define ECCSIZE1_SHIFT 22
+#define ECC1RESULTSIZE 0x1
+#define ECC_CLEAR_SHIFT 8
+#define ECC1 0x1
+
+/**
+ * omap_prefetch_enable - configures and starts prefetch transfer
+ * @cs: cs (chip select) number
+ * @fifo_th: fifo threshold to be used for read/ write
+ * @dma_mode: dma mode enable (1) or disable (0)
+ * @u32_count: number of bytes to be transferred
+ * @is_write: prefetch read(0) or write post(1) mode
+ */
+static int omap_prefetch_enable(int cs, int fifo_th, int dma_mode,
+ unsigned int u32_count, int is_write, struct omap_nand_info *info)
+{
+ u32 val;
+
+ if (fifo_th > PREFETCH_FIFOTHRESHOLD_MAX) {
+ pr_err("gpmc: fifo threshold is not supported\n");
+ return -1;
+ } else if (!(readl(info->reg.gpmc_prefetch_control))) {
+ /* Set the amount of bytes to be prefetched */
+ writel(u32_count, info->reg.gpmc_prefetch_config2);
+
+ /* Set dma/mpu mode, the prefetch read / post write and
+ * enable the engine. Set which cs is has requested for.
+ */
+ val = ((cs << PREFETCH_CONFIG1_CS_SHIFT) |
+ PREFETCH_FIFOTHRESHOLD(fifo_th) |
+ ENABLE_PREFETCH |
+ (dma_mode << DMA_MPU_MODE_SHIFT) |
+ (0x1 & is_write));
+ writel(val, info->reg.gpmc_prefetch_config1);
+
+ /* Start the prefetch engine */
+ writel(0x1, info->reg.gpmc_prefetch_control);
+ } else {
+ return -EBUSY;
+ }
+
+ return 0;
+}
+
+/**
+ * omap_prefetch_reset - disables and stops the prefetch engine
+ */
+static int omap_prefetch_reset(int cs, struct omap_nand_info *info)
+{
+ u32 config1;
+
+ /* check if the same module/cs is trying to reset */
+ config1 = readl(info->reg.gpmc_prefetch_config1);
+ if (((config1 >> PREFETCH_CONFIG1_CS_SHIFT) & CS_MASK) != cs)
+ return -EINVAL;
+
+ /* Stop the PFPW engine */
+ writel(0x0, info->reg.gpmc_prefetch_control);
+
+ /* Reset/disable the PFPW engine */
+ writel(0x0, info->reg.gpmc_prefetch_config1);
+
+ return 0;
+}
+
/**
* omap_hwcontrol - hardware specific access to control-lines
* @mtd: MTD device structure
@@ -149,13 +220,13 @@ static void omap_hwcontrol(struct mtd_info *mtd, int cmd, unsigned int ctrl)
if (cmd != NAND_CMD_NONE) {
if (ctrl & NAND_CLE)
- gpmc_nand_write(info->gpmc_cs, GPMC_NAND_COMMAND, cmd);
+ writeb(cmd, info->reg.gpmc_nand_command);
else if (ctrl & NAND_ALE)
- gpmc_nand_write(info->gpmc_cs, GPMC_NAND_ADDRESS, cmd);
+ writeb(cmd, info->reg.gpmc_nand_address);
else /* NAND_NCE */
- gpmc_nand_write(info->gpmc_cs, GPMC_NAND_DATA, cmd);
+ writeb(cmd, info->reg.gpmc_nand_data);
}
}
@@ -189,7 +260,8 @@ static void omap_write_buf8(struct mtd_info *mtd, const u_char *buf, int len)
iowrite8(*p++, info->nand.IO_ADDR_W);
/* wait until buffer is available for write */
do {
- status = gpmc_read_status(GPMC_STATUS_BUFFER);
+ status = readl(info->reg.gpmc_status) &
+ GPMC_STATUS_BUFF_EMPTY;
} while (!status);
}
}
@@ -226,7 +298,8 @@ static void omap_write_buf16(struct mtd_info *mtd, const u_char * buf, int len)
iowrite16(*p++, info->nand.IO_ADDR_W);
/* wait until buffer is available for write */
do {
- status = gpmc_read_status(GPMC_STATUS_BUFFER);
+ status = readl(info->reg.gpmc_status) &
+ GPMC_STATUS_BUFF_EMPTY;
} while (!status);
}
}
@@ -256,8 +329,8 @@ static void omap_read_buf_pref(struct mtd_info *mtd, u_char *buf, int len)
}
/* configure and start prefetch transfer */
- ret = gpmc_prefetch_enable(info->gpmc_cs,
- PREFETCH_FIFOTHRESHOLD_MAX, 0x0, len, 0x0);
+ ret = omap_prefetch_enable(info->gpmc_cs,
+ PREFETCH_FIFOTHRESHOLD_MAX, 0x0, len, 0x0, info);
if (ret) {
/* PFPW engine is busy, use cpu copy method */
if (info->nand.options & NAND_BUSWIDTH_16)
@@ -266,14 +339,15 @@ static void omap_read_buf_pref(struct mtd_info *mtd, u_char *buf, int len)
omap_read_buf8(mtd, (u_char *)p, len);
} else {
do {
- r_count = gpmc_read_status(GPMC_PREFETCH_FIFO_CNT);
+ r_count = readl(info->reg.gpmc_prefetch_status);
+ r_count = GPMC_PREFETCH_STATUS_FIFO_CNT(r_count);
r_count = r_count >> 2;
ioread32_rep(info->nand.IO_ADDR_R, p, r_count);
p += r_count;
len -= r_count << 2;
} while (len);
/* disable and stop the PFPW engine */
- gpmc_prefetch_reset(info->gpmc_cs);
+ omap_prefetch_reset(info->gpmc_cs, info);
}
}
@@ -292,6 +366,7 @@ static void omap_write_buf_pref(struct mtd_info *mtd,
int i = 0, ret = 0;
u16 *p = (u16 *)buf;
unsigned long tim, limit;
+ u32 val;
/* take care of subpage writes */
if (len % 2 != 0) {
@@ -301,8 +376,8 @@ static void omap_write_buf_pref(struct mtd_info *mtd,
}
/* configure and start prefetch transfer */
- ret = gpmc_prefetch_enable(info->gpmc_cs,
- PREFETCH_FIFOTHRESHOLD_MAX, 0x0, len, 0x1);
+ ret = omap_prefetch_enable(info->gpmc_cs,
+ PREFETCH_FIFOTHRESHOLD_MAX, 0x0, len, 0x1, info);
if (ret) {
/* PFPW engine is busy, use cpu copy method */
if (info->nand.options & NAND_BUSWIDTH_16)
@@ -311,7 +386,8 @@ static void omap_write_buf_pref(struct mtd_info *mtd,
omap_write_buf8(mtd, (u_char *)p, len);
} else {
while (len) {
- w_count = gpmc_read_status(GPMC_PREFETCH_FIFO_CNT);
+ w_count = readl(info->reg.gpmc_prefetch_status);
+ w_count = GPMC_PREFETCH_STATUS_FIFO_CNT(w_count);
w_count = w_count >> 1;
for (i = 0; (i < w_count) && len; i++, len -= 2)
iowrite16(*p++, info->nand.IO_ADDR_W);
@@ -320,11 +396,14 @@ static void omap_write_buf_pref(struct mtd_info *mtd,
tim = 0;
limit = (loops_per_jiffy *
msecs_to_jiffies(OMAP_NAND_TIMEOUT_MS));
- while (gpmc_read_status(GPMC_PREFETCH_COUNT) && (tim++ < limit))
+ do {
cpu_relax();
+ val = readl(info->reg.gpmc_prefetch_status);
+ val = GPMC_PREFETCH_STATUS_COUNT(val);
+ } while (val && (tim++ < limit));
/* disable and stop the PFPW engine */
- gpmc_prefetch_reset(info->gpmc_cs);
+ omap_prefetch_reset(info->gpmc_cs, info);
}
}
@@ -356,6 +435,7 @@ static inline int omap_nand_dma_transfer(struct mtd_info *mtd, void *addr,
dma_addr_t dma_addr;
int ret;
unsigned long tim, limit;
+ u32 val;
/* The fifo depth is 64 bytes max.
* But configure the FIFO-threahold to 32 to get a sync at each frame
@@ -400,8 +480,8 @@ static inline int omap_nand_dma_transfer(struct mtd_info *mtd, void *addr,
OMAP24XX_DMA_GPMC, OMAP_DMA_SRC_SYNC);
}
/* configure and start prefetch transfer */
- ret = gpmc_prefetch_enable(info->gpmc_cs,
- PREFETCH_FIFOTHRESHOLD_MAX, 0x1, len, is_write);
+ ret = omap_prefetch_enable(info->gpmc_cs,
+ PREFETCH_FIFOTHRESHOLD_MAX, 0x1, len, is_write, info);
if (ret)
/* PFPW engine is busy, use cpu copy method */
goto out_copy;
@@ -414,11 +494,15 @@ static inline int omap_nand_dma_transfer(struct mtd_info *mtd, void *addr,
wait_for_completion(&info->comp);
tim = 0;
limit = (loops_per_jiffy * msecs_to_jiffies(OMAP_NAND_TIMEOUT_MS));
- while (gpmc_read_status(GPMC_PREFETCH_COUNT) && (tim++ < limit))
+
+ do {
cpu_relax();
+ val = readl(info->reg.gpmc_prefetch_status);
+ val = GPMC_PREFETCH_STATUS_COUNT(val);
+ } while (val && (tim++ < limit));
/* disable and stop the PFPW engine */
- gpmc_prefetch_reset(info->gpmc_cs);
+ omap_prefetch_reset(info->gpmc_cs, info);
dma_unmap_single(&info->pdev->dev, dma_addr, len, dir);
return 0;
@@ -474,7 +558,8 @@ static irqreturn_t omap_nand_irq(int this_irq, void *dev)
struct omap_nand_info *info = (struct omap_nand_info *) dev;
u32 bytes;
- bytes = gpmc_read_status(GPMC_PREFETCH_FIFO_CNT);
+ bytes = readl(info->reg.gpmc_prefetch_status);
+ bytes = GPMC_PREFETCH_STATUS_FIFO_CNT(bytes);
bytes = bytes & 0xFFFC; /* io in multiple of 4 bytes */
if (info->iomode == OMAP_NAND_IO_WRITE) { /* checks for write io */
if (this_irq == info->gpmc_irq_count)
@@ -531,8 +616,8 @@ static void omap_read_buf_irq_pref(struct mtd_info *mtd, u_char *buf, int len)
init_completion(&info->comp);
/* configure and start prefetch transfer */
- ret = gpmc_prefetch_enable(info->gpmc_cs,
- PREFETCH_FIFOTHRESHOLD_MAX/2, 0x0, len, 0x0);
+ ret = omap_prefetch_enable(info->gpmc_cs,
+ PREFETCH_FIFOTHRESHOLD_MAX/2, 0x0, len, 0x0, info);
if (ret)
/* PFPW engine is busy, use cpu copy method */
goto out_copy;
@@ -546,7 +631,7 @@ static void omap_read_buf_irq_pref(struct mtd_info *mtd, u_char *buf, int len)
wait_for_completion(&info->comp);
/* disable and stop the PFPW engine */
- gpmc_prefetch_reset(info->gpmc_cs);
+ omap_prefetch_reset(info->gpmc_cs, info);
return;
out_copy:
@@ -569,6 +654,7 @@ static void omap_write_buf_irq_pref(struct mtd_info *mtd,
struct omap_nand_info, mtd);
int ret = 0;
unsigned long tim, limit;
+ u32 val;
if (len <= mtd->oobsize) {
omap_write_buf_pref(mtd, buf, len);
@@ -580,8 +666,8 @@ static void omap_write_buf_irq_pref(struct mtd_info *mtd,
init_completion(&info->comp);
/* configure and start prefetch transfer : size=24 */
- ret = gpmc_prefetch_enable(info->gpmc_cs,
- (PREFETCH_FIFOTHRESHOLD_MAX * 3) / 8, 0x0, len, 0x1);
+ ret = omap_prefetch_enable(info->gpmc_cs,
+ (PREFETCH_FIFOTHRESHOLD_MAX * 3) / 8, 0x0, len, 0x1, info);
if (ret)
/* PFPW engine is busy, use cpu copy method */
goto out_copy;
@@ -597,11 +683,14 @@ static void omap_write_buf_irq_pref(struct mtd_info *mtd,
/* wait for data to flushed-out before reset the prefetch */
tim = 0;
limit = (loops_per_jiffy * msecs_to_jiffies(OMAP_NAND_TIMEOUT_MS));
- while (gpmc_read_status(GPMC_PREFETCH_COUNT) && (tim++ < limit))
+ do {
+ val = readl(info->reg.gpmc_prefetch_status);
+ val = GPMC_PREFETCH_STATUS_COUNT(val);
cpu_relax();
+ } while (val && (tim++ < limit));
/* disable and stop the PFPW engine */
- gpmc_prefetch_reset(info->gpmc_cs);
+ omap_prefetch_reset(info->gpmc_cs, info);
return;
out_copy:
@@ -841,7 +930,20 @@ static int omap_calculate_ecc(struct mtd_info *mtd, const u_char *dat,
{
struct omap_nand_info *info = container_of(mtd, struct omap_nand_info,
mtd);
- return gpmc_calculate_ecc(info->gpmc_cs, dat, ecc_code);
+ u32 val;
+
+ val = readl(info->reg.gpmc_ecc_config);
+ if (((val >> ECC_CONFIG_CS_SHIFT) & ~CS_MASK) != info->gpmc_cs)
+ return -EINVAL;
+
+ /* read ecc result */
+ val = readl(info->reg.gpmc_ecc1_result);
+ *ecc_code++ = val; /* P128e, ..., P1e */
+ *ecc_code++ = val >> 16; /* P128o, ..., P1o */
+ /* P2048o, P1024o, P512o, P256o, P2048e, P1024e, P512e, P256e */
+ *ecc_code++ = ((val >> 8) & 0x0f) | ((val >> 20) & 0xf0);
+
+ return 0;
}
/**
@@ -855,8 +957,36 @@ static void omap_enable_hwecc(struct mtd_info *mtd, int mode)
mtd);
struct nand_chip *chip = mtd->priv;
unsigned int dev_width = (chip->options & NAND_BUSWIDTH_16) ? 1 : 0;
+ u32 val;
+
+ /* clear ecc and enable bits */
+ val = ((0x1 << ECC_CLEAR_SHIFT) | ECC1);
+ writel(val, info->reg.gpmc_ecc_control);
+
+ /* program ecc and result sizes */
+ val = ((((info->nand.ecc.size >> 1) - 1) << ECCSIZE1_SHIFT) |
+ ECC1RESULTSIZE);
+ writel(val, info->reg.gpmc_ecc_size_config);
+
+ switch (mode) {
+ case NAND_ECC_READ:
+ writel(0x101, info->reg.gpmc_ecc_control);
+ break;
+ case NAND_ECC_READSYN:
+ writel(0x100, info->reg.gpmc_ecc_control);
+ break;
+ case NAND_ECC_WRITE:
+ writel(0x101, info->reg.gpmc_ecc_control);
+ break;
+ default:
+ dev_info(&info->pdev->dev,
+ "error: unrecognized Mode[%d]!\n", mode);
+ break;
+ }
- gpmc_enable_hwecc(info->gpmc_cs, mode, dev_width, info->nand.ecc.size);
+ /* (ECC 16 or 8 bit col) | ( CS ) | ECC Enable */
+ val = (dev_width << 7) | (info->gpmc_cs << 1) | (0x1);
+ writel(val, info->reg.gpmc_ecc_config);
}
/**
@@ -884,10 +1014,9 @@ static int omap_wait(struct mtd_info *mtd, struct nand_chip *chip)
else
timeo += (HZ * 20) / 1000;
- gpmc_nand_write(info->gpmc_cs,
- GPMC_NAND_COMMAND, (NAND_CMD_STATUS & 0xFF));
+ writeb(NAND_CMD_STATUS & 0xFF, info->reg.gpmc_nand_command);
while (time_before(jiffies, timeo)) {
- status = gpmc_nand_read(info->gpmc_cs, GPMC_NAND_DATA);
+ status = readb(info->reg.gpmc_nand_data);
if (status & NAND_STATUS_READY)
break;
cond_resched();
@@ -905,22 +1034,13 @@ static int omap_dev_ready(struct mtd_info *mtd)
struct omap_nand_info *info = container_of(mtd, struct omap_nand_info,
mtd);
- val = gpmc_read_status(GPMC_GET_IRQ_STATUS);
+ val = readl(info->reg.gpmc_status);
+
if ((val & 0x100) == 0x100) {
- /* Clear IRQ Interrupt */
- val |= 0x100;
- val &= ~(0x0);
- gpmc_cs_configure(info->gpmc_cs, GPMC_SET_IRQ_STATUS, val);
+ return 1;
} else {
- unsigned int cnt = 0;
- while (cnt++ < 0x1FF) {
- if ((val & 0x100) == 0x100)
- return 0;
- val = gpmc_read_status(GPMC_GET_IRQ_STATUS);
- }
+ return 0;
}
-
- return 1;
}
static int __devinit omap_nand_probe(struct platform_device *pdev)
@@ -949,6 +1069,7 @@ static int __devinit omap_nand_probe(struct platform_device *pdev)
info->pdev = pdev;
info->gpmc_cs = pdata->cs;
+ info->reg = pdata->reg;
info->mtd.priv = &info->nand;
info->mtd.name = dev_name(&pdev->dev);
--
1.7.9.3
^ permalink raw reply related [flat|nested] 73+ messages in thread
* [PATCH v3 8/9] mtd: nand: omap2: handle nand on gpmc
@ 2012-04-05 15:47 ` Afzal Mohammed
0 siblings, 0 replies; 73+ messages in thread
From: Afzal Mohammed @ 2012-04-05 15:47 UTC (permalink / raw)
To: linux-arm-kernel
GPMC driver has been modified to fill NAND platform data with GPMC
NAND register details. As these registers are accessible in NAND
driver itself, configure NAND in GPMC by itself.
Note: Verfying that other CS have not yet enabled for prefetch & ecc
has to be incorporated. Currently this causes no issues as there are
no boards that use NAND on multiple CS. With GPMC modifications,
perhaps it would be better to consider NAND connected on multiple CS
as a single peripheral using multiple CS. This would make handling
multiple CS issues easier.
Signed-off-by: Afzal Mohammed <afzal@ti.com>
---
drivers/mtd/nand/omap2.c | 209 ++++++++++++++++++++++++++++++++++++----------
1 file changed, 165 insertions(+), 44 deletions(-)
diff --git a/drivers/mtd/nand/omap2.c b/drivers/mtd/nand/omap2.c
index 440536b..34fb726 100644
--- a/drivers/mtd/nand/omap2.c
+++ b/drivers/mtd/nand/omap2.c
@@ -129,8 +129,79 @@ struct omap_nand_info {
} iomode;
u_char *buf;
int buf_len;
+ struct gpmc_nand_regs reg;
};
+#define PREFETCH_CONFIG1_CS_SHIFT 24
+#define ECC_CONFIG_CS_SHIFT 1
+#define CS_MASK 0x7
+#define ENABLE_PREFETCH (0x1 << 7)
+#define DMA_MPU_MODE_SHIFT 2
+#define ECCSIZE1_SHIFT 22
+#define ECC1RESULTSIZE 0x1
+#define ECC_CLEAR_SHIFT 8
+#define ECC1 0x1
+
+/**
+ * omap_prefetch_enable - configures and starts prefetch transfer
+ * @cs: cs (chip select) number
+ * @fifo_th: fifo threshold to be used for read/ write
+ * @dma_mode: dma mode enable (1) or disable (0)
+ * @u32_count: number of bytes to be transferred
+ * @is_write: prefetch read(0) or write post(1) mode
+ */
+static int omap_prefetch_enable(int cs, int fifo_th, int dma_mode,
+ unsigned int u32_count, int is_write, struct omap_nand_info *info)
+{
+ u32 val;
+
+ if (fifo_th > PREFETCH_FIFOTHRESHOLD_MAX) {
+ pr_err("gpmc: fifo threshold is not supported\n");
+ return -1;
+ } else if (!(readl(info->reg.gpmc_prefetch_control))) {
+ /* Set the amount of bytes to be prefetched */
+ writel(u32_count, info->reg.gpmc_prefetch_config2);
+
+ /* Set dma/mpu mode, the prefetch read / post write and
+ * enable the engine. Set which cs is has requested for.
+ */
+ val = ((cs << PREFETCH_CONFIG1_CS_SHIFT) |
+ PREFETCH_FIFOTHRESHOLD(fifo_th) |
+ ENABLE_PREFETCH |
+ (dma_mode << DMA_MPU_MODE_SHIFT) |
+ (0x1 & is_write));
+ writel(val, info->reg.gpmc_prefetch_config1);
+
+ /* Start the prefetch engine */
+ writel(0x1, info->reg.gpmc_prefetch_control);
+ } else {
+ return -EBUSY;
+ }
+
+ return 0;
+}
+
+/**
+ * omap_prefetch_reset - disables and stops the prefetch engine
+ */
+static int omap_prefetch_reset(int cs, struct omap_nand_info *info)
+{
+ u32 config1;
+
+ /* check if the same module/cs is trying to reset */
+ config1 = readl(info->reg.gpmc_prefetch_config1);
+ if (((config1 >> PREFETCH_CONFIG1_CS_SHIFT) & CS_MASK) != cs)
+ return -EINVAL;
+
+ /* Stop the PFPW engine */
+ writel(0x0, info->reg.gpmc_prefetch_control);
+
+ /* Reset/disable the PFPW engine */
+ writel(0x0, info->reg.gpmc_prefetch_config1);
+
+ return 0;
+}
+
/**
* omap_hwcontrol - hardware specific access to control-lines
* @mtd: MTD device structure
@@ -149,13 +220,13 @@ static void omap_hwcontrol(struct mtd_info *mtd, int cmd, unsigned int ctrl)
if (cmd != NAND_CMD_NONE) {
if (ctrl & NAND_CLE)
- gpmc_nand_write(info->gpmc_cs, GPMC_NAND_COMMAND, cmd);
+ writeb(cmd, info->reg.gpmc_nand_command);
else if (ctrl & NAND_ALE)
- gpmc_nand_write(info->gpmc_cs, GPMC_NAND_ADDRESS, cmd);
+ writeb(cmd, info->reg.gpmc_nand_address);
else /* NAND_NCE */
- gpmc_nand_write(info->gpmc_cs, GPMC_NAND_DATA, cmd);
+ writeb(cmd, info->reg.gpmc_nand_data);
}
}
@@ -189,7 +260,8 @@ static void omap_write_buf8(struct mtd_info *mtd, const u_char *buf, int len)
iowrite8(*p++, info->nand.IO_ADDR_W);
/* wait until buffer is available for write */
do {
- status = gpmc_read_status(GPMC_STATUS_BUFFER);
+ status = readl(info->reg.gpmc_status) &
+ GPMC_STATUS_BUFF_EMPTY;
} while (!status);
}
}
@@ -226,7 +298,8 @@ static void omap_write_buf16(struct mtd_info *mtd, const u_char * buf, int len)
iowrite16(*p++, info->nand.IO_ADDR_W);
/* wait until buffer is available for write */
do {
- status = gpmc_read_status(GPMC_STATUS_BUFFER);
+ status = readl(info->reg.gpmc_status) &
+ GPMC_STATUS_BUFF_EMPTY;
} while (!status);
}
}
@@ -256,8 +329,8 @@ static void omap_read_buf_pref(struct mtd_info *mtd, u_char *buf, int len)
}
/* configure and start prefetch transfer */
- ret = gpmc_prefetch_enable(info->gpmc_cs,
- PREFETCH_FIFOTHRESHOLD_MAX, 0x0, len, 0x0);
+ ret = omap_prefetch_enable(info->gpmc_cs,
+ PREFETCH_FIFOTHRESHOLD_MAX, 0x0, len, 0x0, info);
if (ret) {
/* PFPW engine is busy, use cpu copy method */
if (info->nand.options & NAND_BUSWIDTH_16)
@@ -266,14 +339,15 @@ static void omap_read_buf_pref(struct mtd_info *mtd, u_char *buf, int len)
omap_read_buf8(mtd, (u_char *)p, len);
} else {
do {
- r_count = gpmc_read_status(GPMC_PREFETCH_FIFO_CNT);
+ r_count = readl(info->reg.gpmc_prefetch_status);
+ r_count = GPMC_PREFETCH_STATUS_FIFO_CNT(r_count);
r_count = r_count >> 2;
ioread32_rep(info->nand.IO_ADDR_R, p, r_count);
p += r_count;
len -= r_count << 2;
} while (len);
/* disable and stop the PFPW engine */
- gpmc_prefetch_reset(info->gpmc_cs);
+ omap_prefetch_reset(info->gpmc_cs, info);
}
}
@@ -292,6 +366,7 @@ static void omap_write_buf_pref(struct mtd_info *mtd,
int i = 0, ret = 0;
u16 *p = (u16 *)buf;
unsigned long tim, limit;
+ u32 val;
/* take care of subpage writes */
if (len % 2 != 0) {
@@ -301,8 +376,8 @@ static void omap_write_buf_pref(struct mtd_info *mtd,
}
/* configure and start prefetch transfer */
- ret = gpmc_prefetch_enable(info->gpmc_cs,
- PREFETCH_FIFOTHRESHOLD_MAX, 0x0, len, 0x1);
+ ret = omap_prefetch_enable(info->gpmc_cs,
+ PREFETCH_FIFOTHRESHOLD_MAX, 0x0, len, 0x1, info);
if (ret) {
/* PFPW engine is busy, use cpu copy method */
if (info->nand.options & NAND_BUSWIDTH_16)
@@ -311,7 +386,8 @@ static void omap_write_buf_pref(struct mtd_info *mtd,
omap_write_buf8(mtd, (u_char *)p, len);
} else {
while (len) {
- w_count = gpmc_read_status(GPMC_PREFETCH_FIFO_CNT);
+ w_count = readl(info->reg.gpmc_prefetch_status);
+ w_count = GPMC_PREFETCH_STATUS_FIFO_CNT(w_count);
w_count = w_count >> 1;
for (i = 0; (i < w_count) && len; i++, len -= 2)
iowrite16(*p++, info->nand.IO_ADDR_W);
@@ -320,11 +396,14 @@ static void omap_write_buf_pref(struct mtd_info *mtd,
tim = 0;
limit = (loops_per_jiffy *
msecs_to_jiffies(OMAP_NAND_TIMEOUT_MS));
- while (gpmc_read_status(GPMC_PREFETCH_COUNT) && (tim++ < limit))
+ do {
cpu_relax();
+ val = readl(info->reg.gpmc_prefetch_status);
+ val = GPMC_PREFETCH_STATUS_COUNT(val);
+ } while (val && (tim++ < limit));
/* disable and stop the PFPW engine */
- gpmc_prefetch_reset(info->gpmc_cs);
+ omap_prefetch_reset(info->gpmc_cs, info);
}
}
@@ -356,6 +435,7 @@ static inline int omap_nand_dma_transfer(struct mtd_info *mtd, void *addr,
dma_addr_t dma_addr;
int ret;
unsigned long tim, limit;
+ u32 val;
/* The fifo depth is 64 bytes max.
* But configure the FIFO-threahold to 32 to get a sync at each frame
@@ -400,8 +480,8 @@ static inline int omap_nand_dma_transfer(struct mtd_info *mtd, void *addr,
OMAP24XX_DMA_GPMC, OMAP_DMA_SRC_SYNC);
}
/* configure and start prefetch transfer */
- ret = gpmc_prefetch_enable(info->gpmc_cs,
- PREFETCH_FIFOTHRESHOLD_MAX, 0x1, len, is_write);
+ ret = omap_prefetch_enable(info->gpmc_cs,
+ PREFETCH_FIFOTHRESHOLD_MAX, 0x1, len, is_write, info);
if (ret)
/* PFPW engine is busy, use cpu copy method */
goto out_copy;
@@ -414,11 +494,15 @@ static inline int omap_nand_dma_transfer(struct mtd_info *mtd, void *addr,
wait_for_completion(&info->comp);
tim = 0;
limit = (loops_per_jiffy * msecs_to_jiffies(OMAP_NAND_TIMEOUT_MS));
- while (gpmc_read_status(GPMC_PREFETCH_COUNT) && (tim++ < limit))
+
+ do {
cpu_relax();
+ val = readl(info->reg.gpmc_prefetch_status);
+ val = GPMC_PREFETCH_STATUS_COUNT(val);
+ } while (val && (tim++ < limit));
/* disable and stop the PFPW engine */
- gpmc_prefetch_reset(info->gpmc_cs);
+ omap_prefetch_reset(info->gpmc_cs, info);
dma_unmap_single(&info->pdev->dev, dma_addr, len, dir);
return 0;
@@ -474,7 +558,8 @@ static irqreturn_t omap_nand_irq(int this_irq, void *dev)
struct omap_nand_info *info = (struct omap_nand_info *) dev;
u32 bytes;
- bytes = gpmc_read_status(GPMC_PREFETCH_FIFO_CNT);
+ bytes = readl(info->reg.gpmc_prefetch_status);
+ bytes = GPMC_PREFETCH_STATUS_FIFO_CNT(bytes);
bytes = bytes & 0xFFFC; /* io in multiple of 4 bytes */
if (info->iomode == OMAP_NAND_IO_WRITE) { /* checks for write io */
if (this_irq == info->gpmc_irq_count)
@@ -531,8 +616,8 @@ static void omap_read_buf_irq_pref(struct mtd_info *mtd, u_char *buf, int len)
init_completion(&info->comp);
/* configure and start prefetch transfer */
- ret = gpmc_prefetch_enable(info->gpmc_cs,
- PREFETCH_FIFOTHRESHOLD_MAX/2, 0x0, len, 0x0);
+ ret = omap_prefetch_enable(info->gpmc_cs,
+ PREFETCH_FIFOTHRESHOLD_MAX/2, 0x0, len, 0x0, info);
if (ret)
/* PFPW engine is busy, use cpu copy method */
goto out_copy;
@@ -546,7 +631,7 @@ static void omap_read_buf_irq_pref(struct mtd_info *mtd, u_char *buf, int len)
wait_for_completion(&info->comp);
/* disable and stop the PFPW engine */
- gpmc_prefetch_reset(info->gpmc_cs);
+ omap_prefetch_reset(info->gpmc_cs, info);
return;
out_copy:
@@ -569,6 +654,7 @@ static void omap_write_buf_irq_pref(struct mtd_info *mtd,
struct omap_nand_info, mtd);
int ret = 0;
unsigned long tim, limit;
+ u32 val;
if (len <= mtd->oobsize) {
omap_write_buf_pref(mtd, buf, len);
@@ -580,8 +666,8 @@ static void omap_write_buf_irq_pref(struct mtd_info *mtd,
init_completion(&info->comp);
/* configure and start prefetch transfer : size=24 */
- ret = gpmc_prefetch_enable(info->gpmc_cs,
- (PREFETCH_FIFOTHRESHOLD_MAX * 3) / 8, 0x0, len, 0x1);
+ ret = omap_prefetch_enable(info->gpmc_cs,
+ (PREFETCH_FIFOTHRESHOLD_MAX * 3) / 8, 0x0, len, 0x1, info);
if (ret)
/* PFPW engine is busy, use cpu copy method */
goto out_copy;
@@ -597,11 +683,14 @@ static void omap_write_buf_irq_pref(struct mtd_info *mtd,
/* wait for data to flushed-out before reset the prefetch */
tim = 0;
limit = (loops_per_jiffy * msecs_to_jiffies(OMAP_NAND_TIMEOUT_MS));
- while (gpmc_read_status(GPMC_PREFETCH_COUNT) && (tim++ < limit))
+ do {
+ val = readl(info->reg.gpmc_prefetch_status);
+ val = GPMC_PREFETCH_STATUS_COUNT(val);
cpu_relax();
+ } while (val && (tim++ < limit));
/* disable and stop the PFPW engine */
- gpmc_prefetch_reset(info->gpmc_cs);
+ omap_prefetch_reset(info->gpmc_cs, info);
return;
out_copy:
@@ -841,7 +930,20 @@ static int omap_calculate_ecc(struct mtd_info *mtd, const u_char *dat,
{
struct omap_nand_info *info = container_of(mtd, struct omap_nand_info,
mtd);
- return gpmc_calculate_ecc(info->gpmc_cs, dat, ecc_code);
+ u32 val;
+
+ val = readl(info->reg.gpmc_ecc_config);
+ if (((val >> ECC_CONFIG_CS_SHIFT) & ~CS_MASK) != info->gpmc_cs)
+ return -EINVAL;
+
+ /* read ecc result */
+ val = readl(info->reg.gpmc_ecc1_result);
+ *ecc_code++ = val; /* P128e, ..., P1e */
+ *ecc_code++ = val >> 16; /* P128o, ..., P1o */
+ /* P2048o, P1024o, P512o, P256o, P2048e, P1024e, P512e, P256e */
+ *ecc_code++ = ((val >> 8) & 0x0f) | ((val >> 20) & 0xf0);
+
+ return 0;
}
/**
@@ -855,8 +957,36 @@ static void omap_enable_hwecc(struct mtd_info *mtd, int mode)
mtd);
struct nand_chip *chip = mtd->priv;
unsigned int dev_width = (chip->options & NAND_BUSWIDTH_16) ? 1 : 0;
+ u32 val;
+
+ /* clear ecc and enable bits */
+ val = ((0x1 << ECC_CLEAR_SHIFT) | ECC1);
+ writel(val, info->reg.gpmc_ecc_control);
+
+ /* program ecc and result sizes */
+ val = ((((info->nand.ecc.size >> 1) - 1) << ECCSIZE1_SHIFT) |
+ ECC1RESULTSIZE);
+ writel(val, info->reg.gpmc_ecc_size_config);
+
+ switch (mode) {
+ case NAND_ECC_READ:
+ writel(0x101, info->reg.gpmc_ecc_control);
+ break;
+ case NAND_ECC_READSYN:
+ writel(0x100, info->reg.gpmc_ecc_control);
+ break;
+ case NAND_ECC_WRITE:
+ writel(0x101, info->reg.gpmc_ecc_control);
+ break;
+ default:
+ dev_info(&info->pdev->dev,
+ "error: unrecognized Mode[%d]!\n", mode);
+ break;
+ }
- gpmc_enable_hwecc(info->gpmc_cs, mode, dev_width, info->nand.ecc.size);
+ /* (ECC 16 or 8 bit col) | ( CS ) | ECC Enable */
+ val = (dev_width << 7) | (info->gpmc_cs << 1) | (0x1);
+ writel(val, info->reg.gpmc_ecc_config);
}
/**
@@ -884,10 +1014,9 @@ static int omap_wait(struct mtd_info *mtd, struct nand_chip *chip)
else
timeo += (HZ * 20) / 1000;
- gpmc_nand_write(info->gpmc_cs,
- GPMC_NAND_COMMAND, (NAND_CMD_STATUS & 0xFF));
+ writeb(NAND_CMD_STATUS & 0xFF, info->reg.gpmc_nand_command);
while (time_before(jiffies, timeo)) {
- status = gpmc_nand_read(info->gpmc_cs, GPMC_NAND_DATA);
+ status = readb(info->reg.gpmc_nand_data);
if (status & NAND_STATUS_READY)
break;
cond_resched();
@@ -905,22 +1034,13 @@ static int omap_dev_ready(struct mtd_info *mtd)
struct omap_nand_info *info = container_of(mtd, struct omap_nand_info,
mtd);
- val = gpmc_read_status(GPMC_GET_IRQ_STATUS);
+ val = readl(info->reg.gpmc_status);
+
if ((val & 0x100) == 0x100) {
- /* Clear IRQ Interrupt */
- val |= 0x100;
- val &= ~(0x0);
- gpmc_cs_configure(info->gpmc_cs, GPMC_SET_IRQ_STATUS, val);
+ return 1;
} else {
- unsigned int cnt = 0;
- while (cnt++ < 0x1FF) {
- if ((val & 0x100) == 0x100)
- return 0;
- val = gpmc_read_status(GPMC_GET_IRQ_STATUS);
- }
+ return 0;
}
-
- return 1;
}
static int __devinit omap_nand_probe(struct platform_device *pdev)
@@ -949,6 +1069,7 @@ static int __devinit omap_nand_probe(struct platform_device *pdev)
info->pdev = pdev;
info->gpmc_cs = pdata->cs;
+ info->reg = pdata->reg;
info->mtd.priv = &info->nand;
info->mtd.name = dev_name(&pdev->dev);
--
1.7.9.3
^ permalink raw reply related [flat|nested] 73+ messages in thread
* [TMP] OMAP3EVM: Test gpmc nand & smsc911x
[not found] <cover.1333640054.git.afzal@ti.com>
2012-04-05 15:45 ` Afzal Mohammed
@ 2012-04-05 15:47 ` Afzal Mohammed
2012-04-05 15:46 ` Afzal Mohammed
` (6 subsequent siblings)
8 siblings, 0 replies; 73+ messages in thread
From: Afzal Mohammed @ 2012-04-05 15:47 UTC (permalink / raw)
To: tony, khilman, linux, dwmw2, sameo, grinberg, mike, nm,
artem.bityutskiy, vimal.newwork, dbaryshkov, linux-omap,
linux-arm-kernel, linux-mtd, linux-kernel
Cc: Afzal Mohammed
Signed-off-by: Afzal Mohammed <afzal@ti.com>
---
arch/arm/mach-omap2/board-omap3evm.c | 95 +++++++++++++++++++++++++++++++++-
1 file changed, 94 insertions(+), 1 deletion(-)
diff --git a/arch/arm/mach-omap2/board-omap3evm.c b/arch/arm/mach-omap2/board-omap3evm.c
index 49df127..60938af 100644
--- a/arch/arm/mach-omap2/board-omap3evm.c
+++ b/arch/arm/mach-omap2/board-omap3evm.c
@@ -23,6 +23,7 @@
#include <linux/input/matrix_keypad.h>
#include <linux/leds.h>
#include <linux/interrupt.h>
+#include <linux/mtd/nand.h>
#include <linux/spi/spi.h>
#include <linux/spi/ads7846.h>
@@ -41,6 +42,7 @@
#include <asm/mach/arch.h>
#include <asm/mach/map.h>
+#include <plat/nand.h>
#include <plat/board.h>
#include <plat/usb.h>
#include "common.h"
@@ -52,6 +54,7 @@
#include "sdram-micron-mt46h32m32lf-6.h"
#include "hsmmc.h"
#include "common-board-devices.h"
+#include "board-flash.h"
#define OMAP3_EVM_TS_GPIO 175
#define OMAP3_EVM_EHCI_VBUS 22
@@ -102,6 +105,36 @@ static void __init omap3_evm_get_revision(void)
}
}
+static struct gpmc_device_pdata *gpmc_data_array[3];
+static struct gpmc_device_pdata **gpmc_data_cur = gpmc_data_array;
+
+static struct gpmc_pdata gpmc_data = {
+ .device_pdata = gpmc_data_array,
+};
+
+static struct resource gpmc_resources[] = {
+ {
+ .start = OMAP34XX_GPMC_BASE,
+ .end = OMAP34XX_GPMC_BASE + SZ_4K - 1,
+ .flags = IORESOURCE_MEM,
+ },
+ {
+ .start = INT_34XX_GPMC_IRQ,
+ .end = INT_34XX_GPMC_IRQ,
+ .flags = IORESOURCE_IRQ,
+ },
+};
+
+static struct platform_device gpmc_device = {
+ .name = "omap-gpmc",
+ .id = -1,
+ .num_resources = ARRAY_SIZE(gpmc_resources),
+ .resource = gpmc_resources,
+ .dev = {
+ .platform_data = &gpmc_data,
+ }
+};
+
#if defined(CONFIG_SMSC911X) || defined(CONFIG_SMSC911X_MODULE)
#include <plat/gpmc-smsc911x.h>
@@ -114,6 +147,8 @@ static struct omap_smsc911x_platform_data smsc911x_cfg = {
static inline void __init omap3evm_init_smsc911x(void)
{
+ struct gpmc_device_pdata *gpmc_smsc911x_info;
+
/* Configure ethernet controller reset gpio */
if (cpu_is_omap3430()) {
if (get_omap3_evm_rev() == OMAP3EVM_BOARD_GEN_1)
@@ -122,7 +157,11 @@ static inline void __init omap3evm_init_smsc911x(void)
smsc911x_cfg.gpio_reset = OMAP3EVM_GEN2_ETHR_GPIO_RST;
}
- gpmc_smsc911x_init(&smsc911x_cfg);
+ gpmc_smsc911x_info = gpmc_smsc911x_init(&smsc911x_cfg);
+ if (gpmc_smsc911x_info)
+ *gpmc_data_cur++ = gpmc_smsc911x_info;
+ else
+ pr_err("error: unable to initilaize gpmc smsc911x\n");
}
#else
@@ -523,6 +562,41 @@ static struct usbhs_omap_board_data usbhs_bdata __initdata = {
.reset_gpio_port[2] = -EINVAL
};
+/*
+ * NAND
+ */
+static struct mtd_partition omap3_evm_nand_partitions[] = {
+ /* All the partition sizes are listed in terms of NAND block size */
+ {
+ .name = "X-Loader-NAND",
+ .offset = 0,
+ .size = 4 * (64 * 2048),
+ .mask_flags = MTD_WRITEABLE, /* force read-only */
+ },
+ {
+ .name = "U-Boot-NAND",
+ .offset = MTDPART_OFS_APPEND, /* Offset = 0x80000 */
+ .size = 10 * (64 * 2048),
+ .mask_flags = MTD_WRITEABLE, /* force read-only */
+ },
+ {
+ .name = "Boot Env-NAND",
+
+ .offset = MTDPART_OFS_APPEND, /* Offset = 0x1c0000 */
+ .size = 6 * (64 * 2048),
+ },
+ {
+ .name = "Kernel-NAND",
+ .offset = MTDPART_OFS_APPEND, /* Offset = 0x280000 */
+ .size = 40 * (64 * 2048),
+ },
+ {
+ .name = "File System - NAND",
+ .size = MTDPART_SIZ_FULL,
+ .offset = MTDPART_OFS_APPEND, /* Offset = 0x780000 */
+ },
+};
+
#ifdef CONFIG_OMAP_MUX
static struct omap_board_mux omap35x_board_mux[] __initdata = {
OMAP3_MUX(SYS_NIRQ, OMAP_MUX_MODE0 | OMAP_PIN_INPUT_PULLUP |
@@ -630,6 +704,8 @@ static struct regulator_consumer_supply dummy_supplies[] = {
static void __init omap3_evm_init(void)
{
+ struct omap_nand_platform_data *nand_data;
+
omap3_evm_get_revision();
regulator_register_fixed(0, dummy_supplies, ARRAY_SIZE(dummy_supplies));
@@ -681,6 +757,23 @@ static void __init omap3_evm_init(void)
omap3evm_init_smsc911x();
omap3_evm_display_init();
omap3_evm_wl12xx_init();
+ /* NAND */
+ nand_data = omap_nand_init(omap3_evm_nand_partitions,
+ ARRAY_SIZE(omap3_evm_nand_partitions),
+ 0, NAND_BUSWIDTH_16, nand_default_timings);
+/* nand_data->xfer_type = NAND_OMAP_PREFETCH_IRQ;
+ */ if (nand_data != NULL) {
+ *gpmc_data_cur = gpmc_nand_init(nand_data);
+ (*gpmc_data_cur++)->is_nand = true;
+ } else
+ pr_err("omap_nand_init() failed\n");
+
+
+ gpmc_data.fclk_period = gpmc_get_fclk_period();
+ gpmc_data.irq_start = OMAP_GPMC_IRQ_BASE;
+ gpmc_data.num_irq = OMAP_GPMC_NR_IRQS;
+
+ platform_device_register(&gpmc_device);
}
MACHINE_START(OMAP3EVM, "OMAP3 EVM")
--
1.7.9.3
^ permalink raw reply related [flat|nested] 73+ messages in thread
* [TMP] OMAP3EVM: Test gpmc nand & smsc911x
@ 2012-04-05 15:47 ` Afzal Mohammed
0 siblings, 0 replies; 73+ messages in thread
From: Afzal Mohammed @ 2012-04-05 15:47 UTC (permalink / raw)
To: tony, khilman, linux, dwmw2, sameo, grinberg, mike, nm,
artem.bityutskiy, vimal.newwork, dbaryshkov, linux-omap,
linux-arm-kernel, linux-mtd, linux-kernel
Cc: Afzal Mohammed
Signed-off-by: Afzal Mohammed <afzal@ti.com>
---
arch/arm/mach-omap2/board-omap3evm.c | 95 +++++++++++++++++++++++++++++++++-
1 file changed, 94 insertions(+), 1 deletion(-)
diff --git a/arch/arm/mach-omap2/board-omap3evm.c b/arch/arm/mach-omap2/board-omap3evm.c
index 49df127..60938af 100644
--- a/arch/arm/mach-omap2/board-omap3evm.c
+++ b/arch/arm/mach-omap2/board-omap3evm.c
@@ -23,6 +23,7 @@
#include <linux/input/matrix_keypad.h>
#include <linux/leds.h>
#include <linux/interrupt.h>
+#include <linux/mtd/nand.h>
#include <linux/spi/spi.h>
#include <linux/spi/ads7846.h>
@@ -41,6 +42,7 @@
#include <asm/mach/arch.h>
#include <asm/mach/map.h>
+#include <plat/nand.h>
#include <plat/board.h>
#include <plat/usb.h>
#include "common.h"
@@ -52,6 +54,7 @@
#include "sdram-micron-mt46h32m32lf-6.h"
#include "hsmmc.h"
#include "common-board-devices.h"
+#include "board-flash.h"
#define OMAP3_EVM_TS_GPIO 175
#define OMAP3_EVM_EHCI_VBUS 22
@@ -102,6 +105,36 @@ static void __init omap3_evm_get_revision(void)
}
}
+static struct gpmc_device_pdata *gpmc_data_array[3];
+static struct gpmc_device_pdata **gpmc_data_cur = gpmc_data_array;
+
+static struct gpmc_pdata gpmc_data = {
+ .device_pdata = gpmc_data_array,
+};
+
+static struct resource gpmc_resources[] = {
+ {
+ .start = OMAP34XX_GPMC_BASE,
+ .end = OMAP34XX_GPMC_BASE + SZ_4K - 1,
+ .flags = IORESOURCE_MEM,
+ },
+ {
+ .start = INT_34XX_GPMC_IRQ,
+ .end = INT_34XX_GPMC_IRQ,
+ .flags = IORESOURCE_IRQ,
+ },
+};
+
+static struct platform_device gpmc_device = {
+ .name = "omap-gpmc",
+ .id = -1,
+ .num_resources = ARRAY_SIZE(gpmc_resources),
+ .resource = gpmc_resources,
+ .dev = {
+ .platform_data = &gpmc_data,
+ }
+};
+
#if defined(CONFIG_SMSC911X) || defined(CONFIG_SMSC911X_MODULE)
#include <plat/gpmc-smsc911x.h>
@@ -114,6 +147,8 @@ static struct omap_smsc911x_platform_data smsc911x_cfg = {
static inline void __init omap3evm_init_smsc911x(void)
{
+ struct gpmc_device_pdata *gpmc_smsc911x_info;
+
/* Configure ethernet controller reset gpio */
if (cpu_is_omap3430()) {
if (get_omap3_evm_rev() == OMAP3EVM_BOARD_GEN_1)
@@ -122,7 +157,11 @@ static inline void __init omap3evm_init_smsc911x(void)
smsc911x_cfg.gpio_reset = OMAP3EVM_GEN2_ETHR_GPIO_RST;
}
- gpmc_smsc911x_init(&smsc911x_cfg);
+ gpmc_smsc911x_info = gpmc_smsc911x_init(&smsc911x_cfg);
+ if (gpmc_smsc911x_info)
+ *gpmc_data_cur++ = gpmc_smsc911x_info;
+ else
+ pr_err("error: unable to initilaize gpmc smsc911x\n");
}
#else
@@ -523,6 +562,41 @@ static struct usbhs_omap_board_data usbhs_bdata __initdata = {
.reset_gpio_port[2] = -EINVAL
};
+/*
+ * NAND
+ */
+static struct mtd_partition omap3_evm_nand_partitions[] = {
+ /* All the partition sizes are listed in terms of NAND block size */
+ {
+ .name = "X-Loader-NAND",
+ .offset = 0,
+ .size = 4 * (64 * 2048),
+ .mask_flags = MTD_WRITEABLE, /* force read-only */
+ },
+ {
+ .name = "U-Boot-NAND",
+ .offset = MTDPART_OFS_APPEND, /* Offset = 0x80000 */
+ .size = 10 * (64 * 2048),
+ .mask_flags = MTD_WRITEABLE, /* force read-only */
+ },
+ {
+ .name = "Boot Env-NAND",
+
+ .offset = MTDPART_OFS_APPEND, /* Offset = 0x1c0000 */
+ .size = 6 * (64 * 2048),
+ },
+ {
+ .name = "Kernel-NAND",
+ .offset = MTDPART_OFS_APPEND, /* Offset = 0x280000 */
+ .size = 40 * (64 * 2048),
+ },
+ {
+ .name = "File System - NAND",
+ .size = MTDPART_SIZ_FULL,
+ .offset = MTDPART_OFS_APPEND, /* Offset = 0x780000 */
+ },
+};
+
#ifdef CONFIG_OMAP_MUX
static struct omap_board_mux omap35x_board_mux[] __initdata = {
OMAP3_MUX(SYS_NIRQ, OMAP_MUX_MODE0 | OMAP_PIN_INPUT_PULLUP |
@@ -630,6 +704,8 @@ static struct regulator_consumer_supply dummy_supplies[] = {
static void __init omap3_evm_init(void)
{
+ struct omap_nand_platform_data *nand_data;
+
omap3_evm_get_revision();
regulator_register_fixed(0, dummy_supplies, ARRAY_SIZE(dummy_supplies));
@@ -681,6 +757,23 @@ static void __init omap3_evm_init(void)
omap3evm_init_smsc911x();
omap3_evm_display_init();
omap3_evm_wl12xx_init();
+ /* NAND */
+ nand_data = omap_nand_init(omap3_evm_nand_partitions,
+ ARRAY_SIZE(omap3_evm_nand_partitions),
+ 0, NAND_BUSWIDTH_16, nand_default_timings);
+/* nand_data->xfer_type = NAND_OMAP_PREFETCH_IRQ;
+ */ if (nand_data != NULL) {
+ *gpmc_data_cur = gpmc_nand_init(nand_data);
+ (*gpmc_data_cur++)->is_nand = true;
+ } else
+ pr_err("omap_nand_init() failed\n");
+
+
+ gpmc_data.fclk_period = gpmc_get_fclk_period();
+ gpmc_data.irq_start = OMAP_GPMC_IRQ_BASE;
+ gpmc_data.num_irq = OMAP_GPMC_NR_IRQS;
+
+ platform_device_register(&gpmc_device);
}
MACHINE_START(OMAP3EVM, "OMAP3 EVM")
--
1.7.9.3
^ permalink raw reply related [flat|nested] 73+ messages in thread
* [TMP] OMAP3EVM: Test gpmc nand & smsc911x
@ 2012-04-05 15:47 ` Afzal Mohammed
0 siblings, 0 replies; 73+ messages in thread
From: Afzal Mohammed @ 2012-04-05 16:05 UTC (permalink / raw)
To: tony, khilman, linux, dwmw2, sameo, grinberg, mike, nm,
artem.bityutskiy, vimal.newwork, dbaryshkov, linux-omap,
linux-arm-kernel, linux-mtd, linux-kernel
Cc: Afzal Mohammed
Signed-off-by: Afzal Mohammed <afzal@ti.com>
---
arch/arm/mach-omap2/board-omap3evm.c | 95 +++++++++++++++++++++++++++++++++-
1 file changed, 94 insertions(+), 1 deletion(-)
diff --git a/arch/arm/mach-omap2/board-omap3evm.c b/arch/arm/mach-omap2/board-omap3evm.c
index 49df127..60938af 100644
--- a/arch/arm/mach-omap2/board-omap3evm.c
+++ b/arch/arm/mach-omap2/board-omap3evm.c
@@ -23,6 +23,7 @@
#include <linux/input/matrix_keypad.h>
#include <linux/leds.h>
#include <linux/interrupt.h>
+#include <linux/mtd/nand.h>
#include <linux/spi/spi.h>
#include <linux/spi/ads7846.h>
@@ -41,6 +42,7 @@
#include <asm/mach/arch.h>
#include <asm/mach/map.h>
+#include <plat/nand.h>
#include <plat/board.h>
#include <plat/usb.h>
#include "common.h"
@@ -52,6 +54,7 @@
#include "sdram-micron-mt46h32m32lf-6.h"
#include "hsmmc.h"
#include "common-board-devices.h"
+#include "board-flash.h"
#define OMAP3_EVM_TS_GPIO 175
#define OMAP3_EVM_EHCI_VBUS 22
@@ -102,6 +105,36 @@ static void __init omap3_evm_get_revision(void)
}
}
+static struct gpmc_device_pdata *gpmc_data_array[3];
+static struct gpmc_device_pdata **gpmc_data_cur = gpmc_data_array;
+
+static struct gpmc_pdata gpmc_data = {
+ .device_pdata = gpmc_data_array,
+};
+
+static struct resource gpmc_resources[] = {
+ {
+ .start = OMAP34XX_GPMC_BASE,
+ .end = OMAP34XX_GPMC_BASE + SZ_4K - 1,
+ .flags = IORESOURCE_MEM,
+ },
+ {
+ .start = INT_34XX_GPMC_IRQ,
+ .end = INT_34XX_GPMC_IRQ,
+ .flags = IORESOURCE_IRQ,
+ },
+};
+
+static struct platform_device gpmc_device = {
+ .name = "omap-gpmc",
+ .id = -1,
+ .num_resources = ARRAY_SIZE(gpmc_resources),
+ .resource = gpmc_resources,
+ .dev = {
+ .platform_data = &gpmc_data,
+ }
+};
+
#if defined(CONFIG_SMSC911X) || defined(CONFIG_SMSC911X_MODULE)
#include <plat/gpmc-smsc911x.h>
@@ -114,6 +147,8 @@ static struct omap_smsc911x_platform_data smsc911x_cfg = {
static inline void __init omap3evm_init_smsc911x(void)
{
+ struct gpmc_device_pdata *gpmc_smsc911x_info;
+
/* Configure ethernet controller reset gpio */
if (cpu_is_omap3430()) {
if (get_omap3_evm_rev() == OMAP3EVM_BOARD_GEN_1)
@@ -122,7 +157,11 @@ static inline void __init omap3evm_init_smsc911x(void)
smsc911x_cfg.gpio_reset = OMAP3EVM_GEN2_ETHR_GPIO_RST;
}
- gpmc_smsc911x_init(&smsc911x_cfg);
+ gpmc_smsc911x_info = gpmc_smsc911x_init(&smsc911x_cfg);
+ if (gpmc_smsc911x_info)
+ *gpmc_data_cur++ = gpmc_smsc911x_info;
+ else
+ pr_err("error: unable to initilaize gpmc smsc911x\n");
}
#else
@@ -523,6 +562,41 @@ static struct usbhs_omap_board_data usbhs_bdata __initdata = {
.reset_gpio_port[2] = -EINVAL
};
+/*
+ * NAND
+ */
+static struct mtd_partition omap3_evm_nand_partitions[] = {
+ /* All the partition sizes are listed in terms of NAND block size */
+ {
+ .name = "X-Loader-NAND",
+ .offset = 0,
+ .size = 4 * (64 * 2048),
+ .mask_flags = MTD_WRITEABLE, /* force read-only */
+ },
+ {
+ .name = "U-Boot-NAND",
+ .offset = MTDPART_OFS_APPEND, /* Offset = 0x80000 */
+ .size = 10 * (64 * 2048),
+ .mask_flags = MTD_WRITEABLE, /* force read-only */
+ },
+ {
+ .name = "Boot Env-NAND",
+
+ .offset = MTDPART_OFS_APPEND, /* Offset = 0x1c0000 */
+ .size = 6 * (64 * 2048),
+ },
+ {
+ .name = "Kernel-NAND",
+ .offset = MTDPART_OFS_APPEND, /* Offset = 0x280000 */
+ .size = 40 * (64 * 2048),
+ },
+ {
+ .name = "File System - NAND",
+ .size = MTDPART_SIZ_FULL,
+ .offset = MTDPART_OFS_APPEND, /* Offset = 0x780000 */
+ },
+};
+
#ifdef CONFIG_OMAP_MUX
static struct omap_board_mux omap35x_board_mux[] __initdata = {
OMAP3_MUX(SYS_NIRQ, OMAP_MUX_MODE0 | OMAP_PIN_INPUT_PULLUP |
@@ -630,6 +704,8 @@ static struct regulator_consumer_supply dummy_supplies[] = {
static void __init omap3_evm_init(void)
{
+ struct omap_nand_platform_data *nand_data;
+
omap3_evm_get_revision();
regulator_register_fixed(0, dummy_supplies, ARRAY_SIZE(dummy_supplies));
@@ -681,6 +757,23 @@ static void __init omap3_evm_init(void)
omap3evm_init_smsc911x();
omap3_evm_display_init();
omap3_evm_wl12xx_init();
+ /* NAND */
+ nand_data = omap_nand_init(omap3_evm_nand_partitions,
+ ARRAY_SIZE(omap3_evm_nand_partitions),
+ 0, NAND_BUSWIDTH_16, nand_default_timings);
+/* nand_data->xfer_type = NAND_OMAP_PREFETCH_IRQ;
+ */ if (nand_data != NULL) {
+ *gpmc_data_cur = gpmc_nand_init(nand_data);
+ (*gpmc_data_cur++)->is_nand = true;
+ } else
+ pr_err("omap_nand_init() failed\n");
+
+
+ gpmc_data.fclk_period = gpmc_get_fclk_period();
+ gpmc_data.irq_start = OMAP_GPMC_IRQ_BASE;
+ gpmc_data.num_irq = OMAP_GPMC_NR_IRQS;
+
+ platform_device_register(&gpmc_device);
}
MACHINE_START(OMAP3EVM, "OMAP3 EVM")
--
1.7.9.3
^ permalink raw reply related [flat|nested] 73+ messages in thread
* Re: [PATCH v3 1/9] ARM: OMAP2+: gpmc: driver conversion
2012-04-05 15:45 ` Afzal Mohammed
(?)
(?)
@ 2012-04-05 20:21 ` Jon Hunter
-1 siblings, 0 replies; 73+ messages in thread
From: Jon Hunter @ 2012-04-05 20:21 UTC (permalink / raw)
To: Afzal Mohammed
Cc: tony, Kevin Hilman, linux, dwmw2, sameo, grinberg, mike, nm,
artem.bityutskiy, vimal.newwork, dbaryshkov, linux-omap,
linux-arm-kernel, linux-mtd, linux-kernel, Vaibhav Hiremath
Hi Afzal,
On 04/05/2012 10:45 AM, Afzal Mohammed wrote:
[...]
> +struct gpmc_irq {
> + unsigned irq;
> + u32 regval;
Are you using regval to indicate the bit-mask? If so, maybe call it
"bitmask" instead.
[...]
> +static __devinit
> +int gpmc_setup_cs_irq(struct gpmc *gpmc, struct gpmc_device_pdata *gdp,
> + struct gpmc_cs_data *cs, struct resource *res)
> +{
> + int i, n, val;
> +
> + for (i = 0, n = 0; i< gpmc->num_irq; i++)
> + if (gpmc->irq[i].regval& cs->irq_flags) {
> + res[n].start = res[n].end = gpmc->irq[i].irq;
> + res[n].flags = IORESOURCE_IRQ;
> +
> + dev_info(gpmc->dev, "resource irq %u for %s "
> + "(on CS %d) [bit: %x]\n", res[n].start,
> + gdp->name, cs->cs, __ffs(gpmc->irq[i].regval));
> +
> + switch (gpmc->irq[i].regval) {
> + case GPMC_IRQ_WAIT0EDGEDETECTION:
> + case GPMC_IRQ_WAIT1EDGEDETECTION:
> + case GPMC_IRQ_WAIT2EDGEDETECTION:
> + case GPMC_IRQ_WAIT3EDGEDETECTION:
> + val = __ffs(gpmc->irq[i].regval);
> + val -= __ffs(GPMC_IRQ_WAIT0EDGEDETECTION);
> + gpmc_cs_configure(cs->cs,
> + GPMC_CONFIG_WAITPIN, val);
Why is the configuration of the wait pin done here? It is possible to
use the wait pin may be used without enabling the interrupt.
Where do you handle allocating the wait pins to ensure two devices don't
attempt to use the same one? Like how the CS are managed.
Also, where you you configure the polarity of the wait pins? I would
have thought it would make sense to have the wait pin configured as part
of the cs configuration.
> + }
> + n++;
> + }
> +
> + return n;
> +}
> +
> +static __devinit int gpmc_setup_device(struct gpmc_device_pdata *gdp,
> + struct gpmc_device *dev, struct gpmc *gpmc)
> +{
> + int i, j, n;
> + struct gpmc_cs_data *cs;
> +
> + for (i = 0, n = 0, cs = gdp->cs_data; i< gdp->num_cs; i++, cs++)
> + n += hweight32(cs->irq_flags& GPMC_IRQ_MASK);
> +
> + n += gdp->num_cs;
> +
> + dev->gpmc_res = devm_kzalloc(gpmc->dev, sizeof(*dev->gpmc_res) * n,
> + GFP_KERNEL);
> + if (dev->gpmc_res == NULL) {
> + dev_err(gpmc->dev, "error: memory allocation\n");
> + return -ENOMEM;
> + }
> +
> + for (i = 0, j = 0, cs = gdp->cs_data; i< gdp->num_cs; cs++, i++) {
> + dev->gpmc_res[j] = gpmc_setup_cs_mem(cs, gdp, gpmc);
> + if (dev->gpmc_res[j++].flags& IORESOURCE_MEM)
> + j += gpmc_setup_cs_irq(gpmc, gdp, cs,
> + dev->gpmc_res + j);
> + else {
> + dev_err(gpmc->dev, "error: setup for %s\n", gdp->name);
> + devm_kfree(gpmc->dev, dev->gpmc_res);
> + dev->gpmc_res = NULL;
> + dev->num_gpmc_res = 0;
> + return -EINVAL;
> + }
> }
This section of code is not straight-forward to read. I see what you are
doing, but I am wondering if this could be improved.
First of all, returning a structure from a function is making this code
harder to read. Per the CodingStyle document in the kernel, it is
preferred for a function to return success or failure if the function is
an action, like a setup.
Secondly, do you need to pass cs, gdp and gpmc to gpmc_setup_cs_mem()?
It appears that gdp and gpmc are only used for prints. You could
probably avoid passing gdp and move the print to outside this function.
> + dev->num_gpmc_res = j;
>
> - ret = request_irq(gpmc_irq,
> - gpmc_handle_irq, IRQF_SHARED, "gpmc", gpmc_base);
> - if (ret)
> - pr_err("gpmc: irq-%d could not claim: err %d\n",
> - gpmc_irq, ret);
> - return ret;
> + dev->name = gdp->name;
> + dev->id = gdp->id;
> + dev->pdata = gdp->pdata;
> + dev->pdata_size = gdp->pdata_size;
> + dev->per_res = gdp->per_res;
> + dev->num_per_res = gdp->num_per_res;
> +
> + return 0;
> +}
> +
> +static __devinit
> +struct platform_device *gpmc_create_device(struct gpmc_device *p,
> + struct gpmc *gpmc)
> +{
> + int num = p->num_per_res + p->num_gpmc_res;
> + struct resource *res;
> + struct platform_device *pdev;
> +
> + res = devm_kzalloc(gpmc->dev, sizeof(struct resource) * num,
> + GFP_KERNEL);
> + if (!res) {
> + dev_err(gpmc->dev, "error: allocating memory\n");
> + return NULL;
> + }
> +
> + memcpy((char *)res, (const char *) p->gpmc_res,
> + sizeof(struct resource) * p->num_gpmc_res);
> + memcpy((char *)(res + p->num_gpmc_res), (const char *)p->per_res,
> + sizeof(struct resource) * p->num_per_res);
> +
> + pdev = platform_device_register_resndata(gpmc->dev, p->name, p->id,
> + res, num, p->pdata, p->pdata_size);
> +
> + devm_kfree(gpmc->dev, res);
> +
> + return pdev;
> }
> -postcore_initcall(gpmc_init);
>
> static irqreturn_t gpmc_handle_irq(int irq, void *dev)
> {
> - u8 cs;
> + int i;
> + u32 regval;
> + struct gpmc *gpmc = dev;
>
> - /* check cs to invoke the irq */
> - cs = ((gpmc_read_reg(GPMC_PREFETCH_CONFIG1))>> CS_NUM_SHIFT)& 0x7;
> - if (OMAP_GPMC_IRQ_BASE+cs<= OMAP_GPMC_IRQ_END)
> - generic_handle_irq(OMAP_GPMC_IRQ_BASE+cs);
> + regval = gpmc_read_reg(GPMC_IRQSTATUS);
> +
> +
> + for (i = 0; i< gpmc->num_irq; i++)
> + if (regval& gpmc->irq[i].regval)
> + generic_handle_irq(gpmc->irq[i].irq);
> + gpmc_write_reg(GPMC_IRQSTATUS, regval);
>
> return IRQ_HANDLED;
> }
>
> +static int gpmc_irq_endis(struct irq_data *p, bool endis)
> +{
> + struct gpmc *gpmc = irq_data_get_irq_chip_data(p);
> + int i;
> + u32 regval;
> +
> + for (i = 0; i< gpmc->num_irq; i++)
> + if (p->irq == gpmc->irq[i].irq) {
> + regval = gpmc_read_reg(GPMC_IRQENABLE);
> + if (endis)
> + regval |= gpmc->irq[i].regval;
> + else
> + regval&= ~gpmc->irq[i].regval;
> + gpmc_write_reg(GPMC_IRQENABLE, regval);
> + break;
> + }
> +
> + return 0;
> +}
> +
> +static void gpmc_irq_disable(struct irq_data *p)
> +{
> + gpmc_irq_endis(p, false);
> +}
> +
> +static void gpmc_irq_enable(struct irq_data *p)
> +{
> + gpmc_irq_endis(p, true);
> +}
> +
> +static void gpmc_irq_noop(struct irq_data *data) { }
> +
> +static unsigned int gpmc_irq_noop_ret(struct irq_data *data) { return 0; }
> +
> +static __devinit int gpmc_setup_irq(struct gpmc *gpmc)
> +{
> + int i;
> + u32 regval;
> +
> + if (!gpmc->master_irq)
> + return -EINVAL;
> +
> + if (gpmc->num_irq< GPMC_NR_IRQ) {
> + dev_warn(gpmc->dev, "Insufficient interrupts for device\n");
> + return -EINVAL;
> + } else if (gpmc->num_irq> GPMC_NR_IRQ)
> + gpmc->num_irq = GPMC_NR_IRQ;
Hmmm ... why not just have ...
if (gpmc->num_irq != GPMC_NR_IRQ) {
dev_warn(...);
return -EINVAL;
}
This also raises the question why bother passing num_irq if we always
want it to be GPMC_NR_IRQ? Why not always initialise them all driver?
> + gpmc->irq[0].regval = GPMC_IRQ_FIFOEVENT;
> + gpmc->irq[1].regval = GPMC_IRQ_TERMINALCOUNT;
> + gpmc->irq[2].regval = GPMC_IRQ_WAIT0EDGEDETECTION;
> + gpmc->irq[3].regval = GPMC_IRQ_WAIT1EDGEDETECTION;
> + gpmc->irq[4].regval = GPMC_IRQ_WAIT2EDGEDETECTION;
> + gpmc->irq[5].regval = GPMC_IRQ_WAIT3EDGEDETECTION;
> +
> + for (i = 0; i< gpmc->num_irq; i++)
> + gpmc->irq[i].irq = gpmc->irq_start + i;
> +
> + gpmc->irq_chip.name = "gpmc";
> + gpmc->irq_chip.irq_startup = gpmc_irq_noop_ret;
> + gpmc->irq_chip.irq_enable = gpmc_irq_enable;
> + gpmc->irq_chip.irq_disable = gpmc_irq_disable;
> + gpmc->irq_chip.irq_shutdown = gpmc_irq_noop;
> + gpmc->irq_chip.irq_ack = gpmc_irq_noop;
> + gpmc->irq_chip.irq_mask = gpmc_irq_noop;
> + gpmc->irq_chip.irq_unmask = gpmc_irq_noop;
> +
> + for (i = 0; i< gpmc->num_irq; i++) {
> + irq_set_chip_and_handler(gpmc->irq[i].irq,
> + &gpmc->irq_chip, handle_simple_irq);
> + irq_set_chip_data(gpmc->irq[i].irq, gpmc);
> + set_irq_flags(gpmc->irq[i].irq, IRQF_VALID | IRQF_NOAUTOEN);
> + }
> +
> + /* clear interrupts */
> + regval = gpmc_read_reg(GPMC_IRQSTATUS);
> + gpmc_write_reg(GPMC_IRQSTATUS, regval);
> +
> + return request_irq(gpmc->master_irq, gpmc_handle_irq, IRQF_SHARED,
> + "gpmc", gpmc);
> +}
> +
> +static __devinit int gpmc_probe(struct platform_device *pdev)
> +{
> + u32 l;
> + int i;
> + int ret = 0;
> + struct resource *res = NULL;
> + struct gpmc_pdata *gp = dev_get_platdata(&pdev->dev);
> + struct gpmc_device_pdata **gdq = NULL;
> + struct gpmc_device *gd = NULL;
> +
> + gpmc = devm_kzalloc(&pdev->dev, sizeof(struct gpmc), GFP_KERNEL);
> + if (gpmc == NULL)
> + return -ENOMEM;
> +
> + gpmc->dev =&pdev->dev;
> + gpmc->fclk_period = gp->fclk_period;
> +
> + res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
> + if (res == NULL)
> + return -ENOENT;
> +
> + gpmc->phys_base = res->start;
> + gpmc->memsize = resource_size(res);
> +
> + gpmc->io_base = devm_request_and_ioremap(gpmc->dev, res);
> + if (!gpmc->io_base)
> + return -EADDRNOTAVAIL;
> +
> + res = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
> + if (res == NULL)
> + dev_warn(gpmc->dev, "Failed to get resource: irq\n");
> + else
> + gpmc->master_irq = res->start;
Why not return an error if the IRQ is not found? We don't know if anyone
will be trying to use them.
> + gpmc->irq_start = gp->irq_start;
> + gpmc->num_irq = gp->num_irq;
> + gpmc_setup_irq(gpmc);
> +
> + gpmc->ecc_used = -EINVAL;
> + spin_lock_init(&gpmc->mem_lock);
> + platform_set_drvdata(pdev, gpmc);
> +
> + l = gpmc_read_reg(GPMC_REVISION);
> + dev_info(gpmc->dev, "GPMC revision %d.%d\n", (l>> 4)& 0x0f, l& 0x0f);
> +
> + gpmc_mem_init();
> +
> + for (gdq = gp->device_pdata, gd = gpmc->device; *gdq; gdq++, i++) {
> + ret = gpmc_setup_device(*gdq, gd, gpmc);
> + if (IS_ERR_VALUE(ret))
> + dev_err(gpmc->dev, "gpmc setup on %s failed\n",
> + (*gdq)->name);
> + else
> + gd++;
> + }
Would a while loop be simpler?
The above loop appears to terminate when *gdq == 0. Is this always
guaranteed? In other words, safe?
I see that "i" is not being used in the above loop either.
> + gpmc->num_device = gd - gpmc->device;
> +
> + for (i = 0, gd = gpmc->device; i< gpmc->num_device; i++, gd++)
> + if (IS_ERR(gpmc_create_device(gd, gpmc)))
> + dev_err(gpmc->dev, "device creation on %s failed\n",
> + gd->name);
> +
> + return 0;
> +}
> +
> +static __devexit int gpmc_free_irq(struct gpmc *gpmc)
> +{
> + /* TODO: free gpmc irq chip */
> +
> + if (gpmc->master_irq)
> + free_irq(gpmc->master_irq, gpmc);
> +
> + return 0;
> +}
> +
> +static __devexit int gpmc_remove(struct platform_device *pdev)
> +{
> + struct gpmc *gpmc = platform_get_drvdata(pdev);
> +
> + platform_set_drvdata(pdev, NULL);
> + gpmc_free_irq(gpmc);
> +
> + return 0;
> +}
> +
> +static struct platform_driver gpmc_driver = {
> + .probe = gpmc_probe,
> + .remove = __devexit_p(gpmc_remove),
> + .driver = {
> + .name = DRIVER_NAME,
> + .owner = THIS_MODULE,
> + },
> +};
> +
> +module_platform_driver(gpmc_driver);
> +
> #ifdef CONFIG_ARCH_OMAP3
> static struct omap3_gpmc_regs gpmc_context;
>
> @@ -855,10 +1193,10 @@ int gpmc_enable_hwecc(int cs, int mode, int dev_width, int ecc_size)
> unsigned int val;
>
> /* check if ecc module is in used */
> - if (gpmc_ecc_used != -EINVAL)
> + if (gpmc->ecc_used != -EINVAL)
> return -EINVAL;
>
> - gpmc_ecc_used = cs;
> + gpmc->ecc_used = cs;
>
> /* clear ecc and enable bits */
> val = ((0x00000001<<8) | 0x00000001);
> @@ -906,7 +1244,7 @@ int gpmc_calculate_ecc(int cs, const u_char *dat, u_char *ecc_code)
> {
> unsigned int val = 0x0;
>
> - if (gpmc_ecc_used != cs)
> + if (gpmc->ecc_used != cs)
> return -EINVAL;
>
> /* read ecc result */
> @@ -916,7 +1254,7 @@ int gpmc_calculate_ecc(int cs, const u_char *dat, u_char *ecc_code)
> /* P2048o, P1024o, P512o, P256o, P2048e, P1024e, P512e, P256e */
> *ecc_code++ = ((val>> 8)& 0x0f) | ((val>> 20)& 0xf0);
>
> - gpmc_ecc_used = -EINVAL;
> + gpmc->ecc_used = -EINVAL;
> return 0;
> }
> EXPORT_SYMBOL_GPL(gpmc_calculate_ecc);
> diff --git a/arch/arm/plat-omap/include/plat/gpmc.h b/arch/arm/plat-omap/include/plat/gpmc.h
> index 1527929..fa62cdf 100644
> --- a/arch/arm/plat-omap/include/plat/gpmc.h
> +++ b/arch/arm/plat-omap/include/plat/gpmc.h
> @@ -36,6 +36,7 @@
> #define GPMC_PREFETCH_FIFO_CNT 0x00000007 /* bytes available in FIFO for r/w */
> #define GPMC_PREFETCH_COUNT 0x00000008 /* remaining bytes to be read/write*/
> #define GPMC_STATUS_BUFFER 0x00000009 /* 1: buffer is available to write */
> +#define GPMC_CONFIG_WAITPIN 0x0000000A
>
> #define GPMC_NAND_COMMAND 0x0000000a
> #define GPMC_NAND_ADDRESS 0x0000000b
> @@ -83,6 +84,17 @@
> #define GPMC_IRQ_FIFOEVENTENABLE 0x01
> #define GPMC_IRQ_COUNT_EVENT 0x02
>
> +#define GPMC_IRQ_FIFOEVENT BIT(0)
> +#define GPMC_IRQ_TERMINALCOUNT BIT(1)
> +#define GPMC_IRQ_WAIT0EDGEDETECTION BIT(8)
> +#define GPMC_IRQ_WAIT1EDGEDETECTION BIT(9)
> +#define GPMC_IRQ_WAIT2EDGEDETECTION BIT(10)
> +#define GPMC_IRQ_WAIT3EDGEDETECTION BIT(11)
> +#define GPMC_IRQ_MASK \
> + (GPMC_IRQ_FIFOEVENT | GPMC_IRQ_TERMINALCOUNT | \
> + GPMC_IRQ_WAIT0EDGEDETECTION | GPMC_IRQ_WAIT1EDGEDETECTION | \
> + GPMC_IRQ_WAIT2EDGEDETECTION | GPMC_IRQ_WAIT3EDGEDETECTION)
> +
> #define PREFETCH_FIFOTHRESHOLD_MAX 0x40
> #define PREFETCH_FIFOTHRESHOLD(val) ((val)<< 8)
>
> @@ -131,6 +143,42 @@ struct gpmc_timings {
> u16 wr_data_mux_bus; /* WRDATAONADMUXBUS */
> };
>
> +struct gpmc_config {
> + int cmd;
> + int val;
> +};
> +
> +struct gpmc_cs_data {
> + unsigned cs;
> + unsigned long mem_size;
> + unsigned long mem_start;
> + unsigned long mem_offset;
> + struct gpmc_config *config;
> + unsigned num_config;
> + struct gpmc_timings *timing;
> + unsigned irq_flags;
I found the name irq_flags a bit unclear. This appears to be a mask for
the interrupts used. So may be this should be "irq_mask" or just "irqs".
> +};
> +
> +struct gpmc_device_pdata {
> + char *name;
> + int id;
> + void *pdata;
> + unsigned pdata_size;
> + /* resources configured via GPMC will be created by GPMC driver */
> + struct resource *per_res;
> + unsigned num_per_res;
> + struct gpmc_cs_data *cs_data;
> + unsigned num_cs;
> +};
> +
> +struct gpmc_pdata {
> + /* GPMC_FCLK period in picoseconds */
> + unsigned long fclk_period;
> + struct gpmc_device_pdata **device_pdata;
> + unsigned irq_start;
> + unsigned num_irq;
Again, not sure why we need to pass num_irq.
Cheers
Jon
^ permalink raw reply [flat|nested] 73+ messages in thread
* Re: [PATCH v3 1/9] ARM: OMAP2+: gpmc: driver conversion
@ 2012-04-05 20:21 ` Jon Hunter
0 siblings, 0 replies; 73+ messages in thread
From: Jon Hunter @ 2012-04-05 20:21 UTC (permalink / raw)
To: Afzal Mohammed
Cc: tony, Kevin Hilman, linux, dwmw2, sameo, grinberg, mike, nm,
artem.bityutskiy, vimal.newwork, dbaryshkov, linux-omap,
linux-arm-kernel, linux-mtd, linux-kernel, Vaibhav Hiremath
Hi Afzal,
On 04/05/2012 10:45 AM, Afzal Mohammed wrote:
[...]
> +struct gpmc_irq {
> + unsigned irq;
> + u32 regval;
Are you using regval to indicate the bit-mask? If so, maybe call it
"bitmask" instead.
[...]
> +static __devinit
> +int gpmc_setup_cs_irq(struct gpmc *gpmc, struct gpmc_device_pdata *gdp,
> + struct gpmc_cs_data *cs, struct resource *res)
> +{
> + int i, n, val;
> +
> + for (i = 0, n = 0; i< gpmc->num_irq; i++)
> + if (gpmc->irq[i].regval& cs->irq_flags) {
> + res[n].start = res[n].end = gpmc->irq[i].irq;
> + res[n].flags = IORESOURCE_IRQ;
> +
> + dev_info(gpmc->dev, "resource irq %u for %s "
> + "(on CS %d) [bit: %x]\n", res[n].start,
> + gdp->name, cs->cs, __ffs(gpmc->irq[i].regval));
> +
> + switch (gpmc->irq[i].regval) {
> + case GPMC_IRQ_WAIT0EDGEDETECTION:
> + case GPMC_IRQ_WAIT1EDGEDETECTION:
> + case GPMC_IRQ_WAIT2EDGEDETECTION:
> + case GPMC_IRQ_WAIT3EDGEDETECTION:
> + val = __ffs(gpmc->irq[i].regval);
> + val -= __ffs(GPMC_IRQ_WAIT0EDGEDETECTION);
> + gpmc_cs_configure(cs->cs,
> + GPMC_CONFIG_WAITPIN, val);
Why is the configuration of the wait pin done here? It is possible to
use the wait pin may be used without enabling the interrupt.
Where do you handle allocating the wait pins to ensure two devices don't
attempt to use the same one? Like how the CS are managed.
Also, where you you configure the polarity of the wait pins? I would
have thought it would make sense to have the wait pin configured as part
of the cs configuration.
> + }
> + n++;
> + }
> +
> + return n;
> +}
> +
> +static __devinit int gpmc_setup_device(struct gpmc_device_pdata *gdp,
> + struct gpmc_device *dev, struct gpmc *gpmc)
> +{
> + int i, j, n;
> + struct gpmc_cs_data *cs;
> +
> + for (i = 0, n = 0, cs = gdp->cs_data; i< gdp->num_cs; i++, cs++)
> + n += hweight32(cs->irq_flags& GPMC_IRQ_MASK);
> +
> + n += gdp->num_cs;
> +
> + dev->gpmc_res = devm_kzalloc(gpmc->dev, sizeof(*dev->gpmc_res) * n,
> + GFP_KERNEL);
> + if (dev->gpmc_res == NULL) {
> + dev_err(gpmc->dev, "error: memory allocation\n");
> + return -ENOMEM;
> + }
> +
> + for (i = 0, j = 0, cs = gdp->cs_data; i< gdp->num_cs; cs++, i++) {
> + dev->gpmc_res[j] = gpmc_setup_cs_mem(cs, gdp, gpmc);
> + if (dev->gpmc_res[j++].flags& IORESOURCE_MEM)
> + j += gpmc_setup_cs_irq(gpmc, gdp, cs,
> + dev->gpmc_res + j);
> + else {
> + dev_err(gpmc->dev, "error: setup for %s\n", gdp->name);
> + devm_kfree(gpmc->dev, dev->gpmc_res);
> + dev->gpmc_res = NULL;
> + dev->num_gpmc_res = 0;
> + return -EINVAL;
> + }
> }
This section of code is not straight-forward to read. I see what you are
doing, but I am wondering if this could be improved.
First of all, returning a structure from a function is making this code
harder to read. Per the CodingStyle document in the kernel, it is
preferred for a function to return success or failure if the function is
an action, like a setup.
Secondly, do you need to pass cs, gdp and gpmc to gpmc_setup_cs_mem()?
It appears that gdp and gpmc are only used for prints. You could
probably avoid passing gdp and move the print to outside this function.
> + dev->num_gpmc_res = j;
>
> - ret = request_irq(gpmc_irq,
> - gpmc_handle_irq, IRQF_SHARED, "gpmc", gpmc_base);
> - if (ret)
> - pr_err("gpmc: irq-%d could not claim: err %d\n",
> - gpmc_irq, ret);
> - return ret;
> + dev->name = gdp->name;
> + dev->id = gdp->id;
> + dev->pdata = gdp->pdata;
> + dev->pdata_size = gdp->pdata_size;
> + dev->per_res = gdp->per_res;
> + dev->num_per_res = gdp->num_per_res;
> +
> + return 0;
> +}
> +
> +static __devinit
> +struct platform_device *gpmc_create_device(struct gpmc_device *p,
> + struct gpmc *gpmc)
> +{
> + int num = p->num_per_res + p->num_gpmc_res;
> + struct resource *res;
> + struct platform_device *pdev;
> +
> + res = devm_kzalloc(gpmc->dev, sizeof(struct resource) * num,
> + GFP_KERNEL);
> + if (!res) {
> + dev_err(gpmc->dev, "error: allocating memory\n");
> + return NULL;
> + }
> +
> + memcpy((char *)res, (const char *) p->gpmc_res,
> + sizeof(struct resource) * p->num_gpmc_res);
> + memcpy((char *)(res + p->num_gpmc_res), (const char *)p->per_res,
> + sizeof(struct resource) * p->num_per_res);
> +
> + pdev = platform_device_register_resndata(gpmc->dev, p->name, p->id,
> + res, num, p->pdata, p->pdata_size);
> +
> + devm_kfree(gpmc->dev, res);
> +
> + return pdev;
> }
> -postcore_initcall(gpmc_init);
>
> static irqreturn_t gpmc_handle_irq(int irq, void *dev)
> {
> - u8 cs;
> + int i;
> + u32 regval;
> + struct gpmc *gpmc = dev;
>
> - /* check cs to invoke the irq */
> - cs = ((gpmc_read_reg(GPMC_PREFETCH_CONFIG1))>> CS_NUM_SHIFT)& 0x7;
> - if (OMAP_GPMC_IRQ_BASE+cs<= OMAP_GPMC_IRQ_END)
> - generic_handle_irq(OMAP_GPMC_IRQ_BASE+cs);
> + regval = gpmc_read_reg(GPMC_IRQSTATUS);
> +
> +
> + for (i = 0; i< gpmc->num_irq; i++)
> + if (regval& gpmc->irq[i].regval)
> + generic_handle_irq(gpmc->irq[i].irq);
> + gpmc_write_reg(GPMC_IRQSTATUS, regval);
>
> return IRQ_HANDLED;
> }
>
> +static int gpmc_irq_endis(struct irq_data *p, bool endis)
> +{
> + struct gpmc *gpmc = irq_data_get_irq_chip_data(p);
> + int i;
> + u32 regval;
> +
> + for (i = 0; i< gpmc->num_irq; i++)
> + if (p->irq == gpmc->irq[i].irq) {
> + regval = gpmc_read_reg(GPMC_IRQENABLE);
> + if (endis)
> + regval |= gpmc->irq[i].regval;
> + else
> + regval&= ~gpmc->irq[i].regval;
> + gpmc_write_reg(GPMC_IRQENABLE, regval);
> + break;
> + }
> +
> + return 0;
> +}
> +
> +static void gpmc_irq_disable(struct irq_data *p)
> +{
> + gpmc_irq_endis(p, false);
> +}
> +
> +static void gpmc_irq_enable(struct irq_data *p)
> +{
> + gpmc_irq_endis(p, true);
> +}
> +
> +static void gpmc_irq_noop(struct irq_data *data) { }
> +
> +static unsigned int gpmc_irq_noop_ret(struct irq_data *data) { return 0; }
> +
> +static __devinit int gpmc_setup_irq(struct gpmc *gpmc)
> +{
> + int i;
> + u32 regval;
> +
> + if (!gpmc->master_irq)
> + return -EINVAL;
> +
> + if (gpmc->num_irq< GPMC_NR_IRQ) {
> + dev_warn(gpmc->dev, "Insufficient interrupts for device\n");
> + return -EINVAL;
> + } else if (gpmc->num_irq> GPMC_NR_IRQ)
> + gpmc->num_irq = GPMC_NR_IRQ;
Hmmm ... why not just have ...
if (gpmc->num_irq != GPMC_NR_IRQ) {
dev_warn(...);
return -EINVAL;
}
This also raises the question why bother passing num_irq if we always
want it to be GPMC_NR_IRQ? Why not always initialise them all driver?
> + gpmc->irq[0].regval = GPMC_IRQ_FIFOEVENT;
> + gpmc->irq[1].regval = GPMC_IRQ_TERMINALCOUNT;
> + gpmc->irq[2].regval = GPMC_IRQ_WAIT0EDGEDETECTION;
> + gpmc->irq[3].regval = GPMC_IRQ_WAIT1EDGEDETECTION;
> + gpmc->irq[4].regval = GPMC_IRQ_WAIT2EDGEDETECTION;
> + gpmc->irq[5].regval = GPMC_IRQ_WAIT3EDGEDETECTION;
> +
> + for (i = 0; i< gpmc->num_irq; i++)
> + gpmc->irq[i].irq = gpmc->irq_start + i;
> +
> + gpmc->irq_chip.name = "gpmc";
> + gpmc->irq_chip.irq_startup = gpmc_irq_noop_ret;
> + gpmc->irq_chip.irq_enable = gpmc_irq_enable;
> + gpmc->irq_chip.irq_disable = gpmc_irq_disable;
> + gpmc->irq_chip.irq_shutdown = gpmc_irq_noop;
> + gpmc->irq_chip.irq_ack = gpmc_irq_noop;
> + gpmc->irq_chip.irq_mask = gpmc_irq_noop;
> + gpmc->irq_chip.irq_unmask = gpmc_irq_noop;
> +
> + for (i = 0; i< gpmc->num_irq; i++) {
> + irq_set_chip_and_handler(gpmc->irq[i].irq,
> + &gpmc->irq_chip, handle_simple_irq);
> + irq_set_chip_data(gpmc->irq[i].irq, gpmc);
> + set_irq_flags(gpmc->irq[i].irq, IRQF_VALID | IRQF_NOAUTOEN);
> + }
> +
> + /* clear interrupts */
> + regval = gpmc_read_reg(GPMC_IRQSTATUS);
> + gpmc_write_reg(GPMC_IRQSTATUS, regval);
> +
> + return request_irq(gpmc->master_irq, gpmc_handle_irq, IRQF_SHARED,
> + "gpmc", gpmc);
> +}
> +
> +static __devinit int gpmc_probe(struct platform_device *pdev)
> +{
> + u32 l;
> + int i;
> + int ret = 0;
> + struct resource *res = NULL;
> + struct gpmc_pdata *gp = dev_get_platdata(&pdev->dev);
> + struct gpmc_device_pdata **gdq = NULL;
> + struct gpmc_device *gd = NULL;
> +
> + gpmc = devm_kzalloc(&pdev->dev, sizeof(struct gpmc), GFP_KERNEL);
> + if (gpmc == NULL)
> + return -ENOMEM;
> +
> + gpmc->dev =&pdev->dev;
> + gpmc->fclk_period = gp->fclk_period;
> +
> + res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
> + if (res == NULL)
> + return -ENOENT;
> +
> + gpmc->phys_base = res->start;
> + gpmc->memsize = resource_size(res);
> +
> + gpmc->io_base = devm_request_and_ioremap(gpmc->dev, res);
> + if (!gpmc->io_base)
> + return -EADDRNOTAVAIL;
> +
> + res = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
> + if (res == NULL)
> + dev_warn(gpmc->dev, "Failed to get resource: irq\n");
> + else
> + gpmc->master_irq = res->start;
Why not return an error if the IRQ is not found? We don't know if anyone
will be trying to use them.
> + gpmc->irq_start = gp->irq_start;
> + gpmc->num_irq = gp->num_irq;
> + gpmc_setup_irq(gpmc);
> +
> + gpmc->ecc_used = -EINVAL;
> + spin_lock_init(&gpmc->mem_lock);
> + platform_set_drvdata(pdev, gpmc);
> +
> + l = gpmc_read_reg(GPMC_REVISION);
> + dev_info(gpmc->dev, "GPMC revision %d.%d\n", (l>> 4)& 0x0f, l& 0x0f);
> +
> + gpmc_mem_init();
> +
> + for (gdq = gp->device_pdata, gd = gpmc->device; *gdq; gdq++, i++) {
> + ret = gpmc_setup_device(*gdq, gd, gpmc);
> + if (IS_ERR_VALUE(ret))
> + dev_err(gpmc->dev, "gpmc setup on %s failed\n",
> + (*gdq)->name);
> + else
> + gd++;
> + }
Would a while loop be simpler?
The above loop appears to terminate when *gdq == 0. Is this always
guaranteed? In other words, safe?
I see that "i" is not being used in the above loop either.
> + gpmc->num_device = gd - gpmc->device;
> +
> + for (i = 0, gd = gpmc->device; i< gpmc->num_device; i++, gd++)
> + if (IS_ERR(gpmc_create_device(gd, gpmc)))
> + dev_err(gpmc->dev, "device creation on %s failed\n",
> + gd->name);
> +
> + return 0;
> +}
> +
> +static __devexit int gpmc_free_irq(struct gpmc *gpmc)
> +{
> + /* TODO: free gpmc irq chip */
> +
> + if (gpmc->master_irq)
> + free_irq(gpmc->master_irq, gpmc);
> +
> + return 0;
> +}
> +
> +static __devexit int gpmc_remove(struct platform_device *pdev)
> +{
> + struct gpmc *gpmc = platform_get_drvdata(pdev);
> +
> + platform_set_drvdata(pdev, NULL);
> + gpmc_free_irq(gpmc);
> +
> + return 0;
> +}
> +
> +static struct platform_driver gpmc_driver = {
> + .probe = gpmc_probe,
> + .remove = __devexit_p(gpmc_remove),
> + .driver = {
> + .name = DRIVER_NAME,
> + .owner = THIS_MODULE,
> + },
> +};
> +
> +module_platform_driver(gpmc_driver);
> +
> #ifdef CONFIG_ARCH_OMAP3
> static struct omap3_gpmc_regs gpmc_context;
>
> @@ -855,10 +1193,10 @@ int gpmc_enable_hwecc(int cs, int mode, int dev_width, int ecc_size)
> unsigned int val;
>
> /* check if ecc module is in used */
> - if (gpmc_ecc_used != -EINVAL)
> + if (gpmc->ecc_used != -EINVAL)
> return -EINVAL;
>
> - gpmc_ecc_used = cs;
> + gpmc->ecc_used = cs;
>
> /* clear ecc and enable bits */
> val = ((0x00000001<<8) | 0x00000001);
> @@ -906,7 +1244,7 @@ int gpmc_calculate_ecc(int cs, const u_char *dat, u_char *ecc_code)
> {
> unsigned int val = 0x0;
>
> - if (gpmc_ecc_used != cs)
> + if (gpmc->ecc_used != cs)
> return -EINVAL;
>
> /* read ecc result */
> @@ -916,7 +1254,7 @@ int gpmc_calculate_ecc(int cs, const u_char *dat, u_char *ecc_code)
> /* P2048o, P1024o, P512o, P256o, P2048e, P1024e, P512e, P256e */
> *ecc_code++ = ((val>> 8)& 0x0f) | ((val>> 20)& 0xf0);
>
> - gpmc_ecc_used = -EINVAL;
> + gpmc->ecc_used = -EINVAL;
> return 0;
> }
> EXPORT_SYMBOL_GPL(gpmc_calculate_ecc);
> diff --git a/arch/arm/plat-omap/include/plat/gpmc.h b/arch/arm/plat-omap/include/plat/gpmc.h
> index 1527929..fa62cdf 100644
> --- a/arch/arm/plat-omap/include/plat/gpmc.h
> +++ b/arch/arm/plat-omap/include/plat/gpmc.h
> @@ -36,6 +36,7 @@
> #define GPMC_PREFETCH_FIFO_CNT 0x00000007 /* bytes available in FIFO for r/w */
> #define GPMC_PREFETCH_COUNT 0x00000008 /* remaining bytes to be read/write*/
> #define GPMC_STATUS_BUFFER 0x00000009 /* 1: buffer is available to write */
> +#define GPMC_CONFIG_WAITPIN 0x0000000A
>
> #define GPMC_NAND_COMMAND 0x0000000a
> #define GPMC_NAND_ADDRESS 0x0000000b
> @@ -83,6 +84,17 @@
> #define GPMC_IRQ_FIFOEVENTENABLE 0x01
> #define GPMC_IRQ_COUNT_EVENT 0x02
>
> +#define GPMC_IRQ_FIFOEVENT BIT(0)
> +#define GPMC_IRQ_TERMINALCOUNT BIT(1)
> +#define GPMC_IRQ_WAIT0EDGEDETECTION BIT(8)
> +#define GPMC_IRQ_WAIT1EDGEDETECTION BIT(9)
> +#define GPMC_IRQ_WAIT2EDGEDETECTION BIT(10)
> +#define GPMC_IRQ_WAIT3EDGEDETECTION BIT(11)
> +#define GPMC_IRQ_MASK \
> + (GPMC_IRQ_FIFOEVENT | GPMC_IRQ_TERMINALCOUNT | \
> + GPMC_IRQ_WAIT0EDGEDETECTION | GPMC_IRQ_WAIT1EDGEDETECTION | \
> + GPMC_IRQ_WAIT2EDGEDETECTION | GPMC_IRQ_WAIT3EDGEDETECTION)
> +
> #define PREFETCH_FIFOTHRESHOLD_MAX 0x40
> #define PREFETCH_FIFOTHRESHOLD(val) ((val)<< 8)
>
> @@ -131,6 +143,42 @@ struct gpmc_timings {
> u16 wr_data_mux_bus; /* WRDATAONADMUXBUS */
> };
>
> +struct gpmc_config {
> + int cmd;
> + int val;
> +};
> +
> +struct gpmc_cs_data {
> + unsigned cs;
> + unsigned long mem_size;
> + unsigned long mem_start;
> + unsigned long mem_offset;
> + struct gpmc_config *config;
> + unsigned num_config;
> + struct gpmc_timings *timing;
> + unsigned irq_flags;
I found the name irq_flags a bit unclear. This appears to be a mask for
the interrupts used. So may be this should be "irq_mask" or just "irqs".
> +};
> +
> +struct gpmc_device_pdata {
> + char *name;
> + int id;
> + void *pdata;
> + unsigned pdata_size;
> + /* resources configured via GPMC will be created by GPMC driver */
> + struct resource *per_res;
> + unsigned num_per_res;
> + struct gpmc_cs_data *cs_data;
> + unsigned num_cs;
> +};
> +
> +struct gpmc_pdata {
> + /* GPMC_FCLK period in picoseconds */
> + unsigned long fclk_period;
> + struct gpmc_device_pdata **device_pdata;
> + unsigned irq_start;
> + unsigned num_irq;
Again, not sure why we need to pass num_irq.
Cheers
Jon
^ permalink raw reply [flat|nested] 73+ messages in thread
* Re: [PATCH v3 1/9] ARM: OMAP2+: gpmc: driver conversion
@ 2012-04-05 20:21 ` Jon Hunter
0 siblings, 0 replies; 73+ messages in thread
From: Jon Hunter @ 2012-04-05 20:21 UTC (permalink / raw)
To: Afzal Mohammed
Cc: Kevin Hilman, nm, linux, sameo, tony, artem.bityutskiy,
linux-kernel, Vaibhav Hiremath, dbaryshkov, vimal.newwork,
grinberg, mike, linux-mtd, linux-omap, dwmw2, linux-arm-kernel
Hi Afzal,
On 04/05/2012 10:45 AM, Afzal Mohammed wrote:
[...]
> +struct gpmc_irq {
> + unsigned irq;
> + u32 regval;
Are you using regval to indicate the bit-mask? If so, maybe call it
"bitmask" instead.
[...]
> +static __devinit
> +int gpmc_setup_cs_irq(struct gpmc *gpmc, struct gpmc_device_pdata *gdp,
> + struct gpmc_cs_data *cs, struct resource *res)
> +{
> + int i, n, val;
> +
> + for (i = 0, n = 0; i< gpmc->num_irq; i++)
> + if (gpmc->irq[i].regval& cs->irq_flags) {
> + res[n].start = res[n].end = gpmc->irq[i].irq;
> + res[n].flags = IORESOURCE_IRQ;
> +
> + dev_info(gpmc->dev, "resource irq %u for %s "
> + "(on CS %d) [bit: %x]\n", res[n].start,
> + gdp->name, cs->cs, __ffs(gpmc->irq[i].regval));
> +
> + switch (gpmc->irq[i].regval) {
> + case GPMC_IRQ_WAIT0EDGEDETECTION:
> + case GPMC_IRQ_WAIT1EDGEDETECTION:
> + case GPMC_IRQ_WAIT2EDGEDETECTION:
> + case GPMC_IRQ_WAIT3EDGEDETECTION:
> + val = __ffs(gpmc->irq[i].regval);
> + val -= __ffs(GPMC_IRQ_WAIT0EDGEDETECTION);
> + gpmc_cs_configure(cs->cs,
> + GPMC_CONFIG_WAITPIN, val);
Why is the configuration of the wait pin done here? It is possible to
use the wait pin may be used without enabling the interrupt.
Where do you handle allocating the wait pins to ensure two devices don't
attempt to use the same one? Like how the CS are managed.
Also, where you you configure the polarity of the wait pins? I would
have thought it would make sense to have the wait pin configured as part
of the cs configuration.
> + }
> + n++;
> + }
> +
> + return n;
> +}
> +
> +static __devinit int gpmc_setup_device(struct gpmc_device_pdata *gdp,
> + struct gpmc_device *dev, struct gpmc *gpmc)
> +{
> + int i, j, n;
> + struct gpmc_cs_data *cs;
> +
> + for (i = 0, n = 0, cs = gdp->cs_data; i< gdp->num_cs; i++, cs++)
> + n += hweight32(cs->irq_flags& GPMC_IRQ_MASK);
> +
> + n += gdp->num_cs;
> +
> + dev->gpmc_res = devm_kzalloc(gpmc->dev, sizeof(*dev->gpmc_res) * n,
> + GFP_KERNEL);
> + if (dev->gpmc_res == NULL) {
> + dev_err(gpmc->dev, "error: memory allocation\n");
> + return -ENOMEM;
> + }
> +
> + for (i = 0, j = 0, cs = gdp->cs_data; i< gdp->num_cs; cs++, i++) {
> + dev->gpmc_res[j] = gpmc_setup_cs_mem(cs, gdp, gpmc);
> + if (dev->gpmc_res[j++].flags& IORESOURCE_MEM)
> + j += gpmc_setup_cs_irq(gpmc, gdp, cs,
> + dev->gpmc_res + j);
> + else {
> + dev_err(gpmc->dev, "error: setup for %s\n", gdp->name);
> + devm_kfree(gpmc->dev, dev->gpmc_res);
> + dev->gpmc_res = NULL;
> + dev->num_gpmc_res = 0;
> + return -EINVAL;
> + }
> }
This section of code is not straight-forward to read. I see what you are
doing, but I am wondering if this could be improved.
First of all, returning a structure from a function is making this code
harder to read. Per the CodingStyle document in the kernel, it is
preferred for a function to return success or failure if the function is
an action, like a setup.
Secondly, do you need to pass cs, gdp and gpmc to gpmc_setup_cs_mem()?
It appears that gdp and gpmc are only used for prints. You could
probably avoid passing gdp and move the print to outside this function.
> + dev->num_gpmc_res = j;
>
> - ret = request_irq(gpmc_irq,
> - gpmc_handle_irq, IRQF_SHARED, "gpmc", gpmc_base);
> - if (ret)
> - pr_err("gpmc: irq-%d could not claim: err %d\n",
> - gpmc_irq, ret);
> - return ret;
> + dev->name = gdp->name;
> + dev->id = gdp->id;
> + dev->pdata = gdp->pdata;
> + dev->pdata_size = gdp->pdata_size;
> + dev->per_res = gdp->per_res;
> + dev->num_per_res = gdp->num_per_res;
> +
> + return 0;
> +}
> +
> +static __devinit
> +struct platform_device *gpmc_create_device(struct gpmc_device *p,
> + struct gpmc *gpmc)
> +{
> + int num = p->num_per_res + p->num_gpmc_res;
> + struct resource *res;
> + struct platform_device *pdev;
> +
> + res = devm_kzalloc(gpmc->dev, sizeof(struct resource) * num,
> + GFP_KERNEL);
> + if (!res) {
> + dev_err(gpmc->dev, "error: allocating memory\n");
> + return NULL;
> + }
> +
> + memcpy((char *)res, (const char *) p->gpmc_res,
> + sizeof(struct resource) * p->num_gpmc_res);
> + memcpy((char *)(res + p->num_gpmc_res), (const char *)p->per_res,
> + sizeof(struct resource) * p->num_per_res);
> +
> + pdev = platform_device_register_resndata(gpmc->dev, p->name, p->id,
> + res, num, p->pdata, p->pdata_size);
> +
> + devm_kfree(gpmc->dev, res);
> +
> + return pdev;
> }
> -postcore_initcall(gpmc_init);
>
> static irqreturn_t gpmc_handle_irq(int irq, void *dev)
> {
> - u8 cs;
> + int i;
> + u32 regval;
> + struct gpmc *gpmc = dev;
>
> - /* check cs to invoke the irq */
> - cs = ((gpmc_read_reg(GPMC_PREFETCH_CONFIG1))>> CS_NUM_SHIFT)& 0x7;
> - if (OMAP_GPMC_IRQ_BASE+cs<= OMAP_GPMC_IRQ_END)
> - generic_handle_irq(OMAP_GPMC_IRQ_BASE+cs);
> + regval = gpmc_read_reg(GPMC_IRQSTATUS);
> +
> +
> + for (i = 0; i< gpmc->num_irq; i++)
> + if (regval& gpmc->irq[i].regval)
> + generic_handle_irq(gpmc->irq[i].irq);
> + gpmc_write_reg(GPMC_IRQSTATUS, regval);
>
> return IRQ_HANDLED;
> }
>
> +static int gpmc_irq_endis(struct irq_data *p, bool endis)
> +{
> + struct gpmc *gpmc = irq_data_get_irq_chip_data(p);
> + int i;
> + u32 regval;
> +
> + for (i = 0; i< gpmc->num_irq; i++)
> + if (p->irq == gpmc->irq[i].irq) {
> + regval = gpmc_read_reg(GPMC_IRQENABLE);
> + if (endis)
> + regval |= gpmc->irq[i].regval;
> + else
> + regval&= ~gpmc->irq[i].regval;
> + gpmc_write_reg(GPMC_IRQENABLE, regval);
> + break;
> + }
> +
> + return 0;
> +}
> +
> +static void gpmc_irq_disable(struct irq_data *p)
> +{
> + gpmc_irq_endis(p, false);
> +}
> +
> +static void gpmc_irq_enable(struct irq_data *p)
> +{
> + gpmc_irq_endis(p, true);
> +}
> +
> +static void gpmc_irq_noop(struct irq_data *data) { }
> +
> +static unsigned int gpmc_irq_noop_ret(struct irq_data *data) { return 0; }
> +
> +static __devinit int gpmc_setup_irq(struct gpmc *gpmc)
> +{
> + int i;
> + u32 regval;
> +
> + if (!gpmc->master_irq)
> + return -EINVAL;
> +
> + if (gpmc->num_irq< GPMC_NR_IRQ) {
> + dev_warn(gpmc->dev, "Insufficient interrupts for device\n");
> + return -EINVAL;
> + } else if (gpmc->num_irq> GPMC_NR_IRQ)
> + gpmc->num_irq = GPMC_NR_IRQ;
Hmmm ... why not just have ...
if (gpmc->num_irq != GPMC_NR_IRQ) {
dev_warn(...);
return -EINVAL;
}
This also raises the question why bother passing num_irq if we always
want it to be GPMC_NR_IRQ? Why not always initialise them all driver?
> + gpmc->irq[0].regval = GPMC_IRQ_FIFOEVENT;
> + gpmc->irq[1].regval = GPMC_IRQ_TERMINALCOUNT;
> + gpmc->irq[2].regval = GPMC_IRQ_WAIT0EDGEDETECTION;
> + gpmc->irq[3].regval = GPMC_IRQ_WAIT1EDGEDETECTION;
> + gpmc->irq[4].regval = GPMC_IRQ_WAIT2EDGEDETECTION;
> + gpmc->irq[5].regval = GPMC_IRQ_WAIT3EDGEDETECTION;
> +
> + for (i = 0; i< gpmc->num_irq; i++)
> + gpmc->irq[i].irq = gpmc->irq_start + i;
> +
> + gpmc->irq_chip.name = "gpmc";
> + gpmc->irq_chip.irq_startup = gpmc_irq_noop_ret;
> + gpmc->irq_chip.irq_enable = gpmc_irq_enable;
> + gpmc->irq_chip.irq_disable = gpmc_irq_disable;
> + gpmc->irq_chip.irq_shutdown = gpmc_irq_noop;
> + gpmc->irq_chip.irq_ack = gpmc_irq_noop;
> + gpmc->irq_chip.irq_mask = gpmc_irq_noop;
> + gpmc->irq_chip.irq_unmask = gpmc_irq_noop;
> +
> + for (i = 0; i< gpmc->num_irq; i++) {
> + irq_set_chip_and_handler(gpmc->irq[i].irq,
> + &gpmc->irq_chip, handle_simple_irq);
> + irq_set_chip_data(gpmc->irq[i].irq, gpmc);
> + set_irq_flags(gpmc->irq[i].irq, IRQF_VALID | IRQF_NOAUTOEN);
> + }
> +
> + /* clear interrupts */
> + regval = gpmc_read_reg(GPMC_IRQSTATUS);
> + gpmc_write_reg(GPMC_IRQSTATUS, regval);
> +
> + return request_irq(gpmc->master_irq, gpmc_handle_irq, IRQF_SHARED,
> + "gpmc", gpmc);
> +}
> +
> +static __devinit int gpmc_probe(struct platform_device *pdev)
> +{
> + u32 l;
> + int i;
> + int ret = 0;
> + struct resource *res = NULL;
> + struct gpmc_pdata *gp = dev_get_platdata(&pdev->dev);
> + struct gpmc_device_pdata **gdq = NULL;
> + struct gpmc_device *gd = NULL;
> +
> + gpmc = devm_kzalloc(&pdev->dev, sizeof(struct gpmc), GFP_KERNEL);
> + if (gpmc == NULL)
> + return -ENOMEM;
> +
> + gpmc->dev =&pdev->dev;
> + gpmc->fclk_period = gp->fclk_period;
> +
> + res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
> + if (res == NULL)
> + return -ENOENT;
> +
> + gpmc->phys_base = res->start;
> + gpmc->memsize = resource_size(res);
> +
> + gpmc->io_base = devm_request_and_ioremap(gpmc->dev, res);
> + if (!gpmc->io_base)
> + return -EADDRNOTAVAIL;
> +
> + res = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
> + if (res == NULL)
> + dev_warn(gpmc->dev, "Failed to get resource: irq\n");
> + else
> + gpmc->master_irq = res->start;
Why not return an error if the IRQ is not found? We don't know if anyone
will be trying to use them.
> + gpmc->irq_start = gp->irq_start;
> + gpmc->num_irq = gp->num_irq;
> + gpmc_setup_irq(gpmc);
> +
> + gpmc->ecc_used = -EINVAL;
> + spin_lock_init(&gpmc->mem_lock);
> + platform_set_drvdata(pdev, gpmc);
> +
> + l = gpmc_read_reg(GPMC_REVISION);
> + dev_info(gpmc->dev, "GPMC revision %d.%d\n", (l>> 4)& 0x0f, l& 0x0f);
> +
> + gpmc_mem_init();
> +
> + for (gdq = gp->device_pdata, gd = gpmc->device; *gdq; gdq++, i++) {
> + ret = gpmc_setup_device(*gdq, gd, gpmc);
> + if (IS_ERR_VALUE(ret))
> + dev_err(gpmc->dev, "gpmc setup on %s failed\n",
> + (*gdq)->name);
> + else
> + gd++;
> + }
Would a while loop be simpler?
The above loop appears to terminate when *gdq == 0. Is this always
guaranteed? In other words, safe?
I see that "i" is not being used in the above loop either.
> + gpmc->num_device = gd - gpmc->device;
> +
> + for (i = 0, gd = gpmc->device; i< gpmc->num_device; i++, gd++)
> + if (IS_ERR(gpmc_create_device(gd, gpmc)))
> + dev_err(gpmc->dev, "device creation on %s failed\n",
> + gd->name);
> +
> + return 0;
> +}
> +
> +static __devexit int gpmc_free_irq(struct gpmc *gpmc)
> +{
> + /* TODO: free gpmc irq chip */
> +
> + if (gpmc->master_irq)
> + free_irq(gpmc->master_irq, gpmc);
> +
> + return 0;
> +}
> +
> +static __devexit int gpmc_remove(struct platform_device *pdev)
> +{
> + struct gpmc *gpmc = platform_get_drvdata(pdev);
> +
> + platform_set_drvdata(pdev, NULL);
> + gpmc_free_irq(gpmc);
> +
> + return 0;
> +}
> +
> +static struct platform_driver gpmc_driver = {
> + .probe = gpmc_probe,
> + .remove = __devexit_p(gpmc_remove),
> + .driver = {
> + .name = DRIVER_NAME,
> + .owner = THIS_MODULE,
> + },
> +};
> +
> +module_platform_driver(gpmc_driver);
> +
> #ifdef CONFIG_ARCH_OMAP3
> static struct omap3_gpmc_regs gpmc_context;
>
> @@ -855,10 +1193,10 @@ int gpmc_enable_hwecc(int cs, int mode, int dev_width, int ecc_size)
> unsigned int val;
>
> /* check if ecc module is in used */
> - if (gpmc_ecc_used != -EINVAL)
> + if (gpmc->ecc_used != -EINVAL)
> return -EINVAL;
>
> - gpmc_ecc_used = cs;
> + gpmc->ecc_used = cs;
>
> /* clear ecc and enable bits */
> val = ((0x00000001<<8) | 0x00000001);
> @@ -906,7 +1244,7 @@ int gpmc_calculate_ecc(int cs, const u_char *dat, u_char *ecc_code)
> {
> unsigned int val = 0x0;
>
> - if (gpmc_ecc_used != cs)
> + if (gpmc->ecc_used != cs)
> return -EINVAL;
>
> /* read ecc result */
> @@ -916,7 +1254,7 @@ int gpmc_calculate_ecc(int cs, const u_char *dat, u_char *ecc_code)
> /* P2048o, P1024o, P512o, P256o, P2048e, P1024e, P512e, P256e */
> *ecc_code++ = ((val>> 8)& 0x0f) | ((val>> 20)& 0xf0);
>
> - gpmc_ecc_used = -EINVAL;
> + gpmc->ecc_used = -EINVAL;
> return 0;
> }
> EXPORT_SYMBOL_GPL(gpmc_calculate_ecc);
> diff --git a/arch/arm/plat-omap/include/plat/gpmc.h b/arch/arm/plat-omap/include/plat/gpmc.h
> index 1527929..fa62cdf 100644
> --- a/arch/arm/plat-omap/include/plat/gpmc.h
> +++ b/arch/arm/plat-omap/include/plat/gpmc.h
> @@ -36,6 +36,7 @@
> #define GPMC_PREFETCH_FIFO_CNT 0x00000007 /* bytes available in FIFO for r/w */
> #define GPMC_PREFETCH_COUNT 0x00000008 /* remaining bytes to be read/write*/
> #define GPMC_STATUS_BUFFER 0x00000009 /* 1: buffer is available to write */
> +#define GPMC_CONFIG_WAITPIN 0x0000000A
>
> #define GPMC_NAND_COMMAND 0x0000000a
> #define GPMC_NAND_ADDRESS 0x0000000b
> @@ -83,6 +84,17 @@
> #define GPMC_IRQ_FIFOEVENTENABLE 0x01
> #define GPMC_IRQ_COUNT_EVENT 0x02
>
> +#define GPMC_IRQ_FIFOEVENT BIT(0)
> +#define GPMC_IRQ_TERMINALCOUNT BIT(1)
> +#define GPMC_IRQ_WAIT0EDGEDETECTION BIT(8)
> +#define GPMC_IRQ_WAIT1EDGEDETECTION BIT(9)
> +#define GPMC_IRQ_WAIT2EDGEDETECTION BIT(10)
> +#define GPMC_IRQ_WAIT3EDGEDETECTION BIT(11)
> +#define GPMC_IRQ_MASK \
> + (GPMC_IRQ_FIFOEVENT | GPMC_IRQ_TERMINALCOUNT | \
> + GPMC_IRQ_WAIT0EDGEDETECTION | GPMC_IRQ_WAIT1EDGEDETECTION | \
> + GPMC_IRQ_WAIT2EDGEDETECTION | GPMC_IRQ_WAIT3EDGEDETECTION)
> +
> #define PREFETCH_FIFOTHRESHOLD_MAX 0x40
> #define PREFETCH_FIFOTHRESHOLD(val) ((val)<< 8)
>
> @@ -131,6 +143,42 @@ struct gpmc_timings {
> u16 wr_data_mux_bus; /* WRDATAONADMUXBUS */
> };
>
> +struct gpmc_config {
> + int cmd;
> + int val;
> +};
> +
> +struct gpmc_cs_data {
> + unsigned cs;
> + unsigned long mem_size;
> + unsigned long mem_start;
> + unsigned long mem_offset;
> + struct gpmc_config *config;
> + unsigned num_config;
> + struct gpmc_timings *timing;
> + unsigned irq_flags;
I found the name irq_flags a bit unclear. This appears to be a mask for
the interrupts used. So may be this should be "irq_mask" or just "irqs".
> +};
> +
> +struct gpmc_device_pdata {
> + char *name;
> + int id;
> + void *pdata;
> + unsigned pdata_size;
> + /* resources configured via GPMC will be created by GPMC driver */
> + struct resource *per_res;
> + unsigned num_per_res;
> + struct gpmc_cs_data *cs_data;
> + unsigned num_cs;
> +};
> +
> +struct gpmc_pdata {
> + /* GPMC_FCLK period in picoseconds */
> + unsigned long fclk_period;
> + struct gpmc_device_pdata **device_pdata;
> + unsigned irq_start;
> + unsigned num_irq;
Again, not sure why we need to pass num_irq.
Cheers
Jon
^ permalink raw reply [flat|nested] 73+ messages in thread
* [PATCH v3 1/9] ARM: OMAP2+: gpmc: driver conversion
@ 2012-04-05 20:21 ` Jon Hunter
0 siblings, 0 replies; 73+ messages in thread
From: Jon Hunter @ 2012-04-05 20:21 UTC (permalink / raw)
To: linux-arm-kernel
Hi Afzal,
On 04/05/2012 10:45 AM, Afzal Mohammed wrote:
[...]
> +struct gpmc_irq {
> + unsigned irq;
> + u32 regval;
Are you using regval to indicate the bit-mask? If so, maybe call it
"bitmask" instead.
[...]
> +static __devinit
> +int gpmc_setup_cs_irq(struct gpmc *gpmc, struct gpmc_device_pdata *gdp,
> + struct gpmc_cs_data *cs, struct resource *res)
> +{
> + int i, n, val;
> +
> + for (i = 0, n = 0; i< gpmc->num_irq; i++)
> + if (gpmc->irq[i].regval& cs->irq_flags) {
> + res[n].start = res[n].end = gpmc->irq[i].irq;
> + res[n].flags = IORESOURCE_IRQ;
> +
> + dev_info(gpmc->dev, "resource irq %u for %s "
> + "(on CS %d) [bit: %x]\n", res[n].start,
> + gdp->name, cs->cs, __ffs(gpmc->irq[i].regval));
> +
> + switch (gpmc->irq[i].regval) {
> + case GPMC_IRQ_WAIT0EDGEDETECTION:
> + case GPMC_IRQ_WAIT1EDGEDETECTION:
> + case GPMC_IRQ_WAIT2EDGEDETECTION:
> + case GPMC_IRQ_WAIT3EDGEDETECTION:
> + val = __ffs(gpmc->irq[i].regval);
> + val -= __ffs(GPMC_IRQ_WAIT0EDGEDETECTION);
> + gpmc_cs_configure(cs->cs,
> + GPMC_CONFIG_WAITPIN, val);
Why is the configuration of the wait pin done here? It is possible to
use the wait pin may be used without enabling the interrupt.
Where do you handle allocating the wait pins to ensure two devices don't
attempt to use the same one? Like how the CS are managed.
Also, where you you configure the polarity of the wait pins? I would
have thought it would make sense to have the wait pin configured as part
of the cs configuration.
> + }
> + n++;
> + }
> +
> + return n;
> +}
> +
> +static __devinit int gpmc_setup_device(struct gpmc_device_pdata *gdp,
> + struct gpmc_device *dev, struct gpmc *gpmc)
> +{
> + int i, j, n;
> + struct gpmc_cs_data *cs;
> +
> + for (i = 0, n = 0, cs = gdp->cs_data; i< gdp->num_cs; i++, cs++)
> + n += hweight32(cs->irq_flags& GPMC_IRQ_MASK);
> +
> + n += gdp->num_cs;
> +
> + dev->gpmc_res = devm_kzalloc(gpmc->dev, sizeof(*dev->gpmc_res) * n,
> + GFP_KERNEL);
> + if (dev->gpmc_res == NULL) {
> + dev_err(gpmc->dev, "error: memory allocation\n");
> + return -ENOMEM;
> + }
> +
> + for (i = 0, j = 0, cs = gdp->cs_data; i< gdp->num_cs; cs++, i++) {
> + dev->gpmc_res[j] = gpmc_setup_cs_mem(cs, gdp, gpmc);
> + if (dev->gpmc_res[j++].flags& IORESOURCE_MEM)
> + j += gpmc_setup_cs_irq(gpmc, gdp, cs,
> + dev->gpmc_res + j);
> + else {
> + dev_err(gpmc->dev, "error: setup for %s\n", gdp->name);
> + devm_kfree(gpmc->dev, dev->gpmc_res);
> + dev->gpmc_res = NULL;
> + dev->num_gpmc_res = 0;
> + return -EINVAL;
> + }
> }
This section of code is not straight-forward to read. I see what you are
doing, but I am wondering if this could be improved.
First of all, returning a structure from a function is making this code
harder to read. Per the CodingStyle document in the kernel, it is
preferred for a function to return success or failure if the function is
an action, like a setup.
Secondly, do you need to pass cs, gdp and gpmc to gpmc_setup_cs_mem()?
It appears that gdp and gpmc are only used for prints. You could
probably avoid passing gdp and move the print to outside this function.
> + dev->num_gpmc_res = j;
>
> - ret = request_irq(gpmc_irq,
> - gpmc_handle_irq, IRQF_SHARED, "gpmc", gpmc_base);
> - if (ret)
> - pr_err("gpmc: irq-%d could not claim: err %d\n",
> - gpmc_irq, ret);
> - return ret;
> + dev->name = gdp->name;
> + dev->id = gdp->id;
> + dev->pdata = gdp->pdata;
> + dev->pdata_size = gdp->pdata_size;
> + dev->per_res = gdp->per_res;
> + dev->num_per_res = gdp->num_per_res;
> +
> + return 0;
> +}
> +
> +static __devinit
> +struct platform_device *gpmc_create_device(struct gpmc_device *p,
> + struct gpmc *gpmc)
> +{
> + int num = p->num_per_res + p->num_gpmc_res;
> + struct resource *res;
> + struct platform_device *pdev;
> +
> + res = devm_kzalloc(gpmc->dev, sizeof(struct resource) * num,
> + GFP_KERNEL);
> + if (!res) {
> + dev_err(gpmc->dev, "error: allocating memory\n");
> + return NULL;
> + }
> +
> + memcpy((char *)res, (const char *) p->gpmc_res,
> + sizeof(struct resource) * p->num_gpmc_res);
> + memcpy((char *)(res + p->num_gpmc_res), (const char *)p->per_res,
> + sizeof(struct resource) * p->num_per_res);
> +
> + pdev = platform_device_register_resndata(gpmc->dev, p->name, p->id,
> + res, num, p->pdata, p->pdata_size);
> +
> + devm_kfree(gpmc->dev, res);
> +
> + return pdev;
> }
> -postcore_initcall(gpmc_init);
>
> static irqreturn_t gpmc_handle_irq(int irq, void *dev)
> {
> - u8 cs;
> + int i;
> + u32 regval;
> + struct gpmc *gpmc = dev;
>
> - /* check cs to invoke the irq */
> - cs = ((gpmc_read_reg(GPMC_PREFETCH_CONFIG1))>> CS_NUM_SHIFT)& 0x7;
> - if (OMAP_GPMC_IRQ_BASE+cs<= OMAP_GPMC_IRQ_END)
> - generic_handle_irq(OMAP_GPMC_IRQ_BASE+cs);
> + regval = gpmc_read_reg(GPMC_IRQSTATUS);
> +
> +
> + for (i = 0; i< gpmc->num_irq; i++)
> + if (regval& gpmc->irq[i].regval)
> + generic_handle_irq(gpmc->irq[i].irq);
> + gpmc_write_reg(GPMC_IRQSTATUS, regval);
>
> return IRQ_HANDLED;
> }
>
> +static int gpmc_irq_endis(struct irq_data *p, bool endis)
> +{
> + struct gpmc *gpmc = irq_data_get_irq_chip_data(p);
> + int i;
> + u32 regval;
> +
> + for (i = 0; i< gpmc->num_irq; i++)
> + if (p->irq == gpmc->irq[i].irq) {
> + regval = gpmc_read_reg(GPMC_IRQENABLE);
> + if (endis)
> + regval |= gpmc->irq[i].regval;
> + else
> + regval&= ~gpmc->irq[i].regval;
> + gpmc_write_reg(GPMC_IRQENABLE, regval);
> + break;
> + }
> +
> + return 0;
> +}
> +
> +static void gpmc_irq_disable(struct irq_data *p)
> +{
> + gpmc_irq_endis(p, false);
> +}
> +
> +static void gpmc_irq_enable(struct irq_data *p)
> +{
> + gpmc_irq_endis(p, true);
> +}
> +
> +static void gpmc_irq_noop(struct irq_data *data) { }
> +
> +static unsigned int gpmc_irq_noop_ret(struct irq_data *data) { return 0; }
> +
> +static __devinit int gpmc_setup_irq(struct gpmc *gpmc)
> +{
> + int i;
> + u32 regval;
> +
> + if (!gpmc->master_irq)
> + return -EINVAL;
> +
> + if (gpmc->num_irq< GPMC_NR_IRQ) {
> + dev_warn(gpmc->dev, "Insufficient interrupts for device\n");
> + return -EINVAL;
> + } else if (gpmc->num_irq> GPMC_NR_IRQ)
> + gpmc->num_irq = GPMC_NR_IRQ;
Hmmm ... why not just have ...
if (gpmc->num_irq != GPMC_NR_IRQ) {
dev_warn(...);
return -EINVAL;
}
This also raises the question why bother passing num_irq if we always
want it to be GPMC_NR_IRQ? Why not always initialise them all driver?
> + gpmc->irq[0].regval = GPMC_IRQ_FIFOEVENT;
> + gpmc->irq[1].regval = GPMC_IRQ_TERMINALCOUNT;
> + gpmc->irq[2].regval = GPMC_IRQ_WAIT0EDGEDETECTION;
> + gpmc->irq[3].regval = GPMC_IRQ_WAIT1EDGEDETECTION;
> + gpmc->irq[4].regval = GPMC_IRQ_WAIT2EDGEDETECTION;
> + gpmc->irq[5].regval = GPMC_IRQ_WAIT3EDGEDETECTION;
> +
> + for (i = 0; i< gpmc->num_irq; i++)
> + gpmc->irq[i].irq = gpmc->irq_start + i;
> +
> + gpmc->irq_chip.name = "gpmc";
> + gpmc->irq_chip.irq_startup = gpmc_irq_noop_ret;
> + gpmc->irq_chip.irq_enable = gpmc_irq_enable;
> + gpmc->irq_chip.irq_disable = gpmc_irq_disable;
> + gpmc->irq_chip.irq_shutdown = gpmc_irq_noop;
> + gpmc->irq_chip.irq_ack = gpmc_irq_noop;
> + gpmc->irq_chip.irq_mask = gpmc_irq_noop;
> + gpmc->irq_chip.irq_unmask = gpmc_irq_noop;
> +
> + for (i = 0; i< gpmc->num_irq; i++) {
> + irq_set_chip_and_handler(gpmc->irq[i].irq,
> + &gpmc->irq_chip, handle_simple_irq);
> + irq_set_chip_data(gpmc->irq[i].irq, gpmc);
> + set_irq_flags(gpmc->irq[i].irq, IRQF_VALID | IRQF_NOAUTOEN);
> + }
> +
> + /* clear interrupts */
> + regval = gpmc_read_reg(GPMC_IRQSTATUS);
> + gpmc_write_reg(GPMC_IRQSTATUS, regval);
> +
> + return request_irq(gpmc->master_irq, gpmc_handle_irq, IRQF_SHARED,
> + "gpmc", gpmc);
> +}
> +
> +static __devinit int gpmc_probe(struct platform_device *pdev)
> +{
> + u32 l;
> + int i;
> + int ret = 0;
> + struct resource *res = NULL;
> + struct gpmc_pdata *gp = dev_get_platdata(&pdev->dev);
> + struct gpmc_device_pdata **gdq = NULL;
> + struct gpmc_device *gd = NULL;
> +
> + gpmc = devm_kzalloc(&pdev->dev, sizeof(struct gpmc), GFP_KERNEL);
> + if (gpmc == NULL)
> + return -ENOMEM;
> +
> + gpmc->dev =&pdev->dev;
> + gpmc->fclk_period = gp->fclk_period;
> +
> + res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
> + if (res == NULL)
> + return -ENOENT;
> +
> + gpmc->phys_base = res->start;
> + gpmc->memsize = resource_size(res);
> +
> + gpmc->io_base = devm_request_and_ioremap(gpmc->dev, res);
> + if (!gpmc->io_base)
> + return -EADDRNOTAVAIL;
> +
> + res = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
> + if (res == NULL)
> + dev_warn(gpmc->dev, "Failed to get resource: irq\n");
> + else
> + gpmc->master_irq = res->start;
Why not return an error if the IRQ is not found? We don't know if anyone
will be trying to use them.
> + gpmc->irq_start = gp->irq_start;
> + gpmc->num_irq = gp->num_irq;
> + gpmc_setup_irq(gpmc);
> +
> + gpmc->ecc_used = -EINVAL;
> + spin_lock_init(&gpmc->mem_lock);
> + platform_set_drvdata(pdev, gpmc);
> +
> + l = gpmc_read_reg(GPMC_REVISION);
> + dev_info(gpmc->dev, "GPMC revision %d.%d\n", (l>> 4)& 0x0f, l& 0x0f);
> +
> + gpmc_mem_init();
> +
> + for (gdq = gp->device_pdata, gd = gpmc->device; *gdq; gdq++, i++) {
> + ret = gpmc_setup_device(*gdq, gd, gpmc);
> + if (IS_ERR_VALUE(ret))
> + dev_err(gpmc->dev, "gpmc setup on %s failed\n",
> + (*gdq)->name);
> + else
> + gd++;
> + }
Would a while loop be simpler?
The above loop appears to terminate when *gdq == 0. Is this always
guaranteed? In other words, safe?
I see that "i" is not being used in the above loop either.
> + gpmc->num_device = gd - gpmc->device;
> +
> + for (i = 0, gd = gpmc->device; i< gpmc->num_device; i++, gd++)
> + if (IS_ERR(gpmc_create_device(gd, gpmc)))
> + dev_err(gpmc->dev, "device creation on %s failed\n",
> + gd->name);
> +
> + return 0;
> +}
> +
> +static __devexit int gpmc_free_irq(struct gpmc *gpmc)
> +{
> + /* TODO: free gpmc irq chip */
> +
> + if (gpmc->master_irq)
> + free_irq(gpmc->master_irq, gpmc);
> +
> + return 0;
> +}
> +
> +static __devexit int gpmc_remove(struct platform_device *pdev)
> +{
> + struct gpmc *gpmc = platform_get_drvdata(pdev);
> +
> + platform_set_drvdata(pdev, NULL);
> + gpmc_free_irq(gpmc);
> +
> + return 0;
> +}
> +
> +static struct platform_driver gpmc_driver = {
> + .probe = gpmc_probe,
> + .remove = __devexit_p(gpmc_remove),
> + .driver = {
> + .name = DRIVER_NAME,
> + .owner = THIS_MODULE,
> + },
> +};
> +
> +module_platform_driver(gpmc_driver);
> +
> #ifdef CONFIG_ARCH_OMAP3
> static struct omap3_gpmc_regs gpmc_context;
>
> @@ -855,10 +1193,10 @@ int gpmc_enable_hwecc(int cs, int mode, int dev_width, int ecc_size)
> unsigned int val;
>
> /* check if ecc module is in used */
> - if (gpmc_ecc_used != -EINVAL)
> + if (gpmc->ecc_used != -EINVAL)
> return -EINVAL;
>
> - gpmc_ecc_used = cs;
> + gpmc->ecc_used = cs;
>
> /* clear ecc and enable bits */
> val = ((0x00000001<<8) | 0x00000001);
> @@ -906,7 +1244,7 @@ int gpmc_calculate_ecc(int cs, const u_char *dat, u_char *ecc_code)
> {
> unsigned int val = 0x0;
>
> - if (gpmc_ecc_used != cs)
> + if (gpmc->ecc_used != cs)
> return -EINVAL;
>
> /* read ecc result */
> @@ -916,7 +1254,7 @@ int gpmc_calculate_ecc(int cs, const u_char *dat, u_char *ecc_code)
> /* P2048o, P1024o, P512o, P256o, P2048e, P1024e, P512e, P256e */
> *ecc_code++ = ((val>> 8)& 0x0f) | ((val>> 20)& 0xf0);
>
> - gpmc_ecc_used = -EINVAL;
> + gpmc->ecc_used = -EINVAL;
> return 0;
> }
> EXPORT_SYMBOL_GPL(gpmc_calculate_ecc);
> diff --git a/arch/arm/plat-omap/include/plat/gpmc.h b/arch/arm/plat-omap/include/plat/gpmc.h
> index 1527929..fa62cdf 100644
> --- a/arch/arm/plat-omap/include/plat/gpmc.h
> +++ b/arch/arm/plat-omap/include/plat/gpmc.h
> @@ -36,6 +36,7 @@
> #define GPMC_PREFETCH_FIFO_CNT 0x00000007 /* bytes available in FIFO for r/w */
> #define GPMC_PREFETCH_COUNT 0x00000008 /* remaining bytes to be read/write*/
> #define GPMC_STATUS_BUFFER 0x00000009 /* 1: buffer is available to write */
> +#define GPMC_CONFIG_WAITPIN 0x0000000A
>
> #define GPMC_NAND_COMMAND 0x0000000a
> #define GPMC_NAND_ADDRESS 0x0000000b
> @@ -83,6 +84,17 @@
> #define GPMC_IRQ_FIFOEVENTENABLE 0x01
> #define GPMC_IRQ_COUNT_EVENT 0x02
>
> +#define GPMC_IRQ_FIFOEVENT BIT(0)
> +#define GPMC_IRQ_TERMINALCOUNT BIT(1)
> +#define GPMC_IRQ_WAIT0EDGEDETECTION BIT(8)
> +#define GPMC_IRQ_WAIT1EDGEDETECTION BIT(9)
> +#define GPMC_IRQ_WAIT2EDGEDETECTION BIT(10)
> +#define GPMC_IRQ_WAIT3EDGEDETECTION BIT(11)
> +#define GPMC_IRQ_MASK \
> + (GPMC_IRQ_FIFOEVENT | GPMC_IRQ_TERMINALCOUNT | \
> + GPMC_IRQ_WAIT0EDGEDETECTION | GPMC_IRQ_WAIT1EDGEDETECTION | \
> + GPMC_IRQ_WAIT2EDGEDETECTION | GPMC_IRQ_WAIT3EDGEDETECTION)
> +
> #define PREFETCH_FIFOTHRESHOLD_MAX 0x40
> #define PREFETCH_FIFOTHRESHOLD(val) ((val)<< 8)
>
> @@ -131,6 +143,42 @@ struct gpmc_timings {
> u16 wr_data_mux_bus; /* WRDATAONADMUXBUS */
> };
>
> +struct gpmc_config {
> + int cmd;
> + int val;
> +};
> +
> +struct gpmc_cs_data {
> + unsigned cs;
> + unsigned long mem_size;
> + unsigned long mem_start;
> + unsigned long mem_offset;
> + struct gpmc_config *config;
> + unsigned num_config;
> + struct gpmc_timings *timing;
> + unsigned irq_flags;
I found the name irq_flags a bit unclear. This appears to be a mask for
the interrupts used. So may be this should be "irq_mask" or just "irqs".
> +};
> +
> +struct gpmc_device_pdata {
> + char *name;
> + int id;
> + void *pdata;
> + unsigned pdata_size;
> + /* resources configured via GPMC will be created by GPMC driver */
> + struct resource *per_res;
> + unsigned num_per_res;
> + struct gpmc_cs_data *cs_data;
> + unsigned num_cs;
> +};
> +
> +struct gpmc_pdata {
> + /* GPMC_FCLK period in picoseconds */
> + unsigned long fclk_period;
> + struct gpmc_device_pdata **device_pdata;
> + unsigned irq_start;
> + unsigned num_irq;
Again, not sure why we need to pass num_irq.
Cheers
Jon
^ permalink raw reply [flat|nested] 73+ messages in thread
* Re: [PATCH v3 1/9] ARM: OMAP2+: gpmc: driver conversion
2012-04-05 20:21 ` Jon Hunter
(?)
@ 2012-04-05 20:34 ` Jon Hunter
-1 siblings, 0 replies; 73+ messages in thread
From: Jon Hunter @ 2012-04-05 20:34 UTC (permalink / raw)
To: Afzal Mohammed
Cc: Kevin Hilman, nm, linux, sameo, tony, artem.bityutskiy,
linux-kernel, Vaibhav Hiremath, dbaryshkov, vimal.newwork,
grinberg, mike, linux-mtd, linux-omap, dwmw2, linux-arm-kernel
Hi Afzal,
On 04/05/2012 03:21 PM, Jon Hunter wrote:
> Hi Afzal,
>
> On 04/05/2012 10:45 AM, Afzal Mohammed wrote:
>
> [...]
>
>> +struct gpmc_irq {
>> + unsigned irq;
>> + u32 regval;
>
> Are you using regval to indicate the bit-mask? If so, maybe call it
> "bitmask" instead.
>
> [...]
>
>> +static __devinit
>> +int gpmc_setup_cs_irq(struct gpmc *gpmc, struct gpmc_device_pdata *gdp,
>> + struct gpmc_cs_data *cs, struct resource *res)
>> +{
>> + int i, n, val;
>> +
>> + for (i = 0, n = 0; i< gpmc->num_irq; i++)
>> + if (gpmc->irq[i].regval& cs->irq_flags) {
>> + res[n].start = res[n].end = gpmc->irq[i].irq;
>> + res[n].flags = IORESOURCE_IRQ;
>> +
>> + dev_info(gpmc->dev, "resource irq %u for %s "
>> + "(on CS %d) [bit: %x]\n", res[n].start,
>> + gdp->name, cs->cs, __ffs(gpmc->irq[i].regval));
>> +
>> + switch (gpmc->irq[i].regval) {
>> + case GPMC_IRQ_WAIT0EDGEDETECTION:
>> + case GPMC_IRQ_WAIT1EDGEDETECTION:
>> + case GPMC_IRQ_WAIT2EDGEDETECTION:
>> + case GPMC_IRQ_WAIT3EDGEDETECTION:
>> + val = __ffs(gpmc->irq[i].regval);
>> + val -= __ffs(GPMC_IRQ_WAIT0EDGEDETECTION);
>> + gpmc_cs_configure(cs->cs,
>> + GPMC_CONFIG_WAITPIN, val);
>
> Why is the configuration of the wait pin done here? It is possible to
> use the wait pin may be used without enabling the interrupt.
Sorry very bad english here on my part. I meant "it is possible to use a
wait pin, without enabling the interrupt".
> Where do you handle allocating the wait pins to ensure two devices don't
> attempt to use the same one? Like how the CS are managed.
>
> Also, where you you configure the polarity of the wait pins? I would
> have thought it would make sense to have the wait pin configured as part
> of the cs configuration.
>
>> + }
>> + n++;
>> + }
>> +
>> + return n;
>> +}
>> +
>> +static __devinit int gpmc_setup_device(struct gpmc_device_pdata *gdp,
>> + struct gpmc_device *dev, struct gpmc *gpmc)
>> +{
>> + int i, j, n;
>> + struct gpmc_cs_data *cs;
>> +
>> + for (i = 0, n = 0, cs = gdp->cs_data; i< gdp->num_cs; i++, cs++)
>> + n += hweight32(cs->irq_flags& GPMC_IRQ_MASK);
>> +
>> + n += gdp->num_cs;
>> +
>> + dev->gpmc_res = devm_kzalloc(gpmc->dev, sizeof(*dev->gpmc_res) * n,
>> + GFP_KERNEL);
>> + if (dev->gpmc_res == NULL) {
>> + dev_err(gpmc->dev, "error: memory allocation\n");
>> + return -ENOMEM;
>> + }
>> +
>> + for (i = 0, j = 0, cs = gdp->cs_data; i< gdp->num_cs; cs++, i++) {
>> + dev->gpmc_res[j] = gpmc_setup_cs_mem(cs, gdp, gpmc);
>> + if (dev->gpmc_res[j++].flags& IORESOURCE_MEM)
>> + j += gpmc_setup_cs_irq(gpmc, gdp, cs,
>> + dev->gpmc_res + j);
>> + else {
>> + dev_err(gpmc->dev, "error: setup for %s\n", gdp->name);
>> + devm_kfree(gpmc->dev, dev->gpmc_res);
>> + dev->gpmc_res = NULL;
>> + dev->num_gpmc_res = 0;
>> + return -EINVAL;
>> + }
>> }
>
> This section of code is not straight-forward to read. I see what you are
> doing, but I am wondering if this could be improved.
>
> First of all, returning a structure from a function is making this code
> harder to read. Per the CodingStyle document in the kernel, it is
> preferred for a function to return success or failure if the function is
> an action, like a setup.
>
> Secondly, do you need to pass cs, gdp and gpmc to gpmc_setup_cs_mem()?
> It appears that gdp and gpmc are only used for prints. You could
> probably avoid passing gdp and move the print to outside this function.
>
>> + dev->num_gpmc_res = j;
>>
>> - ret = request_irq(gpmc_irq,
>> - gpmc_handle_irq, IRQF_SHARED, "gpmc", gpmc_base);
>> - if (ret)
>> - pr_err("gpmc: irq-%d could not claim: err %d\n",
>> - gpmc_irq, ret);
>> - return ret;
>> + dev->name = gdp->name;
>> + dev->id = gdp->id;
>> + dev->pdata = gdp->pdata;
>> + dev->pdata_size = gdp->pdata_size;
>> + dev->per_res = gdp->per_res;
>> + dev->num_per_res = gdp->num_per_res;
>> +
>> + return 0;
>> +}
>> +
>> +static __devinit
>> +struct platform_device *gpmc_create_device(struct gpmc_device *p,
>> + struct gpmc *gpmc)
>> +{
>> + int num = p->num_per_res + p->num_gpmc_res;
>> + struct resource *res;
>> + struct platform_device *pdev;
>> +
>> + res = devm_kzalloc(gpmc->dev, sizeof(struct resource) * num,
>> + GFP_KERNEL);
>> + if (!res) {
>> + dev_err(gpmc->dev, "error: allocating memory\n");
>> + return NULL;
>> + }
>> +
>> + memcpy((char *)res, (const char *) p->gpmc_res,
>> + sizeof(struct resource) * p->num_gpmc_res);
>> + memcpy((char *)(res + p->num_gpmc_res), (const char *)p->per_res,
>> + sizeof(struct resource) * p->num_per_res);
>> +
>> + pdev = platform_device_register_resndata(gpmc->dev, p->name, p->id,
>> + res, num, p->pdata, p->pdata_size);
>> +
>> + devm_kfree(gpmc->dev, res);
>> +
>> + return pdev;
>> }
>> -postcore_initcall(gpmc_init);
>>
>> static irqreturn_t gpmc_handle_irq(int irq, void *dev)
>> {
>> - u8 cs;
>> + int i;
>> + u32 regval;
>> + struct gpmc *gpmc = dev;
>>
>> - /* check cs to invoke the irq */
>> - cs = ((gpmc_read_reg(GPMC_PREFETCH_CONFIG1))>> CS_NUM_SHIFT)& 0x7;
>> - if (OMAP_GPMC_IRQ_BASE+cs<= OMAP_GPMC_IRQ_END)
>> - generic_handle_irq(OMAP_GPMC_IRQ_BASE+cs);
>> + regval = gpmc_read_reg(GPMC_IRQSTATUS);
>> +
>> +
>> + for (i = 0; i< gpmc->num_irq; i++)
>> + if (regval& gpmc->irq[i].regval)
>> + generic_handle_irq(gpmc->irq[i].irq);
>> + gpmc_write_reg(GPMC_IRQSTATUS, regval);
>>
>> return IRQ_HANDLED;
>> }
>>
>> +static int gpmc_irq_endis(struct irq_data *p, bool endis)
>> +{
>> + struct gpmc *gpmc = irq_data_get_irq_chip_data(p);
>> + int i;
>> + u32 regval;
>> +
>> + for (i = 0; i< gpmc->num_irq; i++)
>> + if (p->irq == gpmc->irq[i].irq) {
>> + regval = gpmc_read_reg(GPMC_IRQENABLE);
>> + if (endis)
>> + regval |= gpmc->irq[i].regval;
>> + else
>> + regval&= ~gpmc->irq[i].regval;
>> + gpmc_write_reg(GPMC_IRQENABLE, regval);
>> + break;
>> + }
>> +
>> + return 0;
>> +}
>> +
>> +static void gpmc_irq_disable(struct irq_data *p)
>> +{
>> + gpmc_irq_endis(p, false);
>> +}
>> +
>> +static void gpmc_irq_enable(struct irq_data *p)
>> +{
>> + gpmc_irq_endis(p, true);
>> +}
>> +
>> +static void gpmc_irq_noop(struct irq_data *data) { }
>> +
>> +static unsigned int gpmc_irq_noop_ret(struct irq_data *data) { return
>> 0; }
>> +
>> +static __devinit int gpmc_setup_irq(struct gpmc *gpmc)
>> +{
>> + int i;
>> + u32 regval;
>> +
>> + if (!gpmc->master_irq)
>> + return -EINVAL;
>> +
>> + if (gpmc->num_irq< GPMC_NR_IRQ) {
>> + dev_warn(gpmc->dev, "Insufficient interrupts for device\n");
>> + return -EINVAL;
>> + } else if (gpmc->num_irq> GPMC_NR_IRQ)
>> + gpmc->num_irq = GPMC_NR_IRQ;
>
> Hmmm ... why not just have ...
>
> if (gpmc->num_irq != GPMC_NR_IRQ) {
> dev_warn(...);
> return -EINVAL;
> }
>
> This also raises the question why bother passing num_irq if we always
> want it to be GPMC_NR_IRQ? Why not always initialise them all driver?
>
>> + gpmc->irq[0].regval = GPMC_IRQ_FIFOEVENT;
>> + gpmc->irq[1].regval = GPMC_IRQ_TERMINALCOUNT;
>> + gpmc->irq[2].regval = GPMC_IRQ_WAIT0EDGEDETECTION;
>> + gpmc->irq[3].regval = GPMC_IRQ_WAIT1EDGEDETECTION;
>> + gpmc->irq[4].regval = GPMC_IRQ_WAIT2EDGEDETECTION;
>> + gpmc->irq[5].regval = GPMC_IRQ_WAIT3EDGEDETECTION;
We need to be careful here, OMAP4 and OMAP5 devices only have 3 wait
pins. Hence, one less interrupt.
We may need to add a check on GPMC IP revision here.
Cheers
Jon
^ permalink raw reply [flat|nested] 73+ messages in thread
* Re: [PATCH v3 1/9] ARM: OMAP2+: gpmc: driver conversion
@ 2012-04-05 20:34 ` Jon Hunter
0 siblings, 0 replies; 73+ messages in thread
From: Jon Hunter @ 2012-04-05 20:34 UTC (permalink / raw)
To: Afzal Mohammed
Cc: Kevin Hilman, nm, linux, sameo, tony, artem.bityutskiy,
linux-kernel, Vaibhav Hiremath, dbaryshkov, vimal.newwork,
grinberg, mike, linux-mtd, linux-omap, dwmw2, linux-arm-kernel
Hi Afzal,
On 04/05/2012 03:21 PM, Jon Hunter wrote:
> Hi Afzal,
>
> On 04/05/2012 10:45 AM, Afzal Mohammed wrote:
>
> [...]
>
>> +struct gpmc_irq {
>> + unsigned irq;
>> + u32 regval;
>
> Are you using regval to indicate the bit-mask? If so, maybe call it
> "bitmask" instead.
>
> [...]
>
>> +static __devinit
>> +int gpmc_setup_cs_irq(struct gpmc *gpmc, struct gpmc_device_pdata *gdp,
>> + struct gpmc_cs_data *cs, struct resource *res)
>> +{
>> + int i, n, val;
>> +
>> + for (i = 0, n = 0; i< gpmc->num_irq; i++)
>> + if (gpmc->irq[i].regval& cs->irq_flags) {
>> + res[n].start = res[n].end = gpmc->irq[i].irq;
>> + res[n].flags = IORESOURCE_IRQ;
>> +
>> + dev_info(gpmc->dev, "resource irq %u for %s "
>> + "(on CS %d) [bit: %x]\n", res[n].start,
>> + gdp->name, cs->cs, __ffs(gpmc->irq[i].regval));
>> +
>> + switch (gpmc->irq[i].regval) {
>> + case GPMC_IRQ_WAIT0EDGEDETECTION:
>> + case GPMC_IRQ_WAIT1EDGEDETECTION:
>> + case GPMC_IRQ_WAIT2EDGEDETECTION:
>> + case GPMC_IRQ_WAIT3EDGEDETECTION:
>> + val = __ffs(gpmc->irq[i].regval);
>> + val -= __ffs(GPMC_IRQ_WAIT0EDGEDETECTION);
>> + gpmc_cs_configure(cs->cs,
>> + GPMC_CONFIG_WAITPIN, val);
>
> Why is the configuration of the wait pin done here? It is possible to
> use the wait pin may be used without enabling the interrupt.
Sorry very bad english here on my part. I meant "it is possible to use a
wait pin, without enabling the interrupt".
> Where do you handle allocating the wait pins to ensure two devices don't
> attempt to use the same one? Like how the CS are managed.
>
> Also, where you you configure the polarity of the wait pins? I would
> have thought it would make sense to have the wait pin configured as part
> of the cs configuration.
>
>> + }
>> + n++;
>> + }
>> +
>> + return n;
>> +}
>> +
>> +static __devinit int gpmc_setup_device(struct gpmc_device_pdata *gdp,
>> + struct gpmc_device *dev, struct gpmc *gpmc)
>> +{
>> + int i, j, n;
>> + struct gpmc_cs_data *cs;
>> +
>> + for (i = 0, n = 0, cs = gdp->cs_data; i< gdp->num_cs; i++, cs++)
>> + n += hweight32(cs->irq_flags& GPMC_IRQ_MASK);
>> +
>> + n += gdp->num_cs;
>> +
>> + dev->gpmc_res = devm_kzalloc(gpmc->dev, sizeof(*dev->gpmc_res) * n,
>> + GFP_KERNEL);
>> + if (dev->gpmc_res == NULL) {
>> + dev_err(gpmc->dev, "error: memory allocation\n");
>> + return -ENOMEM;
>> + }
>> +
>> + for (i = 0, j = 0, cs = gdp->cs_data; i< gdp->num_cs; cs++, i++) {
>> + dev->gpmc_res[j] = gpmc_setup_cs_mem(cs, gdp, gpmc);
>> + if (dev->gpmc_res[j++].flags& IORESOURCE_MEM)
>> + j += gpmc_setup_cs_irq(gpmc, gdp, cs,
>> + dev->gpmc_res + j);
>> + else {
>> + dev_err(gpmc->dev, "error: setup for %s\n", gdp->name);
>> + devm_kfree(gpmc->dev, dev->gpmc_res);
>> + dev->gpmc_res = NULL;
>> + dev->num_gpmc_res = 0;
>> + return -EINVAL;
>> + }
>> }
>
> This section of code is not straight-forward to read. I see what you are
> doing, but I am wondering if this could be improved.
>
> First of all, returning a structure from a function is making this code
> harder to read. Per the CodingStyle document in the kernel, it is
> preferred for a function to return success or failure if the function is
> an action, like a setup.
>
> Secondly, do you need to pass cs, gdp and gpmc to gpmc_setup_cs_mem()?
> It appears that gdp and gpmc are only used for prints. You could
> probably avoid passing gdp and move the print to outside this function.
>
>> + dev->num_gpmc_res = j;
>>
>> - ret = request_irq(gpmc_irq,
>> - gpmc_handle_irq, IRQF_SHARED, "gpmc", gpmc_base);
>> - if (ret)
>> - pr_err("gpmc: irq-%d could not claim: err %d\n",
>> - gpmc_irq, ret);
>> - return ret;
>> + dev->name = gdp->name;
>> + dev->id = gdp->id;
>> + dev->pdata = gdp->pdata;
>> + dev->pdata_size = gdp->pdata_size;
>> + dev->per_res = gdp->per_res;
>> + dev->num_per_res = gdp->num_per_res;
>> +
>> + return 0;
>> +}
>> +
>> +static __devinit
>> +struct platform_device *gpmc_create_device(struct gpmc_device *p,
>> + struct gpmc *gpmc)
>> +{
>> + int num = p->num_per_res + p->num_gpmc_res;
>> + struct resource *res;
>> + struct platform_device *pdev;
>> +
>> + res = devm_kzalloc(gpmc->dev, sizeof(struct resource) * num,
>> + GFP_KERNEL);
>> + if (!res) {
>> + dev_err(gpmc->dev, "error: allocating memory\n");
>> + return NULL;
>> + }
>> +
>> + memcpy((char *)res, (const char *) p->gpmc_res,
>> + sizeof(struct resource) * p->num_gpmc_res);
>> + memcpy((char *)(res + p->num_gpmc_res), (const char *)p->per_res,
>> + sizeof(struct resource) * p->num_per_res);
>> +
>> + pdev = platform_device_register_resndata(gpmc->dev, p->name, p->id,
>> + res, num, p->pdata, p->pdata_size);
>> +
>> + devm_kfree(gpmc->dev, res);
>> +
>> + return pdev;
>> }
>> -postcore_initcall(gpmc_init);
>>
>> static irqreturn_t gpmc_handle_irq(int irq, void *dev)
>> {
>> - u8 cs;
>> + int i;
>> + u32 regval;
>> + struct gpmc *gpmc = dev;
>>
>> - /* check cs to invoke the irq */
>> - cs = ((gpmc_read_reg(GPMC_PREFETCH_CONFIG1))>> CS_NUM_SHIFT)& 0x7;
>> - if (OMAP_GPMC_IRQ_BASE+cs<= OMAP_GPMC_IRQ_END)
>> - generic_handle_irq(OMAP_GPMC_IRQ_BASE+cs);
>> + regval = gpmc_read_reg(GPMC_IRQSTATUS);
>> +
>> +
>> + for (i = 0; i< gpmc->num_irq; i++)
>> + if (regval& gpmc->irq[i].regval)
>> + generic_handle_irq(gpmc->irq[i].irq);
>> + gpmc_write_reg(GPMC_IRQSTATUS, regval);
>>
>> return IRQ_HANDLED;
>> }
>>
>> +static int gpmc_irq_endis(struct irq_data *p, bool endis)
>> +{
>> + struct gpmc *gpmc = irq_data_get_irq_chip_data(p);
>> + int i;
>> + u32 regval;
>> +
>> + for (i = 0; i< gpmc->num_irq; i++)
>> + if (p->irq == gpmc->irq[i].irq) {
>> + regval = gpmc_read_reg(GPMC_IRQENABLE);
>> + if (endis)
>> + regval |= gpmc->irq[i].regval;
>> + else
>> + regval&= ~gpmc->irq[i].regval;
>> + gpmc_write_reg(GPMC_IRQENABLE, regval);
>> + break;
>> + }
>> +
>> + return 0;
>> +}
>> +
>> +static void gpmc_irq_disable(struct irq_data *p)
>> +{
>> + gpmc_irq_endis(p, false);
>> +}
>> +
>> +static void gpmc_irq_enable(struct irq_data *p)
>> +{
>> + gpmc_irq_endis(p, true);
>> +}
>> +
>> +static void gpmc_irq_noop(struct irq_data *data) { }
>> +
>> +static unsigned int gpmc_irq_noop_ret(struct irq_data *data) { return
>> 0; }
>> +
>> +static __devinit int gpmc_setup_irq(struct gpmc *gpmc)
>> +{
>> + int i;
>> + u32 regval;
>> +
>> + if (!gpmc->master_irq)
>> + return -EINVAL;
>> +
>> + if (gpmc->num_irq< GPMC_NR_IRQ) {
>> + dev_warn(gpmc->dev, "Insufficient interrupts for device\n");
>> + return -EINVAL;
>> + } else if (gpmc->num_irq> GPMC_NR_IRQ)
>> + gpmc->num_irq = GPMC_NR_IRQ;
>
> Hmmm ... why not just have ...
>
> if (gpmc->num_irq != GPMC_NR_IRQ) {
> dev_warn(...);
> return -EINVAL;
> }
>
> This also raises the question why bother passing num_irq if we always
> want it to be GPMC_NR_IRQ? Why not always initialise them all driver?
>
>> + gpmc->irq[0].regval = GPMC_IRQ_FIFOEVENT;
>> + gpmc->irq[1].regval = GPMC_IRQ_TERMINALCOUNT;
>> + gpmc->irq[2].regval = GPMC_IRQ_WAIT0EDGEDETECTION;
>> + gpmc->irq[3].regval = GPMC_IRQ_WAIT1EDGEDETECTION;
>> + gpmc->irq[4].regval = GPMC_IRQ_WAIT2EDGEDETECTION;
>> + gpmc->irq[5].regval = GPMC_IRQ_WAIT3EDGEDETECTION;
We need to be careful here, OMAP4 and OMAP5 devices only have 3 wait
pins. Hence, one less interrupt.
We may need to add a check on GPMC IP revision here.
Cheers
Jon
^ permalink raw reply [flat|nested] 73+ messages in thread
* [PATCH v3 1/9] ARM: OMAP2+: gpmc: driver conversion
@ 2012-04-05 20:34 ` Jon Hunter
0 siblings, 0 replies; 73+ messages in thread
From: Jon Hunter @ 2012-04-05 20:34 UTC (permalink / raw)
To: linux-arm-kernel
Hi Afzal,
On 04/05/2012 03:21 PM, Jon Hunter wrote:
> Hi Afzal,
>
> On 04/05/2012 10:45 AM, Afzal Mohammed wrote:
>
> [...]
>
>> +struct gpmc_irq {
>> + unsigned irq;
>> + u32 regval;
>
> Are you using regval to indicate the bit-mask? If so, maybe call it
> "bitmask" instead.
>
> [...]
>
>> +static __devinit
>> +int gpmc_setup_cs_irq(struct gpmc *gpmc, struct gpmc_device_pdata *gdp,
>> + struct gpmc_cs_data *cs, struct resource *res)
>> +{
>> + int i, n, val;
>> +
>> + for (i = 0, n = 0; i< gpmc->num_irq; i++)
>> + if (gpmc->irq[i].regval& cs->irq_flags) {
>> + res[n].start = res[n].end = gpmc->irq[i].irq;
>> + res[n].flags = IORESOURCE_IRQ;
>> +
>> + dev_info(gpmc->dev, "resource irq %u for %s "
>> + "(on CS %d) [bit: %x]\n", res[n].start,
>> + gdp->name, cs->cs, __ffs(gpmc->irq[i].regval));
>> +
>> + switch (gpmc->irq[i].regval) {
>> + case GPMC_IRQ_WAIT0EDGEDETECTION:
>> + case GPMC_IRQ_WAIT1EDGEDETECTION:
>> + case GPMC_IRQ_WAIT2EDGEDETECTION:
>> + case GPMC_IRQ_WAIT3EDGEDETECTION:
>> + val = __ffs(gpmc->irq[i].regval);
>> + val -= __ffs(GPMC_IRQ_WAIT0EDGEDETECTION);
>> + gpmc_cs_configure(cs->cs,
>> + GPMC_CONFIG_WAITPIN, val);
>
> Why is the configuration of the wait pin done here? It is possible to
> use the wait pin may be used without enabling the interrupt.
Sorry very bad english here on my part. I meant "it is possible to use a
wait pin, without enabling the interrupt".
> Where do you handle allocating the wait pins to ensure two devices don't
> attempt to use the same one? Like how the CS are managed.
>
> Also, where you you configure the polarity of the wait pins? I would
> have thought it would make sense to have the wait pin configured as part
> of the cs configuration.
>
>> + }
>> + n++;
>> + }
>> +
>> + return n;
>> +}
>> +
>> +static __devinit int gpmc_setup_device(struct gpmc_device_pdata *gdp,
>> + struct gpmc_device *dev, struct gpmc *gpmc)
>> +{
>> + int i, j, n;
>> + struct gpmc_cs_data *cs;
>> +
>> + for (i = 0, n = 0, cs = gdp->cs_data; i< gdp->num_cs; i++, cs++)
>> + n += hweight32(cs->irq_flags& GPMC_IRQ_MASK);
>> +
>> + n += gdp->num_cs;
>> +
>> + dev->gpmc_res = devm_kzalloc(gpmc->dev, sizeof(*dev->gpmc_res) * n,
>> + GFP_KERNEL);
>> + if (dev->gpmc_res == NULL) {
>> + dev_err(gpmc->dev, "error: memory allocation\n");
>> + return -ENOMEM;
>> + }
>> +
>> + for (i = 0, j = 0, cs = gdp->cs_data; i< gdp->num_cs; cs++, i++) {
>> + dev->gpmc_res[j] = gpmc_setup_cs_mem(cs, gdp, gpmc);
>> + if (dev->gpmc_res[j++].flags& IORESOURCE_MEM)
>> + j += gpmc_setup_cs_irq(gpmc, gdp, cs,
>> + dev->gpmc_res + j);
>> + else {
>> + dev_err(gpmc->dev, "error: setup for %s\n", gdp->name);
>> + devm_kfree(gpmc->dev, dev->gpmc_res);
>> + dev->gpmc_res = NULL;
>> + dev->num_gpmc_res = 0;
>> + return -EINVAL;
>> + }
>> }
>
> This section of code is not straight-forward to read. I see what you are
> doing, but I am wondering if this could be improved.
>
> First of all, returning a structure from a function is making this code
> harder to read. Per the CodingStyle document in the kernel, it is
> preferred for a function to return success or failure if the function is
> an action, like a setup.
>
> Secondly, do you need to pass cs, gdp and gpmc to gpmc_setup_cs_mem()?
> It appears that gdp and gpmc are only used for prints. You could
> probably avoid passing gdp and move the print to outside this function.
>
>> + dev->num_gpmc_res = j;
>>
>> - ret = request_irq(gpmc_irq,
>> - gpmc_handle_irq, IRQF_SHARED, "gpmc", gpmc_base);
>> - if (ret)
>> - pr_err("gpmc: irq-%d could not claim: err %d\n",
>> - gpmc_irq, ret);
>> - return ret;
>> + dev->name = gdp->name;
>> + dev->id = gdp->id;
>> + dev->pdata = gdp->pdata;
>> + dev->pdata_size = gdp->pdata_size;
>> + dev->per_res = gdp->per_res;
>> + dev->num_per_res = gdp->num_per_res;
>> +
>> + return 0;
>> +}
>> +
>> +static __devinit
>> +struct platform_device *gpmc_create_device(struct gpmc_device *p,
>> + struct gpmc *gpmc)
>> +{
>> + int num = p->num_per_res + p->num_gpmc_res;
>> + struct resource *res;
>> + struct platform_device *pdev;
>> +
>> + res = devm_kzalloc(gpmc->dev, sizeof(struct resource) * num,
>> + GFP_KERNEL);
>> + if (!res) {
>> + dev_err(gpmc->dev, "error: allocating memory\n");
>> + return NULL;
>> + }
>> +
>> + memcpy((char *)res, (const char *) p->gpmc_res,
>> + sizeof(struct resource) * p->num_gpmc_res);
>> + memcpy((char *)(res + p->num_gpmc_res), (const char *)p->per_res,
>> + sizeof(struct resource) * p->num_per_res);
>> +
>> + pdev = platform_device_register_resndata(gpmc->dev, p->name, p->id,
>> + res, num, p->pdata, p->pdata_size);
>> +
>> + devm_kfree(gpmc->dev, res);
>> +
>> + return pdev;
>> }
>> -postcore_initcall(gpmc_init);
>>
>> static irqreturn_t gpmc_handle_irq(int irq, void *dev)
>> {
>> - u8 cs;
>> + int i;
>> + u32 regval;
>> + struct gpmc *gpmc = dev;
>>
>> - /* check cs to invoke the irq */
>> - cs = ((gpmc_read_reg(GPMC_PREFETCH_CONFIG1))>> CS_NUM_SHIFT)& 0x7;
>> - if (OMAP_GPMC_IRQ_BASE+cs<= OMAP_GPMC_IRQ_END)
>> - generic_handle_irq(OMAP_GPMC_IRQ_BASE+cs);
>> + regval = gpmc_read_reg(GPMC_IRQSTATUS);
>> +
>> +
>> + for (i = 0; i< gpmc->num_irq; i++)
>> + if (regval& gpmc->irq[i].regval)
>> + generic_handle_irq(gpmc->irq[i].irq);
>> + gpmc_write_reg(GPMC_IRQSTATUS, regval);
>>
>> return IRQ_HANDLED;
>> }
>>
>> +static int gpmc_irq_endis(struct irq_data *p, bool endis)
>> +{
>> + struct gpmc *gpmc = irq_data_get_irq_chip_data(p);
>> + int i;
>> + u32 regval;
>> +
>> + for (i = 0; i< gpmc->num_irq; i++)
>> + if (p->irq == gpmc->irq[i].irq) {
>> + regval = gpmc_read_reg(GPMC_IRQENABLE);
>> + if (endis)
>> + regval |= gpmc->irq[i].regval;
>> + else
>> + regval&= ~gpmc->irq[i].regval;
>> + gpmc_write_reg(GPMC_IRQENABLE, regval);
>> + break;
>> + }
>> +
>> + return 0;
>> +}
>> +
>> +static void gpmc_irq_disable(struct irq_data *p)
>> +{
>> + gpmc_irq_endis(p, false);
>> +}
>> +
>> +static void gpmc_irq_enable(struct irq_data *p)
>> +{
>> + gpmc_irq_endis(p, true);
>> +}
>> +
>> +static void gpmc_irq_noop(struct irq_data *data) { }
>> +
>> +static unsigned int gpmc_irq_noop_ret(struct irq_data *data) { return
>> 0; }
>> +
>> +static __devinit int gpmc_setup_irq(struct gpmc *gpmc)
>> +{
>> + int i;
>> + u32 regval;
>> +
>> + if (!gpmc->master_irq)
>> + return -EINVAL;
>> +
>> + if (gpmc->num_irq< GPMC_NR_IRQ) {
>> + dev_warn(gpmc->dev, "Insufficient interrupts for device\n");
>> + return -EINVAL;
>> + } else if (gpmc->num_irq> GPMC_NR_IRQ)
>> + gpmc->num_irq = GPMC_NR_IRQ;
>
> Hmmm ... why not just have ...
>
> if (gpmc->num_irq != GPMC_NR_IRQ) {
> dev_warn(...);
> return -EINVAL;
> }
>
> This also raises the question why bother passing num_irq if we always
> want it to be GPMC_NR_IRQ? Why not always initialise them all driver?
>
>> + gpmc->irq[0].regval = GPMC_IRQ_FIFOEVENT;
>> + gpmc->irq[1].regval = GPMC_IRQ_TERMINALCOUNT;
>> + gpmc->irq[2].regval = GPMC_IRQ_WAIT0EDGEDETECTION;
>> + gpmc->irq[3].regval = GPMC_IRQ_WAIT1EDGEDETECTION;
>> + gpmc->irq[4].regval = GPMC_IRQ_WAIT2EDGEDETECTION;
>> + gpmc->irq[5].regval = GPMC_IRQ_WAIT3EDGEDETECTION;
We need to be careful here, OMAP4 and OMAP5 devices only have 3 wait
pins. Hence, one less interrupt.
We may need to add a check on GPMC IP revision here.
Cheers
Jon
^ permalink raw reply [flat|nested] 73+ messages in thread
* RE: [PATCH v3 1/9] ARM: OMAP2+: gpmc: driver conversion
2012-04-05 20:21 ` Jon Hunter
(?)
(?)
@ 2012-04-06 6:52 ` Mohammed, Afzal
-1 siblings, 0 replies; 73+ messages in thread
From: Mohammed, Afzal @ 2012-04-06 6:52 UTC (permalink / raw)
To: Hunter, Jon
Cc: tony, Hilman, Kevin, linux, dwmw2, sameo, grinberg, mike, Menon,
Nishanth, artem.bityutskiy, vimal.newwork, dbaryshkov,
linux-omap, linux-arm-kernel, linux-mtd, linux-kernel, Hiremath,
Vaibhav
Hi Jon,
On Fri, Apr 06, 2012 at 01:51:41, Hunter, Jon wrote:
> > +struct gpmc_irq {
> > + unsigned irq;
> > + u32 regval;
>
> Are you using regval to indicate the bit-mask? If so, maybe call it
> "bitmask" instead.
Yes, bitmask would be better.
> > + switch (gpmc->irq[i].regval) {
> > + case GPMC_IRQ_WAIT0EDGEDETECTION:
> > + case GPMC_IRQ_WAIT1EDGEDETECTION:
> > + case GPMC_IRQ_WAIT2EDGEDETECTION:
> > + case GPMC_IRQ_WAIT3EDGEDETECTION:
> > + val = __ffs(gpmc->irq[i].regval);
> > + val -= __ffs(GPMC_IRQ_WAIT0EDGEDETECTION);
> > + gpmc_cs_configure(cs->cs,
> > + GPMC_CONFIG_WAITPIN, val);
>
> Why is the configuration of the wait pin done here? It is possible to
> use the wait pin may be used without enabling the interrupt.
>
> Where do you handle allocating the wait pins to ensure two devices don't
> attempt to use the same one? Like how the CS are managed.
>
> Also, where you you configure the polarity of the wait pins? I would
> have thought it would make sense to have the wait pin configured as part
> of the cs configuration.
I will revisit waitpin configurations.
> > + for (i = 0, j = 0, cs = gdp->cs_data; i< gdp->num_cs; cs++, i++) {
> > + dev->gpmc_res[j] = gpmc_setup_cs_mem(cs, gdp, gpmc);
> > + if (dev->gpmc_res[j++].flags& IORESOURCE_MEM)
> > + j += gpmc_setup_cs_irq(gpmc, gdp, cs,
> > + dev->gpmc_res + j);
> > + else {
> > + dev_err(gpmc->dev, "error: setup for %s\n", gdp->name);
> > + devm_kfree(gpmc->dev, dev->gpmc_res);
> > + dev->gpmc_res = NULL;
> > + dev->num_gpmc_res = 0;
> > + return -EINVAL;
> > + }
> > }
>
> This section of code is not straight-forward to read. I see what you are
> doing, but I am wondering if this could be improved.
>
> First of all, returning a structure from a function is making this code
> harder to read. Per the CodingStyle document in the kernel, it is
> preferred for a function to return success or failure if the function is
> an action, like a setup.
>
> Secondly, do you need to pass cs, gdp and gpmc to gpmc_setup_cs_mem()?
> It appears that gdp and gpmc are only used for prints. You could
> probably avoid passing gdp and move the print to outside this function.
This section will be modified to make it clearer.
> > + if (gpmc->num_irq< GPMC_NR_IRQ) {
> > + dev_warn(gpmc->dev, "Insufficient interrupts for device\n");
> > + return -EINVAL;
> > + } else if (gpmc->num_irq> GPMC_NR_IRQ)
> > + gpmc->num_irq = GPMC_NR_IRQ;
>
> Hmmm ... why not just have ...
>
> if (gpmc->num_irq != GPMC_NR_IRQ) {
> dev_warn(...);
> return -EINVAL;
> }
This will cause irq setup to fail if num_irq > GPMC_NR_IRQ, even though
irq setup could have been done w/o any problem, only because platform
indicated willingness to accommodate more number of interrupts than
actually required for this device.
> This also raises the question why bother passing num_irq if we always
> want it to be GPMC_NR_IRQ? Why not always initialise them all driver?
Because num_irq (or available irqs for fictitious irq chip) is platform specific.
> > + res = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
> > + if (res == NULL)
> > + dev_warn(gpmc->dev, "Failed to get resource: irq\n");
> > + else
> > + gpmc->master_irq = res->start;
>
> Why not return an error if the IRQ is not found? We don't know if anyone
> will be trying to use them.
Why do you want to do that ?
If someone (say NAND) wants to work with irq, and if interrupt is not
available, NAND driver can fail, and suppose smsc911x ethernet is present
and he is not using gpmc irq, if we fail here, smsc911x also would
not work, which would have worked otherwise.
It is a different matter that even NAND setup will happen properly,
even if interrupt is not available, it is only when NAND is told to
work with IRQ, it fails, please see nand patches.
And as of now in mainline (with the code as is), there is not a single
board that will need gpmc irq for gpmc peripherals to work.
I feel we should try to get more devices working rather than preventing
more devices from working, when it could have.
> > + for (gdq = gp->device_pdata, gd = gpmc->device; *gdq; gdq++, i++) {
> > + ret = gpmc_setup_device(*gdq, gd, gpmc);
> > + if (IS_ERR_VALUE(ret))
> > + dev_err(gpmc->dev, "gpmc setup on %s failed\n",
> > + (*gdq)->name);
> > + else
> > + gd++;
> > + }
>
> Would a while loop be simpler?
My preference is to go with "for"
>
> The above loop appears to terminate when *gdq == 0. Is this always
> guaranteed? In other words, safe?
This is a standard idiom for array of pointers
>
> I see that "i" is not being used in the above loop either.
That was left over code, it will be removed.
> > +struct gpmc_cs_data {
> > + unsigned cs;
> > + unsigned long mem_size;
> > + unsigned long mem_start;
> > + unsigned long mem_offset;
> > + struct gpmc_config *config;
> > + unsigned num_config;
> > + struct gpmc_timings *timing;
> > + unsigned irq_flags;
>
> I found the name irq_flags a bit unclear. This appears to be a mask for
> the interrupts used. So may be this should be "irq_mask" or just "irqs".
Probably, this confusion arose as an attempt was made to club irq bit fields
with irq capability, so as to reduce additional macro definitions.
Here my preference is to keep irq_flags (or can be irq_capabilities), define
a new set of macros, and use bitmask in struct gpmc_irq
Thanks for the comments.
Regards
Afzal
^ permalink raw reply [flat|nested] 73+ messages in thread
* RE: [PATCH v3 1/9] ARM: OMAP2+: gpmc: driver conversion
@ 2012-04-06 6:52 ` Mohammed, Afzal
0 siblings, 0 replies; 73+ messages in thread
From: Mohammed, Afzal @ 2012-04-06 6:52 UTC (permalink / raw)
To: Hunter, Jon
Cc: tony, Hilman, Kevin, linux, dwmw2, sameo, grinberg, mike, Menon,
Nishanth, artem.bityutskiy, vimal.newwork, dbaryshkov,
linux-omap, linux-arm-kernel, linux-mtd, linux-kernel, Hiremath,
Vaibhav
Hi Jon,
On Fri, Apr 06, 2012 at 01:51:41, Hunter, Jon wrote:
> > +struct gpmc_irq {
> > + unsigned irq;
> > + u32 regval;
>
> Are you using regval to indicate the bit-mask? If so, maybe call it
> "bitmask" instead.
Yes, bitmask would be better.
> > + switch (gpmc->irq[i].regval) {
> > + case GPMC_IRQ_WAIT0EDGEDETECTION:
> > + case GPMC_IRQ_WAIT1EDGEDETECTION:
> > + case GPMC_IRQ_WAIT2EDGEDETECTION:
> > + case GPMC_IRQ_WAIT3EDGEDETECTION:
> > + val = __ffs(gpmc->irq[i].regval);
> > + val -= __ffs(GPMC_IRQ_WAIT0EDGEDETECTION);
> > + gpmc_cs_configure(cs->cs,
> > + GPMC_CONFIG_WAITPIN, val);
>
> Why is the configuration of the wait pin done here? It is possible to
> use the wait pin may be used without enabling the interrupt.
>
> Where do you handle allocating the wait pins to ensure two devices don't
> attempt to use the same one? Like how the CS are managed.
>
> Also, where you you configure the polarity of the wait pins? I would
> have thought it would make sense to have the wait pin configured as part
> of the cs configuration.
I will revisit waitpin configurations.
> > + for (i = 0, j = 0, cs = gdp->cs_data; i< gdp->num_cs; cs++, i++) {
> > + dev->gpmc_res[j] = gpmc_setup_cs_mem(cs, gdp, gpmc);
> > + if (dev->gpmc_res[j++].flags& IORESOURCE_MEM)
> > + j += gpmc_setup_cs_irq(gpmc, gdp, cs,
> > + dev->gpmc_res + j);
> > + else {
> > + dev_err(gpmc->dev, "error: setup for %s\n", gdp->name);
> > + devm_kfree(gpmc->dev, dev->gpmc_res);
> > + dev->gpmc_res = NULL;
> > + dev->num_gpmc_res = 0;
> > + return -EINVAL;
> > + }
> > }
>
> This section of code is not straight-forward to read. I see what you are
> doing, but I am wondering if this could be improved.
>
> First of all, returning a structure from a function is making this code
> harder to read. Per the CodingStyle document in the kernel, it is
> preferred for a function to return success or failure if the function is
> an action, like a setup.
>
> Secondly, do you need to pass cs, gdp and gpmc to gpmc_setup_cs_mem()?
> It appears that gdp and gpmc are only used for prints. You could
> probably avoid passing gdp and move the print to outside this function.
This section will be modified to make it clearer.
> > + if (gpmc->num_irq< GPMC_NR_IRQ) {
> > + dev_warn(gpmc->dev, "Insufficient interrupts for device\n");
> > + return -EINVAL;
> > + } else if (gpmc->num_irq> GPMC_NR_IRQ)
> > + gpmc->num_irq = GPMC_NR_IRQ;
>
> Hmmm ... why not just have ...
>
> if (gpmc->num_irq != GPMC_NR_IRQ) {
> dev_warn(...);
> return -EINVAL;
> }
This will cause irq setup to fail if num_irq > GPMC_NR_IRQ, even though
irq setup could have been done w/o any problem, only because platform
indicated willingness to accommodate more number of interrupts than
actually required for this device.
> This also raises the question why bother passing num_irq if we always
> want it to be GPMC_NR_IRQ? Why not always initialise them all driver?
Because num_irq (or available irqs for fictitious irq chip) is platform specific.
> > + res = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
> > + if (res == NULL)
> > + dev_warn(gpmc->dev, "Failed to get resource: irq\n");
> > + else
> > + gpmc->master_irq = res->start;
>
> Why not return an error if the IRQ is not found? We don't know if anyone
> will be trying to use them.
Why do you want to do that ?
If someone (say NAND) wants to work with irq, and if interrupt is not
available, NAND driver can fail, and suppose smsc911x ethernet is present
and he is not using gpmc irq, if we fail here, smsc911x also would
not work, which would have worked otherwise.
It is a different matter that even NAND setup will happen properly,
even if interrupt is not available, it is only when NAND is told to
work with IRQ, it fails, please see nand patches.
And as of now in mainline (with the code as is), there is not a single
board that will need gpmc irq for gpmc peripherals to work.
I feel we should try to get more devices working rather than preventing
more devices from working, when it could have.
> > + for (gdq = gp->device_pdata, gd = gpmc->device; *gdq; gdq++, i++) {
> > + ret = gpmc_setup_device(*gdq, gd, gpmc);
> > + if (IS_ERR_VALUE(ret))
> > + dev_err(gpmc->dev, "gpmc setup on %s failed\n",
> > + (*gdq)->name);
> > + else
> > + gd++;
> > + }
>
> Would a while loop be simpler?
My preference is to go with "for"
>
> The above loop appears to terminate when *gdq == 0. Is this always
> guaranteed? In other words, safe?
This is a standard idiom for array of pointers
>
> I see that "i" is not being used in the above loop either.
That was left over code, it will be removed.
> > +struct gpmc_cs_data {
> > + unsigned cs;
> > + unsigned long mem_size;
> > + unsigned long mem_start;
> > + unsigned long mem_offset;
> > + struct gpmc_config *config;
> > + unsigned num_config;
> > + struct gpmc_timings *timing;
> > + unsigned irq_flags;
>
> I found the name irq_flags a bit unclear. This appears to be a mask for
> the interrupts used. So may be this should be "irq_mask" or just "irqs".
Probably, this confusion arose as an attempt was made to club irq bit fields
with irq capability, so as to reduce additional macro definitions.
Here my preference is to keep irq_flags (or can be irq_capabilities), define
a new set of macros, and use bitmask in struct gpmc_irq
Thanks for the comments.
Regards
Afzal
^ permalink raw reply [flat|nested] 73+ messages in thread
* RE: [PATCH v3 1/9] ARM: OMAP2+: gpmc: driver conversion
@ 2012-04-06 6:52 ` Mohammed, Afzal
0 siblings, 0 replies; 73+ messages in thread
From: Mohammed, Afzal @ 2012-04-06 6:52 UTC (permalink / raw)
To: Hunter, Jon
Cc: Hilman, Kevin, Menon, Nishanth, linux, sameo, tony,
artem.bityutskiy, linux-kernel, Hiremath, Vaibhav, dbaryshkov,
vimal.newwork, grinberg, mike, linux-mtd, linux-omap, dwmw2,
linux-arm-kernel
Hi Jon,
On Fri, Apr 06, 2012 at 01:51:41, Hunter, Jon wrote:
> > +struct gpmc_irq {
> > + unsigned irq;
> > + u32 regval;
>
> Are you using regval to indicate the bit-mask? If so, maybe call it
> "bitmask" instead.
Yes, bitmask would be better.
> > + switch (gpmc->irq[i].regval) {
> > + case GPMC_IRQ_WAIT0EDGEDETECTION:
> > + case GPMC_IRQ_WAIT1EDGEDETECTION:
> > + case GPMC_IRQ_WAIT2EDGEDETECTION:
> > + case GPMC_IRQ_WAIT3EDGEDETECTION:
> > + val = __ffs(gpmc->irq[i].regval);
> > + val -= __ffs(GPMC_IRQ_WAIT0EDGEDETECTION);
> > + gpmc_cs_configure(cs->cs,
> > + GPMC_CONFIG_WAITPIN, val);
>
> Why is the configuration of the wait pin done here? It is possible to
> use the wait pin may be used without enabling the interrupt.
>
> Where do you handle allocating the wait pins to ensure two devices don't
> attempt to use the same one? Like how the CS are managed.
>
> Also, where you you configure the polarity of the wait pins? I would
> have thought it would make sense to have the wait pin configured as part
> of the cs configuration.
I will revisit waitpin configurations.
> > + for (i = 0, j = 0, cs = gdp->cs_data; i< gdp->num_cs; cs++, i++) {
> > + dev->gpmc_res[j] = gpmc_setup_cs_mem(cs, gdp, gpmc);
> > + if (dev->gpmc_res[j++].flags& IORESOURCE_MEM)
> > + j += gpmc_setup_cs_irq(gpmc, gdp, cs,
> > + dev->gpmc_res + j);
> > + else {
> > + dev_err(gpmc->dev, "error: setup for %s\n", gdp->name);
> > + devm_kfree(gpmc->dev, dev->gpmc_res);
> > + dev->gpmc_res = NULL;
> > + dev->num_gpmc_res = 0;
> > + return -EINVAL;
> > + }
> > }
>
> This section of code is not straight-forward to read. I see what you are
> doing, but I am wondering if this could be improved.
>
> First of all, returning a structure from a function is making this code
> harder to read. Per the CodingStyle document in the kernel, it is
> preferred for a function to return success or failure if the function is
> an action, like a setup.
>
> Secondly, do you need to pass cs, gdp and gpmc to gpmc_setup_cs_mem()?
> It appears that gdp and gpmc are only used for prints. You could
> probably avoid passing gdp and move the print to outside this function.
This section will be modified to make it clearer.
> > + if (gpmc->num_irq< GPMC_NR_IRQ) {
> > + dev_warn(gpmc->dev, "Insufficient interrupts for device\n");
> > + return -EINVAL;
> > + } else if (gpmc->num_irq> GPMC_NR_IRQ)
> > + gpmc->num_irq = GPMC_NR_IRQ;
>
> Hmmm ... why not just have ...
>
> if (gpmc->num_irq != GPMC_NR_IRQ) {
> dev_warn(...);
> return -EINVAL;
> }
This will cause irq setup to fail if num_irq > GPMC_NR_IRQ, even though
irq setup could have been done w/o any problem, only because platform
indicated willingness to accommodate more number of interrupts than
actually required for this device.
> This also raises the question why bother passing num_irq if we always
> want it to be GPMC_NR_IRQ? Why not always initialise them all driver?
Because num_irq (or available irqs for fictitious irq chip) is platform specific.
> > + res = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
> > + if (res == NULL)
> > + dev_warn(gpmc->dev, "Failed to get resource: irq\n");
> > + else
> > + gpmc->master_irq = res->start;
>
> Why not return an error if the IRQ is not found? We don't know if anyone
> will be trying to use them.
Why do you want to do that ?
If someone (say NAND) wants to work with irq, and if interrupt is not
available, NAND driver can fail, and suppose smsc911x ethernet is present
and he is not using gpmc irq, if we fail here, smsc911x also would
not work, which would have worked otherwise.
It is a different matter that even NAND setup will happen properly,
even if interrupt is not available, it is only when NAND is told to
work with IRQ, it fails, please see nand patches.
And as of now in mainline (with the code as is), there is not a single
board that will need gpmc irq for gpmc peripherals to work.
I feel we should try to get more devices working rather than preventing
more devices from working, when it could have.
> > + for (gdq = gp->device_pdata, gd = gpmc->device; *gdq; gdq++, i++) {
> > + ret = gpmc_setup_device(*gdq, gd, gpmc);
> > + if (IS_ERR_VALUE(ret))
> > + dev_err(gpmc->dev, "gpmc setup on %s failed\n",
> > + (*gdq)->name);
> > + else
> > + gd++;
> > + }
>
> Would a while loop be simpler?
My preference is to go with "for"
>
> The above loop appears to terminate when *gdq == 0. Is this always
> guaranteed? In other words, safe?
This is a standard idiom for array of pointers
>
> I see that "i" is not being used in the above loop either.
That was left over code, it will be removed.
> > +struct gpmc_cs_data {
> > + unsigned cs;
> > + unsigned long mem_size;
> > + unsigned long mem_start;
> > + unsigned long mem_offset;
> > + struct gpmc_config *config;
> > + unsigned num_config;
> > + struct gpmc_timings *timing;
> > + unsigned irq_flags;
>
> I found the name irq_flags a bit unclear. This appears to be a mask for
> the interrupts used. So may be this should be "irq_mask" or just "irqs".
Probably, this confusion arose as an attempt was made to club irq bit fields
with irq capability, so as to reduce additional macro definitions.
Here my preference is to keep irq_flags (or can be irq_capabilities), define
a new set of macros, and use bitmask in struct gpmc_irq
Thanks for the comments.
Regards
Afzal
^ permalink raw reply [flat|nested] 73+ messages in thread
* [PATCH v3 1/9] ARM: OMAP2+: gpmc: driver conversion
@ 2012-04-06 6:52 ` Mohammed, Afzal
0 siblings, 0 replies; 73+ messages in thread
From: Mohammed, Afzal @ 2012-04-06 6:52 UTC (permalink / raw)
To: linux-arm-kernel
Hi Jon,
On Fri, Apr 06, 2012 at 01:51:41, Hunter, Jon wrote:
> > +struct gpmc_irq {
> > + unsigned irq;
> > + u32 regval;
>
> Are you using regval to indicate the bit-mask? If so, maybe call it
> "bitmask" instead.
Yes, bitmask would be better.
> > + switch (gpmc->irq[i].regval) {
> > + case GPMC_IRQ_WAIT0EDGEDETECTION:
> > + case GPMC_IRQ_WAIT1EDGEDETECTION:
> > + case GPMC_IRQ_WAIT2EDGEDETECTION:
> > + case GPMC_IRQ_WAIT3EDGEDETECTION:
> > + val = __ffs(gpmc->irq[i].regval);
> > + val -= __ffs(GPMC_IRQ_WAIT0EDGEDETECTION);
> > + gpmc_cs_configure(cs->cs,
> > + GPMC_CONFIG_WAITPIN, val);
>
> Why is the configuration of the wait pin done here? It is possible to
> use the wait pin may be used without enabling the interrupt.
>
> Where do you handle allocating the wait pins to ensure two devices don't
> attempt to use the same one? Like how the CS are managed.
>
> Also, where you you configure the polarity of the wait pins? I would
> have thought it would make sense to have the wait pin configured as part
> of the cs configuration.
I will revisit waitpin configurations.
> > + for (i = 0, j = 0, cs = gdp->cs_data; i< gdp->num_cs; cs++, i++) {
> > + dev->gpmc_res[j] = gpmc_setup_cs_mem(cs, gdp, gpmc);
> > + if (dev->gpmc_res[j++].flags& IORESOURCE_MEM)
> > + j += gpmc_setup_cs_irq(gpmc, gdp, cs,
> > + dev->gpmc_res + j);
> > + else {
> > + dev_err(gpmc->dev, "error: setup for %s\n", gdp->name);
> > + devm_kfree(gpmc->dev, dev->gpmc_res);
> > + dev->gpmc_res = NULL;
> > + dev->num_gpmc_res = 0;
> > + return -EINVAL;
> > + }
> > }
>
> This section of code is not straight-forward to read. I see what you are
> doing, but I am wondering if this could be improved.
>
> First of all, returning a structure from a function is making this code
> harder to read. Per the CodingStyle document in the kernel, it is
> preferred for a function to return success or failure if the function is
> an action, like a setup.
>
> Secondly, do you need to pass cs, gdp and gpmc to gpmc_setup_cs_mem()?
> It appears that gdp and gpmc are only used for prints. You could
> probably avoid passing gdp and move the print to outside this function.
This section will be modified to make it clearer.
> > + if (gpmc->num_irq< GPMC_NR_IRQ) {
> > + dev_warn(gpmc->dev, "Insufficient interrupts for device\n");
> > + return -EINVAL;
> > + } else if (gpmc->num_irq> GPMC_NR_IRQ)
> > + gpmc->num_irq = GPMC_NR_IRQ;
>
> Hmmm ... why not just have ...
>
> if (gpmc->num_irq != GPMC_NR_IRQ) {
> dev_warn(...);
> return -EINVAL;
> }
This will cause irq setup to fail if num_irq > GPMC_NR_IRQ, even though
irq setup could have been done w/o any problem, only because platform
indicated willingness to accommodate more number of interrupts than
actually required for this device.
> This also raises the question why bother passing num_irq if we always
> want it to be GPMC_NR_IRQ? Why not always initialise them all driver?
Because num_irq (or available irqs for fictitious irq chip) is platform specific.
> > + res = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
> > + if (res == NULL)
> > + dev_warn(gpmc->dev, "Failed to get resource: irq\n");
> > + else
> > + gpmc->master_irq = res->start;
>
> Why not return an error if the IRQ is not found? We don't know if anyone
> will be trying to use them.
Why do you want to do that ?
If someone (say NAND) wants to work with irq, and if interrupt is not
available, NAND driver can fail, and suppose smsc911x ethernet is present
and he is not using gpmc irq, if we fail here, smsc911x also would
not work, which would have worked otherwise.
It is a different matter that even NAND setup will happen properly,
even if interrupt is not available, it is only when NAND is told to
work with IRQ, it fails, please see nand patches.
And as of now in mainline (with the code as is), there is not a single
board that will need gpmc irq for gpmc peripherals to work.
I feel we should try to get more devices working rather than preventing
more devices from working, when it could have.
> > + for (gdq = gp->device_pdata, gd = gpmc->device; *gdq; gdq++, i++) {
> > + ret = gpmc_setup_device(*gdq, gd, gpmc);
> > + if (IS_ERR_VALUE(ret))
> > + dev_err(gpmc->dev, "gpmc setup on %s failed\n",
> > + (*gdq)->name);
> > + else
> > + gd++;
> > + }
>
> Would a while loop be simpler?
My preference is to go with "for"
>
> The above loop appears to terminate when *gdq == 0. Is this always
> guaranteed? In other words, safe?
This is a standard idiom for array of pointers
>
> I see that "i" is not being used in the above loop either.
That was left over code, it will be removed.
> > +struct gpmc_cs_data {
> > + unsigned cs;
> > + unsigned long mem_size;
> > + unsigned long mem_start;
> > + unsigned long mem_offset;
> > + struct gpmc_config *config;
> > + unsigned num_config;
> > + struct gpmc_timings *timing;
> > + unsigned irq_flags;
>
> I found the name irq_flags a bit unclear. This appears to be a mask for
> the interrupts used. So may be this should be "irq_mask" or just "irqs".
Probably, this confusion arose as an attempt was made to club irq bit fields
with irq capability, so as to reduce additional macro definitions.
Here my preference is to keep irq_flags (or can be irq_capabilities), define
a new set of macros, and use bitmask in struct gpmc_irq
Thanks for the comments.
Regards
Afzal
^ permalink raw reply [flat|nested] 73+ messages in thread
* Re: [PATCH v3 1/9] ARM: OMAP2+: gpmc: driver conversion
2012-04-06 6:52 ` Mohammed, Afzal
(?)
(?)
@ 2012-04-09 19:50 ` Jon Hunter
-1 siblings, 0 replies; 73+ messages in thread
From: Jon Hunter @ 2012-04-09 19:50 UTC (permalink / raw)
To: Mohammed, Afzal
Cc: tony, Hilman, Kevin, linux, dwmw2, sameo, grinberg, mike, Menon,
Nishanth, artem.bityutskiy, vimal.newwork, dbaryshkov,
linux-omap, linux-arm-kernel, linux-mtd, linux-kernel, Hiremath,
Vaibhav
Hi Afzal,
On 04/06/2012 01:52 AM, Mohammed, Afzal wrote:
> Hi Jon,
>
> On Fri, Apr 06, 2012 at 01:51:41, Hunter, Jon wrote:
>>> +struct gpmc_irq {
>>> + unsigned irq;
>>> + u32 regval;
>>
>> Are you using regval to indicate the bit-mask? If so, maybe call it
>> "bitmask" instead.
>
> Yes, bitmask would be better.
>
>>> + switch (gpmc->irq[i].regval) {
>>> + case GPMC_IRQ_WAIT0EDGEDETECTION:
>>> + case GPMC_IRQ_WAIT1EDGEDETECTION:
>>> + case GPMC_IRQ_WAIT2EDGEDETECTION:
>>> + case GPMC_IRQ_WAIT3EDGEDETECTION:
>>> + val = __ffs(gpmc->irq[i].regval);
>>> + val -= __ffs(GPMC_IRQ_WAIT0EDGEDETECTION);
>>> + gpmc_cs_configure(cs->cs,
>>> + GPMC_CONFIG_WAITPIN, val);
>>
>> Why is the configuration of the wait pin done here? It is possible to
>> use the wait pin may be used without enabling the interrupt.
>>
>> Where do you handle allocating the wait pins to ensure two devices don't
>> attempt to use the same one? Like how the CS are managed.
>>
>> Also, where you you configure the polarity of the wait pins? I would
>> have thought it would make sense to have the wait pin configured as part
>> of the cs configuration.
>
> I will revisit waitpin configurations.
Ok.
>>> + for (i = 0, j = 0, cs = gdp->cs_data; i< gdp->num_cs; cs++, i++) {
>>> + dev->gpmc_res[j] = gpmc_setup_cs_mem(cs, gdp, gpmc);
>>> + if (dev->gpmc_res[j++].flags& IORESOURCE_MEM)
>>> + j += gpmc_setup_cs_irq(gpmc, gdp, cs,
>>> + dev->gpmc_res + j);
>>> + else {
>>> + dev_err(gpmc->dev, "error: setup for %s\n", gdp->name);
>>> + devm_kfree(gpmc->dev, dev->gpmc_res);
>>> + dev->gpmc_res = NULL;
>>> + dev->num_gpmc_res = 0;
>>> + return -EINVAL;
>>> + }
>>> }
>>
>> This section of code is not straight-forward to read. I see what you are
>> doing, but I am wondering if this could be improved.
>>
>> First of all, returning a structure from a function is making this code
>> harder to read. Per the CodingStyle document in the kernel, it is
>> preferred for a function to return success or failure if the function is
>> an action, like a setup.
>>
>> Secondly, do you need to pass cs, gdp and gpmc to gpmc_setup_cs_mem()?
>> It appears that gdp and gpmc are only used for prints. You could
>> probably avoid passing gdp and move the print to outside this function.
>
> This section will be modified to make it clearer.
Thanks.
>>> + if (gpmc->num_irq< GPMC_NR_IRQ) {
>>> + dev_warn(gpmc->dev, "Insufficient interrupts for device\n");
>>> + return -EINVAL;
>>> + } else if (gpmc->num_irq> GPMC_NR_IRQ)
>>> + gpmc->num_irq = GPMC_NR_IRQ;
>>
>> Hmmm ... why not just have ...
>>
>> if (gpmc->num_irq != GPMC_NR_IRQ) {
>> dev_warn(...);
>> return -EINVAL;
>> }
>
> This will cause irq setup to fail if num_irq> GPMC_NR_IRQ, even though
> irq setup could have been done w/o any problem, only because platform
> indicated willingness to accommodate more number of interrupts than
> actually required for this device.
Ok, so num_irqs represents OMAP_GPMC_NR_IRQS and we are making sure we
have enough IRQs allocated by the platform.
>> This also raises the question why bother passing num_irq if we always
>> want it to be GPMC_NR_IRQ? Why not always initialise them all driver?
>
> Because num_irq (or available irqs for fictitious irq chip) is platform specific.
Ok, so OMAP_GPMC_NR_IRQS is defined and will not vary from device to
device, so why pass this? Why not use it directly?
Furthermore, GPMC_NR_IRQ is defined as 6 which is correct for OMAP2/3
but not for OMAP4/5, it is 5. Therefore, we need to detect whether we
are using an OMAP2/3 or OMAP4+ and set num_irqs based upon this. This
could be done in the probe and we can avoid passing this.
So we could simplify this by configuring num_irqs in the probe function
and then just make sure num_irqs is less than OMAP_GPMC_NR_IRQS above.
>>> + res = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
>>> + if (res == NULL)
>>> + dev_warn(gpmc->dev, "Failed to get resource: irq\n");
>>> + else
>>> + gpmc->master_irq = res->start;
>>
>> Why not return an error if the IRQ is not found? We don't know if anyone
>> will be trying to use them.
>
> Why do you want to do that ?
Because this indicates a BUG :-)
> If someone (say NAND) wants to work with irq, and if interrupt is not
> available, NAND driver can fail, and suppose smsc911x ethernet is present
> and he is not using gpmc irq, if we fail here, smsc911x also would
> not work, which would have worked otherwise.
>
> It is a different matter that even NAND setup will happen properly,
> even if interrupt is not available, it is only when NAND is told to
> work with IRQ, it fails, please see nand patches.
>
> And as of now in mainline (with the code as is), there is not a single
> board that will need gpmc irq for gpmc peripherals to work.
>
> I feel we should try to get more devices working rather than preventing
> more devices from working, when it could have.
I understand your point, but then you are hiding a BUG. If someone
introduces a BUG that causes this to fail, then it is easier to detect,
find and fix.
From my perspective get the resources should never fail and if it does
and break the driver for all devices, then so be it, because a BUG has
been introduced. Ok, this may not be critical at this point but still is
should not fail.
>>> + for (gdq = gp->device_pdata, gd = gpmc->device; *gdq; gdq++, i++) {
>>> + ret = gpmc_setup_device(*gdq, gd, gpmc);
>>> + if (IS_ERR_VALUE(ret))
>>> + dev_err(gpmc->dev, "gpmc setup on %s failed\n",
>>> + (*gdq)->name);
>>> + else
>>> + gd++;
>>> + }
>>
>> Would a while loop be simpler?
>
> My preference is to go with "for"
Ok, just wondering if this could be cleaned up a little.
>>
>> The above loop appears to terminate when *gdq == 0. Is this always
>> guaranteed? In other words, safe?
>
> This is a standard idiom for array of pointers
Ok.
>>
>> I see that "i" is not being used in the above loop either.
>
> That was left over code, it will be removed.
Thanks.
>>> +struct gpmc_cs_data {
>>> + unsigned cs;
>>> + unsigned long mem_size;
>>> + unsigned long mem_start;
>>> + unsigned long mem_offset;
>>> + struct gpmc_config *config;
>>> + unsigned num_config;
>>> + struct gpmc_timings *timing;
>>> + unsigned irq_flags;
>>
>> I found the name irq_flags a bit unclear. This appears to be a mask for
>> the interrupts used. So may be this should be "irq_mask" or just "irqs".
>
> Probably, this confusion arose as an attempt was made to club irq bit fields
> with irq capability, so as to reduce additional macro definitions.
>
> Here my preference is to keep irq_flags (or can be irq_capabilities), define
> a new set of macros, and use bitmask in struct gpmc_irq
Ok, how about irq_config? The name irq_flags make me think of flags
passed to configure the irq as in the set_irq_flags() API.
> Thanks for the comments.
No problem.
Jon
^ permalink raw reply [flat|nested] 73+ messages in thread
* Re: [PATCH v3 1/9] ARM: OMAP2+: gpmc: driver conversion
@ 2012-04-09 19:50 ` Jon Hunter
0 siblings, 0 replies; 73+ messages in thread
From: Jon Hunter @ 2012-04-09 19:50 UTC (permalink / raw)
To: Mohammed, Afzal
Cc: tony, Hilman, Kevin, linux, dwmw2, sameo, grinberg, mike, Menon,
Nishanth, artem.bityutskiy, vimal.newwork, dbaryshkov,
linux-omap, linux-arm-kernel, linux-mtd, linux-kernel, Hiremath,
Vaibhav
Hi Afzal,
On 04/06/2012 01:52 AM, Mohammed, Afzal wrote:
> Hi Jon,
>
> On Fri, Apr 06, 2012 at 01:51:41, Hunter, Jon wrote:
>>> +struct gpmc_irq {
>>> + unsigned irq;
>>> + u32 regval;
>>
>> Are you using regval to indicate the bit-mask? If so, maybe call it
>> "bitmask" instead.
>
> Yes, bitmask would be better.
>
>>> + switch (gpmc->irq[i].regval) {
>>> + case GPMC_IRQ_WAIT0EDGEDETECTION:
>>> + case GPMC_IRQ_WAIT1EDGEDETECTION:
>>> + case GPMC_IRQ_WAIT2EDGEDETECTION:
>>> + case GPMC_IRQ_WAIT3EDGEDETECTION:
>>> + val = __ffs(gpmc->irq[i].regval);
>>> + val -= __ffs(GPMC_IRQ_WAIT0EDGEDETECTION);
>>> + gpmc_cs_configure(cs->cs,
>>> + GPMC_CONFIG_WAITPIN, val);
>>
>> Why is the configuration of the wait pin done here? It is possible to
>> use the wait pin may be used without enabling the interrupt.
>>
>> Where do you handle allocating the wait pins to ensure two devices don't
>> attempt to use the same one? Like how the CS are managed.
>>
>> Also, where you you configure the polarity of the wait pins? I would
>> have thought it would make sense to have the wait pin configured as part
>> of the cs configuration.
>
> I will revisit waitpin configurations.
Ok.
>>> + for (i = 0, j = 0, cs = gdp->cs_data; i< gdp->num_cs; cs++, i++) {
>>> + dev->gpmc_res[j] = gpmc_setup_cs_mem(cs, gdp, gpmc);
>>> + if (dev->gpmc_res[j++].flags& IORESOURCE_MEM)
>>> + j += gpmc_setup_cs_irq(gpmc, gdp, cs,
>>> + dev->gpmc_res + j);
>>> + else {
>>> + dev_err(gpmc->dev, "error: setup for %s\n", gdp->name);
>>> + devm_kfree(gpmc->dev, dev->gpmc_res);
>>> + dev->gpmc_res = NULL;
>>> + dev->num_gpmc_res = 0;
>>> + return -EINVAL;
>>> + }
>>> }
>>
>> This section of code is not straight-forward to read. I see what you are
>> doing, but I am wondering if this could be improved.
>>
>> First of all, returning a structure from a function is making this code
>> harder to read. Per the CodingStyle document in the kernel, it is
>> preferred for a function to return success or failure if the function is
>> an action, like a setup.
>>
>> Secondly, do you need to pass cs, gdp and gpmc to gpmc_setup_cs_mem()?
>> It appears that gdp and gpmc are only used for prints. You could
>> probably avoid passing gdp and move the print to outside this function.
>
> This section will be modified to make it clearer.
Thanks.
>>> + if (gpmc->num_irq< GPMC_NR_IRQ) {
>>> + dev_warn(gpmc->dev, "Insufficient interrupts for device\n");
>>> + return -EINVAL;
>>> + } else if (gpmc->num_irq> GPMC_NR_IRQ)
>>> + gpmc->num_irq = GPMC_NR_IRQ;
>>
>> Hmmm ... why not just have ...
>>
>> if (gpmc->num_irq != GPMC_NR_IRQ) {
>> dev_warn(...);
>> return -EINVAL;
>> }
>
> This will cause irq setup to fail if num_irq> GPMC_NR_IRQ, even though
> irq setup could have been done w/o any problem, only because platform
> indicated willingness to accommodate more number of interrupts than
> actually required for this device.
Ok, so num_irqs represents OMAP_GPMC_NR_IRQS and we are making sure we
have enough IRQs allocated by the platform.
>> This also raises the question why bother passing num_irq if we always
>> want it to be GPMC_NR_IRQ? Why not always initialise them all driver?
>
> Because num_irq (or available irqs for fictitious irq chip) is platform specific.
Ok, so OMAP_GPMC_NR_IRQS is defined and will not vary from device to
device, so why pass this? Why not use it directly?
Furthermore, GPMC_NR_IRQ is defined as 6 which is correct for OMAP2/3
but not for OMAP4/5, it is 5. Therefore, we need to detect whether we
are using an OMAP2/3 or OMAP4+ and set num_irqs based upon this. This
could be done in the probe and we can avoid passing this.
So we could simplify this by configuring num_irqs in the probe function
and then just make sure num_irqs is less than OMAP_GPMC_NR_IRQS above.
>>> + res = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
>>> + if (res == NULL)
>>> + dev_warn(gpmc->dev, "Failed to get resource: irq\n");
>>> + else
>>> + gpmc->master_irq = res->start;
>>
>> Why not return an error if the IRQ is not found? We don't know if anyone
>> will be trying to use them.
>
> Why do you want to do that ?
Because this indicates a BUG :-)
> If someone (say NAND) wants to work with irq, and if interrupt is not
> available, NAND driver can fail, and suppose smsc911x ethernet is present
> and he is not using gpmc irq, if we fail here, smsc911x also would
> not work, which would have worked otherwise.
>
> It is a different matter that even NAND setup will happen properly,
> even if interrupt is not available, it is only when NAND is told to
> work with IRQ, it fails, please see nand patches.
>
> And as of now in mainline (with the code as is), there is not a single
> board that will need gpmc irq for gpmc peripherals to work.
>
> I feel we should try to get more devices working rather than preventing
> more devices from working, when it could have.
I understand your point, but then you are hiding a BUG. If someone
introduces a BUG that causes this to fail, then it is easier to detect,
find and fix.
From my perspective get the resources should never fail and if it does
and break the driver for all devices, then so be it, because a BUG has
been introduced. Ok, this may not be critical at this point but still is
should not fail.
>>> + for (gdq = gp->device_pdata, gd = gpmc->device; *gdq; gdq++, i++) {
>>> + ret = gpmc_setup_device(*gdq, gd, gpmc);
>>> + if (IS_ERR_VALUE(ret))
>>> + dev_err(gpmc->dev, "gpmc setup on %s failed\n",
>>> + (*gdq)->name);
>>> + else
>>> + gd++;
>>> + }
>>
>> Would a while loop be simpler?
>
> My preference is to go with "for"
Ok, just wondering if this could be cleaned up a little.
>>
>> The above loop appears to terminate when *gdq == 0. Is this always
>> guaranteed? In other words, safe?
>
> This is a standard idiom for array of pointers
Ok.
>>
>> I see that "i" is not being used in the above loop either.
>
> That was left over code, it will be removed.
Thanks.
>>> +struct gpmc_cs_data {
>>> + unsigned cs;
>>> + unsigned long mem_size;
>>> + unsigned long mem_start;
>>> + unsigned long mem_offset;
>>> + struct gpmc_config *config;
>>> + unsigned num_config;
>>> + struct gpmc_timings *timing;
>>> + unsigned irq_flags;
>>
>> I found the name irq_flags a bit unclear. This appears to be a mask for
>> the interrupts used. So may be this should be "irq_mask" or just "irqs".
>
> Probably, this confusion arose as an attempt was made to club irq bit fields
> with irq capability, so as to reduce additional macro definitions.
>
> Here my preference is to keep irq_flags (or can be irq_capabilities), define
> a new set of macros, and use bitmask in struct gpmc_irq
Ok, how about irq_config? The name irq_flags make me think of flags
passed to configure the irq as in the set_irq_flags() API.
> Thanks for the comments.
No problem.
Jon
^ permalink raw reply [flat|nested] 73+ messages in thread
* Re: [PATCH v3 1/9] ARM: OMAP2+: gpmc: driver conversion
@ 2012-04-09 19:50 ` Jon Hunter
0 siblings, 0 replies; 73+ messages in thread
From: Jon Hunter @ 2012-04-09 19:50 UTC (permalink / raw)
To: Mohammed, Afzal
Cc: Hilman, Kevin, Menon, Nishanth, linux, sameo, tony,
artem.bityutskiy, linux-kernel, Hiremath, Vaibhav, dbaryshkov,
vimal.newwork, grinberg, mike, linux-mtd, linux-omap, dwmw2,
linux-arm-kernel
Hi Afzal,
On 04/06/2012 01:52 AM, Mohammed, Afzal wrote:
> Hi Jon,
>
> On Fri, Apr 06, 2012 at 01:51:41, Hunter, Jon wrote:
>>> +struct gpmc_irq {
>>> + unsigned irq;
>>> + u32 regval;
>>
>> Are you using regval to indicate the bit-mask? If so, maybe call it
>> "bitmask" instead.
>
> Yes, bitmask would be better.
>
>>> + switch (gpmc->irq[i].regval) {
>>> + case GPMC_IRQ_WAIT0EDGEDETECTION:
>>> + case GPMC_IRQ_WAIT1EDGEDETECTION:
>>> + case GPMC_IRQ_WAIT2EDGEDETECTION:
>>> + case GPMC_IRQ_WAIT3EDGEDETECTION:
>>> + val = __ffs(gpmc->irq[i].regval);
>>> + val -= __ffs(GPMC_IRQ_WAIT0EDGEDETECTION);
>>> + gpmc_cs_configure(cs->cs,
>>> + GPMC_CONFIG_WAITPIN, val);
>>
>> Why is the configuration of the wait pin done here? It is possible to
>> use the wait pin may be used without enabling the interrupt.
>>
>> Where do you handle allocating the wait pins to ensure two devices don't
>> attempt to use the same one? Like how the CS are managed.
>>
>> Also, where you you configure the polarity of the wait pins? I would
>> have thought it would make sense to have the wait pin configured as part
>> of the cs configuration.
>
> I will revisit waitpin configurations.
Ok.
>>> + for (i = 0, j = 0, cs = gdp->cs_data; i< gdp->num_cs; cs++, i++) {
>>> + dev->gpmc_res[j] = gpmc_setup_cs_mem(cs, gdp, gpmc);
>>> + if (dev->gpmc_res[j++].flags& IORESOURCE_MEM)
>>> + j += gpmc_setup_cs_irq(gpmc, gdp, cs,
>>> + dev->gpmc_res + j);
>>> + else {
>>> + dev_err(gpmc->dev, "error: setup for %s\n", gdp->name);
>>> + devm_kfree(gpmc->dev, dev->gpmc_res);
>>> + dev->gpmc_res = NULL;
>>> + dev->num_gpmc_res = 0;
>>> + return -EINVAL;
>>> + }
>>> }
>>
>> This section of code is not straight-forward to read. I see what you are
>> doing, but I am wondering if this could be improved.
>>
>> First of all, returning a structure from a function is making this code
>> harder to read. Per the CodingStyle document in the kernel, it is
>> preferred for a function to return success or failure if the function is
>> an action, like a setup.
>>
>> Secondly, do you need to pass cs, gdp and gpmc to gpmc_setup_cs_mem()?
>> It appears that gdp and gpmc are only used for prints. You could
>> probably avoid passing gdp and move the print to outside this function.
>
> This section will be modified to make it clearer.
Thanks.
>>> + if (gpmc->num_irq< GPMC_NR_IRQ) {
>>> + dev_warn(gpmc->dev, "Insufficient interrupts for device\n");
>>> + return -EINVAL;
>>> + } else if (gpmc->num_irq> GPMC_NR_IRQ)
>>> + gpmc->num_irq = GPMC_NR_IRQ;
>>
>> Hmmm ... why not just have ...
>>
>> if (gpmc->num_irq != GPMC_NR_IRQ) {
>> dev_warn(...);
>> return -EINVAL;
>> }
>
> This will cause irq setup to fail if num_irq> GPMC_NR_IRQ, even though
> irq setup could have been done w/o any problem, only because platform
> indicated willingness to accommodate more number of interrupts than
> actually required for this device.
Ok, so num_irqs represents OMAP_GPMC_NR_IRQS and we are making sure we
have enough IRQs allocated by the platform.
>> This also raises the question why bother passing num_irq if we always
>> want it to be GPMC_NR_IRQ? Why not always initialise them all driver?
>
> Because num_irq (or available irqs for fictitious irq chip) is platform specific.
Ok, so OMAP_GPMC_NR_IRQS is defined and will not vary from device to
device, so why pass this? Why not use it directly?
Furthermore, GPMC_NR_IRQ is defined as 6 which is correct for OMAP2/3
but not for OMAP4/5, it is 5. Therefore, we need to detect whether we
are using an OMAP2/3 or OMAP4+ and set num_irqs based upon this. This
could be done in the probe and we can avoid passing this.
So we could simplify this by configuring num_irqs in the probe function
and then just make sure num_irqs is less than OMAP_GPMC_NR_IRQS above.
>>> + res = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
>>> + if (res == NULL)
>>> + dev_warn(gpmc->dev, "Failed to get resource: irq\n");
>>> + else
>>> + gpmc->master_irq = res->start;
>>
>> Why not return an error if the IRQ is not found? We don't know if anyone
>> will be trying to use them.
>
> Why do you want to do that ?
Because this indicates a BUG :-)
> If someone (say NAND) wants to work with irq, and if interrupt is not
> available, NAND driver can fail, and suppose smsc911x ethernet is present
> and he is not using gpmc irq, if we fail here, smsc911x also would
> not work, which would have worked otherwise.
>
> It is a different matter that even NAND setup will happen properly,
> even if interrupt is not available, it is only when NAND is told to
> work with IRQ, it fails, please see nand patches.
>
> And as of now in mainline (with the code as is), there is not a single
> board that will need gpmc irq for gpmc peripherals to work.
>
> I feel we should try to get more devices working rather than preventing
> more devices from working, when it could have.
I understand your point, but then you are hiding a BUG. If someone
introduces a BUG that causes this to fail, then it is easier to detect,
find and fix.
From my perspective get the resources should never fail and if it does
and break the driver for all devices, then so be it, because a BUG has
been introduced. Ok, this may not be critical at this point but still is
should not fail.
>>> + for (gdq = gp->device_pdata, gd = gpmc->device; *gdq; gdq++, i++) {
>>> + ret = gpmc_setup_device(*gdq, gd, gpmc);
>>> + if (IS_ERR_VALUE(ret))
>>> + dev_err(gpmc->dev, "gpmc setup on %s failed\n",
>>> + (*gdq)->name);
>>> + else
>>> + gd++;
>>> + }
>>
>> Would a while loop be simpler?
>
> My preference is to go with "for"
Ok, just wondering if this could be cleaned up a little.
>>
>> The above loop appears to terminate when *gdq == 0. Is this always
>> guaranteed? In other words, safe?
>
> This is a standard idiom for array of pointers
Ok.
>>
>> I see that "i" is not being used in the above loop either.
>
> That was left over code, it will be removed.
Thanks.
>>> +struct gpmc_cs_data {
>>> + unsigned cs;
>>> + unsigned long mem_size;
>>> + unsigned long mem_start;
>>> + unsigned long mem_offset;
>>> + struct gpmc_config *config;
>>> + unsigned num_config;
>>> + struct gpmc_timings *timing;
>>> + unsigned irq_flags;
>>
>> I found the name irq_flags a bit unclear. This appears to be a mask for
>> the interrupts used. So may be this should be "irq_mask" or just "irqs".
>
> Probably, this confusion arose as an attempt was made to club irq bit fields
> with irq capability, so as to reduce additional macro definitions.
>
> Here my preference is to keep irq_flags (or can be irq_capabilities), define
> a new set of macros, and use bitmask in struct gpmc_irq
Ok, how about irq_config? The name irq_flags make me think of flags
passed to configure the irq as in the set_irq_flags() API.
> Thanks for the comments.
No problem.
Jon
^ permalink raw reply [flat|nested] 73+ messages in thread
* [PATCH v3 1/9] ARM: OMAP2+: gpmc: driver conversion
@ 2012-04-09 19:50 ` Jon Hunter
0 siblings, 0 replies; 73+ messages in thread
From: Jon Hunter @ 2012-04-09 19:50 UTC (permalink / raw)
To: linux-arm-kernel
Hi Afzal,
On 04/06/2012 01:52 AM, Mohammed, Afzal wrote:
> Hi Jon,
>
> On Fri, Apr 06, 2012 at 01:51:41, Hunter, Jon wrote:
>>> +struct gpmc_irq {
>>> + unsigned irq;
>>> + u32 regval;
>>
>> Are you using regval to indicate the bit-mask? If so, maybe call it
>> "bitmask" instead.
>
> Yes, bitmask would be better.
>
>>> + switch (gpmc->irq[i].regval) {
>>> + case GPMC_IRQ_WAIT0EDGEDETECTION:
>>> + case GPMC_IRQ_WAIT1EDGEDETECTION:
>>> + case GPMC_IRQ_WAIT2EDGEDETECTION:
>>> + case GPMC_IRQ_WAIT3EDGEDETECTION:
>>> + val = __ffs(gpmc->irq[i].regval);
>>> + val -= __ffs(GPMC_IRQ_WAIT0EDGEDETECTION);
>>> + gpmc_cs_configure(cs->cs,
>>> + GPMC_CONFIG_WAITPIN, val);
>>
>> Why is the configuration of the wait pin done here? It is possible to
>> use the wait pin may be used without enabling the interrupt.
>>
>> Where do you handle allocating the wait pins to ensure two devices don't
>> attempt to use the same one? Like how the CS are managed.
>>
>> Also, where you you configure the polarity of the wait pins? I would
>> have thought it would make sense to have the wait pin configured as part
>> of the cs configuration.
>
> I will revisit waitpin configurations.
Ok.
>>> + for (i = 0, j = 0, cs = gdp->cs_data; i< gdp->num_cs; cs++, i++) {
>>> + dev->gpmc_res[j] = gpmc_setup_cs_mem(cs, gdp, gpmc);
>>> + if (dev->gpmc_res[j++].flags& IORESOURCE_MEM)
>>> + j += gpmc_setup_cs_irq(gpmc, gdp, cs,
>>> + dev->gpmc_res + j);
>>> + else {
>>> + dev_err(gpmc->dev, "error: setup for %s\n", gdp->name);
>>> + devm_kfree(gpmc->dev, dev->gpmc_res);
>>> + dev->gpmc_res = NULL;
>>> + dev->num_gpmc_res = 0;
>>> + return -EINVAL;
>>> + }
>>> }
>>
>> This section of code is not straight-forward to read. I see what you are
>> doing, but I am wondering if this could be improved.
>>
>> First of all, returning a structure from a function is making this code
>> harder to read. Per the CodingStyle document in the kernel, it is
>> preferred for a function to return success or failure if the function is
>> an action, like a setup.
>>
>> Secondly, do you need to pass cs, gdp and gpmc to gpmc_setup_cs_mem()?
>> It appears that gdp and gpmc are only used for prints. You could
>> probably avoid passing gdp and move the print to outside this function.
>
> This section will be modified to make it clearer.
Thanks.
>>> + if (gpmc->num_irq< GPMC_NR_IRQ) {
>>> + dev_warn(gpmc->dev, "Insufficient interrupts for device\n");
>>> + return -EINVAL;
>>> + } else if (gpmc->num_irq> GPMC_NR_IRQ)
>>> + gpmc->num_irq = GPMC_NR_IRQ;
>>
>> Hmmm ... why not just have ...
>>
>> if (gpmc->num_irq != GPMC_NR_IRQ) {
>> dev_warn(...);
>> return -EINVAL;
>> }
>
> This will cause irq setup to fail if num_irq> GPMC_NR_IRQ, even though
> irq setup could have been done w/o any problem, only because platform
> indicated willingness to accommodate more number of interrupts than
> actually required for this device.
Ok, so num_irqs represents OMAP_GPMC_NR_IRQS and we are making sure we
have enough IRQs allocated by the platform.
>> This also raises the question why bother passing num_irq if we always
>> want it to be GPMC_NR_IRQ? Why not always initialise them all driver?
>
> Because num_irq (or available irqs for fictitious irq chip) is platform specific.
Ok, so OMAP_GPMC_NR_IRQS is defined and will not vary from device to
device, so why pass this? Why not use it directly?
Furthermore, GPMC_NR_IRQ is defined as 6 which is correct for OMAP2/3
but not for OMAP4/5, it is 5. Therefore, we need to detect whether we
are using an OMAP2/3 or OMAP4+ and set num_irqs based upon this. This
could be done in the probe and we can avoid passing this.
So we could simplify this by configuring num_irqs in the probe function
and then just make sure num_irqs is less than OMAP_GPMC_NR_IRQS above.
>>> + res = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
>>> + if (res == NULL)
>>> + dev_warn(gpmc->dev, "Failed to get resource: irq\n");
>>> + else
>>> + gpmc->master_irq = res->start;
>>
>> Why not return an error if the IRQ is not found? We don't know if anyone
>> will be trying to use them.
>
> Why do you want to do that ?
Because this indicates a BUG :-)
> If someone (say NAND) wants to work with irq, and if interrupt is not
> available, NAND driver can fail, and suppose smsc911x ethernet is present
> and he is not using gpmc irq, if we fail here, smsc911x also would
> not work, which would have worked otherwise.
>
> It is a different matter that even NAND setup will happen properly,
> even if interrupt is not available, it is only when NAND is told to
> work with IRQ, it fails, please see nand patches.
>
> And as of now in mainline (with the code as is), there is not a single
> board that will need gpmc irq for gpmc peripherals to work.
>
> I feel we should try to get more devices working rather than preventing
> more devices from working, when it could have.
I understand your point, but then you are hiding a BUG. If someone
introduces a BUG that causes this to fail, then it is easier to detect,
find and fix.
From my perspective get the resources should never fail and if it does
and break the driver for all devices, then so be it, because a BUG has
been introduced. Ok, this may not be critical at this point but still is
should not fail.
>>> + for (gdq = gp->device_pdata, gd = gpmc->device; *gdq; gdq++, i++) {
>>> + ret = gpmc_setup_device(*gdq, gd, gpmc);
>>> + if (IS_ERR_VALUE(ret))
>>> + dev_err(gpmc->dev, "gpmc setup on %s failed\n",
>>> + (*gdq)->name);
>>> + else
>>> + gd++;
>>> + }
>>
>> Would a while loop be simpler?
>
> My preference is to go with "for"
Ok, just wondering if this could be cleaned up a little.
>>
>> The above loop appears to terminate when *gdq == 0. Is this always
>> guaranteed? In other words, safe?
>
> This is a standard idiom for array of pointers
Ok.
>>
>> I see that "i" is not being used in the above loop either.
>
> That was left over code, it will be removed.
Thanks.
>>> +struct gpmc_cs_data {
>>> + unsigned cs;
>>> + unsigned long mem_size;
>>> + unsigned long mem_start;
>>> + unsigned long mem_offset;
>>> + struct gpmc_config *config;
>>> + unsigned num_config;
>>> + struct gpmc_timings *timing;
>>> + unsigned irq_flags;
>>
>> I found the name irq_flags a bit unclear. This appears to be a mask for
>> the interrupts used. So may be this should be "irq_mask" or just "irqs".
>
> Probably, this confusion arose as an attempt was made to club irq bit fields
> with irq capability, so as to reduce additional macro definitions.
>
> Here my preference is to keep irq_flags (or can be irq_capabilities), define
> a new set of macros, and use bitmask in struct gpmc_irq
Ok, how about irq_config? The name irq_flags make me think of flags
passed to configure the irq as in the set_irq_flags() API.
> Thanks for the comments.
No problem.
Jon
^ permalink raw reply [flat|nested] 73+ messages in thread
* RE: [PATCH v3 1/9] ARM: OMAP2+: gpmc: driver conversion
2012-04-09 19:50 ` Jon Hunter
(?)
(?)
@ 2012-04-10 11:00 ` Mohammed, Afzal
-1 siblings, 0 replies; 73+ messages in thread
From: Mohammed, Afzal @ 2012-04-10 11:00 UTC (permalink / raw)
To: Hunter, Jon
Cc: tony, Hilman, Kevin, linux, dwmw2, sameo, grinberg, mike, Menon,
Nishanth, artem.bityutskiy, vimal.newwork, dbaryshkov,
linux-omap, linux-arm-kernel, linux-mtd, linux-kernel, Hiremath,
Vaibhav
Hi Jon,
On Tue, Apr 10, 2012 at 01:20:37, Hunter, Jon wrote:
> > Because num_irq (or available irqs for fictitious irq chip) is platform specific.
>
> Ok, so OMAP_GPMC_NR_IRQS is defined and will not vary from device to
> device, so why pass this? Why not use it directly?
Because OMAP_GPMC_NR_IRQS is platform specific, final intention is to
not have any platform specific header files in GPMC driver, not sure
as of now whether it would be possible. So keeping platform specific
things away from the driver as much as possible.
And consider scenario where GPMC IP is used in other than OMAP family,
even though this a theoretical case, wanted to stress the point that
intention is to keep driver platform independent.
Or else dynamic allocation of irqs may have to be used.
>
> Furthermore, GPMC_NR_IRQ is defined as 6 which is correct for OMAP2/3
> but not for OMAP4/5, it is 5. Therefore, we need to detect whether we
> are using an OMAP2/3 or OMAP4+ and set num_irqs based upon this. This
> could be done in the probe and we can avoid passing this.
Is it dependent on OMAPX or GPMC IP version? if it is IP version, then driver
can be enhanced to handle it, if not, platform has to pass this information.
> >>> + res = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
> >>> + if (res == NULL)
> >>> + dev_warn(gpmc->dev, "Failed to get resource: irq\n");
> >>> + else
> >>> + gpmc->master_irq = res->start;
> >>
> >> Why not return an error if the IRQ is not found? We don't know if anyone
> >> will be trying to use them.
> >
> > Why do you want to do that ?
>
> Because this indicates a BUG :-)
I disagree, this need not be considered a bug always,
for eg. If gpmc irq is not connected to intc
>
> > If someone (say NAND) wants to work with irq, and if interrupt is not
> > available, NAND driver can fail, and suppose smsc911x ethernet is present
> > and he is not using gpmc irq, if we fail here, smsc911x also would
> > not work, which would have worked otherwise.
> >
> > It is a different matter that even NAND setup will happen properly,
> > even if interrupt is not available, it is only when NAND is told to
> > work with IRQ, it fails, please see nand patches.
> >
> > And as of now in mainline (with the code as is), there is not a single
> > board that will need gpmc irq for gpmc peripherals to work.
> >
> > I feel we should try to get more devices working rather than preventing
> > more devices from working, when it could have.
>
> I understand your point, but then you are hiding a BUG. If someone
> introduces a BUG that causes this to fail, then it is easier to detect,
> find and fix.
>
> From my perspective get the resources should never fail and if it does
> and break the driver for all devices, then so be it, because a BUG has
> been introduced. Ok, this may not be critical at this point but still is
> should not fail.
Agree for resources which are a must for device to work, not for resources
that can enhance its capability.
>
> >>> + for (gdq = gp->device_pdata, gd = gpmc->device; *gdq; gdq++, i++) {
> >>> + ret = gpmc_setup_device(*gdq, gd, gpmc);
> >>> + if (IS_ERR_VALUE(ret))
> >>> + dev_err(gpmc->dev, "gpmc setup on %s failed\n",
> >>> + (*gdq)->name);
> >>> + else
> >>> + gd++;
> >>> + }
> >>
> >> Would a while loop be simpler?
> >
> > My preference is to go with "for"
>
> Ok, just wondering if this could be cleaned up a little.
For travelling through array of pointers, for looks natural to me, if you
have a better way, please send it, it can be folded in next version.
Regards
Afzal
^ permalink raw reply [flat|nested] 73+ messages in thread
* RE: [PATCH v3 1/9] ARM: OMAP2+: gpmc: driver conversion
@ 2012-04-10 11:00 ` Mohammed, Afzal
0 siblings, 0 replies; 73+ messages in thread
From: Mohammed, Afzal @ 2012-04-10 11:00 UTC (permalink / raw)
To: Hunter, Jon
Cc: tony, Hilman, Kevin, linux, dwmw2, sameo, grinberg, mike, Menon,
Nishanth, artem.bityutskiy, vimal.newwork, dbaryshkov,
linux-omap, linux-arm-kernel, linux-mtd, linux-kernel, Hiremath,
Vaibhav
Hi Jon,
On Tue, Apr 10, 2012 at 01:20:37, Hunter, Jon wrote:
> > Because num_irq (or available irqs for fictitious irq chip) is platform specific.
>
> Ok, so OMAP_GPMC_NR_IRQS is defined and will not vary from device to
> device, so why pass this? Why not use it directly?
Because OMAP_GPMC_NR_IRQS is platform specific, final intention is to
not have any platform specific header files in GPMC driver, not sure
as of now whether it would be possible. So keeping platform specific
things away from the driver as much as possible.
And consider scenario where GPMC IP is used in other than OMAP family,
even though this a theoretical case, wanted to stress the point that
intention is to keep driver platform independent.
Or else dynamic allocation of irqs may have to be used.
>
> Furthermore, GPMC_NR_IRQ is defined as 6 which is correct for OMAP2/3
> but not for OMAP4/5, it is 5. Therefore, we need to detect whether we
> are using an OMAP2/3 or OMAP4+ and set num_irqs based upon this. This
> could be done in the probe and we can avoid passing this.
Is it dependent on OMAPX or GPMC IP version? if it is IP version, then driver
can be enhanced to handle it, if not, platform has to pass this information.
> >>> + res = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
> >>> + if (res == NULL)
> >>> + dev_warn(gpmc->dev, "Failed to get resource: irq\n");
> >>> + else
> >>> + gpmc->master_irq = res->start;
> >>
> >> Why not return an error if the IRQ is not found? We don't know if anyone
> >> will be trying to use them.
> >
> > Why do you want to do that ?
>
> Because this indicates a BUG :-)
I disagree, this need not be considered a bug always,
for eg. If gpmc irq is not connected to intc
>
> > If someone (say NAND) wants to work with irq, and if interrupt is not
> > available, NAND driver can fail, and suppose smsc911x ethernet is present
> > and he is not using gpmc irq, if we fail here, smsc911x also would
> > not work, which would have worked otherwise.
> >
> > It is a different matter that even NAND setup will happen properly,
> > even if interrupt is not available, it is only when NAND is told to
> > work with IRQ, it fails, please see nand patches.
> >
> > And as of now in mainline (with the code as is), there is not a single
> > board that will need gpmc irq for gpmc peripherals to work.
> >
> > I feel we should try to get more devices working rather than preventing
> > more devices from working, when it could have.
>
> I understand your point, but then you are hiding a BUG. If someone
> introduces a BUG that causes this to fail, then it is easier to detect,
> find and fix.
>
> From my perspective get the resources should never fail and if it does
> and break the driver for all devices, then so be it, because a BUG has
> been introduced. Ok, this may not be critical at this point but still is
> should not fail.
Agree for resources which are a must for device to work, not for resources
that can enhance its capability.
>
> >>> + for (gdq = gp->device_pdata, gd = gpmc->device; *gdq; gdq++, i++) {
> >>> + ret = gpmc_setup_device(*gdq, gd, gpmc);
> >>> + if (IS_ERR_VALUE(ret))
> >>> + dev_err(gpmc->dev, "gpmc setup on %s failed\n",
> >>> + (*gdq)->name);
> >>> + else
> >>> + gd++;
> >>> + }
> >>
> >> Would a while loop be simpler?
> >
> > My preference is to go with "for"
>
> Ok, just wondering if this could be cleaned up a little.
For travelling through array of pointers, for looks natural to me, if you
have a better way, please send it, it can be folded in next version.
Regards
Afzal
^ permalink raw reply [flat|nested] 73+ messages in thread
* RE: [PATCH v3 1/9] ARM: OMAP2+: gpmc: driver conversion
@ 2012-04-10 11:00 ` Mohammed, Afzal
0 siblings, 0 replies; 73+ messages in thread
From: Mohammed, Afzal @ 2012-04-10 11:00 UTC (permalink / raw)
To: Hunter, Jon
Cc: Hilman, Kevin, Menon, Nishanth, linux, sameo, tony,
artem.bityutskiy, linux-kernel, Hiremath, Vaibhav, dbaryshkov,
vimal.newwork, grinberg, mike, linux-mtd, linux-omap, dwmw2,
linux-arm-kernel
Hi Jon,
On Tue, Apr 10, 2012 at 01:20:37, Hunter, Jon wrote:
> > Because num_irq (or available irqs for fictitious irq chip) is platform specific.
>
> Ok, so OMAP_GPMC_NR_IRQS is defined and will not vary from device to
> device, so why pass this? Why not use it directly?
Because OMAP_GPMC_NR_IRQS is platform specific, final intention is to
not have any platform specific header files in GPMC driver, not sure
as of now whether it would be possible. So keeping platform specific
things away from the driver as much as possible.
And consider scenario where GPMC IP is used in other than OMAP family,
even though this a theoretical case, wanted to stress the point that
intention is to keep driver platform independent.
Or else dynamic allocation of irqs may have to be used.
>
> Furthermore, GPMC_NR_IRQ is defined as 6 which is correct for OMAP2/3
> but not for OMAP4/5, it is 5. Therefore, we need to detect whether we
> are using an OMAP2/3 or OMAP4+ and set num_irqs based upon this. This
> could be done in the probe and we can avoid passing this.
Is it dependent on OMAPX or GPMC IP version? if it is IP version, then driver
can be enhanced to handle it, if not, platform has to pass this information.
> >>> + res = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
> >>> + if (res == NULL)
> >>> + dev_warn(gpmc->dev, "Failed to get resource: irq\n");
> >>> + else
> >>> + gpmc->master_irq = res->start;
> >>
> >> Why not return an error if the IRQ is not found? We don't know if anyone
> >> will be trying to use them.
> >
> > Why do you want to do that ?
>
> Because this indicates a BUG :-)
I disagree, this need not be considered a bug always,
for eg. If gpmc irq is not connected to intc
>
> > If someone (say NAND) wants to work with irq, and if interrupt is not
> > available, NAND driver can fail, and suppose smsc911x ethernet is present
> > and he is not using gpmc irq, if we fail here, smsc911x also would
> > not work, which would have worked otherwise.
> >
> > It is a different matter that even NAND setup will happen properly,
> > even if interrupt is not available, it is only when NAND is told to
> > work with IRQ, it fails, please see nand patches.
> >
> > And as of now in mainline (with the code as is), there is not a single
> > board that will need gpmc irq for gpmc peripherals to work.
> >
> > I feel we should try to get more devices working rather than preventing
> > more devices from working, when it could have.
>
> I understand your point, but then you are hiding a BUG. If someone
> introduces a BUG that causes this to fail, then it is easier to detect,
> find and fix.
>
> From my perspective get the resources should never fail and if it does
> and break the driver for all devices, then so be it, because a BUG has
> been introduced. Ok, this may not be critical at this point but still is
> should not fail.
Agree for resources which are a must for device to work, not for resources
that can enhance its capability.
>
> >>> + for (gdq = gp->device_pdata, gd = gpmc->device; *gdq; gdq++, i++) {
> >>> + ret = gpmc_setup_device(*gdq, gd, gpmc);
> >>> + if (IS_ERR_VALUE(ret))
> >>> + dev_err(gpmc->dev, "gpmc setup on %s failed\n",
> >>> + (*gdq)->name);
> >>> + else
> >>> + gd++;
> >>> + }
> >>
> >> Would a while loop be simpler?
> >
> > My preference is to go with "for"
>
> Ok, just wondering if this could be cleaned up a little.
For travelling through array of pointers, for looks natural to me, if you
have a better way, please send it, it can be folded in next version.
Regards
Afzal
^ permalink raw reply [flat|nested] 73+ messages in thread
* [PATCH v3 1/9] ARM: OMAP2+: gpmc: driver conversion
@ 2012-04-10 11:00 ` Mohammed, Afzal
0 siblings, 0 replies; 73+ messages in thread
From: Mohammed, Afzal @ 2012-04-10 11:00 UTC (permalink / raw)
To: linux-arm-kernel
Hi Jon,
On Tue, Apr 10, 2012 at 01:20:37, Hunter, Jon wrote:
> > Because num_irq (or available irqs for fictitious irq chip) is platform specific.
>
> Ok, so OMAP_GPMC_NR_IRQS is defined and will not vary from device to
> device, so why pass this? Why not use it directly?
Because OMAP_GPMC_NR_IRQS is platform specific, final intention is to
not have any platform specific header files in GPMC driver, not sure
as of now whether it would be possible. So keeping platform specific
things away from the driver as much as possible.
And consider scenario where GPMC IP is used in other than OMAP family,
even though this a theoretical case, wanted to stress the point that
intention is to keep driver platform independent.
Or else dynamic allocation of irqs may have to be used.
>
> Furthermore, GPMC_NR_IRQ is defined as 6 which is correct for OMAP2/3
> but not for OMAP4/5, it is 5. Therefore, we need to detect whether we
> are using an OMAP2/3 or OMAP4+ and set num_irqs based upon this. This
> could be done in the probe and we can avoid passing this.
Is it dependent on OMAPX or GPMC IP version? if it is IP version, then driver
can be enhanced to handle it, if not, platform has to pass this information.
> >>> + res = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
> >>> + if (res == NULL)
> >>> + dev_warn(gpmc->dev, "Failed to get resource: irq\n");
> >>> + else
> >>> + gpmc->master_irq = res->start;
> >>
> >> Why not return an error if the IRQ is not found? We don't know if anyone
> >> will be trying to use them.
> >
> > Why do you want to do that ?
>
> Because this indicates a BUG :-)
I disagree, this need not be considered a bug always,
for eg. If gpmc irq is not connected to intc
>
> > If someone (say NAND) wants to work with irq, and if interrupt is not
> > available, NAND driver can fail, and suppose smsc911x ethernet is present
> > and he is not using gpmc irq, if we fail here, smsc911x also would
> > not work, which would have worked otherwise.
> >
> > It is a different matter that even NAND setup will happen properly,
> > even if interrupt is not available, it is only when NAND is told to
> > work with IRQ, it fails, please see nand patches.
> >
> > And as of now in mainline (with the code as is), there is not a single
> > board that will need gpmc irq for gpmc peripherals to work.
> >
> > I feel we should try to get more devices working rather than preventing
> > more devices from working, when it could have.
>
> I understand your point, but then you are hiding a BUG. If someone
> introduces a BUG that causes this to fail, then it is easier to detect,
> find and fix.
>
> From my perspective get the resources should never fail and if it does
> and break the driver for all devices, then so be it, because a BUG has
> been introduced. Ok, this may not be critical at this point but still is
> should not fail.
Agree for resources which are a must for device to work, not for resources
that can enhance its capability.
>
> >>> + for (gdq = gp->device_pdata, gd = gpmc->device; *gdq; gdq++, i++) {
> >>> + ret = gpmc_setup_device(*gdq, gd, gpmc);
> >>> + if (IS_ERR_VALUE(ret))
> >>> + dev_err(gpmc->dev, "gpmc setup on %s failed\n",
> >>> + (*gdq)->name);
> >>> + else
> >>> + gd++;
> >>> + }
> >>
> >> Would a while loop be simpler?
> >
> > My preference is to go with "for"
>
> Ok, just wondering if this could be cleaned up a little.
For travelling through array of pointers, for looks natural to me, if you
have a better way, please send it, it can be folded in next version.
Regards
Afzal
^ permalink raw reply [flat|nested] 73+ messages in thread
* Re: [PATCH v3 1/9] ARM: OMAP2+: gpmc: driver conversion
2012-04-10 11:00 ` Mohammed, Afzal
(?)
(?)
@ 2012-04-10 19:23 ` Jon Hunter
-1 siblings, 0 replies; 73+ messages in thread
From: Jon Hunter @ 2012-04-10 19:23 UTC (permalink / raw)
To: Mohammed, Afzal
Cc: tony, Hilman, Kevin, linux, dwmw2, sameo, grinberg, mike, Menon,
Nishanth, artem.bityutskiy, vimal.newwork, dbaryshkov,
linux-omap, linux-arm-kernel, linux-mtd, linux-kernel, Hiremath,
Vaibhav
Hi Afzal,
On 04/10/2012 06:00 AM, Mohammed, Afzal wrote:
> Hi Jon,
>
> On Tue, Apr 10, 2012 at 01:20:37, Hunter, Jon wrote:
>>> Because num_irq (or available irqs for fictitious irq chip) is platform specific.
>>
>> Ok, so OMAP_GPMC_NR_IRQS is defined and will not vary from device to
>> device, so why pass this? Why not use it directly?
>
> Because OMAP_GPMC_NR_IRQS is platform specific, final intention is to
> not have any platform specific header files in GPMC driver, not sure
> as of now whether it would be possible. So keeping platform specific
> things away from the driver as much as possible.
>
> And consider scenario where GPMC IP is used in other than OMAP family,
> even though this a theoretical case, wanted to stress the point that
> intention is to keep driver platform independent.
>
> Or else dynamic allocation of irqs may have to be used.
I agree with your argument but I was thinking today only OMAP uses the
GPMC so we could not worry about this. Ok, leave as-is, but can we
modify the code as follows as the "else if" is not really needed...
if (gpmc->num_irq < GPMC_NR_IRQ) {
dev_warn(gpmc->dev, "Insufficient interrupts for device\n");
return -EINVAL;
}
gpmc->num_irq = GPMC_NR_IRQ;
>>
>> Furthermore, GPMC_NR_IRQ is defined as 6 which is correct for OMAP2/3
>> but not for OMAP4/5, it is 5. Therefore, we need to detect whether we
>> are using an OMAP2/3 or OMAP4+ and set num_irqs based upon this. This
>> could be done in the probe and we can avoid passing this.
>
> Is it dependent on OMAPX or GPMC IP version? if it is IP version, then driver
> can be enhanced to handle it, if not, platform has to pass this information.
Here are the GPMC IP revisions ...
OMAP5430 = 0x00000060
OMAP4430 = 0x00000060
OMAP3630 = 0x00000050
OMAP3430 = 0x00000050
So this should work for OMAP. We should check OMAP2 as well. What about
the AMxxx devices?
>>>>> + res = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
>>>>> + if (res == NULL)
>>>>> + dev_warn(gpmc->dev, "Failed to get resource: irq\n");
>>>>> + else
>>>>> + gpmc->master_irq = res->start;
>>>>
>>>> Why not return an error if the IRQ is not found? We don't know if anyone
>>>> will be trying to use them.
>>>
>>> Why do you want to do that ?
>>
>> Because this indicates a BUG :-)
>
> I disagree, this need not be considered a bug always,
> for eg. If gpmc irq is not connected to intc
Ok, so for devices existing today this indicates a bug ;-)
At a minimum you need to improve the error handing here. If the
platform_get_resource fails you are still calling "gpmc_setup_irq()"
which appears to be pointless. It would be better if the gpmc irq chip
is not initialised in this case so that drivers attempting to request
these irqs failed.
Also in gpmc_setup_irq() you have two for loops incrementing through 0
to gpmc->num_irq, can these for loops be combined?
>>> If someone (say NAND) wants to work with irq, and if interrupt is not
>>> available, NAND driver can fail, and suppose smsc911x ethernet is present
>>> and he is not using gpmc irq, if we fail here, smsc911x also would
>>> not work, which would have worked otherwise.
>>>
>>> It is a different matter that even NAND setup will happen properly,
>>> even if interrupt is not available, it is only when NAND is told to
>>> work with IRQ, it fails, please see nand patches.
>>>
>>> And as of now in mainline (with the code as is), there is not a single
>>> board that will need gpmc irq for gpmc peripherals to work.
>>>
>>> I feel we should try to get more devices working rather than preventing
>>> more devices from working, when it could have.
>>
>> I understand your point, but then you are hiding a BUG. If someone
>> introduces a BUG that causes this to fail, then it is easier to detect,
>> find and fix.
>>
>> From my perspective get the resources should never fail and if it does
>> and break the driver for all devices, then so be it, because a BUG has
>> been introduced. Ok, this may not be critical at this point but still is
>> should not fail.
>
> Agree for resources which are a must for device to work, not for resources
> that can enhance its capability.
If we can ensure that a device using the gpmc driver would fail when
requesting a specific gpmc irq (if the gpmc driver has failed to
initialise its irqs) then this would be ok. In other words, a device
calling request_irq for one of the pseudo gpmc irqs returns failure if
the gpmc itself failed to setup them up.
>>
>>>>> + for (gdq = gp->device_pdata, gd = gpmc->device; *gdq; gdq++, i++) {
>>>>> + ret = gpmc_setup_device(*gdq, gd, gpmc);
>>>>> + if (IS_ERR_VALUE(ret))
>>>>> + dev_err(gpmc->dev, "gpmc setup on %s failed\n",
>>>>> + (*gdq)->name);
>>>>> + else
>>>>> + gd++;
>>>>> + }
>>>>
>>>> Would a while loop be simpler?
>>>
>>> My preference is to go with "for"
>>
>> Ok, just wondering if this could be cleaned up a little.
>
> For travelling through array of pointers, for looks natural to me, if you
> have a better way, please send it, it can be folded in next version.
Could you have num_devices to indicate how many platform devices there
are and then a simple for-loop of 0 to num_devices?
Cheers
Jon
^ permalink raw reply [flat|nested] 73+ messages in thread
* Re: [PATCH v3 1/9] ARM: OMAP2+: gpmc: driver conversion
@ 2012-04-10 19:23 ` Jon Hunter
0 siblings, 0 replies; 73+ messages in thread
From: Jon Hunter @ 2012-04-10 19:23 UTC (permalink / raw)
To: Mohammed, Afzal
Cc: tony, Hilman, Kevin, linux, dwmw2, sameo, grinberg, mike, Menon,
Nishanth, artem.bityutskiy, vimal.newwork, dbaryshkov,
linux-omap, linux-arm-kernel, linux-mtd, linux-kernel, Hiremath,
Vaibhav
Hi Afzal,
On 04/10/2012 06:00 AM, Mohammed, Afzal wrote:
> Hi Jon,
>
> On Tue, Apr 10, 2012 at 01:20:37, Hunter, Jon wrote:
>>> Because num_irq (or available irqs for fictitious irq chip) is platform specific.
>>
>> Ok, so OMAP_GPMC_NR_IRQS is defined and will not vary from device to
>> device, so why pass this? Why not use it directly?
>
> Because OMAP_GPMC_NR_IRQS is platform specific, final intention is to
> not have any platform specific header files in GPMC driver, not sure
> as of now whether it would be possible. So keeping platform specific
> things away from the driver as much as possible.
>
> And consider scenario where GPMC IP is used in other than OMAP family,
> even though this a theoretical case, wanted to stress the point that
> intention is to keep driver platform independent.
>
> Or else dynamic allocation of irqs may have to be used.
I agree with your argument but I was thinking today only OMAP uses the
GPMC so we could not worry about this. Ok, leave as-is, but can we
modify the code as follows as the "else if" is not really needed...
if (gpmc->num_irq < GPMC_NR_IRQ) {
dev_warn(gpmc->dev, "Insufficient interrupts for device\n");
return -EINVAL;
}
gpmc->num_irq = GPMC_NR_IRQ;
>>
>> Furthermore, GPMC_NR_IRQ is defined as 6 which is correct for OMAP2/3
>> but not for OMAP4/5, it is 5. Therefore, we need to detect whether we
>> are using an OMAP2/3 or OMAP4+ and set num_irqs based upon this. This
>> could be done in the probe and we can avoid passing this.
>
> Is it dependent on OMAPX or GPMC IP version? if it is IP version, then driver
> can be enhanced to handle it, if not, platform has to pass this information.
Here are the GPMC IP revisions ...
OMAP5430 = 0x00000060
OMAP4430 = 0x00000060
OMAP3630 = 0x00000050
OMAP3430 = 0x00000050
So this should work for OMAP. We should check OMAP2 as well. What about
the AMxxx devices?
>>>>> + res = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
>>>>> + if (res == NULL)
>>>>> + dev_warn(gpmc->dev, "Failed to get resource: irq\n");
>>>>> + else
>>>>> + gpmc->master_irq = res->start;
>>>>
>>>> Why not return an error if the IRQ is not found? We don't know if anyone
>>>> will be trying to use them.
>>>
>>> Why do you want to do that ?
>>
>> Because this indicates a BUG :-)
>
> I disagree, this need not be considered a bug always,
> for eg. If gpmc irq is not connected to intc
Ok, so for devices existing today this indicates a bug ;-)
At a minimum you need to improve the error handing here. If the
platform_get_resource fails you are still calling "gpmc_setup_irq()"
which appears to be pointless. It would be better if the gpmc irq chip
is not initialised in this case so that drivers attempting to request
these irqs failed.
Also in gpmc_setup_irq() you have two for loops incrementing through 0
to gpmc->num_irq, can these for loops be combined?
>>> If someone (say NAND) wants to work with irq, and if interrupt is not
>>> available, NAND driver can fail, and suppose smsc911x ethernet is present
>>> and he is not using gpmc irq, if we fail here, smsc911x also would
>>> not work, which would have worked otherwise.
>>>
>>> It is a different matter that even NAND setup will happen properly,
>>> even if interrupt is not available, it is only when NAND is told to
>>> work with IRQ, it fails, please see nand patches.
>>>
>>> And as of now in mainline (with the code as is), there is not a single
>>> board that will need gpmc irq for gpmc peripherals to work.
>>>
>>> I feel we should try to get more devices working rather than preventing
>>> more devices from working, when it could have.
>>
>> I understand your point, but then you are hiding a BUG. If someone
>> introduces a BUG that causes this to fail, then it is easier to detect,
>> find and fix.
>>
>> From my perspective get the resources should never fail and if it does
>> and break the driver for all devices, then so be it, because a BUG has
>> been introduced. Ok, this may not be critical at this point but still is
>> should not fail.
>
> Agree for resources which are a must for device to work, not for resources
> that can enhance its capability.
If we can ensure that a device using the gpmc driver would fail when
requesting a specific gpmc irq (if the gpmc driver has failed to
initialise its irqs) then this would be ok. In other words, a device
calling request_irq for one of the pseudo gpmc irqs returns failure if
the gpmc itself failed to setup them up.
>>
>>>>> + for (gdq = gp->device_pdata, gd = gpmc->device; *gdq; gdq++, i++) {
>>>>> + ret = gpmc_setup_device(*gdq, gd, gpmc);
>>>>> + if (IS_ERR_VALUE(ret))
>>>>> + dev_err(gpmc->dev, "gpmc setup on %s failed\n",
>>>>> + (*gdq)->name);
>>>>> + else
>>>>> + gd++;
>>>>> + }
>>>>
>>>> Would a while loop be simpler?
>>>
>>> My preference is to go with "for"
>>
>> Ok, just wondering if this could be cleaned up a little.
>
> For travelling through array of pointers, for looks natural to me, if you
> have a better way, please send it, it can be folded in next version.
Could you have num_devices to indicate how many platform devices there
are and then a simple for-loop of 0 to num_devices?
Cheers
Jon
^ permalink raw reply [flat|nested] 73+ messages in thread
* Re: [PATCH v3 1/9] ARM: OMAP2+: gpmc: driver conversion
@ 2012-04-10 19:23 ` Jon Hunter
0 siblings, 0 replies; 73+ messages in thread
From: Jon Hunter @ 2012-04-10 19:23 UTC (permalink / raw)
To: Mohammed, Afzal
Cc: Hilman, Kevin, Menon, Nishanth, linux, sameo, tony,
artem.bityutskiy, linux-kernel, Hiremath, Vaibhav, dbaryshkov,
vimal.newwork, grinberg, mike, linux-mtd, linux-omap, dwmw2,
linux-arm-kernel
Hi Afzal,
On 04/10/2012 06:00 AM, Mohammed, Afzal wrote:
> Hi Jon,
>
> On Tue, Apr 10, 2012 at 01:20:37, Hunter, Jon wrote:
>>> Because num_irq (or available irqs for fictitious irq chip) is platform specific.
>>
>> Ok, so OMAP_GPMC_NR_IRQS is defined and will not vary from device to
>> device, so why pass this? Why not use it directly?
>
> Because OMAP_GPMC_NR_IRQS is platform specific, final intention is to
> not have any platform specific header files in GPMC driver, not sure
> as of now whether it would be possible. So keeping platform specific
> things away from the driver as much as possible.
>
> And consider scenario where GPMC IP is used in other than OMAP family,
> even though this a theoretical case, wanted to stress the point that
> intention is to keep driver platform independent.
>
> Or else dynamic allocation of irqs may have to be used.
I agree with your argument but I was thinking today only OMAP uses the
GPMC so we could not worry about this. Ok, leave as-is, but can we
modify the code as follows as the "else if" is not really needed...
if (gpmc->num_irq < GPMC_NR_IRQ) {
dev_warn(gpmc->dev, "Insufficient interrupts for device\n");
return -EINVAL;
}
gpmc->num_irq = GPMC_NR_IRQ;
>>
>> Furthermore, GPMC_NR_IRQ is defined as 6 which is correct for OMAP2/3
>> but not for OMAP4/5, it is 5. Therefore, we need to detect whether we
>> are using an OMAP2/3 or OMAP4+ and set num_irqs based upon this. This
>> could be done in the probe and we can avoid passing this.
>
> Is it dependent on OMAPX or GPMC IP version? if it is IP version, then driver
> can be enhanced to handle it, if not, platform has to pass this information.
Here are the GPMC IP revisions ...
OMAP5430 = 0x00000060
OMAP4430 = 0x00000060
OMAP3630 = 0x00000050
OMAP3430 = 0x00000050
So this should work for OMAP. We should check OMAP2 as well. What about
the AMxxx devices?
>>>>> + res = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
>>>>> + if (res == NULL)
>>>>> + dev_warn(gpmc->dev, "Failed to get resource: irq\n");
>>>>> + else
>>>>> + gpmc->master_irq = res->start;
>>>>
>>>> Why not return an error if the IRQ is not found? We don't know if anyone
>>>> will be trying to use them.
>>>
>>> Why do you want to do that ?
>>
>> Because this indicates a BUG :-)
>
> I disagree, this need not be considered a bug always,
> for eg. If gpmc irq is not connected to intc
Ok, so for devices existing today this indicates a bug ;-)
At a minimum you need to improve the error handing here. If the
platform_get_resource fails you are still calling "gpmc_setup_irq()"
which appears to be pointless. It would be better if the gpmc irq chip
is not initialised in this case so that drivers attempting to request
these irqs failed.
Also in gpmc_setup_irq() you have two for loops incrementing through 0
to gpmc->num_irq, can these for loops be combined?
>>> If someone (say NAND) wants to work with irq, and if interrupt is not
>>> available, NAND driver can fail, and suppose smsc911x ethernet is present
>>> and he is not using gpmc irq, if we fail here, smsc911x also would
>>> not work, which would have worked otherwise.
>>>
>>> It is a different matter that even NAND setup will happen properly,
>>> even if interrupt is not available, it is only when NAND is told to
>>> work with IRQ, it fails, please see nand patches.
>>>
>>> And as of now in mainline (with the code as is), there is not a single
>>> board that will need gpmc irq for gpmc peripherals to work.
>>>
>>> I feel we should try to get more devices working rather than preventing
>>> more devices from working, when it could have.
>>
>> I understand your point, but then you are hiding a BUG. If someone
>> introduces a BUG that causes this to fail, then it is easier to detect,
>> find and fix.
>>
>> From my perspective get the resources should never fail and if it does
>> and break the driver for all devices, then so be it, because a BUG has
>> been introduced. Ok, this may not be critical at this point but still is
>> should not fail.
>
> Agree for resources which are a must for device to work, not for resources
> that can enhance its capability.
If we can ensure that a device using the gpmc driver would fail when
requesting a specific gpmc irq (if the gpmc driver has failed to
initialise its irqs) then this would be ok. In other words, a device
calling request_irq for one of the pseudo gpmc irqs returns failure if
the gpmc itself failed to setup them up.
>>
>>>>> + for (gdq = gp->device_pdata, gd = gpmc->device; *gdq; gdq++, i++) {
>>>>> + ret = gpmc_setup_device(*gdq, gd, gpmc);
>>>>> + if (IS_ERR_VALUE(ret))
>>>>> + dev_err(gpmc->dev, "gpmc setup on %s failed\n",
>>>>> + (*gdq)->name);
>>>>> + else
>>>>> + gd++;
>>>>> + }
>>>>
>>>> Would a while loop be simpler?
>>>
>>> My preference is to go with "for"
>>
>> Ok, just wondering if this could be cleaned up a little.
>
> For travelling through array of pointers, for looks natural to me, if you
> have a better way, please send it, it can be folded in next version.
Could you have num_devices to indicate how many platform devices there
are and then a simple for-loop of 0 to num_devices?
Cheers
Jon
^ permalink raw reply [flat|nested] 73+ messages in thread
* [PATCH v3 1/9] ARM: OMAP2+: gpmc: driver conversion
@ 2012-04-10 19:23 ` Jon Hunter
0 siblings, 0 replies; 73+ messages in thread
From: Jon Hunter @ 2012-04-10 19:23 UTC (permalink / raw)
To: linux-arm-kernel
Hi Afzal,
On 04/10/2012 06:00 AM, Mohammed, Afzal wrote:
> Hi Jon,
>
> On Tue, Apr 10, 2012 at 01:20:37, Hunter, Jon wrote:
>>> Because num_irq (or available irqs for fictitious irq chip) is platform specific.
>>
>> Ok, so OMAP_GPMC_NR_IRQS is defined and will not vary from device to
>> device, so why pass this? Why not use it directly?
>
> Because OMAP_GPMC_NR_IRQS is platform specific, final intention is to
> not have any platform specific header files in GPMC driver, not sure
> as of now whether it would be possible. So keeping platform specific
> things away from the driver as much as possible.
>
> And consider scenario where GPMC IP is used in other than OMAP family,
> even though this a theoretical case, wanted to stress the point that
> intention is to keep driver platform independent.
>
> Or else dynamic allocation of irqs may have to be used.
I agree with your argument but I was thinking today only OMAP uses the
GPMC so we could not worry about this. Ok, leave as-is, but can we
modify the code as follows as the "else if" is not really needed...
if (gpmc->num_irq < GPMC_NR_IRQ) {
dev_warn(gpmc->dev, "Insufficient interrupts for device\n");
return -EINVAL;
}
gpmc->num_irq = GPMC_NR_IRQ;
>>
>> Furthermore, GPMC_NR_IRQ is defined as 6 which is correct for OMAP2/3
>> but not for OMAP4/5, it is 5. Therefore, we need to detect whether we
>> are using an OMAP2/3 or OMAP4+ and set num_irqs based upon this. This
>> could be done in the probe and we can avoid passing this.
>
> Is it dependent on OMAPX or GPMC IP version? if it is IP version, then driver
> can be enhanced to handle it, if not, platform has to pass this information.
Here are the GPMC IP revisions ...
OMAP5430 = 0x00000060
OMAP4430 = 0x00000060
OMAP3630 = 0x00000050
OMAP3430 = 0x00000050
So this should work for OMAP. We should check OMAP2 as well. What about
the AMxxx devices?
>>>>> + res = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
>>>>> + if (res == NULL)
>>>>> + dev_warn(gpmc->dev, "Failed to get resource: irq\n");
>>>>> + else
>>>>> + gpmc->master_irq = res->start;
>>>>
>>>> Why not return an error if the IRQ is not found? We don't know if anyone
>>>> will be trying to use them.
>>>
>>> Why do you want to do that ?
>>
>> Because this indicates a BUG :-)
>
> I disagree, this need not be considered a bug always,
> for eg. If gpmc irq is not connected to intc
Ok, so for devices existing today this indicates a bug ;-)
At a minimum you need to improve the error handing here. If the
platform_get_resource fails you are still calling "gpmc_setup_irq()"
which appears to be pointless. It would be better if the gpmc irq chip
is not initialised in this case so that drivers attempting to request
these irqs failed.
Also in gpmc_setup_irq() you have two for loops incrementing through 0
to gpmc->num_irq, can these for loops be combined?
>>> If someone (say NAND) wants to work with irq, and if interrupt is not
>>> available, NAND driver can fail, and suppose smsc911x ethernet is present
>>> and he is not using gpmc irq, if we fail here, smsc911x also would
>>> not work, which would have worked otherwise.
>>>
>>> It is a different matter that even NAND setup will happen properly,
>>> even if interrupt is not available, it is only when NAND is told to
>>> work with IRQ, it fails, please see nand patches.
>>>
>>> And as of now in mainline (with the code as is), there is not a single
>>> board that will need gpmc irq for gpmc peripherals to work.
>>>
>>> I feel we should try to get more devices working rather than preventing
>>> more devices from working, when it could have.
>>
>> I understand your point, but then you are hiding a BUG. If someone
>> introduces a BUG that causes this to fail, then it is easier to detect,
>> find and fix.
>>
>> From my perspective get the resources should never fail and if it does
>> and break the driver for all devices, then so be it, because a BUG has
>> been introduced. Ok, this may not be critical at this point but still is
>> should not fail.
>
> Agree for resources which are a must for device to work, not for resources
> that can enhance its capability.
If we can ensure that a device using the gpmc driver would fail when
requesting a specific gpmc irq (if the gpmc driver has failed to
initialise its irqs) then this would be ok. In other words, a device
calling request_irq for one of the pseudo gpmc irqs returns failure if
the gpmc itself failed to setup them up.
>>
>>>>> + for (gdq = gp->device_pdata, gd = gpmc->device; *gdq; gdq++, i++) {
>>>>> + ret = gpmc_setup_device(*gdq, gd, gpmc);
>>>>> + if (IS_ERR_VALUE(ret))
>>>>> + dev_err(gpmc->dev, "gpmc setup on %s failed\n",
>>>>> + (*gdq)->name);
>>>>> + else
>>>>> + gd++;
>>>>> + }
>>>>
>>>> Would a while loop be simpler?
>>>
>>> My preference is to go with "for"
>>
>> Ok, just wondering if this could be cleaned up a little.
>
> For travelling through array of pointers, for looks natural to me, if you
> have a better way, please send it, it can be folded in next version.
Could you have num_devices to indicate how many platform devices there
are and then a simple for-loop of 0 to num_devices?
Cheers
Jon
^ permalink raw reply [flat|nested] 73+ messages in thread
* Re: [PATCH v3 4/9] ARM: OMAP2+: gpmc-nand: populate gpmc configs
2012-04-05 15:46 ` Afzal Mohammed
(?)
(?)
@ 2012-04-10 19:24 ` Jon Hunter
-1 siblings, 0 replies; 73+ messages in thread
From: Jon Hunter @ 2012-04-10 19:24 UTC (permalink / raw)
To: Afzal Mohammed
Cc: tony, khilman, linux, dwmw2, sameo, grinberg, mike, nm,
artem.bityutskiy, vimal.newwork, dbaryshkov, linux-omap,
linux-arm-kernel, linux-mtd, linux-kernel
Hi Afzal,
On 04/05/2012 10:46 AM, Afzal Mohammed wrote:
> Currently gpmc is configured in platform for nand.
> As configuring gpmc has been moved to gpmc driver,
> populate details needed for the driver to configure
> gpmc. gpmc driver would configure based on this
> information.
>
> Signed-off-by: Afzal Mohammed<afzal@ti.com>
> ---
> arch/arm/mach-omap2/gpmc-nand.c | 97 ++++++++++++++------------------
> arch/arm/plat-omap/include/plat/nand.h | 8 ++-
> 2 files changed, 48 insertions(+), 57 deletions(-)
>
> diff --git a/arch/arm/mach-omap2/gpmc-nand.c b/arch/arm/mach-omap2/gpmc-nand.c
> index 386dec8..85de31f 100644
> --- a/arch/arm/mach-omap2/gpmc-nand.c
> +++ b/arch/arm/mach-omap2/gpmc-nand.c
> @@ -21,24 +21,38 @@
> #include<plat/board.h>
> #include<plat/gpmc.h>
>
> -static struct resource gpmc_nand_resource = {
> - .flags = IORESOURCE_MEM,
> +
> +#define GPMC_NAND_CONFIG_NUM 4
Where does 4 come from?
Jon
^ permalink raw reply [flat|nested] 73+ messages in thread
* Re: [PATCH v3 4/9] ARM: OMAP2+: gpmc-nand: populate gpmc configs
@ 2012-04-10 19:24 ` Jon Hunter
0 siblings, 0 replies; 73+ messages in thread
From: Jon Hunter @ 2012-04-10 19:24 UTC (permalink / raw)
To: Afzal Mohammed
Cc: tony, khilman, linux, dwmw2, sameo, grinberg, mike, nm,
artem.bityutskiy, vimal.newwork, dbaryshkov, linux-omap,
linux-arm-kernel, linux-mtd, linux-kernel
Hi Afzal,
On 04/05/2012 10:46 AM, Afzal Mohammed wrote:
> Currently gpmc is configured in platform for nand.
> As configuring gpmc has been moved to gpmc driver,
> populate details needed for the driver to configure
> gpmc. gpmc driver would configure based on this
> information.
>
> Signed-off-by: Afzal Mohammed<afzal@ti.com>
> ---
> arch/arm/mach-omap2/gpmc-nand.c | 97 ++++++++++++++------------------
> arch/arm/plat-omap/include/plat/nand.h | 8 ++-
> 2 files changed, 48 insertions(+), 57 deletions(-)
>
> diff --git a/arch/arm/mach-omap2/gpmc-nand.c b/arch/arm/mach-omap2/gpmc-nand.c
> index 386dec8..85de31f 100644
> --- a/arch/arm/mach-omap2/gpmc-nand.c
> +++ b/arch/arm/mach-omap2/gpmc-nand.c
> @@ -21,24 +21,38 @@
> #include<plat/board.h>
> #include<plat/gpmc.h>
>
> -static struct resource gpmc_nand_resource = {
> - .flags = IORESOURCE_MEM,
> +
> +#define GPMC_NAND_CONFIG_NUM 4
Where does 4 come from?
Jon
^ permalink raw reply [flat|nested] 73+ messages in thread
* Re: [PATCH v3 4/9] ARM: OMAP2+: gpmc-nand: populate gpmc configs
@ 2012-04-10 19:24 ` Jon Hunter
0 siblings, 0 replies; 73+ messages in thread
From: Jon Hunter @ 2012-04-10 19:24 UTC (permalink / raw)
To: Afzal Mohammed
Cc: khilman, nm, linux, sameo, tony, artem.bityutskiy, linux-kernel,
dbaryshkov, vimal.newwork, grinberg, mike, linux-mtd, linux-omap,
dwmw2, linux-arm-kernel
Hi Afzal,
On 04/05/2012 10:46 AM, Afzal Mohammed wrote:
> Currently gpmc is configured in platform for nand.
> As configuring gpmc has been moved to gpmc driver,
> populate details needed for the driver to configure
> gpmc. gpmc driver would configure based on this
> information.
>
> Signed-off-by: Afzal Mohammed<afzal@ti.com>
> ---
> arch/arm/mach-omap2/gpmc-nand.c | 97 ++++++++++++++------------------
> arch/arm/plat-omap/include/plat/nand.h | 8 ++-
> 2 files changed, 48 insertions(+), 57 deletions(-)
>
> diff --git a/arch/arm/mach-omap2/gpmc-nand.c b/arch/arm/mach-omap2/gpmc-nand.c
> index 386dec8..85de31f 100644
> --- a/arch/arm/mach-omap2/gpmc-nand.c
> +++ b/arch/arm/mach-omap2/gpmc-nand.c
> @@ -21,24 +21,38 @@
> #include<plat/board.h>
> #include<plat/gpmc.h>
>
> -static struct resource gpmc_nand_resource = {
> - .flags = IORESOURCE_MEM,
> +
> +#define GPMC_NAND_CONFIG_NUM 4
Where does 4 come from?
Jon
^ permalink raw reply [flat|nested] 73+ messages in thread
* [PATCH v3 4/9] ARM: OMAP2+: gpmc-nand: populate gpmc configs
@ 2012-04-10 19:24 ` Jon Hunter
0 siblings, 0 replies; 73+ messages in thread
From: Jon Hunter @ 2012-04-10 19:24 UTC (permalink / raw)
To: linux-arm-kernel
Hi Afzal,
On 04/05/2012 10:46 AM, Afzal Mohammed wrote:
> Currently gpmc is configured in platform for nand.
> As configuring gpmc has been moved to gpmc driver,
> populate details needed for the driver to configure
> gpmc. gpmc driver would configure based on this
> information.
>
> Signed-off-by: Afzal Mohammed<afzal@ti.com>
> ---
> arch/arm/mach-omap2/gpmc-nand.c | 97 ++++++++++++++------------------
> arch/arm/plat-omap/include/plat/nand.h | 8 ++-
> 2 files changed, 48 insertions(+), 57 deletions(-)
>
> diff --git a/arch/arm/mach-omap2/gpmc-nand.c b/arch/arm/mach-omap2/gpmc-nand.c
> index 386dec8..85de31f 100644
> --- a/arch/arm/mach-omap2/gpmc-nand.c
> +++ b/arch/arm/mach-omap2/gpmc-nand.c
> @@ -21,24 +21,38 @@
> #include<plat/board.h>
> #include<plat/gpmc.h>
>
> -static struct resource gpmc_nand_resource = {
> - .flags = IORESOURCE_MEM,
> +
> +#define GPMC_NAND_CONFIG_NUM 4
Where does 4 come from?
Jon
^ permalink raw reply [flat|nested] 73+ messages in thread
* RE: [PATCH v3 1/9] ARM: OMAP2+: gpmc: driver conversion
2012-04-10 19:23 ` Jon Hunter
(?)
(?)
@ 2012-04-11 5:11 ` Mohammed, Afzal
-1 siblings, 0 replies; 73+ messages in thread
From: Mohammed, Afzal @ 2012-04-11 5:11 UTC (permalink / raw)
To: Hunter, Jon
Cc: tony, Hilman, Kevin, linux, dwmw2, sameo, grinberg, mike, Menon,
Nishanth, artem.bityutskiy, vimal.newwork, dbaryshkov,
linux-omap, linux-arm-kernel, linux-mtd, linux-kernel, Hiremath,
Vaibhav
Hi Jon,
On Wed, Apr 11, 2012 at 00:53:14, Hunter, Jon wrote:
> I agree with your argument but I was thinking today only OMAP uses the
> GPMC so we could not worry about this. Ok, leave as-is, but can we
> modify the code as follows as the "else if" is not really needed...
>
> if (gpmc->num_irq < GPMC_NR_IRQ) {
> dev_warn(gpmc->dev, "Insufficient interrupts for device\n");
> return -EINVAL;
> }
>
> gpmc->num_irq = GPMC_NR_IRQ;
Yes, it is better
>
> >>
> >> Furthermore, GPMC_NR_IRQ is defined as 6 which is correct for OMAP2/3
> >> but not for OMAP4/5, it is 5. Therefore, we need to detect whether we
> >> are using an OMAP2/3 or OMAP4+ and set num_irqs based upon this. This
> >> could be done in the probe and we can avoid passing this.
> >
> > Is it dependent on OMAPX or GPMC IP version? if it is IP version, then driver
> > can be enhanced to handle it, if not, platform has to pass this information.
>
> Here are the GPMC IP revisions ...
>
> OMAP5430 = 0x00000060
> OMAP4430 = 0x00000060
> OMAP3630 = 0x00000050
> OMAP3430 = 0x00000050
>
> So this should work for OMAP. We should check OMAP2 as well. What about
> the AMxxx devices?
I badly needed this information, thanks.
AM3359 = 0x00000060, it has only 2 waitpin interrupts
> >>>>> + res = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
> >>>>> + if (res == NULL)
> >>>>> + dev_warn(gpmc->dev, "Failed to get resource: irq\n");
> >>>>> + else
> >>>>> + gpmc->master_irq = res->start;
> >>>>
> >>>> Why not return an error if the IRQ is not found? We don't know if anyone
> >>>> will be trying to use them.
> >>>
> >>> Why do you want to do that ?
> >>
> >> Because this indicates a BUG :-)
> >
> > I disagree, this need not be considered a bug always,
> > for eg. If gpmc irq is not connected to intc
>
> Ok, so for devices existing today this indicates a bug ;-)
I do not want to consider that case to be bug enough for probe
to fail, there are other drivers which does similar enhancing
its use cases,
eg. 1e351a9 mfd: Make TPS65910 usable without interrupts
>
> At a minimum you need to improve the error handing here. If the
> platform_get_resource fails you are still calling "gpmc_setup_irq()"
> which appears to be pointless. It would be better if the gpmc irq chip
> is not initialised in this case so that drivers attempting to request
> these irqs failed.
Please see gpmc_setup_irq, if irq is not present, it returns in the
beginning, and gpmc_irq_chip is not initialized in that case.
> >>>>> + for (gdq = gp->device_pdata, gd = gpmc->device; *gdq; gdq++, i++) {
> >>>>> + ret = gpmc_setup_device(*gdq, gd, gpmc);
> >>>>> + if (IS_ERR_VALUE(ret))
> >>>>> + dev_err(gpmc->dev, "gpmc setup on %s failed\n",
> >>>>> + (*gdq)->name);
> >>>>> + else
> >>>>> + gd++;
> >>>>> + }
> >>>>
> >>>> Would a while loop be simpler?
> >>>
> >>> My preference is to go with "for"
> >>
> >> Ok, just wondering if this could be cleaned up a little.
> >
> > For travelling through array of pointers, for looks natural to me, if you
> > have a better way, please send it, it can be folded in next version.
>
> Could you have num_devices to indicate how many platform devices there
> are and then a simple for-loop of 0 to num_devices?
This will cause coding to be done by platform to be less simple, and my
preference is not to use another variable
Regards
Afzal
^ permalink raw reply [flat|nested] 73+ messages in thread
* RE: [PATCH v3 1/9] ARM: OMAP2+: gpmc: driver conversion
@ 2012-04-11 5:11 ` Mohammed, Afzal
0 siblings, 0 replies; 73+ messages in thread
From: Mohammed, Afzal @ 2012-04-11 5:11 UTC (permalink / raw)
To: Hunter, Jon
Cc: tony, Hilman, Kevin, linux, dwmw2, sameo, grinberg, mike, Menon,
Nishanth, artem.bityutskiy, vimal.newwork, dbaryshkov,
linux-omap, linux-arm-kernel, linux-mtd, linux-kernel, Hiremath,
Vaibhav
Hi Jon,
On Wed, Apr 11, 2012 at 00:53:14, Hunter, Jon wrote:
> I agree with your argument but I was thinking today only OMAP uses the
> GPMC so we could not worry about this. Ok, leave as-is, but can we
> modify the code as follows as the "else if" is not really needed...
>
> if (gpmc->num_irq < GPMC_NR_IRQ) {
> dev_warn(gpmc->dev, "Insufficient interrupts for device\n");
> return -EINVAL;
> }
>
> gpmc->num_irq = GPMC_NR_IRQ;
Yes, it is better
>
> >>
> >> Furthermore, GPMC_NR_IRQ is defined as 6 which is correct for OMAP2/3
> >> but not for OMAP4/5, it is 5. Therefore, we need to detect whether we
> >> are using an OMAP2/3 or OMAP4+ and set num_irqs based upon this. This
> >> could be done in the probe and we can avoid passing this.
> >
> > Is it dependent on OMAPX or GPMC IP version? if it is IP version, then driver
> > can be enhanced to handle it, if not, platform has to pass this information.
>
> Here are the GPMC IP revisions ...
>
> OMAP5430 = 0x00000060
> OMAP4430 = 0x00000060
> OMAP3630 = 0x00000050
> OMAP3430 = 0x00000050
>
> So this should work for OMAP. We should check OMAP2 as well. What about
> the AMxxx devices?
I badly needed this information, thanks.
AM3359 = 0x00000060, it has only 2 waitpin interrupts
> >>>>> + res = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
> >>>>> + if (res == NULL)
> >>>>> + dev_warn(gpmc->dev, "Failed to get resource: irq\n");
> >>>>> + else
> >>>>> + gpmc->master_irq = res->start;
> >>>>
> >>>> Why not return an error if the IRQ is not found? We don't know if anyone
> >>>> will be trying to use them.
> >>>
> >>> Why do you want to do that ?
> >>
> >> Because this indicates a BUG :-)
> >
> > I disagree, this need not be considered a bug always,
> > for eg. If gpmc irq is not connected to intc
>
> Ok, so for devices existing today this indicates a bug ;-)
I do not want to consider that case to be bug enough for probe
to fail, there are other drivers which does similar enhancing
its use cases,
eg. 1e351a9 mfd: Make TPS65910 usable without interrupts
>
> At a minimum you need to improve the error handing here. If the
> platform_get_resource fails you are still calling "gpmc_setup_irq()"
> which appears to be pointless. It would be better if the gpmc irq chip
> is not initialised in this case so that drivers attempting to request
> these irqs failed.
Please see gpmc_setup_irq, if irq is not present, it returns in the
beginning, and gpmc_irq_chip is not initialized in that case.
> >>>>> + for (gdq = gp->device_pdata, gd = gpmc->device; *gdq; gdq++, i++) {
> >>>>> + ret = gpmc_setup_device(*gdq, gd, gpmc);
> >>>>> + if (IS_ERR_VALUE(ret))
> >>>>> + dev_err(gpmc->dev, "gpmc setup on %s failed\n",
> >>>>> + (*gdq)->name);
> >>>>> + else
> >>>>> + gd++;
> >>>>> + }
> >>>>
> >>>> Would a while loop be simpler?
> >>>
> >>> My preference is to go with "for"
> >>
> >> Ok, just wondering if this could be cleaned up a little.
> >
> > For travelling through array of pointers, for looks natural to me, if you
> > have a better way, please send it, it can be folded in next version.
>
> Could you have num_devices to indicate how many platform devices there
> are and then a simple for-loop of 0 to num_devices?
This will cause coding to be done by platform to be less simple, and my
preference is not to use another variable
Regards
Afzal
^ permalink raw reply [flat|nested] 73+ messages in thread
* RE: [PATCH v3 1/9] ARM: OMAP2+: gpmc: driver conversion
@ 2012-04-11 5:11 ` Mohammed, Afzal
0 siblings, 0 replies; 73+ messages in thread
From: Mohammed, Afzal @ 2012-04-11 5:11 UTC (permalink / raw)
To: Hunter, Jon
Cc: Hilman, Kevin, Menon, Nishanth, linux, sameo, tony,
artem.bityutskiy, linux-kernel, Hiremath, Vaibhav, dbaryshkov,
vimal.newwork, grinberg, mike, linux-mtd, linux-omap, dwmw2,
linux-arm-kernel
Hi Jon,
On Wed, Apr 11, 2012 at 00:53:14, Hunter, Jon wrote:
> I agree with your argument but I was thinking today only OMAP uses the
> GPMC so we could not worry about this. Ok, leave as-is, but can we
> modify the code as follows as the "else if" is not really needed...
>
> if (gpmc->num_irq < GPMC_NR_IRQ) {
> dev_warn(gpmc->dev, "Insufficient interrupts for device\n");
> return -EINVAL;
> }
>
> gpmc->num_irq = GPMC_NR_IRQ;
Yes, it is better
>
> >>
> >> Furthermore, GPMC_NR_IRQ is defined as 6 which is correct for OMAP2/3
> >> but not for OMAP4/5, it is 5. Therefore, we need to detect whether we
> >> are using an OMAP2/3 or OMAP4+ and set num_irqs based upon this. This
> >> could be done in the probe and we can avoid passing this.
> >
> > Is it dependent on OMAPX or GPMC IP version? if it is IP version, then driver
> > can be enhanced to handle it, if not, platform has to pass this information.
>
> Here are the GPMC IP revisions ...
>
> OMAP5430 = 0x00000060
> OMAP4430 = 0x00000060
> OMAP3630 = 0x00000050
> OMAP3430 = 0x00000050
>
> So this should work for OMAP. We should check OMAP2 as well. What about
> the AMxxx devices?
I badly needed this information, thanks.
AM3359 = 0x00000060, it has only 2 waitpin interrupts
> >>>>> + res = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
> >>>>> + if (res == NULL)
> >>>>> + dev_warn(gpmc->dev, "Failed to get resource: irq\n");
> >>>>> + else
> >>>>> + gpmc->master_irq = res->start;
> >>>>
> >>>> Why not return an error if the IRQ is not found? We don't know if anyone
> >>>> will be trying to use them.
> >>>
> >>> Why do you want to do that ?
> >>
> >> Because this indicates a BUG :-)
> >
> > I disagree, this need not be considered a bug always,
> > for eg. If gpmc irq is not connected to intc
>
> Ok, so for devices existing today this indicates a bug ;-)
I do not want to consider that case to be bug enough for probe
to fail, there are other drivers which does similar enhancing
its use cases,
eg. 1e351a9 mfd: Make TPS65910 usable without interrupts
>
> At a minimum you need to improve the error handing here. If the
> platform_get_resource fails you are still calling "gpmc_setup_irq()"
> which appears to be pointless. It would be better if the gpmc irq chip
> is not initialised in this case so that drivers attempting to request
> these irqs failed.
Please see gpmc_setup_irq, if irq is not present, it returns in the
beginning, and gpmc_irq_chip is not initialized in that case.
> >>>>> + for (gdq = gp->device_pdata, gd = gpmc->device; *gdq; gdq++, i++) {
> >>>>> + ret = gpmc_setup_device(*gdq, gd, gpmc);
> >>>>> + if (IS_ERR_VALUE(ret))
> >>>>> + dev_err(gpmc->dev, "gpmc setup on %s failed\n",
> >>>>> + (*gdq)->name);
> >>>>> + else
> >>>>> + gd++;
> >>>>> + }
> >>>>
> >>>> Would a while loop be simpler?
> >>>
> >>> My preference is to go with "for"
> >>
> >> Ok, just wondering if this could be cleaned up a little.
> >
> > For travelling through array of pointers, for looks natural to me, if you
> > have a better way, please send it, it can be folded in next version.
>
> Could you have num_devices to indicate how many platform devices there
> are and then a simple for-loop of 0 to num_devices?
This will cause coding to be done by platform to be less simple, and my
preference is not to use another variable
Regards
Afzal
^ permalink raw reply [flat|nested] 73+ messages in thread
* [PATCH v3 1/9] ARM: OMAP2+: gpmc: driver conversion
@ 2012-04-11 5:11 ` Mohammed, Afzal
0 siblings, 0 replies; 73+ messages in thread
From: Mohammed, Afzal @ 2012-04-11 5:11 UTC (permalink / raw)
To: linux-arm-kernel
Hi Jon,
On Wed, Apr 11, 2012 at 00:53:14, Hunter, Jon wrote:
> I agree with your argument but I was thinking today only OMAP uses the
> GPMC so we could not worry about this. Ok, leave as-is, but can we
> modify the code as follows as the "else if" is not really needed...
>
> if (gpmc->num_irq < GPMC_NR_IRQ) {
> dev_warn(gpmc->dev, "Insufficient interrupts for device\n");
> return -EINVAL;
> }
>
> gpmc->num_irq = GPMC_NR_IRQ;
Yes, it is better
>
> >>
> >> Furthermore, GPMC_NR_IRQ is defined as 6 which is correct for OMAP2/3
> >> but not for OMAP4/5, it is 5. Therefore, we need to detect whether we
> >> are using an OMAP2/3 or OMAP4+ and set num_irqs based upon this. This
> >> could be done in the probe and we can avoid passing this.
> >
> > Is it dependent on OMAPX or GPMC IP version? if it is IP version, then driver
> > can be enhanced to handle it, if not, platform has to pass this information.
>
> Here are the GPMC IP revisions ...
>
> OMAP5430 = 0x00000060
> OMAP4430 = 0x00000060
> OMAP3630 = 0x00000050
> OMAP3430 = 0x00000050
>
> So this should work for OMAP. We should check OMAP2 as well. What about
> the AMxxx devices?
I badly needed this information, thanks.
AM3359 = 0x00000060, it has only 2 waitpin interrupts
> >>>>> + res = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
> >>>>> + if (res == NULL)
> >>>>> + dev_warn(gpmc->dev, "Failed to get resource: irq\n");
> >>>>> + else
> >>>>> + gpmc->master_irq = res->start;
> >>>>
> >>>> Why not return an error if the IRQ is not found? We don't know if anyone
> >>>> will be trying to use them.
> >>>
> >>> Why do you want to do that ?
> >>
> >> Because this indicates a BUG :-)
> >
> > I disagree, this need not be considered a bug always,
> > for eg. If gpmc irq is not connected to intc
>
> Ok, so for devices existing today this indicates a bug ;-)
I do not want to consider that case to be bug enough for probe
to fail, there are other drivers which does similar enhancing
its use cases,
eg. 1e351a9 mfd: Make TPS65910 usable without interrupts
>
> At a minimum you need to improve the error handing here. If the
> platform_get_resource fails you are still calling "gpmc_setup_irq()"
> which appears to be pointless. It would be better if the gpmc irq chip
> is not initialised in this case so that drivers attempting to request
> these irqs failed.
Please see gpmc_setup_irq, if irq is not present, it returns in the
beginning, and gpmc_irq_chip is not initialized in that case.
> >>>>> + for (gdq = gp->device_pdata, gd = gpmc->device; *gdq; gdq++, i++) {
> >>>>> + ret = gpmc_setup_device(*gdq, gd, gpmc);
> >>>>> + if (IS_ERR_VALUE(ret))
> >>>>> + dev_err(gpmc->dev, "gpmc setup on %s failed\n",
> >>>>> + (*gdq)->name);
> >>>>> + else
> >>>>> + gd++;
> >>>>> + }
> >>>>
> >>>> Would a while loop be simpler?
> >>>
> >>> My preference is to go with "for"
> >>
> >> Ok, just wondering if this could be cleaned up a little.
> >
> > For travelling through array of pointers, for looks natural to me, if you
> > have a better way, please send it, it can be folded in next version.
>
> Could you have num_devices to indicate how many platform devices there
> are and then a simple for-loop of 0 to num_devices?
This will cause coding to be done by platform to be less simple, and my
preference is not to use another variable
Regards
Afzal
^ permalink raw reply [flat|nested] 73+ messages in thread
* RE: [PATCH v3 4/9] ARM: OMAP2+: gpmc-nand: populate gpmc configs
2012-04-10 19:24 ` Jon Hunter
(?)
@ 2012-04-11 5:15 ` Mohammed, Afzal
-1 siblings, 0 replies; 73+ messages in thread
From: Mohammed, Afzal @ 2012-04-11 5:15 UTC (permalink / raw)
To: Hunter, Jon
Cc: tony, Hilman, Kevin, linux, dwmw2, sameo, grinberg, mike, Menon,
Nishanth, artem.bityutskiy, vimal.newwork, dbaryshkov,
linux-omap, linux-arm-kernel, linux-mtd, linux-kernel
Hi Jon,
On Wed, Apr 11, 2012 at 00:54:58, Hunter, Jon wrote:
> > +#define GPMC_NAND_CONFIG_NUM 4
>
> Where does 4 come from?
It depends on the use case, for NAND, with the way it was being
configured (or number of times gpmc_cs_configure was being called)
4 are needed.
Regards
Afzal
^ permalink raw reply [flat|nested] 73+ messages in thread
* RE: [PATCH v3 4/9] ARM: OMAP2+: gpmc-nand: populate gpmc configs
@ 2012-04-11 5:15 ` Mohammed, Afzal
0 siblings, 0 replies; 73+ messages in thread
From: Mohammed, Afzal @ 2012-04-11 5:15 UTC (permalink / raw)
To: Hunter, Jon
Cc: Hilman, Kevin, Menon, Nishanth, linux, sameo, tony,
artem.bityutskiy, linux-kernel, dbaryshkov, vimal.newwork,
grinberg, mike, linux-mtd, linux-omap, dwmw2, linux-arm-kernel
Hi Jon,
On Wed, Apr 11, 2012 at 00:54:58, Hunter, Jon wrote:
> > +#define GPMC_NAND_CONFIG_NUM 4
>
> Where does 4 come from?
It depends on the use case, for NAND, with the way it was being
configured (or number of times gpmc_cs_configure was being called)
4 are needed.
Regards
Afzal
^ permalink raw reply [flat|nested] 73+ messages in thread
* [PATCH v3 4/9] ARM: OMAP2+: gpmc-nand: populate gpmc configs
@ 2012-04-11 5:15 ` Mohammed, Afzal
0 siblings, 0 replies; 73+ messages in thread
From: Mohammed, Afzal @ 2012-04-11 5:15 UTC (permalink / raw)
To: linux-arm-kernel
Hi Jon,
On Wed, Apr 11, 2012 at 00:54:58, Hunter, Jon wrote:
> > +#define GPMC_NAND_CONFIG_NUM 4
>
> Where does 4 come from?
It depends on the use case, for NAND, with the way it was being
configured (or number of times gpmc_cs_configure was being called)
4 are needed.
Regards
Afzal
^ permalink raw reply [flat|nested] 73+ messages in thread
* Re: [PATCH v3 1/9] ARM: OMAP2+: gpmc: driver conversion
2012-04-11 5:11 ` Mohammed, Afzal
(?)
(?)
@ 2012-04-11 15:47 ` Jon Hunter
-1 siblings, 0 replies; 73+ messages in thread
From: Jon Hunter @ 2012-04-11 15:47 UTC (permalink / raw)
To: Mohammed, Afzal
Cc: tony, Hilman, Kevin, linux, dwmw2, sameo, grinberg, mike, Menon,
Nishanth, artem.bityutskiy, vimal.newwork, dbaryshkov,
linux-omap, linux-arm-kernel, linux-mtd, linux-kernel, Hiremath,
Vaibhav
Hi Afzal,
On 04/11/2012 12:11 AM, Mohammed, Afzal wrote:
> Hi Jon,
>
> On Wed, Apr 11, 2012 at 00:53:14, Hunter, Jon wrote:
>> I agree with your argument but I was thinking today only OMAP uses the
>> GPMC so we could not worry about this. Ok, leave as-is, but can we
>> modify the code as follows as the "else if" is not really needed...
>>
>> if (gpmc->num_irq < GPMC_NR_IRQ) {
>> dev_warn(gpmc->dev, "Insufficient interrupts for device\n");
>> return -EINVAL;
>> }
>>
>> gpmc->num_irq = GPMC_NR_IRQ;
>
> Yes, it is better
>
>>
>>>>
>>>> Furthermore, GPMC_NR_IRQ is defined as 6 which is correct for OMAP2/3
>>>> but not for OMAP4/5, it is 5. Therefore, we need to detect whether we
>>>> are using an OMAP2/3 or OMAP4+ and set num_irqs based upon this. This
>>>> could be done in the probe and we can avoid passing this.
>>>
>>> Is it dependent on OMAPX or GPMC IP version? if it is IP version, then driver
>>> can be enhanced to handle it, if not, platform has to pass this information.
>>
>> Here are the GPMC IP revisions ...
>>
>> OMAP5430 = 0x00000060
>> OMAP4430 = 0x00000060
>> OMAP3630 = 0x00000050
>> OMAP3430 = 0x00000050
>>
>> So this should work for OMAP. We should check OMAP2 as well. What about
>> the AMxxx devices?
>
>
> I badly needed this information, thanks.
>
> AM3359 = 0x00000060, it has only 2 waitpin interrupts
Great so this is consistent!
>>>>>>> + res = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
>>>>>>> + if (res == NULL)
>>>>>>> + dev_warn(gpmc->dev, "Failed to get resource: irq\n");
>>>>>>> + else
>>>>>>> + gpmc->master_irq = res->start;
>>>>>>
>>>>>> Why not return an error if the IRQ is not found? We don't know if anyone
>>>>>> will be trying to use them.
>>>>>
>>>>> Why do you want to do that ?
>>>>
>>>> Because this indicates a BUG :-)
>>>
>>> I disagree, this need not be considered a bug always,
>>> for eg. If gpmc irq is not connected to intc
>>
>> Ok, so for devices existing today this indicates a bug ;-)
>
> I do not want to consider that case to be bug enough for probe
> to fail, there are other drivers which does similar enhancing
> its use cases,
>
> eg. 1e351a9 mfd: Make TPS65910 usable without interrupts
Ok, fine.
>>
>> At a minimum you need to improve the error handing here. If the
>> platform_get_resource fails you are still calling "gpmc_setup_irq()"
>> which appears to be pointless. It would be better if the gpmc irq chip
>> is not initialised in this case so that drivers attempting to request
>> these irqs failed.
>
> Please see gpmc_setup_irq, if irq is not present, it returns in the
> beginning, and gpmc_irq_chip is not initialized in that case.
Yes you are right.
>>>>>>> + for (gdq = gp->device_pdata, gd = gpmc->device; *gdq; gdq++, i++) {
>>>>>>> + ret = gpmc_setup_device(*gdq, gd, gpmc);
>>>>>>> + if (IS_ERR_VALUE(ret))
>>>>>>> + dev_err(gpmc->dev, "gpmc setup on %s failed\n",
>>>>>>> + (*gdq)->name);
>>>>>>> + else
>>>>>>> + gd++;
>>>>>>> + }
>>>>>>
>>>>>> Would a while loop be simpler?
>>>>>
>>>>> My preference is to go with "for"
>>>>
>>>> Ok, just wondering if this could be cleaned up a little.
>>>
>>> For travelling through array of pointers, for looks natural to me, if you
>>> have a better way, please send it, it can be folded in next version.
>>
>> Could you have num_devices to indicate how many platform devices there
>> are and then a simple for-loop of 0 to num_devices?
>
> This will cause coding to be done by platform to be less simple, and my
> preference is not to use another variable
Hehe, I wondered if that would make life a little more difficult. Ok
lets leave it for now.
Jon
^ permalink raw reply [flat|nested] 73+ messages in thread
* Re: [PATCH v3 1/9] ARM: OMAP2+: gpmc: driver conversion
@ 2012-04-11 15:47 ` Jon Hunter
0 siblings, 0 replies; 73+ messages in thread
From: Jon Hunter @ 2012-04-11 15:47 UTC (permalink / raw)
To: Mohammed, Afzal
Cc: tony, Hilman, Kevin, linux, dwmw2, sameo, grinberg, mike, Menon,
Nishanth, artem.bityutskiy, vimal.newwork, dbaryshkov,
linux-omap, linux-arm-kernel, linux-mtd, linux-kernel, Hiremath,
Vaibhav
Hi Afzal,
On 04/11/2012 12:11 AM, Mohammed, Afzal wrote:
> Hi Jon,
>
> On Wed, Apr 11, 2012 at 00:53:14, Hunter, Jon wrote:
>> I agree with your argument but I was thinking today only OMAP uses the
>> GPMC so we could not worry about this. Ok, leave as-is, but can we
>> modify the code as follows as the "else if" is not really needed...
>>
>> if (gpmc->num_irq < GPMC_NR_IRQ) {
>> dev_warn(gpmc->dev, "Insufficient interrupts for device\n");
>> return -EINVAL;
>> }
>>
>> gpmc->num_irq = GPMC_NR_IRQ;
>
> Yes, it is better
>
>>
>>>>
>>>> Furthermore, GPMC_NR_IRQ is defined as 6 which is correct for OMAP2/3
>>>> but not for OMAP4/5, it is 5. Therefore, we need to detect whether we
>>>> are using an OMAP2/3 or OMAP4+ and set num_irqs based upon this. This
>>>> could be done in the probe and we can avoid passing this.
>>>
>>> Is it dependent on OMAPX or GPMC IP version? if it is IP version, then driver
>>> can be enhanced to handle it, if not, platform has to pass this information.
>>
>> Here are the GPMC IP revisions ...
>>
>> OMAP5430 = 0x00000060
>> OMAP4430 = 0x00000060
>> OMAP3630 = 0x00000050
>> OMAP3430 = 0x00000050
>>
>> So this should work for OMAP. We should check OMAP2 as well. What about
>> the AMxxx devices?
>
>
> I badly needed this information, thanks.
>
> AM3359 = 0x00000060, it has only 2 waitpin interrupts
Great so this is consistent!
>>>>>>> + res = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
>>>>>>> + if (res == NULL)
>>>>>>> + dev_warn(gpmc->dev, "Failed to get resource: irq\n");
>>>>>>> + else
>>>>>>> + gpmc->master_irq = res->start;
>>>>>>
>>>>>> Why not return an error if the IRQ is not found? We don't know if anyone
>>>>>> will be trying to use them.
>>>>>
>>>>> Why do you want to do that ?
>>>>
>>>> Because this indicates a BUG :-)
>>>
>>> I disagree, this need not be considered a bug always,
>>> for eg. If gpmc irq is not connected to intc
>>
>> Ok, so for devices existing today this indicates a bug ;-)
>
> I do not want to consider that case to be bug enough for probe
> to fail, there are other drivers which does similar enhancing
> its use cases,
>
> eg. 1e351a9 mfd: Make TPS65910 usable without interrupts
Ok, fine.
>>
>> At a minimum you need to improve the error handing here. If the
>> platform_get_resource fails you are still calling "gpmc_setup_irq()"
>> which appears to be pointless. It would be better if the gpmc irq chip
>> is not initialised in this case so that drivers attempting to request
>> these irqs failed.
>
> Please see gpmc_setup_irq, if irq is not present, it returns in the
> beginning, and gpmc_irq_chip is not initialized in that case.
Yes you are right.
>>>>>>> + for (gdq = gp->device_pdata, gd = gpmc->device; *gdq; gdq++, i++) {
>>>>>>> + ret = gpmc_setup_device(*gdq, gd, gpmc);
>>>>>>> + if (IS_ERR_VALUE(ret))
>>>>>>> + dev_err(gpmc->dev, "gpmc setup on %s failed\n",
>>>>>>> + (*gdq)->name);
>>>>>>> + else
>>>>>>> + gd++;
>>>>>>> + }
>>>>>>
>>>>>> Would a while loop be simpler?
>>>>>
>>>>> My preference is to go with "for"
>>>>
>>>> Ok, just wondering if this could be cleaned up a little.
>>>
>>> For travelling through array of pointers, for looks natural to me, if you
>>> have a better way, please send it, it can be folded in next version.
>>
>> Could you have num_devices to indicate how many platform devices there
>> are and then a simple for-loop of 0 to num_devices?
>
> This will cause coding to be done by platform to be less simple, and my
> preference is not to use another variable
Hehe, I wondered if that would make life a little more difficult. Ok
lets leave it for now.
Jon
^ permalink raw reply [flat|nested] 73+ messages in thread
* Re: [PATCH v3 1/9] ARM: OMAP2+: gpmc: driver conversion
@ 2012-04-11 15:47 ` Jon Hunter
0 siblings, 0 replies; 73+ messages in thread
From: Jon Hunter @ 2012-04-11 15:47 UTC (permalink / raw)
To: Mohammed, Afzal
Cc: Hilman, Kevin, Menon, Nishanth, linux, sameo, tony,
artem.bityutskiy, linux-kernel, Hiremath, Vaibhav, dbaryshkov,
vimal.newwork, grinberg, mike, linux-mtd, linux-omap, dwmw2,
linux-arm-kernel
Hi Afzal,
On 04/11/2012 12:11 AM, Mohammed, Afzal wrote:
> Hi Jon,
>
> On Wed, Apr 11, 2012 at 00:53:14, Hunter, Jon wrote:
>> I agree with your argument but I was thinking today only OMAP uses the
>> GPMC so we could not worry about this. Ok, leave as-is, but can we
>> modify the code as follows as the "else if" is not really needed...
>>
>> if (gpmc->num_irq < GPMC_NR_IRQ) {
>> dev_warn(gpmc->dev, "Insufficient interrupts for device\n");
>> return -EINVAL;
>> }
>>
>> gpmc->num_irq = GPMC_NR_IRQ;
>
> Yes, it is better
>
>>
>>>>
>>>> Furthermore, GPMC_NR_IRQ is defined as 6 which is correct for OMAP2/3
>>>> but not for OMAP4/5, it is 5. Therefore, we need to detect whether we
>>>> are using an OMAP2/3 or OMAP4+ and set num_irqs based upon this. This
>>>> could be done in the probe and we can avoid passing this.
>>>
>>> Is it dependent on OMAPX or GPMC IP version? if it is IP version, then driver
>>> can be enhanced to handle it, if not, platform has to pass this information.
>>
>> Here are the GPMC IP revisions ...
>>
>> OMAP5430 = 0x00000060
>> OMAP4430 = 0x00000060
>> OMAP3630 = 0x00000050
>> OMAP3430 = 0x00000050
>>
>> So this should work for OMAP. We should check OMAP2 as well. What about
>> the AMxxx devices?
>
>
> I badly needed this information, thanks.
>
> AM3359 = 0x00000060, it has only 2 waitpin interrupts
Great so this is consistent!
>>>>>>> + res = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
>>>>>>> + if (res == NULL)
>>>>>>> + dev_warn(gpmc->dev, "Failed to get resource: irq\n");
>>>>>>> + else
>>>>>>> + gpmc->master_irq = res->start;
>>>>>>
>>>>>> Why not return an error if the IRQ is not found? We don't know if anyone
>>>>>> will be trying to use them.
>>>>>
>>>>> Why do you want to do that ?
>>>>
>>>> Because this indicates a BUG :-)
>>>
>>> I disagree, this need not be considered a bug always,
>>> for eg. If gpmc irq is not connected to intc
>>
>> Ok, so for devices existing today this indicates a bug ;-)
>
> I do not want to consider that case to be bug enough for probe
> to fail, there are other drivers which does similar enhancing
> its use cases,
>
> eg. 1e351a9 mfd: Make TPS65910 usable without interrupts
Ok, fine.
>>
>> At a minimum you need to improve the error handing here. If the
>> platform_get_resource fails you are still calling "gpmc_setup_irq()"
>> which appears to be pointless. It would be better if the gpmc irq chip
>> is not initialised in this case so that drivers attempting to request
>> these irqs failed.
>
> Please see gpmc_setup_irq, if irq is not present, it returns in the
> beginning, and gpmc_irq_chip is not initialized in that case.
Yes you are right.
>>>>>>> + for (gdq = gp->device_pdata, gd = gpmc->device; *gdq; gdq++, i++) {
>>>>>>> + ret = gpmc_setup_device(*gdq, gd, gpmc);
>>>>>>> + if (IS_ERR_VALUE(ret))
>>>>>>> + dev_err(gpmc->dev, "gpmc setup on %s failed\n",
>>>>>>> + (*gdq)->name);
>>>>>>> + else
>>>>>>> + gd++;
>>>>>>> + }
>>>>>>
>>>>>> Would a while loop be simpler?
>>>>>
>>>>> My preference is to go with "for"
>>>>
>>>> Ok, just wondering if this could be cleaned up a little.
>>>
>>> For travelling through array of pointers, for looks natural to me, if you
>>> have a better way, please send it, it can be folded in next version.
>>
>> Could you have num_devices to indicate how many platform devices there
>> are and then a simple for-loop of 0 to num_devices?
>
> This will cause coding to be done by platform to be less simple, and my
> preference is not to use another variable
Hehe, I wondered if that would make life a little more difficult. Ok
lets leave it for now.
Jon
^ permalink raw reply [flat|nested] 73+ messages in thread
* [PATCH v3 1/9] ARM: OMAP2+: gpmc: driver conversion
@ 2012-04-11 15:47 ` Jon Hunter
0 siblings, 0 replies; 73+ messages in thread
From: Jon Hunter @ 2012-04-11 15:47 UTC (permalink / raw)
To: linux-arm-kernel
Hi Afzal,
On 04/11/2012 12:11 AM, Mohammed, Afzal wrote:
> Hi Jon,
>
> On Wed, Apr 11, 2012 at 00:53:14, Hunter, Jon wrote:
>> I agree with your argument but I was thinking today only OMAP uses the
>> GPMC so we could not worry about this. Ok, leave as-is, but can we
>> modify the code as follows as the "else if" is not really needed...
>>
>> if (gpmc->num_irq < GPMC_NR_IRQ) {
>> dev_warn(gpmc->dev, "Insufficient interrupts for device\n");
>> return -EINVAL;
>> }
>>
>> gpmc->num_irq = GPMC_NR_IRQ;
>
> Yes, it is better
>
>>
>>>>
>>>> Furthermore, GPMC_NR_IRQ is defined as 6 which is correct for OMAP2/3
>>>> but not for OMAP4/5, it is 5. Therefore, we need to detect whether we
>>>> are using an OMAP2/3 or OMAP4+ and set num_irqs based upon this. This
>>>> could be done in the probe and we can avoid passing this.
>>>
>>> Is it dependent on OMAPX or GPMC IP version? if it is IP version, then driver
>>> can be enhanced to handle it, if not, platform has to pass this information.
>>
>> Here are the GPMC IP revisions ...
>>
>> OMAP5430 = 0x00000060
>> OMAP4430 = 0x00000060
>> OMAP3630 = 0x00000050
>> OMAP3430 = 0x00000050
>>
>> So this should work for OMAP. We should check OMAP2 as well. What about
>> the AMxxx devices?
>
>
> I badly needed this information, thanks.
>
> AM3359 = 0x00000060, it has only 2 waitpin interrupts
Great so this is consistent!
>>>>>>> + res = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
>>>>>>> + if (res == NULL)
>>>>>>> + dev_warn(gpmc->dev, "Failed to get resource: irq\n");
>>>>>>> + else
>>>>>>> + gpmc->master_irq = res->start;
>>>>>>
>>>>>> Why not return an error if the IRQ is not found? We don't know if anyone
>>>>>> will be trying to use them.
>>>>>
>>>>> Why do you want to do that ?
>>>>
>>>> Because this indicates a BUG :-)
>>>
>>> I disagree, this need not be considered a bug always,
>>> for eg. If gpmc irq is not connected to intc
>>
>> Ok, so for devices existing today this indicates a bug ;-)
>
> I do not want to consider that case to be bug enough for probe
> to fail, there are other drivers which does similar enhancing
> its use cases,
>
> eg. 1e351a9 mfd: Make TPS65910 usable without interrupts
Ok, fine.
>>
>> At a minimum you need to improve the error handing here. If the
>> platform_get_resource fails you are still calling "gpmc_setup_irq()"
>> which appears to be pointless. It would be better if the gpmc irq chip
>> is not initialised in this case so that drivers attempting to request
>> these irqs failed.
>
> Please see gpmc_setup_irq, if irq is not present, it returns in the
> beginning, and gpmc_irq_chip is not initialized in that case.
Yes you are right.
>>>>>>> + for (gdq = gp->device_pdata, gd = gpmc->device; *gdq; gdq++, i++) {
>>>>>>> + ret = gpmc_setup_device(*gdq, gd, gpmc);
>>>>>>> + if (IS_ERR_VALUE(ret))
>>>>>>> + dev_err(gpmc->dev, "gpmc setup on %s failed\n",
>>>>>>> + (*gdq)->name);
>>>>>>> + else
>>>>>>> + gd++;
>>>>>>> + }
>>>>>>
>>>>>> Would a while loop be simpler?
>>>>>
>>>>> My preference is to go with "for"
>>>>
>>>> Ok, just wondering if this could be cleaned up a little.
>>>
>>> For travelling through array of pointers, for looks natural to me, if you
>>> have a better way, please send it, it can be folded in next version.
>>
>> Could you have num_devices to indicate how many platform devices there
>> are and then a simple for-loop of 0 to num_devices?
>
> This will cause coding to be done by platform to be less simple, and my
> preference is not to use another variable
Hehe, I wondered if that would make life a little more difficult. Ok
lets leave it for now.
Jon
^ permalink raw reply [flat|nested] 73+ messages in thread
* Re: [TMP] OMAP3EVM: Test gpmc nand & smsc911x
2012-04-05 15:47 ` Afzal Mohammed
(?)
@ 2012-04-25 16:47 ` Tony Lindgren
-1 siblings, 0 replies; 73+ messages in thread
From: Tony Lindgren @ 2012-04-25 16:47 UTC (permalink / raw)
To: Afzal Mohammed
Cc: khilman, linux, dwmw2, sameo, grinberg, mike, nm,
artem.bityutskiy, vimal.newwork, dbaryshkov, linux-omap,
linux-arm-kernel, linux-mtd, linux-kernel
* Afzal Mohammed <afzal@ti.com> [120405 09:08]:
> @@ -114,6 +147,8 @@ static struct omap_smsc911x_platform_data smsc911x_cfg = {
>
> static inline void __init omap3evm_init_smsc911x(void)
> {
> + struct gpmc_device_pdata *gpmc_smsc911x_info;
> +
> /* Configure ethernet controller reset gpio */
> if (cpu_is_omap3430()) {
> if (get_omap3_evm_rev() == OMAP3EVM_BOARD_GEN_1)
> @@ -122,7 +157,11 @@ static inline void __init omap3evm_init_smsc911x(void)
> smsc911x_cfg.gpio_reset = OMAP3EVM_GEN2_ETHR_GPIO_RST;
> }
>
> - gpmc_smsc911x_init(&smsc911x_cfg);
> + gpmc_smsc911x_info = gpmc_smsc911x_init(&smsc911x_cfg);
> + if (gpmc_smsc911x_info)
> + *gpmc_data_cur++ = gpmc_smsc911x_info;
> + else
> + pr_err("error: unable to initilaize gpmc smsc911x\n");
> }
>
> #else
Obviously we can't merge any of this if until all the board-*.c files
are changed and tested.
Can you maybe still keep the old interfaces in addition to the new ones
so we can do the conversion one board-*.c file at a time while keeping
things working?
Regards,
Tony
^ permalink raw reply [flat|nested] 73+ messages in thread
* Re: [TMP] OMAP3EVM: Test gpmc nand & smsc911x
@ 2012-04-25 16:47 ` Tony Lindgren
0 siblings, 0 replies; 73+ messages in thread
From: Tony Lindgren @ 2012-04-25 16:47 UTC (permalink / raw)
To: Afzal Mohammed
Cc: khilman, nm, linux, sameo, dbaryshkov, artem.bityutskiy,
linux-kernel, vimal.newwork, grinberg, mike, linux-mtd,
linux-omap, dwmw2, linux-arm-kernel
* Afzal Mohammed <afzal@ti.com> [120405 09:08]:
> @@ -114,6 +147,8 @@ static struct omap_smsc911x_platform_data smsc911x_cfg = {
>
> static inline void __init omap3evm_init_smsc911x(void)
> {
> + struct gpmc_device_pdata *gpmc_smsc911x_info;
> +
> /* Configure ethernet controller reset gpio */
> if (cpu_is_omap3430()) {
> if (get_omap3_evm_rev() == OMAP3EVM_BOARD_GEN_1)
> @@ -122,7 +157,11 @@ static inline void __init omap3evm_init_smsc911x(void)
> smsc911x_cfg.gpio_reset = OMAP3EVM_GEN2_ETHR_GPIO_RST;
> }
>
> - gpmc_smsc911x_init(&smsc911x_cfg);
> + gpmc_smsc911x_info = gpmc_smsc911x_init(&smsc911x_cfg);
> + if (gpmc_smsc911x_info)
> + *gpmc_data_cur++ = gpmc_smsc911x_info;
> + else
> + pr_err("error: unable to initilaize gpmc smsc911x\n");
> }
>
> #else
Obviously we can't merge any of this if until all the board-*.c files
are changed and tested.
Can you maybe still keep the old interfaces in addition to the new ones
so we can do the conversion one board-*.c file at a time while keeping
things working?
Regards,
Tony
^ permalink raw reply [flat|nested] 73+ messages in thread
* [TMP] OMAP3EVM: Test gpmc nand & smsc911x
@ 2012-04-25 16:47 ` Tony Lindgren
0 siblings, 0 replies; 73+ messages in thread
From: Tony Lindgren @ 2012-04-25 16:47 UTC (permalink / raw)
To: linux-arm-kernel
* Afzal Mohammed <afzal@ti.com> [120405 09:08]:
> @@ -114,6 +147,8 @@ static struct omap_smsc911x_platform_data smsc911x_cfg = {
>
> static inline void __init omap3evm_init_smsc911x(void)
> {
> + struct gpmc_device_pdata *gpmc_smsc911x_info;
> +
> /* Configure ethernet controller reset gpio */
> if (cpu_is_omap3430()) {
> if (get_omap3_evm_rev() == OMAP3EVM_BOARD_GEN_1)
> @@ -122,7 +157,11 @@ static inline void __init omap3evm_init_smsc911x(void)
> smsc911x_cfg.gpio_reset = OMAP3EVM_GEN2_ETHR_GPIO_RST;
> }
>
> - gpmc_smsc911x_init(&smsc911x_cfg);
> + gpmc_smsc911x_info = gpmc_smsc911x_init(&smsc911x_cfg);
> + if (gpmc_smsc911x_info)
> + *gpmc_data_cur++ = gpmc_smsc911x_info;
> + else
> + pr_err("error: unable to initilaize gpmc smsc911x\n");
> }
>
> #else
Obviously we can't merge any of this if until all the board-*.c files
are changed and tested.
Can you maybe still keep the old interfaces in addition to the new ones
so we can do the conversion one board-*.c file at a time while keeping
things working?
Regards,
Tony
^ permalink raw reply [flat|nested] 73+ messages in thread
* RE: [TMP] OMAP3EVM: Test gpmc nand & smsc911x
2012-04-25 16:47 ` Tony Lindgren
(?)
(?)
@ 2012-04-26 5:21 ` Mohammed, Afzal
-1 siblings, 0 replies; 73+ messages in thread
From: Mohammed, Afzal @ 2012-04-26 5:21 UTC (permalink / raw)
To: Tony Lindgren
Cc: Hilman, Kevin, linux, dwmw2, sameo, grinberg, mike, Menon,
Nishanth, artem.bityutskiy, vimal.newwork, dbaryshkov,
linux-omap, linux-arm-kernel, linux-mtd, linux-kernel
Hi Tony,
On Wed, Apr 25, 2012 at 22:17:26, Tony Lindgren wrote:
> Obviously we can't merge any of this if until all the board-*.c files
> are changed and tested.
>
> Can you maybe still keep the old interfaces in addition to the new ones
> so we can do the conversion one board-*.c file at a time while keeping
> things working?
As there are peripherals using helper functions, to handle those, you
meant to create a new altered similar function to deal for each too ?,
while keeping existing functions as such.
i.e. like having gpmc_smsc911x_init & gpmc_smsc911x_new_init for
each peripheral ?, with gpmc_smsc911x_new_init using gpmc driver,
and gpmc_smsc911x_init as is.
Regards
Afzal
^ permalink raw reply [flat|nested] 73+ messages in thread
* RE: [TMP] OMAP3EVM: Test gpmc nand & smsc911x
@ 2012-04-26 5:21 ` Mohammed, Afzal
0 siblings, 0 replies; 73+ messages in thread
From: Mohammed, Afzal @ 2012-04-26 5:21 UTC (permalink / raw)
To: Tony Lindgren
Cc: Hilman, Kevin, linux, dwmw2, sameo, grinberg, mike, Menon,
Nishanth, artem.bityutskiy, vimal.newwork, dbaryshkov,
linux-omap, linux-arm-kernel, linux-mtd, linux-kernel
Hi Tony,
On Wed, Apr 25, 2012 at 22:17:26, Tony Lindgren wrote:
> Obviously we can't merge any of this if until all the board-*.c files
> are changed and tested.
>
> Can you maybe still keep the old interfaces in addition to the new ones
> so we can do the conversion one board-*.c file at a time while keeping
> things working?
As there are peripherals using helper functions, to handle those, you
meant to create a new altered similar function to deal for each too ?,
while keeping existing functions as such.
i.e. like having gpmc_smsc911x_init & gpmc_smsc911x_new_init for
each peripheral ?, with gpmc_smsc911x_new_init using gpmc driver,
and gpmc_smsc911x_init as is.
Regards
Afzal
^ permalink raw reply [flat|nested] 73+ messages in thread
* RE: [TMP] OMAP3EVM: Test gpmc nand & smsc911x
@ 2012-04-26 5:21 ` Mohammed, Afzal
0 siblings, 0 replies; 73+ messages in thread
From: Mohammed, Afzal @ 2012-04-26 5:21 UTC (permalink / raw)
To: Tony Lindgren
Cc: Hilman, Kevin, Menon, Nishanth, linux, sameo, dbaryshkov,
artem.bityutskiy, linux-kernel, vimal.newwork, grinberg, mike,
linux-mtd, linux-omap, dwmw2, linux-arm-kernel
Hi Tony,
On Wed, Apr 25, 2012 at 22:17:26, Tony Lindgren wrote:
> Obviously we can't merge any of this if until all the board-*.c files
> are changed and tested.
>
> Can you maybe still keep the old interfaces in addition to the new ones
> so we can do the conversion one board-*.c file at a time while keeping
> things working?
As there are peripherals using helper functions, to handle those, you
meant to create a new altered similar function to deal for each too ?,
while keeping existing functions as such.
i.e. like having gpmc_smsc911x_init & gpmc_smsc911x_new_init for
each peripheral ?, with gpmc_smsc911x_new_init using gpmc driver,
and gpmc_smsc911x_init as is.
Regards
Afzal
^ permalink raw reply [flat|nested] 73+ messages in thread
* [TMP] OMAP3EVM: Test gpmc nand & smsc911x
@ 2012-04-26 5:21 ` Mohammed, Afzal
0 siblings, 0 replies; 73+ messages in thread
From: Mohammed, Afzal @ 2012-04-26 5:21 UTC (permalink / raw)
To: linux-arm-kernel
Hi Tony,
On Wed, Apr 25, 2012 at 22:17:26, Tony Lindgren wrote:
> Obviously we can't merge any of this if until all the board-*.c files
> are changed and tested.
>
> Can you maybe still keep the old interfaces in addition to the new ones
> so we can do the conversion one board-*.c file at a time while keeping
> things working?
As there are peripherals using helper functions, to handle those, you
meant to create a new altered similar function to deal for each too ?,
while keeping existing functions as such.
i.e. like having gpmc_smsc911x_init & gpmc_smsc911x_new_init for
each peripheral ?, with gpmc_smsc911x_new_init using gpmc driver,
and gpmc_smsc911x_init as is.
Regards
Afzal
^ permalink raw reply [flat|nested] 73+ messages in thread
end of thread, other threads:[~2012-04-26 5:22 UTC | newest]
Thread overview: 73+ messages (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
[not found] <cover.1333640054.git.afzal@ti.com>
2012-04-05 15:45 ` [PATCH v3 1/9] ARM: OMAP2+: gpmc: driver conversion Afzal Mohammed
2012-04-05 15:45 ` Afzal Mohammed
2012-04-05 15:45 ` Afzal Mohammed
2012-04-05 15:45 ` Afzal Mohammed
2012-04-05 20:21 ` Jon Hunter
2012-04-05 20:21 ` Jon Hunter
2012-04-05 20:21 ` Jon Hunter
2012-04-05 20:21 ` Jon Hunter
2012-04-05 20:34 ` Jon Hunter
2012-04-05 20:34 ` Jon Hunter
2012-04-05 20:34 ` Jon Hunter
2012-04-06 6:52 ` Mohammed, Afzal
2012-04-06 6:52 ` Mohammed, Afzal
2012-04-06 6:52 ` Mohammed, Afzal
2012-04-06 6:52 ` Mohammed, Afzal
2012-04-09 19:50 ` Jon Hunter
2012-04-09 19:50 ` Jon Hunter
2012-04-09 19:50 ` Jon Hunter
2012-04-09 19:50 ` Jon Hunter
2012-04-10 11:00 ` Mohammed, Afzal
2012-04-10 11:00 ` Mohammed, Afzal
2012-04-10 11:00 ` Mohammed, Afzal
2012-04-10 11:00 ` Mohammed, Afzal
2012-04-10 19:23 ` Jon Hunter
2012-04-10 19:23 ` Jon Hunter
2012-04-10 19:23 ` Jon Hunter
2012-04-10 19:23 ` Jon Hunter
2012-04-11 5:11 ` Mohammed, Afzal
2012-04-11 5:11 ` Mohammed, Afzal
2012-04-11 5:11 ` Mohammed, Afzal
2012-04-11 5:11 ` Mohammed, Afzal
2012-04-11 15:47 ` Jon Hunter
2012-04-11 15:47 ` Jon Hunter
2012-04-11 15:47 ` Jon Hunter
2012-04-11 15:47 ` Jon Hunter
2012-04-05 15:46 ` [PATCH v3 2/9] ARM: OMAP2+: gpmc: registers for nand driver Afzal Mohammed
2012-04-05 15:46 ` Afzal Mohammed
2012-04-05 15:46 ` Afzal Mohammed
2012-04-05 15:46 ` [PATCH v3 3/9] ARM: OMAP2+: nand: create platform data structure Afzal Mohammed
2012-04-05 15:46 ` Afzal Mohammed
2012-04-05 15:46 ` Afzal Mohammed
2012-04-05 15:46 ` [PATCH v3 4/9] ARM: OMAP2+: gpmc-nand: populate gpmc configs Afzal Mohammed
2012-04-05 15:46 ` Afzal Mohammed
2012-04-05 15:46 ` Afzal Mohammed
2012-04-10 19:24 ` Jon Hunter
2012-04-10 19:24 ` Jon Hunter
2012-04-10 19:24 ` Jon Hunter
2012-04-10 19:24 ` Jon Hunter
2012-04-11 5:15 ` Mohammed, Afzal
2012-04-11 5:15 ` Mohammed, Afzal
2012-04-11 5:15 ` Mohammed, Afzal
2012-04-05 15:46 ` [PATCH v3 5/9] ARM: OMAP2+: gpmc-smsc911x: gpmc driver information Afzal Mohammed
2012-04-05 15:46 ` Afzal Mohammed
2012-04-05 15:46 ` Afzal Mohammed
2012-04-05 15:46 ` [PATCH v3 6/9] mtd: nand: omap2: obtain memory from resource Afzal Mohammed
2012-04-05 15:46 ` Afzal Mohammed
2012-04-05 15:46 ` Afzal Mohammed
2012-04-05 15:47 ` [PATCH v3 7/9] mtd: nand: omap2: use gpmc provided irqs Afzal Mohammed
2012-04-05 15:47 ` Afzal Mohammed
2012-04-05 15:47 ` Afzal Mohammed
2012-04-05 15:47 ` [PATCH v3 8/9] mtd: nand: omap2: handle nand on gpmc Afzal Mohammed
2012-04-05 15:47 ` Afzal Mohammed
2012-04-05 15:47 ` Afzal Mohammed
2012-04-05 15:47 ` [TMP] OMAP3EVM: Test gpmc nand & smsc911x Afzal Mohammed
2012-04-05 16:05 ` Afzal Mohammed
2012-04-05 15:47 ` Afzal Mohammed
2012-04-25 16:47 ` Tony Lindgren
2012-04-25 16:47 ` Tony Lindgren
2012-04-25 16:47 ` Tony Lindgren
2012-04-26 5:21 ` Mohammed, Afzal
2012-04-26 5:21 ` Mohammed, Afzal
2012-04-26 5:21 ` Mohammed, Afzal
2012-04-26 5:21 ` Mohammed, Afzal
This is an external index of several public inboxes,
see mirroring instructions on how to clone and mirror
all data and code used by this external index.