From 979da4dafc99a9e841ea59ef5a08025ae2ff7d75 Mon Sep 17 00:00:00 2001 From: John Bowler Date: Mon, 16 Jan 2006 01:32:22 +0000 Subject: ixp4xx-kernel: create generic and machine specific images/packages in 2.6.15 - the generic ixp4xx-kernel package now creates the same generic kernel regardless of how MACHINE is set, it then appends shims to the kernel to obtain machine specific kernels and produces packages of the results. Still TBD is the command line fixup. The generic command line is the nslu2 one, this is a temporary hack to keep the NSLU2 build working. --- .../11-mtdpart-redboot-config-byteswap.patch | 74 ++++++ .../linux/ixp4xx-kernel/2.6.15/40-rtc-class.patch | 253 ++++++++++++++------- 2 files changed, 239 insertions(+), 88 deletions(-) create mode 100644 packages/linux/ixp4xx-kernel/2.6.15/11-mtdpart-redboot-config-byteswap.patch (limited to 'packages/linux/ixp4xx-kernel') diff --git a/packages/linux/ixp4xx-kernel/2.6.15/11-mtdpart-redboot-config-byteswap.patch b/packages/linux/ixp4xx-kernel/2.6.15/11-mtdpart-redboot-config-byteswap.patch new file mode 100644 index 0000000000..e258567462 --- /dev/null +++ b/packages/linux/ixp4xx-kernel/2.6.15/11-mtdpart-redboot-config-byteswap.patch @@ -0,0 +1,74 @@ +A more robust test for swapped RedBoot FIS directory partitions. This +changes the test to check the flash_base value for the FIS directory, +since we know where the FIS directory base is we can work out whether +the flash address stored in the directory itself is byte swapped under +most circumstances. If the value is 0 the directory is at the start +of the flash and the test fails. In this case the fallback is to use +the original test made slightly more robust. + +Signed-off-by: John Bowler + +--- linux-2.6.15/drivers/mtd/redboot.c 1970-01-01 00:00:00.000000000 +0000 ++++ linux-2.6.15/drivers/mtd/redboot.c 1970-01-01 00:00:00.000000000 +0000 +@@ -91,14 +91,41 @@ static int parse_redboot_partitions(stru + } + if (!memcmp(buf[i].name, "FIS directory", 14)) { + /* This is apparently the FIS directory entry for the +- * FIS directory itself. The FIS directory size is +- * one erase block; if the buf[i].size field is +- * swab32(erasesize) then we know we are looking at +- * a byte swapped FIS directory - swap all the entries! +- * (NOTE: this is 'size' not 'data_length'; size is +- * the full size of the entry.) ++ * FIS directory itself. To discover whether the entries ++ * in this are native byte sex or byte swapped look at ++ * the flash_base field - we know the FIS directory is ++ * at 'offset' within the flash. + */ +- if (swab32(buf[i].size) == master->erasesize) { ++ int maybe_native, maybe_swapped; ++ if (fis_origin != 0) { ++ maybe_native = ++ buf[i].flash_base == fis_origin + offset; ++ maybe_swapped = ++ swab32(buf[i].flash_base) == fis_origin + offset; ++ } else if (offset != 0 || buf[i].flash_base != 0) { ++ maybe_native = ++ (buf[i].flash_base & (master->size-1)) == offset; ++ maybe_swapped = ++ (swab32(buf[i].flash_base) & (master->size-1)) == offset; ++ } else { ++ /* The FIS directory is at the start of the flash and ++ * the 'flash_base' field is 0. The critical case is when ++ * we are booting off this flash, but then we don't expect ++ * this because the boot loader is pretty much always at ++ * the start! Since the FIS directory is always less than ++ * or equal to one erase block do the following: ++ */ ++ maybe_native = buf[i].size <= master->erasesize; ++ maybe_swapped = swab32(buf[i].size) <= master->erasesize; ++ } ++ ++ if (maybe_native && maybe_swapped) ++ printk(KERN_WARNING "RedBoot directory 0x%lx(0x%lx) assumed native\n", ++ buf[i].flash_base, buf[i].size); ++ else if (!maybe_native && !maybe_swapped) ++ printk(KERN_ERR "RedBoot directory 0x%lx(0x%lx) forced native\n", ++ buf[i].flash_base, buf[i].size); ++ else if (maybe_swapped) { + int j; + for (j = 0; j < numslots && buf[j].name[0] != 0xff; ++j) { + /* The unsigned long fields were written with the +@@ -112,7 +139,11 @@ static int parse_redboot_partitions(stru + swab32s(&buf[j].desc_cksum); + swab32s(&buf[j].file_cksum); + } +- } ++ printk(KERN_NOTICE "RedBoot directory 0x%lx(0x%lx) swapped\n", ++ buf[i].flash_base, buf[i].size); ++ } else ++ printk(KERN_NOTICE "RedBoot directory 0x%lx(0x%lx) native\n", ++ buf[i].flash_base, buf[i].size); + break; + } + } diff --git a/packages/linux/ixp4xx-kernel/2.6.15/40-rtc-class.patch b/packages/linux/ixp4xx-kernel/2.6.15/40-rtc-class.patch index 8e0380bfe5..e10998f8d2 100644 --- a/packages/linux/ixp4xx-kernel/2.6.15/40-rtc-class.patch +++ b/packages/linux/ixp4xx-kernel/2.6.15/40-rtc-class.patch @@ -1,5 +1,5 @@ ---- linux-nslu2.orig/include/linux/rtc.h 2006-01-03 15:31:18.000000000 +0100 -+++ linux-nslu2/include/linux/rtc.h 2006-01-03 15:34:24.000000000 +0100 +--- linux-nslu2.orig/include/linux/rtc.h 2006-01-08 18:54:58.000000000 +0100 ++++ linux-nslu2/include/linux/rtc.h 2006-01-08 18:55:19.000000000 +0100 @@ -91,8 +91,81 @@ struct rtc_pll_info { #define RTC_PLL_GET _IOR('p', 0x11, struct rtc_pll_info) /* Get PLL correction */ #define RTC_PLL_SET _IOW('p', 0x12, struct rtc_pll_info) /* Set PLL correction */ @@ -38,8 +38,8 @@ +{ + int id; + struct module *owner; -+ struct rw_semaphore lock; + struct class_device class_dev; ++ struct semaphore ops_lock; + struct rtc_class_ops *ops; + char name[RTC_DEVICE_NAME_SIZE]; + @@ -82,8 +82,8 @@ typedef struct rtc_task { void (*func)(void *private_data); void *private_data; ---- linux-nslu2.orig/drivers/Kconfig 2006-01-03 15:31:19.000000000 +0100 -+++ linux-nslu2/drivers/Kconfig 2006-01-04 01:27:31.000000000 +0100 +--- linux-nslu2.orig/drivers/Kconfig 2006-01-08 18:54:58.000000000 +0100 ++++ linux-nslu2/drivers/Kconfig 2006-01-08 18:55:19.000000000 +0100 @@ -66,4 +66,6 @@ source "drivers/infiniband/Kconfig" source "drivers/sn/Kconfig" @@ -91,8 +91,8 @@ +source "drivers/rtc/Kconfig" + endmenu ---- linux-nslu2.orig/drivers/Makefile 2006-01-03 15:33:32.000000000 +0100 -+++ linux-nslu2/drivers/Makefile 2006-01-04 01:27:31.000000000 +0100 +--- linux-nslu2.orig/drivers/Makefile 2006-01-08 18:54:58.000000000 +0100 ++++ linux-nslu2/drivers/Makefile 2006-01-08 18:55:19.000000000 +0100 @@ -54,6 +54,7 @@ obj-$(CONFIG_USB_GADGET) += usb/gadget/ obj-$(CONFIG_GAMEPORT) += input/gameport/ obj-$(CONFIG_INPUT) += input/ @@ -102,8 +102,8 @@ obj-$(CONFIG_W1) += w1/ obj-$(CONFIG_HWMON) += hwmon/ --- /dev/null 1970-01-01 00:00:00.000000000 +0000 -+++ linux-nslu2/drivers/rtc/class.c 2006-01-03 15:45:19.000000000 +0100 -@@ -0,0 +1,141 @@ ++++ linux-nslu2/drivers/rtc/class.c 2006-01-08 18:55:19.000000000 +0100 +@@ -0,0 +1,143 @@ +/* + * RTC subsystem, base class + * @@ -178,7 +178,7 @@ + rtc->class_dev.class = rtc_class; + rtc->class_dev.release = rtc_device_release; + -+ init_rwsem(&rtc->lock); ++ init_MUTEX(&rtc->ops_lock); + spin_lock_init(&rtc->irq_lock); + spin_lock_init(&rtc->irq_task_lock); + @@ -212,7 +212,9 @@ + */ +void rtc_device_unregister(struct rtc_device *rtc) +{ -+ down_write(&rtc->lock); ++ down(&rtc->ops_lock); ++ rtc->ops = NULL; ++ up(&rtc->ops_lock); + class_device_unregister(&rtc->class_dev); +} +EXPORT_SYMBOL_GPL(rtc_device_unregister); @@ -246,7 +248,7 @@ +MODULE_DESCRIPTION("RTC class support"); +MODULE_LICENSE("GPL"); --- /dev/null 1970-01-01 00:00:00.000000000 +0000 -+++ linux-nslu2/drivers/rtc/Kconfig 2006-01-04 01:27:21.000000000 +0100 ++++ linux-nslu2/drivers/rtc/Kconfig 2006-01-09 04:17:02.000000000 +0100 @@ -0,0 +1,93 @@ +# +# RTC class/drivers configuration @@ -342,7 +344,7 @@ + +endmenu --- /dev/null 1970-01-01 00:00:00.000000000 +0000 -+++ linux-nslu2/drivers/rtc/Makefile 2006-01-04 01:27:21.000000000 +0100 ++++ linux-nslu2/drivers/rtc/Makefile 2006-01-09 04:17:02.000000000 +0100 @@ -0,0 +1,15 @@ +# +# Makefile for RTC class/drivers. @@ -360,8 +362,8 @@ +obj-$(CONFIG_RTC_DRV_DS1672) += rtc-ds1672.o + --- /dev/null 1970-01-01 00:00:00.000000000 +0000 -+++ linux-nslu2/drivers/rtc/interface.c 2006-01-03 15:34:24.000000000 +0100 -@@ -0,0 +1,189 @@ ++++ linux-nslu2/drivers/rtc/interface.c 2006-01-09 03:39:33.000000000 +0100 +@@ -0,0 +1,232 @@ +/* + * RTC subsystem, interface functions + * @@ -381,13 +383,22 @@ + +int rtc_read_time(struct class_device *class_dev, struct rtc_time *tm) +{ -+ int err = -EINVAL; -+ struct rtc_class_ops *ops = to_rtc_device(class_dev)->ops; ++ int err; ++ struct rtc_device *rtc = to_rtc_device(class_dev); ++ ++ if ((err = down_interruptible(&rtc->ops_lock))) ++ return err; + -+ if (ops->read_time) { ++ if (!rtc->ops) ++ err = -ENODEV; ++ else if (!rtc->ops->read_time) ++ err = -EINVAL; ++ else { + memset(tm, 0, sizeof(struct rtc_time)); -+ err = ops->read_time(class_dev->dev, tm); ++ err = rtc->ops->read_time(class_dev->dev, tm); + } ++ ++ up(&rtc->ops_lock); + return err; +} +EXPORT_SYMBOL(rtc_read_time); @@ -395,36 +406,64 @@ +int rtc_set_time(struct class_device *class_dev, struct rtc_time *tm) +{ + int err; -+ struct rtc_class_ops *ops = to_rtc_device(class_dev)->ops; ++ struct rtc_device *rtc = to_rtc_device(class_dev); + -+ err = rtc_valid_tm(tm); -+ if (err == 0 && ops->set_time) -+ err = ops->set_time(class_dev->dev, tm); ++ if ((err = rtc_valid_tm(tm)) != 0) ++ return err; ++ ++ if ((err = down_interruptible(&rtc->ops_lock))) ++ return err; + ++ if (!rtc->ops) ++ err = -ENODEV; ++ else if (!rtc->ops->set_time) ++ err = -EINVAL; ++ else ++ err = rtc->ops->set_time(class_dev->dev, tm); ++ ++ up(&rtc->ops_lock); + return err; +} +EXPORT_SYMBOL(rtc_set_time); + +int rtc_read_alarm(struct class_device *class_dev, struct rtc_wkalrm *alarm) +{ -+ struct rtc_class_ops *ops = to_rtc_device(class_dev)->ops; -+ int err = -EINVAL; ++ int err; ++ struct rtc_device *rtc = to_rtc_device(class_dev); ++ ++ if ((err = down_interruptible(&rtc->ops_lock))) ++ return err; + -+ if (ops->read_alarm) { ++ if (rtc->ops == NULL) ++ err = -ENODEV; ++ else if (!rtc->ops->read_alarm) ++ err = -EINVAL; ++ else { + memset(alarm, 0, sizeof(struct rtc_wkalrm)); -+ err = ops->read_alarm(class_dev->dev, alarm); ++ err = rtc->ops->read_alarm(class_dev->dev, alarm); + } ++ ++ up(&rtc->ops_lock); + return err; +} +EXPORT_SYMBOL(rtc_read_alarm); + +int rtc_set_alarm(struct class_device *class_dev, struct rtc_wkalrm *alarm) +{ -+ int err = -EINVAL; -+ struct rtc_class_ops *ops = to_rtc_device(class_dev)->ops; ++ int err; ++ struct rtc_device *rtc = to_rtc_device(class_dev); + -+ if (ops->set_alarm) -+ err = ops->set_alarm(class_dev->dev, alarm); ++ if ((err = down_interruptible(&rtc->ops_lock))) ++ return err; ++ ++ if (!rtc->ops) ++ err = -ENODEV; ++ else if (!rtc->ops->set_alarm) ++ err = -EINVAL; ++ else ++ err = rtc->ops->set_alarm(class_dev->dev, alarm); ++ ++ up(&rtc->ops_lock); + return err; +} +EXPORT_SYMBOL(rtc_set_alarm); @@ -460,6 +499,11 @@ + break; + } + } ++ ++ if (class_dev) { ++ if (!try_module_get(to_rtc_device(class_dev)->owner)) ++ class_dev = NULL; ++ } + up(&rtc_class->sem); + + return class_dev; @@ -468,6 +512,7 @@ + +void rtc_close(struct class_device *class_dev) +{ ++ module_put(to_rtc_device(class_dev)->owner); +} +EXPORT_SYMBOL(rtc_close); + @@ -552,7 +597,7 @@ + +} --- /dev/null 1970-01-01 00:00:00.000000000 +0000 -+++ linux-nslu2/drivers/rtc/utils.c 2006-01-03 15:34:24.000000000 +0100 ++++ linux-nslu2/drivers/rtc/utils.c 2006-01-08 18:55:19.000000000 +0100 @@ -0,0 +1,97 @@ +/* + * RTC subsystem, utility functions @@ -651,8 +696,8 @@ + return 0; +} +EXPORT_SYMBOL(rtc_tm_to_time); ---- linux-nslu2.orig/arch/arm/Kconfig 2006-01-04 01:27:04.000000000 +0100 -+++ linux-nslu2/arch/arm/Kconfig 2006-01-04 01:27:31.000000000 +0100 +--- linux-nslu2.orig/arch/arm/Kconfig 2006-01-09 03:36:04.000000000 +0100 ++++ linux-nslu2/arch/arm/Kconfig 2006-01-09 03:39:50.000000000 +0100 @@ -748,6 +748,8 @@ source "drivers/usb/Kconfig" source "drivers/mmc/Kconfig" @@ -662,8 +707,8 @@ endmenu source "fs/Kconfig" ---- linux-nslu2.orig/arch/arm/common/rtctime.c 2006-01-04 01:27:04.000000000 +0100 -+++ linux-nslu2/arch/arm/common/rtctime.c 2006-01-04 01:27:09.000000000 +0100 +--- linux-nslu2.orig/arch/arm/common/rtctime.c 2006-01-09 03:36:04.000000000 +0100 ++++ linux-nslu2/arch/arm/common/rtctime.c 2006-01-09 03:39:50.000000000 +0100 @@ -40,89 +40,6 @@ static struct rtc_ops *rtc_ops; #define rtc_epoch 1900UL @@ -852,8 +897,8 @@ p += sprintf(p, "alrm_time\t: "); if ((unsigned int)alrm.time.tm_hour <= 24) p += sprintf(p, "%02d:", alrm.time.tm_hour); ---- linux-nslu2.orig/include/asm-arm/rtc.h 2006-01-04 01:27:04.000000000 +0100 -+++ linux-nslu2/include/asm-arm/rtc.h 2006-01-04 01:27:09.000000000 +0100 +--- linux-nslu2.orig/include/asm-arm/rtc.h 2006-01-09 03:36:04.000000000 +0100 ++++ linux-nslu2/include/asm-arm/rtc.h 2006-01-09 03:39:50.000000000 +0100 @@ -25,9 +25,6 @@ struct rtc_ops { int (*proc)(char *buf); }; @@ -865,8 +910,8 @@ void rtc_update(unsigned long, unsigned long); int register_rtc(struct rtc_ops *); --- /dev/null 1970-01-01 00:00:00.000000000 +0000 -+++ linux-nslu2/drivers/rtc/rtc-sysfs.c 2006-01-04 01:27:12.000000000 +0100 -@@ -0,0 +1,125 @@ ++++ linux-nslu2/drivers/rtc/rtc-sysfs.c 2006-01-09 03:39:50.000000000 +0100 +@@ -0,0 +1,128 @@ +/* + * RTC subsystem, sysfs interface + * @@ -891,58 +936,61 @@ + +static ssize_t rtc_sysfs_show_date(struct class_device *dev, char *buf) +{ -+ ssize_t retval = 0; ++ ssize_t retval = -ENODEV; + struct rtc_device *rtc = to_rtc_device(dev); + struct rtc_time tm; + -+ if (down_read_trylock(&rtc->lock) == 0) -+ return -ENODEV; ++ if ((retval = down_interruptible(&rtc->ops_lock))) ++ return retval; + -+ if (rtc_read_time(dev, &tm) == 0) { ++ if (rtc->ops && ((retval = rtc_read_time(dev, &tm)) == 0)) { + retval = sprintf(buf, "%04d-%02d-%02d\n", + tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday); + } + -+ up_read(&rtc->lock); ++ up(&rtc->ops_lock); ++ + return retval; +} +static CLASS_DEVICE_ATTR(date, S_IRUGO, rtc_sysfs_show_date, NULL); + +static ssize_t rtc_sysfs_show_time(struct class_device *dev, char *buf) +{ -+ ssize_t retval = 0; ++ ssize_t retval = -ENODEV; + struct rtc_device *rtc = to_rtc_device(dev); + struct rtc_time tm; + -+ if (down_read_trylock(&rtc->lock) == 0) -+ return -ENODEV; ++ if ((retval = down_interruptible(&rtc->ops_lock))) ++ return retval; + -+ if (rtc_read_time(dev, &tm) == 0) { ++ if (rtc->ops && ((retval = rtc_read_time(dev, &tm)) == 0)) { + retval = sprintf(buf, "%02d:%02d:%02d\n", + tm.tm_hour, tm.tm_min, tm.tm_sec); + } + -+ up_read(&rtc->lock); ++ up(&rtc->ops_lock); ++ + return retval; +} +static CLASS_DEVICE_ATTR(time, S_IRUGO, rtc_sysfs_show_time, NULL); + +static ssize_t rtc_sysfs_show_since_epoch(struct class_device *dev, char *buf) +{ -+ ssize_t retval = 0; ++ ssize_t retval = -ENODEV; + struct rtc_device *rtc = to_rtc_device(dev); + struct rtc_time tm; + -+ if (down_read_trylock(&rtc->lock) == 0) -+ return -ENODEV; ++ if ((retval = down_interruptible(&rtc->ops_lock))) ++ return retval; + -+ if (rtc_read_time(dev, &tm) == 0) { ++ if (rtc->ops && ((retval = rtc_read_time(dev, &tm)) == 0)) { + unsigned long time; + rtc_tm_to_time(&tm, &time); + retval = sprintf(buf, "%lu\n", time); + } + -+ up_read(&rtc->lock); ++ up(&rtc->ops_lock); ++ + return retval; +} +static CLASS_DEVICE_ATTR(since_epoch, S_IRUGO, rtc_sysfs_show_since_epoch, NULL); @@ -993,7 +1041,7 @@ +MODULE_DESCRIPTION("RTC class sysfs interface"); +MODULE_LICENSE("GPL"); --- /dev/null 1970-01-01 00:00:00.000000000 +0000 -+++ linux-nslu2/drivers/rtc/rtc-proc.c 2006-01-04 01:27:14.000000000 +0100 ++++ linux-nslu2/drivers/rtc/rtc-proc.c 2006-01-09 03:39:50.000000000 +0100 @@ -0,0 +1,158 @@ +/* + * RTC subsystem, proc interface @@ -1154,7 +1202,7 @@ +MODULE_DESCRIPTION("RTC class proc interface"); +MODULE_LICENSE("GPL"); --- /dev/null 1970-01-01 00:00:00.000000000 +0000 -+++ linux-nslu2/drivers/rtc/rtc-dev.c 2006-01-04 01:27:15.000000000 +0100 ++++ linux-nslu2/drivers/rtc/rtc-dev.c 2006-01-09 04:00:16.000000000 +0100 @@ -0,0 +1,372 @@ +/* + * RTC subsystem, dev interface @@ -1529,7 +1577,7 @@ +MODULE_DESCRIPTION("RTC class dev interface"); +MODULE_LICENSE("GPL"); --- /dev/null 1970-01-01 00:00:00.000000000 +0000 -+++ linux-nslu2/drivers/rtc/rtc-x1205.c 2006-01-04 01:27:17.000000000 +0100 ++++ linux-nslu2/drivers/rtc/rtc-x1205.c 2006-01-09 04:17:02.000000000 +0100 @@ -0,0 +1,725 @@ +/* + * An i2c driver for the Xicor/Intersil X1205 RTC @@ -1906,7 +1954,7 @@ + do_settimeofday(&tv); + + dev_info(&client->dev, -+ "setting the system clock to %d-%d-%d %d:%d:%d\n", ++ "setting the system clock to %02d-%02d-%d %02d:%02d:%02d\n", + tm.tm_year + 1900, tm.tm_mon + 1, + tm.tm_mday, tm.tm_hour, tm.tm_min, + tm.tm_sec); @@ -2257,8 +2305,8 @@ +module_init(x1205_init); +module_exit(x1205_exit); --- /dev/null 1970-01-01 00:00:00.000000000 +0000 -+++ linux-nslu2/drivers/rtc/rtc-test.c 2006-01-04 01:27:19.000000000 +0100 -@@ -0,0 +1,189 @@ ++++ linux-nslu2/drivers/rtc/rtc-test.c 2006-01-09 04:17:02.000000000 +0100 +@@ -0,0 +1,206 @@ +/* + * An RTC test device/driver + * Copyright (C) 2005 Tower Technologies @@ -2275,6 +2323,9 @@ +#include +#include + ++struct platform_device *test0 = NULL, *test1 = NULL; ++ ++ +static int test_rtc_read_alarm(struct device *dev, + struct rtc_wkalrm *alrm) +{ @@ -2391,7 +2442,7 @@ + return 0; +} + -+static int test_remove(struct platform_device *plat_dev) ++static int __devexit test_remove(struct platform_device *plat_dev) +{ + struct rtc_device *rtc = platform_get_drvdata(plat_dev); + @@ -2401,25 +2452,9 @@ + return 0; +} + -+static void test_release(struct device * dev) -+{ -+} -+ -+struct platform_device test_dev_zero = { -+ .name = "rtc-test", -+ .id = 0, -+ .dev.release = test_release, -+}; -+ -+struct platform_device test_dev_one = { -+ .name = "rtc-test", -+ .id = 1, -+ .dev.release = test_release, -+}; -+ -+struct platform_driver test_drv = { ++static struct platform_driver test_drv = { + .probe = test_probe, -+ .remove = test_remove, ++ .remove = __devexit_p(test_remove), + .driver = { + .name = "rtc-test", + .owner = THIS_MODULE, @@ -2428,18 +2463,48 @@ + +static int __init test_init(void) +{ -+ platform_device_register(&test_dev_zero); -+ platform_device_register(&test_dev_one); -+ platform_driver_register(&test_drv); ++ int err; ++ ++ if ((err = platform_driver_register(&test_drv))) ++ return err; ++ ++ if ((test0 = platform_device_alloc("rtc-test", 0)) == NULL) { ++ err = -ENOMEM; ++ goto exit_driver_unregister; ++ } ++ ++ if ((test1 = platform_device_alloc("rtc-test", 1)) == NULL) { ++ err = -ENOMEM; ++ goto exit_free_test0; ++ } ++ ++ if ((err = platform_device_add(test0))) ++ goto exit_free_test1; ++ ++ if ((err = platform_device_add(test1))) ++ goto exit_device_unregister; + + return 0; ++ ++exit_device_unregister: ++ platform_device_unregister(test0); ++ ++exit_free_test1: ++ platform_device_put(test1); ++ ++exit_free_test0: ++ platform_device_put(test0); ++ ++exit_driver_unregister: ++ platform_driver_unregister(&test_drv); ++ return err; +} + +static void __exit test_exit(void) +{ ++ platform_device_unregister(test0); ++ platform_device_unregister(test1); + platform_driver_unregister(&test_drv); -+ platform_device_unregister(&test_dev_zero); -+ platform_device_unregister(&test_dev_one); +} + +MODULE_AUTHOR("Alessandro Zummo "); @@ -2449,8 +2514,8 @@ +module_init(test_init); +module_exit(test_exit); --- /dev/null 1970-01-01 00:00:00.000000000 +0000 -+++ linux-nslu2/drivers/rtc/rtc-ds1672.c 2006-01-04 01:27:21.000000000 +0100 -@@ -0,0 +1,266 @@ ++++ linux-nslu2/drivers/rtc/rtc-ds1672.c 2006-01-12 00:31:05.000000000 +0100 +@@ -0,0 +1,278 @@ +/* + * An rtc/i2c driver for the Dallas DS1672 + * Copyright 2005 Alessandro Zummo @@ -2465,7 +2530,7 @@ +#include +#include + -+#define DRV_VERSION "0.1" ++#define DRV_VERSION "0.2" + +/* Addresses to scan: none. This chip cannot be detected. */ +static unsigned short normal_i2c[] = { I2C_CLIENT_END }; @@ -2493,8 +2558,20 @@ +static int ds1672_get_datetime(struct i2c_client *client, struct rtc_time *tm) +{ + unsigned long time; ++ unsigned char addr = DS1672_REG_CNT_BASE; + unsigned char buf[4]; + ++ struct i2c_msg msgs[] = { ++ { client->addr, 0, 1, &addr }, /* setup read ptr */ ++ { client->addr, I2C_M_RD, 4, buf }, /* read date */ ++ }; ++ ++ /* read date registers */ ++ if ((i2c_transfer(client->adapter, &msgs[0], 2)) != 2) { ++ dev_err(&client->dev, "%s: read error\n", __FUNCTION__); ++ return -EIO; ++ } ++ + dev_dbg(&client->dev, + "%s: raw read data - counters=%02x,%02x,%02x,%02x\n" + __FUNCTION__, -- cgit v1.2.3 From f99c03dff8ea114ab0bfe297a391a0fa90aa9922 Mon Sep 17 00:00:00 2001 From: John Bowler Date: Mon, 16 Jan 2006 05:19:51 +0000 Subject: ixp4xx-kernel: add loft EEPROM MAC support in 2.6.15 --- .../ixp4xx-kernel/2.6.15/45-eeprom-notifier.patch | 184 +++++++++++++++++++++ .../ixp4xx-kernel/2.6.15/93-loft-maclist.patch | 96 +++++++++++ 2 files changed, 280 insertions(+) create mode 100644 packages/linux/ixp4xx-kernel/2.6.15/45-eeprom-notifier.patch create mode 100644 packages/linux/ixp4xx-kernel/2.6.15/93-loft-maclist.patch (limited to 'packages/linux/ixp4xx-kernel') diff --git a/packages/linux/ixp4xx-kernel/2.6.15/45-eeprom-notifier.patch b/packages/linux/ixp4xx-kernel/2.6.15/45-eeprom-notifier.patch new file mode 100644 index 0000000000..a3597a9c3f --- /dev/null +++ b/packages/linux/ixp4xx-kernel/2.6.15/45-eeprom-notifier.patch @@ -0,0 +1,184 @@ +Add EEPROM notifiers + +These help board level code by allowing a callback when EEPROMs are +loaded, this permits system level configuration to be loaded from the +EEPROM. This is particularly useful when the ethernet MAC ids are +stored in EEPROM and when the ethernet hardware is generic (so it +has no board level knowledge), then the MACs can be loaded into +the 'maclist' code and read out by the ethernet config. + +Signed-off-by: John Bowler + +--- linux-2.6.15/drivers/i2c/chips/eeprom.c 1970-01-01 00:00:00.000000000 +0000 ++++ linux-2.6.15/drivers/i2c/chips/eeprom.c 1970-01-01 00:00:00.000000000 +0000 +@@ -25,7 +25,6 @@ + along with this program; if not, write to the Free Software + Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ +- + #include + #include + #include +@@ -33,6 +32,9 @@ + #include + #include + #include ++#include ++ ++#include + + /* Addresses to scan */ + static unsigned short normal_i2c[] = { 0x50, 0x51, 0x52, 0x53, 0x54, +@@ -41,6 +43,9 @@ static unsigned short normal_i2c[] = { 0 + /* Insmod parameters */ + I2C_CLIENT_INSMOD_1(eeprom); + ++/* Notifier list */ ++static DECLARE_MUTEX(eeprom_notifier_mutex); ++static LIST_HEAD(eeprom_notifiers); + + /* Size of EEPROM in bytes */ + #define EEPROM_SIZE 256 +@@ -160,6 +165,7 @@ static int eeprom_detect(struct i2c_adap + struct i2c_client *new_client; + struct eeprom_data *data; + int err = 0; ++ struct list_head *this; + + /* There are three ways we can read the EEPROM data: + (1) I2C block reads (faster, but unsupported by most adapters) +@@ -196,7 +202,7 @@ static int eeprom_detect(struct i2c_adap + + /* Detect the Vaio nature of EEPROMs. + We use the "PCG-" prefix as the signature. */ +- if (address == 0x57) { ++ if (list_empty(&eeprom_notifiers) && address == 0x57) { + if (i2c_smbus_read_byte_data(new_client, 0x80) == 'P' + && i2c_smbus_read_byte(new_client) == 'C' + && i2c_smbus_read_byte(new_client) == 'G' +@@ -210,6 +216,14 @@ static int eeprom_detect(struct i2c_adap + /* create the sysfs eeprom file */ + sysfs_create_bin_file(&new_client->dev.kobj, &eeprom_attr); + ++ /* Call each notifier callback */ ++ down(&eeprom_notifier_mutex); ++ list_for_each(this, &eeprom_notifiers) { ++ struct eeprom_notifier *not = list_entry(this, struct eeprom_notifier, list); ++ not->add(address, kind, &new_client->dev.kobj, &eeprom_attr); ++ } ++ up(&eeprom_notifier_mutex); ++ + return 0; + + exit_kfree: +@@ -231,6 +245,51 @@ static int eeprom_detach_client(struct i + return 0; + } + ++/** ++ * register_eeprom_user - register a 'user' of EEPROM devices. ++ * @new: pointer to notifier info structure ++ * ++ * Registers a callback function to be called upon detection ++ * of an EEPROM device. Detection invokes the 'add' callback ++ * with the kobj of the mutex and a bin_attribute which allows ++ * read from the EEPROM. The intention is that the notifier ++ * will be able to read system configuration from the notifier. ++ * ++ * Only EEPROMs detected *after* the addition of the notifier ++ * are notified. I.e. EEPROMs already known to the system ++ * will not be notified - add the notifier from board level ++ * code! ++ */ ++void register_eeprom_user (struct eeprom_notifier *new) ++{ ++ down(&eeprom_notifier_mutex); ++ ++ list_add(&new->list, &eeprom_notifiers); ++ ++ up(&eeprom_notifier_mutex); ++} ++ ++/** ++ * unregister_eeprom_user - unregister a 'user' of EEPROM devices. ++ * @old: pointer to notifier info structure ++ * ++ * Removes a callback function from the list of 'users' to be ++ * notified upon detection of EEPROM devices. ++ */ ++void unregister_eeprom_user (struct eeprom_notifier *old) ++{ ++ down(&eeprom_notifier_mutex); ++ ++ list_del(&old->list); ++ ++ up(&eeprom_notifier_mutex); ++} ++ ++ ++EXPORT_SYMBOL(register_eeprom_user); ++EXPORT_SYMBOL(unregister_eeprom_user); ++ ++ + static int __init eeprom_init(void) + { + return i2c_add_driver(&eeprom_driver); +--- linux-2.6.15/include/linux/eeprom.h 1970-01-01 00:00:00.000000000 +0000 ++++ linux-2.6.15/include/linux/eeprom.h 1970-01-01 00:00:00.000000000 +0000 +@@ -0,0 +1,56 @@ ++#ifndef _LINUX_EEPROM_H ++#define _LINUX_EEPROM_H ++/* ++ * $Id$ ++ * ++ * Copyright (C) 2006 John Bowler ++ */ ++ ++/* ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License as published by ++ * the Free Software Foundation; either version 2 of the License, or ++ * (at your option) any later version. ++ * ++ * This program is distributed in the hope that it will be useful, ++ * but WITHOUT ANY WARRANTY; without even the implied warranty of ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ++ * GNU General Public License for more details. ++ * ++ * You should have received a copy of the GNU General Public License ++ * along with this program; if not, write to the Free Software ++ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA ++ */ ++ ++#ifndef __KERNEL__ ++#error This is a kernel header ++#endif ++ ++#include ++#include ++#include ++ ++/* ++ * This is very basic. ++ * ++ * If an EEPROM is detected on the I2C bus (this only works for ++ * I2C EEPROMs) the eeprom_notifier::add method is called with ++ * both the I2C information and the kobject for the sysfs ++ * device which has been registers. It is then possible to ++ * read from the device via the bin_attribute::read method ++ * to extract configuration information. ++ * ++ * Register the notifier in the board level code, there is no ++ * need to unregister it but you can if you want (it will save ++ * a little bit or kernel memory to do so). ++ */ ++struct eeprom_notifier { ++ void (*add)(int address, int kind, struct kobject *kobj, ++ struct bin_attribute *eeprom_attr); ++ struct list_head list; ++}; ++ ++extern void register_eeprom_user (struct eeprom_notifier *new); ++extern void unregister_eeprom_user (struct eeprom_notifier *old); ++ ++#endif /* _LINUX_EEPROM_H */ diff --git a/packages/linux/ixp4xx-kernel/2.6.15/93-loft-maclist.patch b/packages/linux/ixp4xx-kernel/2.6.15/93-loft-maclist.patch new file mode 100644 index 0000000000..ffda1136ef --- /dev/null +++ b/packages/linux/ixp4xx-kernel/2.6.15/93-loft-maclist.patch @@ -0,0 +1,96 @@ +add loft support for setting the maclist from EEPROM + +Signed-off-by: John Bowler + +--- linux-2.6.15/arch/arm/mach-ixp4xx/ixdp425-setup.c 1970-01-01 00:00:00.000000000 +0000 ++++ linux-2.6.15/arch/arm/mach-ixp4xx/ixdp425-setup.c 1970-01-01 00:00:00.000000000 +0000 +@@ -14,6 +14,7 @@ + #include + #include + #include ++#include + + #include + #include +@@ -24,6 +25,8 @@ + #include + #include + ++#include ++ + static struct flash_platform_data ixdp425_flash_data = { + .map_name = "cfi_probe", + .width = 2, +@@ -188,9 +191,62 @@ MACHINE_END + /* + * Loft is functionally equivalent to Avila except that it has a + * different number for the maximum PCI devices. The MACHINE +- * structure below is identical to Avila except for the comment. ++ * structure below is identical to Avila except for the and ++ * the use of a loft specific init. ++ * ++ * The loft init registers a notifier on the on-board EEPROM to ++ * detect the MAC addresses. ++ * NOTE: this probably works for all Gateworks Avila boards and ++ * maybe the ixdp425 too. + */ + #ifdef CONFIG_MACH_LOFT ++/* ++ * When the EEPROM is added the MAC address are read from it. ++ */ ++static void loft_eeprom_add(int address, int kind, struct kobject *kobj, ++ struct bin_attribute *eeprom_attr) { ++ /* The MACs are the first 12 bytes in the eeprom at address 0x51 */ ++ if (address == 0x51) { ++ ssize_t retlen; ++ char data[12]; ++ ++ /* Two Macs, one at 0, the other at 6, maclist_add will ++ * complain if the ID is not a valid MAC. ++ */ ++ retlen = eeprom_attr->read(kobj, data, 0, sizeof data); ++ if (retlen >= 6) { ++ u8 mac[6]; ++ memcpy(mac, data+0, sizeof mac); ++ printk(KERN_INFO "LOFT MAC[0]: %.2x:%.2x:%.2x:%.2x:%.2x:%.2x\n", ++ mac[0], mac[1], mac[2], mac[3], mac[4], mac[5]); ++ maclist_add(mac); ++ } ++ if (retlen >= 12) { ++ u8 mac[6]; ++ memcpy(mac, data+6, sizeof mac); ++ printk(KERN_INFO "LOFT MAC[1]: %.2x:%.2x:%.2x:%.2x:%.2x:%.2x\n", ++ mac[0], mac[1], mac[2], mac[3], mac[4], mac[5]); ++ maclist_add(mac); ++ } ++ } ++} ++ ++static struct eeprom_notifier loft_eeprom_notifier = { ++ .add = loft_eeprom_add ++}; ++ ++static void __init loft_init(void) ++{ ++ /* The EEPROM has two ethernet MACs embedded in it which we need, ++ * that is all this notifier does. ++ */ ++ register_eeprom_user(&loft_eeprom_notifier); ++ ++ ixp4xx_sys_init(); ++ ++ platform_add_devices(ixdp425_devices, ARRAY_SIZE(ixdp425_devices)); ++} ++ + MACHINE_START(LOFT, "Giant Shoulder Inc Loft board") + /* Maintainer: Tom Billman */ + .phys_ram = PHYS_OFFSET, +@@ -200,7 +256,7 @@ MACHINE_START(LOFT, "Giant Shoulder Inc + .init_irq = ixp4xx_init_irq, + .timer = &ixp4xx_timer, + .boot_params = 0x0100, +- .init_machine = ixdp425_init, ++ .init_machine = loft_init, + MACHINE_END + #endif + -- cgit v1.2.3