The patch titled atmel_tc library (update) has been added to the -mm tree. Its filename is atmel_tc-library-update.patch Before you just go and hit "reply", please: a) Consider who else should be cc'ed b) Prefer to cc a suitable mailing list as well c) Ideally: find the original patch on the mailing list and do a reply-to-all to that, adding suitable additional cc's *** Remember to use Documentation/SubmitChecklist when testing your code *** See http://www.zip.com.au/~akpm/linux/patches/stuff/added-to-mm.txt to find out what to do about this The current -mm tree may be found at http://userweb.kernel.org/~akpm/mmotm/ ------------------------------------------------------ Subject: atmel_tc library (update) From: David Brownell <david-b@xxxxxxxxxxx> * Drop unneeded inclusion of <linux/mutex.h> * Support an arbitrary number of TC blocks * Return a struct with information about a TC block from atmel_tc_alloc() instead of using a combination of return values and "out" parameters. * ioremap() the I/O registers on allocation * Look up clocks and irqs for all channels * Add "name" parameter to atmel_tc_alloc() and use this when requesting the iomem resource. * Check if the platform provided the necessary resources at probe() time instead of when the TCB is allocated. Signed-off-by: David Brownell <dbrownell@xxxxxxxxxxxxxxxxxxxxx> Signed-off-by: Haavard Skinnemoen <hskinnemoen@xxxxxxxxx> Cc: Nicolas Ferre <nicolas.ferre@xxxxxxxxxxxxx> Cc: Andrew Victor <linux@xxxxxxxxxxxx> Signed-off-by: Andrew Morton <akpm@xxxxxxxxxxxxxxxxxxxx> --- drivers/misc/atmel_tclib.c | 144 ++++++++++++++++++++++++----------- include/linux/atmel_tc.h | 37 ++++++++ 2 files changed, 133 insertions(+), 48 deletions(-) diff -puN drivers/misc/atmel_tclib.c~atmel_tc-library-update drivers/misc/atmel_tclib.c --- a/drivers/misc/atmel_tclib.c~atmel_tc-library-update +++ a/drivers/misc/atmel_tclib.c @@ -1,9 +1,14 @@ +#include <linux/atmel_tc.h> +#include <linux/clk.h> +#include <linux/err.h> #include <linux/init.h> -#include <linux/kernel.h> -#include <linux/mutex.h> +#include <linux/io.h> #include <linux/ioport.h> +#include <linux/kernel.h> #include <linux/platform_device.h> -#include <linux/atmel_tc.h> + +/* Number of bytes to reserve for the iomem resource */ +#define ATMEL_TC_IOMEM_SIZE 256 /* @@ -24,75 +29,124 @@ EXPORT_SYMBOL(atmel_tc_divisors); #endif -/* we "know" that there will be either one or two TC blocks */ -static struct platform_device *blocks[2]; - +static DEFINE_SPINLOCK(tc_list_lock); +static LIST_HEAD(tc_list); /** * atmel_tc_alloc - allocate a specified TC block * @block: which block to allocate - * @iomem: used to return its IO memory resource + * @name: name to be associated with the iomem resource * - * Caller allocates a block. If it is available, its I/O space is requested - * and returned through the iomem pointer, and the device node for the block - * is returned. When it is not available, NULL is returned. - * - * On some platforms, each TC channel has its own clocks and IRQs. Drivers - * should clk_get() and clk_enable() "t0_clk", "t1_clk, and "t2_clk". - * In the same vein, they should platform_get_irq() for irqs 0, 1, and 2. - * On other platforms, only irq 0 and "t0_clk" will be available; drivers - * should handle with both configurations. + * Caller allocates a block. If it is available, a pointer to a + * pre-initialized struct atmel_tc is returned. The caller can access + * the registers directly through the "regs" field. */ -struct platform_device *atmel_tc_alloc(unsigned block, struct resource **iomem) +struct atmel_tc *atmel_tc_alloc(unsigned block, const char *name) { - struct platform_device *tc; + struct atmel_tc *tc; + struct platform_device *pdev = NULL; struct resource *r; - if (block >= ARRAY_SIZE(blocks) || !iomem) - return NULL; - - tc = blocks[block]; - if (tc) { - r = platform_get_resource(tc, IORESOURCE_MEM, 0); - if (r) - r = request_mem_region(r->start, 256, NULL); - *iomem = r; - if (!r) - tc = NULL; + spin_lock(&tc_list_lock); + list_for_each_entry(tc, &tc_list, node) { + if (tc->pdev->id == block) { + pdev = tc->pdev; + break; + } } + if (!pdev || tc->iomem) + goto fail; + + r = platform_get_resource(pdev, IORESOURCE_MEM, 0); + r = request_mem_region(r->start, ATMEL_TC_IOMEM_SIZE, name); + if (!r) + goto fail; + + tc->regs = ioremap(r->start, ATMEL_TC_IOMEM_SIZE); + if (!tc->regs) + goto fail_ioremap; + + tc->iomem = r; + +out: + spin_unlock(&tc_list_lock); return tc; + +fail_ioremap: + release_resource(r); +fail: + tc = NULL; + goto out; } EXPORT_SYMBOL_GPL(atmel_tc_alloc); /** * atmel_tc_free - release a specified TC block - * @block: which block to release + * @tc: Timer/counter block that was returned by atmel_tc_alloc() * - * This reverses the effect of atmel_tc_alloc(), invalidating the resource - * returned by that routine and making the TC available to other drivers. + * This reverses the effect of atmel_tc_alloc(), unmapping the I/O + * registers, invalidating the resource returned by that routine and + * making the TC available to other drivers. */ -void atmel_tc_free(struct platform_device *tc) +void atmel_tc_free(struct atmel_tc *tc) { - if (tc->id >= 0 && tc->id < ARRAY_SIZE(blocks)) { - struct resource *r; - - r = platform_get_resource(tc, IORESOURCE_MEM, 0); - release_mem_region(r->start, 256); + spin_lock(&tc_list_lock); + if (tc->regs) { + iounmap(tc->regs); + release_resource(tc->iomem); + tc->regs = NULL; + tc->iomem = NULL; } + spin_unlock(&tc_list_lock); } EXPORT_SYMBOL_GPL(atmel_tc_free); static int __init tc_probe(struct platform_device *pdev) { - static char __initdata e2big[] = - KERN_ERR "tclib: can't record TC block %d\n"; - - if (pdev->id < 0 || pdev->id >= ARRAY_SIZE(blocks)) { - printk(e2big, pdev->id); - return -ENFILE; + struct atmel_tc *tc; + struct clk *clk; + int irq; + + if (!platform_get_resource(pdev, IORESOURCE_MEM, 0)) + return -EINVAL; + + irq = platform_get_irq(pdev, 0); + if (irq < 0) + return -EINVAL; + + tc = kzalloc(sizeof(struct atmel_tc), GFP_KERNEL); + if (!tc) + return -ENOMEM; + + tc->pdev = pdev; + + clk = clk_get(&pdev->dev, "t0_clk"); + if (IS_ERR(clk)) { + kfree(tc); + return -EINVAL; } - blocks[pdev->id] = pdev; + + tc->clk[0] = clk; + tc->clk[1] = clk_get(&pdev->dev, "t1_clk"); + if (IS_ERR(tc->clk[1])) + tc->clk[1] = clk; + tc->clk[2] = clk_get(&pdev->dev, "t2_clk"); + if (IS_ERR(tc->clk[2])) + tc->clk[2] = clk; + + tc->irq[0] = irq; + tc->irq[1] = platform_get_irq(pdev, 1); + if (tc->irq[1] < 0) + tc->irq[1] = irq; + tc->irq[2] = platform_get_irq(pdev, 2); + if (tc->irq[2] < 0) + tc->irq[2] = irq; + + spin_lock(&tc_list_lock); + list_add_tail(&tc->node, &tc_list); + spin_unlock(&tc_list_lock); + return 0; } diff -puN include/linux/atmel_tc.h~atmel_tc-library-update include/linux/atmel_tc.h --- a/include/linux/atmel_tc.h~atmel_tc-library-update +++ a/include/linux/atmel_tc.h @@ -10,6 +10,9 @@ #ifndef ATMEL_TC_H #define ATMEL_TC_H +#include <linux/compiler.h> +#include <linux/list.h> + /* * Many 32-bit Atmel SOCs include one or more TC blocks, each of which holds * three general-purpose 16-bit timers. These timers share one register bank. @@ -27,9 +30,37 @@ * timers. Then they use clk_get() and platform_get_irq() to get clock and * IRQ resources. */ -extern struct platform_device *atmel_tc_alloc(unsigned block, - struct resource **iomem); -extern void atmel_tc_free(struct platform_device *tc); + +struct clk; + +/** + * struct atmel_tc - information about a Timer/Counter Block + * @pdev: physical device + * @iomem: resource associated with the I/O register + * @regs: mapping through which the I/O registers can be accessed + * @irq: irq for each of the three channels + * @clk: internal clock source for each of the three channels + * @node: list node, for tclib internal use + * + * On some platforms, each TC channel has its own clocks and IRQs, + * while on others, all TC channels share the same clock and IRQ. + * Drivers should clk_enable() all the clocks they need even though + * all the entries in @clk may point to the same physical clock. + * Likewise, drivers should request irqs independently for each + * channel, but they must use IRQF_SHARED in case some of the entries + * in @irq are actually the same IRQ. + */ +struct atmel_tc { + struct platform_device *pdev; + struct resource *iomem; + void __iomem *regs; + int irq[3]; + struct clk *clk[3]; + struct list_head node; +}; + +extern struct atmel_tc *atmel_tc_alloc(unsigned block, const char *name); +extern void atmel_tc_free(struct atmel_tc *tc); /* platform-specific ATMEL_TC_TIMER_CLOCKx divisors (0 means 32KiHz) */ extern const u8 atmel_tc_divisors[5]; _ Patches currently in -mm which might be from david-b@xxxxxxxxxxx are git-acpi.patch at91-correct-at91sam9263ek-lcd-power-gpio-pin.patch git-avr32.patch input-add-debouncing-for-generic-gpio-input-device-gpio_keyc.patch usb-net-asix-does-not-really-need-10-100mbit.patch spi-pxa2xx_spi-sparse-fixes.patch rtc-avoid-legacy-drivers-with-generic-framework.patch rtc-isl1208-new-style-conversion-and-minor-bug-fixes.patch rtc-isl1208-new-style-conversion-and-minor-bug-fixes-checkpatch-fixes.patch rtc-pcf8563-new-style-conversion.patch rtc-pcf8563-new-style-conversion-checkpatch-fixes.patch rtc-pcf8563-new-style-conversion-checkpatch-fixes-fix.patch rtc-x1205-new-style-conversion.patch rtc-x1205-new-style-conversion-checkpatch-fixes.patch rtc-silence-section-mismatch-warning-in-rtc-test.patch make-ds1511_rtc_readset_time-static.patch rtc-replace-remaining-__function__-occurrences.patch atmel_tc-library.patch atmel_tc-library-update.patch atmel_tc-clocksource-clockevent-code.patch atmel_tc-clocksource-clockevent-code-update.patch remove-duplicated-unlikely-in-is_err.patch -- To unsubscribe from this list: send the line "unsubscribe mm-commits" in the body of a message to majordomo@xxxxxxxxxxxxxxx More majordomo info at http://vger.kernel.org/majordomo-info.html