From c435f0f5b01e8df3a0a3a567077741b1f8d4be04 Mon Sep 17 00:00:00 2001 From: Rod Whitby Date: Wed, 4 Jan 2006 11:52:21 +0000 Subject: ixp4xx-kernel: Initial version - patches need to be cleaned up to coexist with other ixp4xx machines, updated patchsets to match 2.6.15, removed some patches, and combined some others. --- packages/linux/ixp4xx-kernel.inc | 198 ++ packages/linux/ixp4xx-kernel/.mtn2git_empty | 0 packages/linux/ixp4xx-kernel/2.6.15/.mtn2git_empty | 0 .../2.6.15/00-memory-h-page-shift.patch | 91 + .../2.6.15/10-mtdpart-redboot-fis-byteswap.patch | 77 + .../ixp4xx-kernel/2.6.15/19-jffs2-force-be.patch | 13 + .../linux/ixp4xx-kernel/2.6.15/40-rtc-class.patch | 2719 ++++++++++++++++++++ .../ixp4xx-kernel/2.6.15/50-nas100d-arch.patch | 453 ++++ .../ixp4xx-kernel/2.6.15/60-nas100d-i2c.patch | 531 ++++ .../ixp4xx-kernel/2.6.15/60-nas100d-ide.patch | 155 ++ .../ixp4xx-kernel/2.6.15/60-nslu2-beeper.patch | 184 ++ .../linux/ixp4xx-kernel/2.6.15/75-nslu2-leds.patch | 272 ++ .../linux/ixp4xx-kernel/2.6.15/80-nslu2-io.patch | 560 ++++ packages/linux/ixp4xx-kernel/2.6.15/85-timer.patch | 285 ++ .../linux/ixp4xx-kernel/2.6.15/91-maclist.patch | 377 +++ .../ixp4xx-kernel/2.6.15/92-nas100d-maclist.patch | 72 + .../ixp4xx-kernel/2.6.15/92-nslu2-maclist.patch | 80 + packages/linux/ixp4xx-kernel/2.6.15/defconfig | 1603 ++++++++++++ packages/linux/ixp4xx-kernel_2.6.15.bb | 38 + 19 files changed, 7708 insertions(+) create mode 100644 packages/linux/ixp4xx-kernel.inc create mode 100644 packages/linux/ixp4xx-kernel/.mtn2git_empty create mode 100644 packages/linux/ixp4xx-kernel/2.6.15/.mtn2git_empty create mode 100644 packages/linux/ixp4xx-kernel/2.6.15/00-memory-h-page-shift.patch create mode 100644 packages/linux/ixp4xx-kernel/2.6.15/10-mtdpart-redboot-fis-byteswap.patch create mode 100644 packages/linux/ixp4xx-kernel/2.6.15/19-jffs2-force-be.patch create mode 100644 packages/linux/ixp4xx-kernel/2.6.15/40-rtc-class.patch create mode 100644 packages/linux/ixp4xx-kernel/2.6.15/50-nas100d-arch.patch create mode 100644 packages/linux/ixp4xx-kernel/2.6.15/60-nas100d-i2c.patch create mode 100644 packages/linux/ixp4xx-kernel/2.6.15/60-nas100d-ide.patch create mode 100644 packages/linux/ixp4xx-kernel/2.6.15/60-nslu2-beeper.patch create mode 100644 packages/linux/ixp4xx-kernel/2.6.15/75-nslu2-leds.patch create mode 100644 packages/linux/ixp4xx-kernel/2.6.15/80-nslu2-io.patch create mode 100644 packages/linux/ixp4xx-kernel/2.6.15/85-timer.patch create mode 100644 packages/linux/ixp4xx-kernel/2.6.15/91-maclist.patch create mode 100644 packages/linux/ixp4xx-kernel/2.6.15/92-nas100d-maclist.patch create mode 100644 packages/linux/ixp4xx-kernel/2.6.15/92-nslu2-maclist.patch create mode 100644 packages/linux/ixp4xx-kernel/2.6.15/defconfig create mode 100644 packages/linux/ixp4xx-kernel_2.6.15.bb diff --git a/packages/linux/ixp4xx-kernel.inc b/packages/linux/ixp4xx-kernel.inc new file mode 100644 index 0000000000..54679ebfdf --- /dev/null +++ b/packages/linux/ixp4xx-kernel.inc @@ -0,0 +1,198 @@ +# ixp4xx-kernel.inc +# +# Standard definitions for any IXP4xx Linux kernel. +# Include this file in a .bb which specifies, at least, +# PN,PV,PR for the desired kernel +# +# Define the following *before* including this file as +# required: +# +# IXP4XX_PATCHES - full list of patches to apply +# +# IXP4XX_SUFFIX - the suffix to add after 'zImage-' in the +# deploy/images directory - defaults to "ixp4xx" +# +# -------------------------------------------------------------- +# +# Within this file bitbake variables local to the file are +# named N1K_FOO +# +SECTION = "kernel" +DESCRIPTION = "Linux kernel for the Intel IXP4xx device" +LICENSE = "GPL" +MAINTAINER = "NSLU2-Linux " + +DEPENDS += "devio-native" + +# Linux kernel source has the general form linux-X.Y.Z-patchP, +# X.Y is the major version number, Z (which may have multiple +# parts) is a sub-version and 'patch' is something like 'mm' or +# 'ac' with a patch version. The original bz2 archive will be +# in a directory/file vX.Y/linux-X.Y.Z.tar.bz2. The unpacked +# source will be in the directory linux-X.Y.Z and this directory +# name corresponds to the module directory (in /lib/modules). +# +# The corresponding .bb file should be called: +# +# package_X.Y.Z-patchP +# +# Giving PN=package PV=X.Y.Z-patchP (and PR is set in the .bb +# file). Files, including the all important defconfig, are +# searched for in the following directories (last one first): +# +# ixp4xx-kernel/files +# ixp4xx-kernel/X.Y +# ixp4xx-kernel/X.Y.Z +# ixp4xx-kernel/X.Y.Z-patch +# ixp4xx-kernel/X.Y.Z-patchP +# package-X.Y.Z-patchP +# +# This allows sharing of patch files and other useful source! +# To share a file or patch with an earlier version put it in +# the shared directory - e.g. to use foo.patch on 2.6.11.2 and +# 2.6.11.4 it should be in directory ixp4xx-kernel/2.6.11. +# +# Note that when there are multiple patches the X.Y.Z-patch form +# uses base-patch (e.g. 2.6.12-mm) whereas X.Y.Z-patchP has the +# full form, for example 2.6.12-rc3-mm1 (in the same case). + +#PN=package-name +#PV=package-version (full) + +# The patch has the general form (rcN|preN|acN|mmN|bkN)* with the +# separate patch items being separated by '-' characters. The +# rc patch is first and has the important property that it +# requires the *preceding* kernel base version and that this +# will be the source directory name. +python () { + # The patches list may be empty. This code starts with the base + # kernel version and steps through the patches. Because the rc and + # pre patches actually require the *preceding* kernel version the code + # fixes that up appropriately. + pv = bb.data.getVar("PV",d,1).split('-') + kernel = pv[0].split('.') + base = pv[0] + name = [base] + major = '.'.join(name[0].split('.')[0:2]) + minor = '.'.join(name[0].split('.')[0:3]) + patch_uri = [ None ] + filedir = "${FILE_DIRNAME}/ixp4xx-kernel/%s" + # This entry will become the last one (everything is inserted before it) + filepath = [ filedir % "files" ] + pref = 10 + mmac = 0 + for patch in pv[1:]: + name.append(patch) + pname = '-'.join(name) + if patch[0:2] == "rc" or patch[0:3] == "pre": + patch_uri.append("ftp://ftp.kernel.org/pub/linux/kernel/v%s/testing/patch-%s.bz2;patch=1;pname=%s" % (major, pname, pname)) + kernel[-1] = str(int(kernel[-1]) - 1) + if patch[0:2] == "rc" and pref == 10: + pref = 6 + filepath[0:0] = [ filedir % name[0] ] + filepath[0:0] = [ filedir % (name[0] + "-rc") ] + else: + pref = 2 + elif patch[0:2] == "bk" or patch[0:3] == "git": + patch_uri.append("ftp://ftp.kernel.org/pub/linux/kernel/v%s/snapshots/patch-%s.bz2;patch=1;pname=%s" % (major, pname, pname)) + pref = 2 + elif patch[0:2] == "ac": + patch_uri.append("ftp://ftp.kernel.org/pub/linux/kernel/people/alan/linux-%s/%s/patch-%s" % (major, base, pname)) + mmac = 2 + filepath[0:0] = [ filedir % (name[0] + "-ac") ] + elif patch[0:2] == "mm": + patch_uri.append("ftp://ftp.kernel.org/pub/linux/kernel/people/akpm/patches/%s/%s/%s/%s.bz2;patch=1;pname=%s" % (major, base, pname, pname, pname)) + mmac = 2 + filepath[0:0] = [ filedir % (name[0] + "-mm") ] + else: + raise bb.build.FuncFailed("ixp4xx-kernel: patch %s not recognized in %s" % (patch, '-'.join(pv))) + filepath[0:0] = [ filedir % pname ] + base = pname + + base = '.'.join(kernel) + patch_uri[0] = "ftp://ftp.kernel.org/pub/linux/kernel/v%s/linux-%s.tar.bz2" % (major, base) + filepath[-1:-1] = [ filedir % base ] + if base != minor: + filepath[-1:-1] = [ filedir % minor ] + filepath[-1:-1] = [ filedir % major ] + + bb.data.setVar("IXP4XX_SRCMAJ", major, d) + # bb.note("IXP4XX_SRCMAJ := %s" % major) + bb.data.setVar("IXP4XX_SRCVER", base, d) + # bb.note("IXP4XX_SRCVER := %s" % base) + bb.data.setVar("IXP4XX_SRCURI", ' '.join(patch_uri), d) + # bb.note("IXP4XX_SRCURI := %s" % ' '.join(patch_uri)) + bb.data.setVar("IXP4XX_FILESPATH", ':'.join(filepath), d) + # bb.note("IXP4XX_FILESPATH := %s" % ' '.join(filepath)) + bb.data.setVar("DEFAULT_PREFERENCE", pref-mmac, d) + # bb.note("DEFAULT_PREFERENCE := %s" % (pref-mmac)) +} + +# FILESPATH: this list is in order last-searched-first, therefore +# the first entry is the *latest* and/or most specific +FILESPATH = "${IXP4XX_FILESPATH}:${FILE_DIRNAME}/ixp4xx-kernel/" + +# The working directory will be the 'base' version (which may not be the +# same as implied by the PV variable because it corresponds to the prior +# minor version for rc and pre patched versions). +S = "${WORKDIR}/linux-${IXP4XX_SRCVER}" + +# IXP4XX_PATCHES is a list of additional patches to apply +IXP4XX_PATCHES ?= "" + +IXP4XX_SUFFIX ?= "ixp4xx" + +SRC_URI = "${IXP4XX_SRCURI}" +SRC_URI += "${IXP4XX_PATCHES}" +SRC_URI += "file://defconfig" + +COMPATIBLE_HOST = 'arm.*-linux' + +inherit kernel + +ARCH = "arm" +KERNEL_IMAGETYPE = "zImage" +# To specify the console set KERNEL_CONSOLE in the .bb file. +# CMDLINE_ROOT contains the boot options, CMDLINE_KERNEL_OPTIONS +# contains the things for a specific kernel. +# CMDLINE_KERNEL_OPTIONS ?= "reboot=s" +CMDLINE_KERNEL_OPTIONS ?= +CMDLINE_ROOT = "root=/dev/mtdblock2 rw rootfstype=jffs2 mem=64M@0x00000000 init=/linuxrc" +CMDLINE_DEBUG = +CMDLINE = "${CMDLINE_ROOT} ${CMDLINE_KERNEL_OPTIONS} ${CMDLINE_DEBUG} ${CMDLINE_CONSOLE}" + +# Add the architecture compiler flags to KERNEL_CC and KERNEL_LD as +# required. Notice that this has to be done for each separately built +# module as well! +KERNEL_CC += "${TARGET_CC_KERNEL_ARCH}" +KERNEL_LD += "${TARGET_LD_KERNEL_ARCH}" + +# Set EXTRAVERSION and LOCALVERSION to "" so that the kernel version +# remains pinned to the x.y.z form, also turn off the directory +# printing which provides almost all the output of an incremental build. +EXTRA_OEMAKE += "EXTRAVERSION=" +EXTRA_OEMAKE += "LOCALVERSION=" +EXTRA_OEMAKE += "MAKEFLAGS='--no-print-directory'" + +# Override KERNEL_RELEASE from kernel.bbclass to match: +KERNEL_RELEASE = "${KERNEL_VERSION}" + +do_configure_prepend() { + rm -f ${S}/.config + echo "CONFIG_CMDLINE=\"${CMDLINE}\"" >>'${S}/.config' + if test '${ARCH_BYTE_SEX}' = be + then + echo 'CONFIG_CPU_BIG_ENDIAN=y' >>'${S}/.config' + fi + sed -e '/CONFIG_CPU_BIG_ENDIAN/d' -e '/CONFIG_CMDLINE=/d' '${WORKDIR}/defconfig' >>'${S}/.config' + rm -rf ${S}/include/asm-arm/arch ${S}/include/asm-arm/proc \ + ${S}/include/asm-arm/.proc ${S}/include/asm-arm/.arch +} + +do_deploy[dirs] = "${S}" +do_deploy() { + install -d ${DEPLOY_DIR}/images + install -m 644 arch/${ARCH}/boot/${KERNEL_IMAGETYPE} ${DEPLOY_DIR}/images/${KERNEL_IMAGETYPE}-${IXP4XX_SUFFIX} +} + +addtask deploy before do_build after do_compile diff --git a/packages/linux/ixp4xx-kernel/.mtn2git_empty b/packages/linux/ixp4xx-kernel/.mtn2git_empty new file mode 100644 index 0000000000..e69de29bb2 diff --git a/packages/linux/ixp4xx-kernel/2.6.15/.mtn2git_empty b/packages/linux/ixp4xx-kernel/2.6.15/.mtn2git_empty new file mode 100644 index 0000000000..e69de29bb2 diff --git a/packages/linux/ixp4xx-kernel/2.6.15/00-memory-h-page-shift.patch b/packages/linux/ixp4xx-kernel/2.6.15/00-memory-h-page-shift.patch new file mode 100644 index 0000000000..30d34952d5 --- /dev/null +++ b/packages/linux/ixp4xx-kernel/2.6.15/00-memory-h-page-shift.patch @@ -0,0 +1,91 @@ +http://www.arm.linux.org.uk/developer/patches/viewpatch.php?id=3218/1 + +PAGE_SHIFT is undeclared in include/asm-arm/arch-ixp4xx/memory.h, identified by the following kernel compilation error: + +CC [M] sound/core/memory.o +In file included from include/asm/memory.h:27, +from include/asm/io.h:28, +from sound/core/memory.c:24: +include/asm/arch/memory.h: In function `__arch_adjust_zones': +include/asm/arch/memory.h:28: error: `PAGE_SHIFT' undeclared (first use +in this function) + +This patch replaces my previous attempt at fixing this problem (Patch 3214/1) and is based on the following feedback: + +Russell King wrote: +> The error you see came up on SA1100. The best solution was to move +> the __arch_adjust_zones() function out of line. I suggest ixp4xx +> does the same. + +I have moved the function out of line into arch/arm/mach-ixp4xx/common-pci.c as suggested. + +Signed-off-by: Rod Whitby + +--- linux-2.6.15-rc7/include/asm-arm/arch-ixp4xx/memory.h~ 2005-12-30 05:18:27.000000000 +1030 ++++ linux-2.6.15-rc7/include/asm-arm/arch-ixp4xx/memory.h 2005-12-30 05:36:04.000000000 +1030 +@@ -16,31 +16,10 @@ + + #ifndef __ASSEMBLY__ + +-/* +- * Only first 64MB of memory can be accessed via PCI. +- * We use GFP_DMA to allocate safe buffers to do map/unmap. +- * This is really ugly and we need a better way of specifying +- * DMA-capable regions of memory. +- */ +-static inline void __arch_adjust_zones(int node, unsigned long *zone_size, +- unsigned long *zhole_size) +-{ +- unsigned int sz = SZ_64M >> PAGE_SHIFT; +- +- /* +- * Only adjust if > 64M on current system +- */ +- if (node || (zone_size[0] <= sz)) +- return; +- +- zone_size[1] = zone_size[0] - sz; +- zone_size[0] = sz; +- zhole_size[1] = zhole_size[0]; +- zhole_size[0] = 0; +-} ++void ixp4xx_adjust_zones(int node, unsigned long *size, unsigned long *holes); + + #define arch_adjust_zones(node, size, holes) \ +- __arch_adjust_zones(node, size, holes) ++ ixp4xx_adjust_zones(node, size, holes) + + #define ISA_DMA_THRESHOLD (SZ_64M - 1) + +--- linux-2.6.15-rc7/arch/arm/mach-ixp4xx/common-pci.c~ 2005-12-30 05:16:03.000000000 +1030 ++++ linux-2.6.15-rc7/arch/arm/mach-ixp4xx/common-pci.c 2005-12-30 05:43:55.000000000 +1030 +@@ -341,6 +341,29 @@ int dma_needs_bounce(struct device *dev, + return (dev->bus == &pci_bus_type ) && ((dma_addr + size) >= SZ_64M); + } + ++/* ++ * Only first 64MB of memory can be accessed via PCI. ++ * We use GFP_DMA to allocate safe buffers to do map/unmap. ++ * This is really ugly and we need a better way of specifying ++ * DMA-capable regions of memory. ++ */ ++void __init ixp4xx_adjust_zones(int node, unsigned long *zone_size, ++ unsigned long *zhole_size) ++{ ++ unsigned int sz = SZ_64M >> PAGE_SHIFT; ++ ++ /* ++ * Only adjust if > 64M on current system ++ */ ++ if (node || (zone_size[0] <= sz)) ++ return; ++ ++ zone_size[1] = zone_size[0] - sz; ++ zone_size[0] = sz; ++ zhole_size[1] = zhole_size[0]; ++ zhole_size[0] = 0; ++} ++ + void __init ixp4xx_pci_preinit(void) + { + unsigned long processor_id; diff --git a/packages/linux/ixp4xx-kernel/2.6.15/10-mtdpart-redboot-fis-byteswap.patch b/packages/linux/ixp4xx-kernel/2.6.15/10-mtdpart-redboot-fis-byteswap.patch new file mode 100644 index 0000000000..077aa00816 --- /dev/null +++ b/packages/linux/ixp4xx-kernel/2.6.15/10-mtdpart-redboot-fis-byteswap.patch @@ -0,0 +1,77 @@ +drivers/mtd/redboot.c: recognise a foreign byte sex partition table + +The RedBoot boot loader writes flash partition tables containing native +byte sex 32 bit values. When booting an opposite byte sex kernel (e.g. an +LE kernel from BE RedBoot) the current MTD driver fails to handle the +partition table and therefore is unable to generate the correct partition +map for the flash. + +The patch recognises that the FIS directory (the partition table) is +byte-reversed by examining the partition table size, which is known to be +one erase block (this is an assumption made elsewhere in redboot.c). If +the size matches the erase block after byte swapping the value then +byte-reversal is assumed, if not no further action is taken. The patched +code is fail safe; should redboot.c be changed to support a partition table +with a modified size field the test will fail and the partition table will +be assumed to have the host byte sex. + +If byte-reversal is detected the patch byte swaps the remainder of the 32 +bit fields in the copy of the table; this copy is then used to set up the +MTD partition map. + +Signed-off-by: John Bowler +Signed-off-by: Andrew Morton +Modified slightly and +Signed-off-by: David Woodhouse + +Index: drivers/mtd/redboot.c +=================================================================== +RCS file: /home/cvs/mtd/drivers/mtd/redboot.c,v +retrieving revision 1.18 +retrieving revision 1.19 +diff -u -p -r1.18 -r1.19 +--- 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 +@@ -1,5 +1,5 @@ + /* +- * $Id: redboot.c,v 1.18 2005/11/07 11:14:21 gleixner Exp $ ++ * $Id: redboot.c,v 1.19 2005/12/01 10:03:51 dwmw2 Exp $ + * + * Parse RedBoot-style Flash Image System (FIS) tables and + * produce a Linux partition array to match. +@@ -89,8 +89,32 @@ static int parse_redboot_partitions(stru + i = numslots; + break; + } +- if (!memcmp(buf[i].name, "FIS directory", 14)) ++ 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.) ++ */ ++ if (swab32(buf[i].size) == master->erasesize) { ++ int j; ++ for (j = 0; j < numslots && buf[j].name[0] != 0xff; ++j) { ++ /* The unsigned long fields were written with the ++ * wrong byte sex, name and pad have no byte sex. ++ */ ++ swab32s(&buf[j].flash_base); ++ swab32s(&buf[j].mem_base); ++ swab32s(&buf[j].size); ++ swab32s(&buf[j].entry_point); ++ swab32s(&buf[j].data_length); ++ swab32s(&buf[j].desc_cksum); ++ swab32s(&buf[j].file_cksum); ++ } ++ } + break; ++ } + } + if (i == numslots) { + /* Didn't find it */ + + diff --git a/packages/linux/ixp4xx-kernel/2.6.15/19-jffs2-force-be.patch b/packages/linux/ixp4xx-kernel/2.6.15/19-jffs2-force-be.patch new file mode 100644 index 0000000000..09379031dd --- /dev/null +++ b/packages/linux/ixp4xx-kernel/2.6.15/19-jffs2-force-be.patch @@ -0,0 +1,13 @@ +--- linux-2.6.15/fs/jffs2/nodelist.h 1970-01-01 00:00:00.000000000 +0000 ++++ linux-2.6.15/fs/jffs2/nodelist.h 1970-01-01 00:00:00.000000000 +0000 +@@ -44,7 +44,9 @@ + #define D2(x) + #endif + +-#define JFFS2_NATIVE_ENDIAN ++#undef JFFS2_NATIVE_ENDIAN ++#define JFFS2_BIG_ENDIAN 1 ++#undef JFFS2_LITTLE_ENDIAN + + /* Note we handle mode bits conversion from JFFS2 (i.e. Linux) to/from + whatever OS we're actually running on here too. */ 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 new file mode 100644 index 0000000000..feea3f2f8b --- /dev/null +++ b/packages/linux/ixp4xx-kernel/2.6.15/40-rtc-class.patch @@ -0,0 +1,2719 @@ +--- 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 +@@ -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 */ + ++/* interrupt flags */ ++#define RTC_IRQF 0x80 /* any of the following is active */ ++#define RTC_PF 0x40 ++#define RTC_AF 0x20 ++#define RTC_UF 0x10 ++ + #ifdef __KERNEL__ + ++#include ++#include ++#include ++#include ++ ++struct rtc_class_ops { ++ int (*open)(struct device *); ++ void (*release)(struct device *); ++ int (*ioctl)(struct device *, unsigned int, unsigned long); ++ int (*read_time)(struct device *, struct rtc_time *); ++ int (*set_time)(struct device *, struct rtc_time *); ++ int (*read_alarm)(struct device *, struct rtc_wkalrm *); ++ int (*set_alarm)(struct device *, struct rtc_wkalrm *); ++ int (*proc)(struct device *, struct seq_file *); ++ int (*set_mmss)(struct device *, unsigned long secs); ++ int (*irq_set_state)(struct device *, int enabled); ++ int (*irq_set_freq)(struct device *, int freq); ++}; ++ ++#define RTC_DEVICE_NAME_SIZE 20 ++struct rtc_task; ++ ++struct rtc_device ++{ ++ int id; ++ struct module *owner; ++ struct rw_semaphore lock; ++ struct class_device class_dev; ++ struct rtc_class_ops *ops; ++ char name[RTC_DEVICE_NAME_SIZE]; ++ ++ struct cdev char_dev; ++ struct semaphore char_sem; ++ ++ unsigned long irq_data; ++ spinlock_t irq_lock; ++ wait_queue_head_t irq_queue; ++ struct fasync_struct *async_queue; ++ ++ spinlock_t irq_task_lock; ++ struct rtc_task *irq_task; ++ int irq_freq; ++}; ++#define to_rtc_device(d) container_of(d, struct rtc_device, class_dev) ++ ++extern struct rtc_device *rtc_device_register(char *name, ++ struct device *dev, ++ struct rtc_class_ops *ops, ++ struct module *owner); ++extern void rtc_device_unregister(struct rtc_device *rdev); ++extern int rtc_interface_register(struct class_interface *intf); ++ ++ ++extern int rtc_month_days(unsigned int month, unsigned int year); ++extern int rtc_valid_tm(struct rtc_time *tm); ++extern int rtc_tm_to_time(struct rtc_time *tm, unsigned long *time); ++extern void rtc_time_to_tm(unsigned long time, struct rtc_time *tm); ++ ++extern int rtc_read_time(struct class_device *class_dev, struct rtc_time *tm); ++extern int rtc_set_time(struct class_device *class_dev, struct rtc_time *tm); ++extern int rtc_read_alarm(struct class_device *class_dev, ++ struct rtc_wkalrm *alrm); ++extern int rtc_set_alarm(struct class_device *class_dev, ++ struct rtc_wkalrm *alrm); ++extern void rtc_update_irq(struct class_device *class_dev, ++ unsigned long num, unsigned long events); ++ + 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 +@@ -66,4 +66,6 @@ source "drivers/infiniband/Kconfig" + + source "drivers/sn/Kconfig" + ++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 +@@ -54,6 +54,7 @@ obj-$(CONFIG_USB_GADGET) += usb/gadget/ + obj-$(CONFIG_GAMEPORT) += input/gameport/ + obj-$(CONFIG_INPUT) += input/ + obj-$(CONFIG_I2O) += message/ ++obj-y += rtc/ + obj-$(CONFIG_I2C) += i2c/ + 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 @@ ++/* ++ * RTC subsystem, base class ++ * ++ * Copyright (C) 2005 Tower Technologies ++ * Author: Alessandro Zummo ++ * ++ * class skeleton from drivers/hwmon/hwmon.c ++ * ++ * 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; version 2 of the License. ++*/ ++ ++#include ++#include ++#include ++#include ++ ++static DEFINE_IDR(rtc_idr); ++static DECLARE_MUTEX(idr_lock); ++struct class *rtc_class; ++ ++static void rtc_device_release(struct class_device *class_dev) ++{ ++ struct rtc_device *rtc = to_rtc_device(class_dev); ++ down(&idr_lock); ++ idr_remove(&rtc_idr, rtc->id); ++ up(&idr_lock); ++ kfree(rtc); ++} ++ ++/** ++ * rtc_device_register - register w/ RTC class ++ * @dev: the device to register ++ * ++ * rtc_device_unregister() must be called when the class device is no ++ * longer needed. ++ * ++ * Returns the pointer to the new struct class device. ++ */ ++struct rtc_device *rtc_device_register(char *name, struct device *dev, ++ struct rtc_class_ops *ops, ++ struct module *owner) ++{ ++ struct rtc_device *rtc; ++ int id, err; ++ ++ if (idr_pre_get(&rtc_idr, GFP_KERNEL) == 0) { ++ err = -ENOMEM; ++ goto exit; ++ } ++ ++ ++ down(&idr_lock); ++ err = idr_get_new(&rtc_idr, NULL, &id); ++ up(&idr_lock); ++ ++ if (err < 0) ++ goto exit; ++ ++ id = id & MAX_ID_MASK; ++ ++ if ((rtc = kzalloc(sizeof(struct rtc_device), GFP_KERNEL)) == NULL) { ++ err = -ENOMEM; ++ goto exit_idr; ++ } ++ ++ rtc->id = id; ++ rtc->ops = ops; ++ rtc->owner = owner; ++ rtc->class_dev.dev = dev; ++ rtc->class_dev.class = rtc_class; ++ rtc->class_dev.release = rtc_device_release; ++ ++ init_rwsem(&rtc->lock); ++ spin_lock_init(&rtc->irq_lock); ++ spin_lock_init(&rtc->irq_task_lock); ++ ++ strlcpy(rtc->name, name, RTC_DEVICE_NAME_SIZE); ++ snprintf(rtc->class_dev.class_id, BUS_ID_SIZE, "rtc%d", id); ++ ++ if ((err = class_device_register(&rtc->class_dev))) ++ goto exit_kfree; ++ ++ dev_info(dev, "rtc core: registered %s as %s\n", ++ rtc->name, rtc->class_dev.class_id); ++ ++ return rtc; ++ ++exit_kfree: ++ kfree(rtc); ++ ++exit_idr: ++ idr_remove(&rtc_idr, id); ++ ++exit: ++ return ERR_PTR(err); ++} ++EXPORT_SYMBOL_GPL(rtc_device_register); ++ ++ ++/** ++ * rtc_device_unregister - removes the previously registered RTC class device ++ * ++ * @rtc: the RTC class device to destroy ++ */ ++void rtc_device_unregister(struct rtc_device *rtc) ++{ ++ down_write(&rtc->lock); ++ class_device_unregister(&rtc->class_dev); ++} ++EXPORT_SYMBOL_GPL(rtc_device_unregister); ++ ++int rtc_interface_register(struct class_interface *intf) ++{ ++ intf->class = rtc_class; ++ return class_interface_register(intf); ++} ++EXPORT_SYMBOL_GPL(rtc_interface_register); ++ ++static int __init rtc_init(void) ++{ ++ rtc_class = class_create(THIS_MODULE, "rtc"); ++ if (IS_ERR(rtc_class)) { ++ printk(KERN_ERR "%s: couldn't create class\n", __FILE__); ++ return PTR_ERR(rtc_class); ++ } ++ return 0; ++} ++ ++static void __exit rtc_exit(void) ++{ ++ class_destroy(rtc_class); ++} ++ ++module_init(rtc_init); ++module_exit(rtc_exit); ++ ++MODULE_AUTHOR("Alessandro Zummo "); ++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 +@@ -0,0 +1,93 @@ ++# ++# RTC class/drivers configuration ++# ++ ++menu "Real Time Clock" ++ ++config RTC_CLASS ++ tristate "RTC class" ++ depends on EXPERIMENTAL ++ default y ++ help ++ Generic RTC class support. If you say yes here, you will ++ be allowed to plug one or more RTCs to your system. You will ++ probably want to enable one of more of the interfaces below. ++ ++ This driver can also be built as a module. If so, the module ++ will be called rtc-class. ++ ++comment "RTC interfaces" ++ depends on RTC_CLASS ++ ++config RTC_INTF_SYSFS ++ tristate "sysfs" ++ depends on RTC_CLASS && SYSFS ++ default RTC_CLASS ++ help ++ Say yes here if you want to use your RTC using the sysfs ++ interface, /sys/class/rtc/rtcX . ++ ++ This driver can also be built as a module. If so, the module ++ will be called rtc-sysfs. ++ ++config RTC_INTF_PROC ++ tristate "proc" ++ depends on RTC_CLASS && PROC_FS ++ default RTC_CLASS ++ help ++ Say yes here if you want to use your RTC using the proc ++ interface, /proc/driver/rtc . ++ ++ This driver can also be built as a module. If so, the module ++ will be called rtc-proc. ++ ++config RTC_INTF_DEV ++ tristate "dev" ++ depends on RTC_CLASS ++ default RTC_CLASS ++ help ++ Say yes here if you want to use your RTC using the dev ++ interface, /dev/rtc . ++ ++ This driver can also be built as a module. If so, the module ++ will be called rtc-dev. ++ ++comment "RTC drivers" ++ depends on RTC_CLASS ++ ++config RTC_DRV_X1205 ++ tristate "Xicor/Intersil X1205 RTC chip" ++ depends on RTC_CLASS && I2C ++ help ++ If you say yes here you get support for the ++ Xicor/Intersil X1205 RTC chip. ++ ++ This driver can also be built as a module. If so, the module ++ will be called rtc-x1205. ++ ++config RTC_DRV_DS1672 ++ tristate "Dallas/Maxim DS1672" ++ depends on RTC_CLASS && I2C ++ help ++ If you say yes here you get support for the ++ Dallas/Maxim DS1672 timekeeping chip. ++ ++ This driver can also be built as a module. If so, the module ++ will be called rtc-ds1672. ++ ++config RTC_DRV_TEST ++ tristate "Test driver/device" ++ depends on RTC_CLASS ++ help ++ If you say yes here you get support for the ++ RTC test driver. It's a software RTC which can be ++ used to test the RTC subsystem APIs. It gets ++ the time from the system clock. ++ You want this driver only if you are doing development ++ on the RTC subsystem. Please read the source code ++ for further details. ++ ++ This driver can also be built as a module. If so, the module ++ will be called rtc-test. ++ ++endmenu +--- /dev/null 1970-01-01 00:00:00.000000000 +0000 ++++ linux-nslu2/drivers/rtc/Makefile 2006-01-04 01:27:21.000000000 +0100 +@@ -0,0 +1,15 @@ ++# ++# Makefile for RTC class/drivers. ++# ++ ++obj-y += utils.o ++obj-$(CONFIG_RTC_CLASS) += rtc-core.o ++rtc-core-y := class.o interface.o ++obj-$(CONFIG_RTC_INTF_SYSFS) += rtc-sysfs.o ++obj-$(CONFIG_RTC_INTF_PROC) += rtc-proc.o ++obj-$(CONFIG_RTC_INTF_DEV) += rtc-dev.o ++ ++obj-$(CONFIG_RTC_DRV_X1205) += rtc-x1205.o ++obj-$(CONFIG_RTC_DRV_TEST) += rtc-test.o ++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 @@ ++/* ++ * RTC subsystem, interface functions ++ * ++ * Copyright (C) 2005 Tower Technologies ++ * Author: Alessandro Zummo ++ * ++ * based on arch/arm/common/rtctime.c ++ * ++ * 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; version 2 of the License. ++*/ ++ ++#include ++ ++extern struct class *rtc_class; ++ ++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; ++ ++ if (ops->read_time) { ++ memset(tm, 0, sizeof(struct rtc_time)); ++ err = ops->read_time(class_dev->dev, tm); ++ } ++ return err; ++} ++EXPORT_SYMBOL(rtc_read_time); ++ ++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; ++ ++ err = rtc_valid_tm(tm); ++ if (err == 0 && ops->set_time) ++ err = ops->set_time(class_dev->dev, tm); ++ ++ 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; ++ ++ if (ops->read_alarm) { ++ memset(alarm, 0, sizeof(struct rtc_wkalrm)); ++ err = ops->read_alarm(class_dev->dev, alarm); ++ } ++ 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; ++ ++ if (ops->set_alarm) ++ err = ops->set_alarm(class_dev->dev, alarm); ++ return err; ++} ++EXPORT_SYMBOL(rtc_set_alarm); ++ ++void rtc_update_irq(struct class_device *class_dev, ++ unsigned long num, unsigned long events) ++{ ++ struct rtc_device *rtc = to_rtc_device(class_dev); ++ ++ spin_lock(&rtc->irq_lock); ++ rtc->irq_data = (rtc->irq_data + (num << 8)) | events; ++ spin_unlock(&rtc->irq_lock); ++ ++ spin_lock(&rtc->irq_task_lock); ++ if (rtc->irq_task) ++ rtc->irq_task->func(rtc->irq_task->private_data); ++ spin_unlock(&rtc->irq_task_lock); ++ ++ wake_up_interruptible(&rtc->irq_queue); ++ kill_fasync(&rtc->async_queue, SIGIO, POLL_IN); ++} ++EXPORT_SYMBOL(rtc_update_irq); ++ ++struct class_device *rtc_open(char *name) ++{ ++ struct class_device *class_dev = NULL, ++ *class_dev_tmp; ++ ++ down(&rtc_class->sem); ++ list_for_each_entry(class_dev_tmp, &rtc_class->children, node) { ++ if (strncmp(class_dev_tmp->class_id, name, BUS_ID_SIZE) == 0) { ++ class_dev = class_dev_tmp; ++ break; ++ } ++ } ++ up(&rtc_class->sem); ++ ++ return class_dev; ++} ++EXPORT_SYMBOL(rtc_open); ++ ++void rtc_close(struct class_device *class_dev) ++{ ++} ++EXPORT_SYMBOL(rtc_close); ++ ++int rtc_irq_register(struct class_device *class_dev, struct rtc_task *task) ++{ ++ int retval = -EBUSY; ++ struct rtc_device *rtc = to_rtc_device(class_dev); ++ ++ if (task == NULL || task->func == NULL) ++ return -EINVAL; ++ ++ spin_lock(&rtc->irq_task_lock); ++ if (rtc->irq_task == NULL) { ++ rtc->irq_task = task; ++ retval = 0; ++ } ++ spin_unlock(&rtc->irq_task_lock); ++ ++ return retval; ++} ++EXPORT_SYMBOL(rtc_irq_register); ++ ++void rtc_irq_unregister(struct class_device *class_dev, struct rtc_task *task) ++{ ++ struct rtc_device *rtc = to_rtc_device(class_dev); ++ ++ spin_lock(&rtc->irq_task_lock); ++ if (rtc->irq_task == task) ++ rtc->irq_task = NULL; ++ spin_unlock(&rtc->irq_task_lock); ++} ++EXPORT_SYMBOL(rtc_irq_unregister); ++ ++int rtc_irq_set_state(struct class_device *class_dev, struct rtc_task *task, int enabled) ++{ ++ int err = 0; ++ unsigned long flags; ++ struct rtc_device *rtc = to_rtc_device(class_dev); ++ ++ spin_lock_irqsave(&rtc->irq_task_lock, flags); ++ if (rtc->irq_task != task) ++ err = -ENXIO; ++ spin_unlock_irqrestore(&rtc->irq_task_lock, flags); ++ ++ if (err == 0) ++ err = rtc->ops->irq_set_state(class_dev->dev, enabled); ++ ++ return err; ++} ++EXPORT_SYMBOL(rtc_irq_set_state); ++ ++int rtc_irq_set_freq(struct class_device *class_dev, struct rtc_task *task, int freq) ++{ ++ int err = 0, tmp = 0; ++ unsigned long flags; ++ struct rtc_device *rtc = to_rtc_device(class_dev); ++ ++ /* allowed range is 2-8192 */ ++ if (freq < 2 || freq > 8192) ++ return -EINVAL; ++ ++/* if ((freq > rtc_max_user_freq) && (!capable(CAP_SYS_RESOURCE))) ++ return -EACCES; ++*/ ++ /* check if freq is a power of 2 */ ++ while (freq > (1 << tmp)) ++ tmp++; ++ ++ if (freq != (1 << tmp)) ++ return -EINVAL; ++ ++ spin_lock_irqsave(&rtc->irq_task_lock, flags); ++ if (rtc->irq_task != task) ++ err = -ENXIO; ++ spin_unlock_irqrestore(&rtc->irq_task_lock, flags); ++ ++ if (err == 0) { ++ if ((err = rtc->ops->irq_set_freq(class_dev->dev, freq)) == 0) ++ rtc->irq_freq = freq; ++ } ++ return err; ++ ++} +--- /dev/null 1970-01-01 00:00:00.000000000 +0000 ++++ linux-nslu2/drivers/rtc/utils.c 2006-01-03 15:34:24.000000000 +0100 +@@ -0,0 +1,97 @@ ++/* ++ * RTC subsystem, utility functions ++ * ++ * Copyright (C) 2005 Tower Technologies ++ * Author: Alessandro Zummo ++ * ++ * based on arch/arm/common/rtctime.c ++ * ++ * 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; version 2 of the License. ++*/ ++ ++#include ++ ++static const unsigned char rtc_days_in_month[] = { ++ 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 ++}; ++ ++#define LEAPS_THRU_END_OF(y) ((y)/4 - (y)/100 + (y)/400) ++#define LEAP_YEAR(year) ((!(year % 4) && (year % 100)) || !(year % 400)) ++ ++int rtc_month_days(unsigned int month, unsigned int year) ++{ ++ return rtc_days_in_month[month] + (LEAP_YEAR(year) && month == 1); ++} ++EXPORT_SYMBOL(rtc_month_days); ++ ++/* ++ * Convert seconds since 01-01-1970 00:00:00 to Gregorian date. ++ */ ++void rtc_time_to_tm(unsigned long time, struct rtc_time *tm) ++{ ++ int days, month, year; ++ ++ days = time / 86400; ++ time -= days * 86400; ++ ++ tm->tm_wday = (days + 4) % 7; ++ ++ year = 1970 + days / 365; ++ days -= (year - 1970) * 365 ++ + LEAPS_THRU_END_OF(year - 1) ++ - LEAPS_THRU_END_OF(1970 - 1); ++ if (days < 0) { ++ year -= 1; ++ days += 365 + LEAP_YEAR(year); ++ } ++ tm->tm_year = year - 1900; ++ tm->tm_yday = days + 1; ++ ++ for (month = 0; month < 11; month++) { ++ int newdays; ++ ++ newdays = days - rtc_month_days(month, year); ++ if (newdays < 0) ++ break; ++ days = newdays; ++ } ++ tm->tm_mon = month; ++ tm->tm_mday = days + 1; ++ ++ tm->tm_hour = time / 3600; ++ time -= tm->tm_hour * 3600; ++ tm->tm_min = time / 60; ++ tm->tm_sec = time - tm->tm_min * 60; ++} ++EXPORT_SYMBOL(rtc_time_to_tm); ++ ++/* ++ * Does the rtc_time represent a valid date/time? ++ */ ++int rtc_valid_tm(struct rtc_time *tm) ++{ ++ if (tm->tm_year < 70 || ++ tm->tm_mon >= 12 || ++ tm->tm_mday < 1 || ++ tm->tm_mday > rtc_month_days(tm->tm_mon, tm->tm_year + 1900) || ++ tm->tm_hour >= 24 || ++ tm->tm_min >= 60 || ++ tm->tm_sec >= 60) ++ return -EINVAL; ++ ++ return 0; ++} ++EXPORT_SYMBOL(rtc_valid_tm); ++ ++/* ++ * Convert Gregorian date to seconds since 01-01-1970 00:00:00. ++ */ ++int rtc_tm_to_time(struct rtc_time *tm, unsigned long *time) ++{ ++ *time = mktime(tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday, ++ tm->tm_hour, tm->tm_min, tm->tm_sec); ++ 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 +@@ -750,6 +750,8 @@ source "drivers/usb/Kconfig" + + source "drivers/mmc/Kconfig" + ++source "drivers/rtc/Kconfig" ++ + 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 +@@ -40,89 +40,6 @@ static struct rtc_ops *rtc_ops; + + #define rtc_epoch 1900UL + +-static const unsigned char days_in_month[] = { +- 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 +-}; +- +-#define LEAPS_THRU_END_OF(y) ((y)/4 - (y)/100 + (y)/400) +-#define LEAP_YEAR(year) ((!(year % 4) && (year % 100)) || !(year % 400)) +- +-static int month_days(unsigned int month, unsigned int year) +-{ +- return days_in_month[month] + (LEAP_YEAR(year) && month == 1); +-} +- +-/* +- * Convert seconds since 01-01-1970 00:00:00 to Gregorian date. +- */ +-void rtc_time_to_tm(unsigned long time, struct rtc_time *tm) +-{ +- int days, month, year; +- +- days = time / 86400; +- time -= days * 86400; +- +- tm->tm_wday = (days + 4) % 7; +- +- year = 1970 + days / 365; +- days -= (year - 1970) * 365 +- + LEAPS_THRU_END_OF(year - 1) +- - LEAPS_THRU_END_OF(1970 - 1); +- if (days < 0) { +- year -= 1; +- days += 365 + LEAP_YEAR(year); +- } +- tm->tm_year = year - 1900; +- tm->tm_yday = days + 1; +- +- for (month = 0; month < 11; month++) { +- int newdays; +- +- newdays = days - month_days(month, year); +- if (newdays < 0) +- break; +- days = newdays; +- } +- tm->tm_mon = month; +- tm->tm_mday = days + 1; +- +- tm->tm_hour = time / 3600; +- time -= tm->tm_hour * 3600; +- tm->tm_min = time / 60; +- tm->tm_sec = time - tm->tm_min * 60; +-} +-EXPORT_SYMBOL(rtc_time_to_tm); +- +-/* +- * Does the rtc_time represent a valid date/time? +- */ +-int rtc_valid_tm(struct rtc_time *tm) +-{ +- if (tm->tm_year < 70 || +- tm->tm_mon >= 12 || +- tm->tm_mday < 1 || +- tm->tm_mday > month_days(tm->tm_mon, tm->tm_year + 1900) || +- tm->tm_hour >= 24 || +- tm->tm_min >= 60 || +- tm->tm_sec >= 60) +- return -EINVAL; +- +- return 0; +-} +-EXPORT_SYMBOL(rtc_valid_tm); +- +-/* +- * Convert Gregorian date to seconds since 01-01-1970 00:00:00. +- */ +-int rtc_tm_to_time(struct rtc_time *tm, unsigned long *time) +-{ +- *time = mktime(tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday, +- tm->tm_hour, tm->tm_min, tm->tm_sec); +- +- return 0; +-} +-EXPORT_SYMBOL(rtc_tm_to_time); +- + /* + * Calculate the next alarm time given the requested alarm time mask + * and the current time. +@@ -141,13 +58,13 @@ void rtc_next_alarm_time(struct rtc_time + next->tm_sec = alrm->tm_sec; + } + +-static inline int rtc_read_time(struct rtc_ops *ops, struct rtc_time *tm) ++static inline int rtc_arm_read_time(struct rtc_ops *ops, struct rtc_time *tm) + { + memset(tm, 0, sizeof(struct rtc_time)); + return ops->read_time(tm); + } + +-static inline int rtc_set_time(struct rtc_ops *ops, struct rtc_time *tm) ++static inline int rtc_arm_set_time(struct rtc_ops *ops, struct rtc_time *tm) + { + int ret; + +@@ -158,7 +75,7 @@ static inline int rtc_set_time(struct rt + return ret; + } + +-static inline int rtc_read_alarm(struct rtc_ops *ops, struct rtc_wkalrm *alrm) ++static inline int rtc_arm_read_alarm(struct rtc_ops *ops, struct rtc_wkalrm *alrm) + { + int ret = -EINVAL; + if (ops->read_alarm) { +@@ -168,7 +85,7 @@ static inline int rtc_read_alarm(struct + return ret; + } + +-static inline int rtc_set_alarm(struct rtc_ops *ops, struct rtc_wkalrm *alrm) ++static inline int rtc_arm_set_alarm(struct rtc_ops *ops, struct rtc_wkalrm *alrm) + { + int ret = -EINVAL; + if (ops->set_alarm) +@@ -256,7 +173,7 @@ static int rtc_ioctl(struct inode *inode + + switch (cmd) { + case RTC_ALM_READ: +- ret = rtc_read_alarm(ops, &alrm); ++ ret = rtc_arm_read_alarm(ops, &alrm); + if (ret) + break; + ret = copy_to_user(uarg, &alrm.time, sizeof(tm)); +@@ -278,11 +195,11 @@ static int rtc_ioctl(struct inode *inode + alrm.time.tm_wday = -1; + alrm.time.tm_yday = -1; + alrm.time.tm_isdst = -1; +- ret = rtc_set_alarm(ops, &alrm); ++ ret = rtc_arm_set_alarm(ops, &alrm); + break; + + case RTC_RD_TIME: +- ret = rtc_read_time(ops, &tm); ++ ret = rtc_arm_read_time(ops, &tm); + if (ret) + break; + ret = copy_to_user(uarg, &tm, sizeof(tm)); +@@ -300,7 +217,7 @@ static int rtc_ioctl(struct inode *inode + ret = -EFAULT; + break; + } +- ret = rtc_set_time(ops, &tm); ++ ret = rtc_arm_set_time(ops, &tm); + break; + + case RTC_EPOCH_SET: +@@ -331,11 +248,11 @@ static int rtc_ioctl(struct inode *inode + ret = -EFAULT; + break; + } +- ret = rtc_set_alarm(ops, &alrm); ++ ret = rtc_arm_set_alarm(ops, &alrm); + break; + + case RTC_WKALM_RD: +- ret = rtc_read_alarm(ops, &alrm); ++ ret = rtc_arm_read_alarm(ops, &alrm); + if (ret) + break; + ret = copy_to_user(uarg, &alrm, sizeof(alrm)); +@@ -425,7 +342,7 @@ static int rtc_read_proc(char *page, cha + struct rtc_time tm; + char *p = page; + +- if (rtc_read_time(ops, &tm) == 0) { ++ if (rtc_arm_read_time(ops, &tm) == 0) { + p += sprintf(p, + "rtc_time\t: %02d:%02d:%02d\n" + "rtc_date\t: %04d-%02d-%02d\n" +@@ -435,7 +352,7 @@ static int rtc_read_proc(char *page, cha + rtc_epoch); + } + +- if (rtc_read_alarm(ops, &alrm) == 0) { ++ if (rtc_arm_read_alarm(ops, &alrm) == 0) { + 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 +@@ -25,9 +25,6 @@ struct rtc_ops { + int (*proc)(char *buf); + }; + +-void rtc_time_to_tm(unsigned long, struct rtc_time *); +-int rtc_tm_to_time(struct rtc_time *, unsigned long *); +-int rtc_valid_tm(struct rtc_time *); + void rtc_next_alarm_time(struct rtc_time *, struct rtc_time *, struct rtc_time *); + 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 @@ ++/* ++ * RTC subsystem, sysfs interface ++ * ++ * Copyright (C) 2005 Tower Technologies ++ * Author: Alessandro Zummo ++ * ++ * 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; version 2 of the License. ++*/ ++ ++#include ++#include ++ ++/* device attributes */ ++ ++static ssize_t rtc_sysfs_show_name(struct class_device *dev, char *buf) ++{ ++ return sprintf(buf, "%s\n", to_rtc_device(dev)->name); ++} ++static CLASS_DEVICE_ATTR(name, S_IRUGO, rtc_sysfs_show_name, NULL); ++ ++static ssize_t rtc_sysfs_show_date(struct class_device *dev, char *buf) ++{ ++ ssize_t retval = 0; ++ struct rtc_device *rtc = to_rtc_device(dev); ++ struct rtc_time tm; ++ ++ if (down_read_trylock(&rtc->lock) == 0) ++ return -ENODEV; ++ ++ if (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); ++ 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; ++ struct rtc_device *rtc = to_rtc_device(dev); ++ struct rtc_time tm; ++ ++ if (down_read_trylock(&rtc->lock) == 0) ++ return -ENODEV; ++ ++ if (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); ++ 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; ++ struct rtc_device *rtc = to_rtc_device(dev); ++ struct rtc_time tm; ++ ++ if (down_read_trylock(&rtc->lock) == 0) ++ return -ENODEV; ++ ++ if (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); ++ return retval; ++} ++static CLASS_DEVICE_ATTR(since_epoch, S_IRUGO, rtc_sysfs_show_since_epoch, NULL); ++ ++/* insertion/removal hooks */ ++ ++static int __devinit rtc_sysfs_add_device(struct class_device *class_dev, ++ struct class_interface *class_intf) ++{ ++ class_device_create_file(class_dev, &class_device_attr_name); ++ class_device_create_file(class_dev, &class_device_attr_date); ++ class_device_create_file(class_dev, &class_device_attr_time); ++ class_device_create_file(class_dev, &class_device_attr_since_epoch); ++ dev_info(class_dev->dev, "rtc intf: sysfs\n"); ++ return 0; ++} ++ ++static void rtc_sysfs_remove_device(struct class_device *class_dev, ++ struct class_interface *class_intf) ++{ ++ class_device_remove_file(class_dev, &class_device_attr_name); ++ class_device_remove_file(class_dev, &class_device_attr_date); ++ class_device_remove_file(class_dev, &class_device_attr_time); ++ class_device_remove_file(class_dev, &class_device_attr_since_epoch); ++} ++ ++/* interface registration */ ++ ++struct class_interface rtc_sysfs_interface = { ++ .add = &rtc_sysfs_add_device, ++ .remove = &rtc_sysfs_remove_device, ++}; ++ ++static int __init rtc_sysfs_init(void) ++{ ++ return rtc_interface_register(&rtc_sysfs_interface); ++} ++ ++static void __exit rtc_sysfs_exit(void) ++{ ++ class_interface_unregister(&rtc_sysfs_interface); ++} ++ ++module_init(rtc_sysfs_init); ++module_exit(rtc_sysfs_exit); ++ ++MODULE_AUTHOR("Alessandro Zummo "); ++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 +@@ -0,0 +1,158 @@ ++/* ++ * RTC subsystem, proc interface ++ * ++ * Copyright (C) 2005 Tower Technologies ++ * Author: Alessandro Zummo ++ * ++ * based on arch/arm/common/rtctime.c ++ * ++ * 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; version 2 of the License. ++*/ ++ ++#include ++#include ++#include ++#include ++ ++static struct class_device *rtc_dev = NULL; ++static DECLARE_MUTEX(rtc_sem); ++ ++static int rtc_proc_show(struct seq_file *seq, void *offset) ++{ ++ struct class_device *class_dev = seq->private; ++ struct rtc_class_ops *ops = to_rtc_device(class_dev)->ops; ++ struct rtc_wkalrm alrm; ++ struct rtc_time tm; ++ ++ if (rtc_read_time(class_dev, &tm) == 0) { ++ seq_printf(seq, ++ "rtc_time\t: %02d:%02d:%02d\n" ++ "rtc_date\t: %04d-%02d-%02d\n", ++ tm.tm_hour, tm.tm_min, tm.tm_sec, ++ tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday); ++ } ++ ++ if (rtc_read_alarm(class_dev, &alrm) == 0) { ++ seq_printf(seq, "alrm_time\t: "); ++ if ((unsigned int)alrm.time.tm_hour <= 24) ++ seq_printf(seq, "%02d:", alrm.time.tm_hour); ++ else ++ seq_printf(seq, "**:"); ++ if ((unsigned int)alrm.time.tm_min <= 59) ++ seq_printf(seq, "%02d:", alrm.time.tm_min); ++ else ++ seq_printf(seq, "**:"); ++ if ((unsigned int)alrm.time.tm_sec <= 59) ++ seq_printf(seq, "%02d\n", alrm.time.tm_sec); ++ else ++ seq_printf(seq, "**\n"); ++ ++ seq_printf(seq, "alrm_date\t: "); ++ if ((unsigned int)alrm.time.tm_year <= 200) ++ seq_printf(seq, "%04d-", alrm.time.tm_year + 1900); ++ else ++ seq_printf(seq, "****-"); ++ if ((unsigned int)alrm.time.tm_mon <= 11) ++ seq_printf(seq, "%02d-", alrm.time.tm_mon + 1); ++ else ++ seq_printf(seq, "**-"); ++ if ((unsigned int)alrm.time.tm_mday <= 31) ++ seq_printf(seq, "%02d\n", alrm.time.tm_mday); ++ else ++ seq_printf(seq, "**\n"); ++ seq_printf(seq, "alrm_wakeup\t: %s\n", ++ alrm.enabled ? "yes" : "no"); ++ seq_printf(seq, "alrm_pending\t: %s\n", ++ alrm.pending ? "yes" : "no"); ++ } ++ ++ if (ops->proc) ++ ops->proc(class_dev->dev, seq); ++ ++ return 0; ++} ++ ++static int rtc_proc_open(struct inode *inode, struct file *file) ++{ ++ struct class_device *class_dev = PDE(inode)->data; ++ ++ if (!try_module_get(THIS_MODULE)) ++ return -ENODEV; ++ ++ return single_open(file, rtc_proc_show, class_dev); ++} ++ ++static int rtc_proc_release(struct inode *inode, struct file *file) ++{ ++ int res = single_release(inode, file); ++ module_put(THIS_MODULE); ++ return res; ++} ++ ++static struct file_operations rtc_proc_fops = { ++ .open = rtc_proc_open, ++ .read = seq_read, ++ .llseek = seq_lseek, ++ .release = rtc_proc_release, ++}; ++ ++static int rtc_proc_add_device(struct class_device *class_dev, ++ struct class_interface *class_intf) ++{ ++ down(&rtc_sem); ++ if (rtc_dev == NULL) { ++ struct proc_dir_entry *ent; ++ ++ rtc_dev = class_dev; ++ ++ if ((ent = create_proc_entry("driver/rtc", 0, NULL))) { ++ struct rtc_device *rtc = to_rtc_device(class_dev); ++ ++ ent->proc_fops = &rtc_proc_fops; ++ ent->owner = rtc->owner; ++ ent->data = class_dev; ++ ++ dev_info(class_dev->dev, "rtc intf: proc\n"); ++ } ++ else ++ rtc_dev = NULL; ++ } ++ up(&rtc_sem); ++ ++ return 0; ++} ++ ++static void rtc_proc_remove_device(struct class_device *class_dev, ++ struct class_interface *class_intf) ++{ ++ down(&rtc_sem); ++ if (rtc_dev == class_dev) { ++ remove_proc_entry("driver/rtc", NULL); ++ rtc_dev = NULL; ++ } ++ up(&rtc_sem); ++} ++ ++struct class_interface rtc_proc_interface = { ++ .add = &rtc_proc_add_device, ++ .remove = &rtc_proc_remove_device, ++}; ++ ++static int __init rtc_proc_init(void) ++{ ++ return rtc_interface_register(&rtc_proc_interface); ++} ++ ++static void __exit rtc_proc_exit(void) ++{ ++ class_interface_unregister(&rtc_proc_interface); ++} ++ ++module_init(rtc_proc_init); ++module_exit(rtc_proc_exit); ++ ++MODULE_AUTHOR("Alessandro Zummo "); ++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 +@@ -0,0 +1,372 @@ ++/* ++ * RTC subsystem, dev interface ++ * ++ * Copyright (C) 2005 Tower Technologies ++ * Author: Alessandro Zummo ++ * ++ * based on arch/arm/common/rtctime.c ++ * ++ * 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; version 2 of the License. ++*/ ++ ++#include ++#include ++ ++static dev_t rtc_devt; ++ ++#define RTC_DEV_MAX 16 /* 16 RTCs should be enough for everyone... */ ++ ++static int rtc_dev_open(struct inode *inode, struct file *file) ++{ ++ int err; ++ struct rtc_device *rtc = container_of(inode->i_cdev, ++ struct rtc_device, char_dev); ++ struct rtc_class_ops *ops = rtc->ops; ++ ++ /* We keep the lock as long as the device is in use ++ * and return immediately if busy ++ */ ++ if (down_trylock(&rtc->char_sem)) ++ return -EBUSY; ++ ++ file->private_data = &rtc->class_dev; ++ ++ err = ops->open ? ops->open(rtc->class_dev.dev) : 0; ++ if (err == 0) { ++ ++ spin_lock_irq(&rtc->irq_lock); ++ rtc->irq_data = 0; ++ spin_unlock_irq(&rtc->irq_lock); ++ ++ return 0; ++ } ++ ++ /* something has gone wrong, release the lock */ ++ up(&rtc->char_sem); ++ return err; ++} ++ ++ ++static ssize_t ++rtc_dev_read(struct file *file, char __user *buf, size_t count, loff_t *ppos) ++{ ++ struct rtc_device *rtc = to_rtc_device(file->private_data); ++ ++ DECLARE_WAITQUEUE(wait, current); ++ unsigned long data; ++ ssize_t ret; ++ ++ if (count < sizeof(unsigned long)) ++ return -EINVAL; ++ ++ add_wait_queue(&rtc->irq_queue, &wait); ++ do { ++ __set_current_state(TASK_INTERRUPTIBLE); ++ ++ spin_lock_irq(&rtc->irq_lock); ++ data = rtc->irq_data; ++ rtc->irq_data = 0; ++ spin_unlock_irq(&rtc->irq_lock); ++ ++ if (data != 0) { ++ ret = 0; ++ break; ++ } ++ if (file->f_flags & O_NONBLOCK) { ++ ret = -EAGAIN; ++ break; ++ } ++ if (signal_pending(current)) { ++ ret = -ERESTARTSYS; ++ break; ++ } ++ schedule(); ++ } while (1); ++ set_current_state(TASK_RUNNING); ++ remove_wait_queue(&rtc->irq_queue, &wait); ++ ++ if (ret == 0) { ++ ret = put_user(data, (unsigned long __user *)buf); ++ if (ret == 0) ++ ret = sizeof(unsigned long); ++ } ++ return ret; ++} ++ ++static unsigned int rtc_dev_poll(struct file *file, poll_table *wait) ++{ ++ struct rtc_device *rtc = to_rtc_device(file->private_data); ++ unsigned long data; ++ ++ poll_wait(file, &rtc->irq_queue, wait); ++ ++ spin_lock_irq(&rtc->irq_lock); ++ data = rtc->irq_data; ++ spin_unlock_irq(&rtc->irq_lock); ++ ++ return data != 0 ? POLLIN | POLLRDNORM : 0; ++} ++ ++static int rtc_dev_ioctl(struct inode *inode, struct file *file, unsigned int cmd, ++ unsigned long arg) ++{ ++ int err = 0; ++ struct class_device *class_dev = file->private_data; ++ struct rtc_device *rtc = to_rtc_device(class_dev); ++ struct rtc_class_ops *ops = rtc->ops; ++ struct rtc_time tm; ++ struct rtc_wkalrm alarm; ++ void __user *uarg = (void __user *) arg; ++ ++ /* avoid conflicting IRQ users */ ++ if (cmd == RTC_PIE_ON || cmd == RTC_PIE_OFF || cmd == RTC_IRQP_SET) { ++ spin_lock(&rtc->irq_task_lock); ++ if (rtc->irq_task) ++ err = -EBUSY; ++ spin_unlock(&rtc->irq_task_lock); ++ ++ if (err < 0) ++ return err; ++ } ++ ++ /* try the driver's ioctl interface */ ++ if (ops->ioctl) { ++ err = ops->ioctl(class_dev->dev, cmd, arg); ++ if (err < 0 && err != -EINVAL) ++ return err; ++ } ++ ++ /* if the driver does not provide the ioctl interface ++ * or if that particular ioctl was not implemented ++ * (-EINVAL), we will try to emulate here. ++ */ ++ ++ switch (cmd) { ++ case RTC_ALM_READ: ++ if ((err = rtc_read_alarm(class_dev, &alarm)) < 0) ++ return err; ++ ++ if ((err = copy_to_user(uarg, &alarm.time, sizeof(tm)))) ++ return -EFAULT; ++ break; ++ ++ case RTC_ALM_SET: ++ if ((err = copy_from_user(&alarm.time, uarg, sizeof(tm)))) ++ return -EFAULT; ++ ++ alarm.enabled = 0; ++ alarm.pending = 0; ++ alarm.time.tm_mday = -1; ++ alarm.time.tm_mon = -1; ++ alarm.time.tm_year = -1; ++ alarm.time.tm_wday = -1; ++ alarm.time.tm_yday = -1; ++ alarm.time.tm_isdst = -1; ++ err = rtc_set_alarm(class_dev, &alarm); ++ break; ++ ++ case RTC_RD_TIME: ++ if ((err = rtc_read_time(class_dev, &tm)) < 0) ++ return err; ++ ++ if ((err = copy_to_user(uarg, &tm, sizeof(tm)))) ++ return -EFAULT; ++ break; ++ ++ case RTC_SET_TIME: ++ if (!capable(CAP_SYS_TIME)) ++ return -EACCES; ++ ++ if ((err = copy_from_user(&tm, uarg, sizeof(tm)))) ++ return -EFAULT; ++ ++ err = rtc_set_time(class_dev, &tm); ++ break; ++#if 0 ++ case RTC_EPOCH_SET: ++#ifndef rtc_epoch ++ /* ++ * There were no RTC clocks before 1900. ++ */ ++ if (arg < 1900) { ++ err = -EINVAL; ++ break; ++ } ++ if (!capable(CAP_SYS_TIME)) { ++ err = -EACCES; ++ break; ++ } ++ rtc_epoch = arg; ++ err = 0; ++#endif ++ break; ++ ++ case RTC_EPOCH_READ: ++ err = put_user(rtc_epoch, (unsigned long __user *)uarg); ++ break; ++#endif ++ case RTC_WKALM_SET: ++ if ((err = copy_from_user(&alarm, uarg, sizeof(alarm)))) ++ return -EFAULT; ++ ++ err = rtc_set_alarm(class_dev, &alarm); ++ break; ++ ++ case RTC_WKALM_RD: ++ if ((err = rtc_read_alarm(class_dev, &alarm)) < 0) ++ return err; ++ ++ if ((err = copy_to_user(uarg, &alarm, sizeof(alarm)))) ++ return -EFAULT; ++ break; ++ ++ default: ++ err = -EINVAL; ++ break; ++ } ++ ++ return err; ++} ++ ++static int rtc_dev_release(struct inode *inode, struct file *file) ++{ ++ struct rtc_device *rtc = to_rtc_device(file->private_data); ++ ++ if (rtc->ops->release) ++ rtc->ops->release(rtc->class_dev.dev); ++ ++ spin_lock_irq(&rtc->irq_lock); ++ rtc->irq_data = 0; ++ spin_unlock_irq(&rtc->irq_lock); ++ ++ up(&rtc->char_sem); ++ return 0; ++} ++ ++static int rtc_dev_fasync(int fd, struct file *file, int on) ++{ ++ struct rtc_device *rtc = to_rtc_device(file->private_data); ++ return fasync_helper(fd, file, on, &rtc->async_queue); ++} ++ ++static struct file_operations rtc_dev_fops = { ++ .owner = THIS_MODULE, ++ .llseek = no_llseek, ++ .read = rtc_dev_read, ++ .poll = rtc_dev_poll, ++ .ioctl = rtc_dev_ioctl, ++ .open = rtc_dev_open, ++ .release = rtc_dev_release, ++ .fasync = rtc_dev_fasync, ++}; ++ ++static ssize_t rtc_dev_show_dev(struct class_device *class_dev, char *buf) ++{ ++ return print_dev_t(buf, class_dev->devt); ++} ++static CLASS_DEVICE_ATTR(dev, S_IRUGO, rtc_dev_show_dev, NULL); ++ ++/* insertion/removal hooks */ ++ ++static int rtc_dev_add_device(struct class_device *class_dev, ++ struct class_interface *class_intf) ++{ ++ struct rtc_device *rtc = to_rtc_device(class_dev); ++ ++ if (rtc->id >= RTC_DEV_MAX) { ++ dev_err(class_dev->dev, "too many RTCs\n"); ++ return -EINVAL; ++ } ++ ++ init_MUTEX(&rtc->char_sem); ++ spin_lock_init(&rtc->irq_lock); ++ init_waitqueue_head(&rtc->irq_queue); ++ ++ cdev_init(&rtc->char_dev, &rtc_dev_fops); ++ rtc->char_dev.owner = rtc->owner; ++ class_dev->devt = MKDEV(MAJOR(rtc_devt), rtc->id); ++ ++ if (cdev_add(&rtc->char_dev, class_dev->devt, 1)) { ++ cdev_del(&rtc->char_dev); ++ ++ dev_err(class_dev->dev, ++ "failed to add char device %d:%d\n", ++ MAJOR(class_dev->devt), ++ MINOR(class_dev->devt)); ++ ++ class_dev->devt = MKDEV(0, 0); ++ return -ENODEV; ++ } ++ ++ class_device_create_file(class_dev, &class_device_attr_dev); ++ ++ dev_info(class_dev->dev, "rtc intf: dev (%d:%d)\n", ++ MAJOR(class_dev->devt), ++ MINOR(class_dev->devt)); ++ ++ kobject_hotplug(&class_dev->kobj, KOBJ_ADD); ++ ++ return 0; ++} ++ ++static void rtc_dev_remove_device(struct class_device *class_dev, ++ struct class_interface *class_intf) ++{ ++ struct rtc_device *rtc = to_rtc_device(class_dev); ++ ++ class_device_remove_file(class_dev, &class_device_attr_dev); ++ ++ if (MAJOR(class_dev->devt)) { ++ dev_dbg(class_dev->dev, "removing char %d:%d\n", ++ MAJOR(class_dev->devt), ++ MINOR(class_dev->devt)); ++ cdev_del(&rtc->char_dev); ++ ++ kobject_hotplug(&class_dev->kobj, KOBJ_REMOVE); ++ ++ class_dev->devt = MKDEV(0, 0); ++ } ++} ++ ++/* interface registration */ ++ ++struct class_interface rtc_dev_interface = { ++ .add = &rtc_dev_add_device, ++ .remove = &rtc_dev_remove_device, ++}; ++ ++static int __init rtc_dev_init(void) ++{ ++ int err; ++ ++ if ((err = alloc_chrdev_region(&rtc_devt, 0, RTC_DEV_MAX, "rtc")) < 0) { ++ printk(KERN_ERR "%s: failed to allocate char dev region\n", ++ __FILE__); ++ return err; ++ } ++ ++ if ((err = rtc_interface_register(&rtc_dev_interface)) < 0) { ++ printk(KERN_ERR "%s: failed to register the interface\n", ++ __FILE__); ++ unregister_chrdev_region(rtc_devt, RTC_DEV_MAX); ++ return err; ++ } ++ ++ return 0; ++} ++ ++static void __exit rtc_dev_exit(void) ++{ ++ class_interface_unregister(&rtc_dev_interface); ++ ++ unregister_chrdev_region(rtc_devt, RTC_DEV_MAX); ++} ++ ++module_init(rtc_dev_init); ++module_exit(rtc_dev_exit); ++ ++MODULE_AUTHOR("Alessandro Zummo "); ++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 +@@ -0,0 +1,725 @@ ++/* ++ * An i2c driver for the Xicor/Intersil X1205 RTC ++ * Copyright 2004 Karen Spearel ++ * Copyright 2005 Alessandro Zummo ++ * ++ * please send all reports to: ++ * kas11 at tampabay dot rr dot com ++ * a dot zummo at towertech dot it ++ * ++ * based on a lot of other RTC drivers. ++ * ++ * 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. ++ */ ++ ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++ ++#define DRV_VERSION "1.0.5" ++ ++/* Addresses to scan: none. This chip is located at ++ * 0x6f and uses a two bytes register addressing. ++ * Two bytes need to be written to read a single register, ++ * while most other chips just require one and take the second ++ * one as the data to be written. To prevent corrupting ++ * unknown chips, the user must explicitely set the probe parameter. ++ */ ++ ++static unsigned short normal_i2c[] = { I2C_CLIENT_END }; ++ ++/* Insmod parameters */ ++I2C_CLIENT_INSMOD; ++I2C_CLIENT_MODULE_PARM(hctosys, ++ "Set the system time from the hardware clock upon initialization"); ++ ++/* offsets into CCR area */ ++ ++#define CCR_SEC 0 ++#define CCR_MIN 1 ++#define CCR_HOUR 2 ++#define CCR_MDAY 3 ++#define CCR_MONTH 4 ++#define CCR_YEAR 5 ++#define CCR_WDAY 6 ++#define CCR_Y2K 7 ++ ++#define X1205_REG_SR 0x3F /* status register */ ++#define X1205_REG_Y2K 0x37 ++#define X1205_REG_DW 0x36 ++#define X1205_REG_YR 0x35 ++#define X1205_REG_MO 0x34 ++#define X1205_REG_DT 0x33 ++#define X1205_REG_HR 0x32 ++#define X1205_REG_MN 0x31 ++#define X1205_REG_SC 0x30 ++#define X1205_REG_DTR 0x13 ++#define X1205_REG_ATR 0x12 ++#define X1205_REG_INT 0x11 ++#define X1205_REG_0 0x10 ++#define X1205_REG_Y2K1 0x0F ++#define X1205_REG_DWA1 0x0E ++#define X1205_REG_YRA1 0x0D ++#define X1205_REG_MOA1 0x0C ++#define X1205_REG_DTA1 0x0B ++#define X1205_REG_HRA1 0x0A ++#define X1205_REG_MNA1 0x09 ++#define X1205_REG_SCA1 0x08 ++#define X1205_REG_Y2K0 0x07 ++#define X1205_REG_DWA0 0x06 ++#define X1205_REG_YRA0 0x05 ++#define X1205_REG_MOA0 0x04 ++#define X1205_REG_DTA0 0x03 ++#define X1205_REG_HRA0 0x02 ++#define X1205_REG_MNA0 0x01 ++#define X1205_REG_SCA0 0x00 ++ ++#define X1205_CCR_BASE 0x30 /* Base address of CCR */ ++#define X1205_ALM0_BASE 0x00 /* Base address of ALARM0 */ ++ ++#define X1205_SR_RTCF 0x01 /* Clock failure */ ++#define X1205_SR_WEL 0x02 /* Write Enable Latch */ ++#define X1205_SR_RWEL 0x04 /* Register Write Enable */ ++ ++#define X1205_DTR_DTR0 0x01 ++#define X1205_DTR_DTR1 0x02 ++#define X1205_DTR_DTR2 0x04 ++ ++#define X1205_HR_MIL 0x80 /* Set in ccr.hour for 24 hr mode */ ++ ++/* Prototypes */ ++static int x1205_attach(struct i2c_adapter *adapter); ++static int x1205_detach(struct i2c_client *client); ++static int x1205_probe(struct i2c_adapter *adapter, int address, int kind); ++ ++static struct i2c_driver x1205_driver = { ++ .owner = THIS_MODULE, ++ .name = "x1205", ++ .flags = I2C_DF_NOTIFY, ++ .attach_adapter = &x1205_attach, ++ .detach_client = &x1205_detach, ++}; ++ ++/* ++ * In the routines that deal directly with the x1205 hardware, we use ++ * rtc_time -- month 0-11, hour 0-23, yr = calendar year-epoch ++ * Epoch is initialized as 2000. Time is set to UTC. ++ */ ++static int x1205_get_datetime(struct i2c_client *client, struct rtc_time *tm, ++ unsigned char reg_base) ++{ ++ unsigned char dt_addr[2] = { 0, reg_base }; ++ ++ unsigned char buf[8]; ++ ++ struct i2c_msg msgs[] = { ++ { client->addr, 0, 2, dt_addr }, /* setup read ptr */ ++ { client->addr, I2C_M_RD, 8, 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 - sec=%02x, min=%02x, hr=%02x, " ++ "mday=%02x, mon=%02x, year=%02x,