diff options
| author | Koen Kooi <koen@openembedded.org> | 2005-06-30 08:19:37 +0000 |
|---|---|---|
| committer | OpenEmbedded Project <openembedded-devel@lists.openembedded.org> | 2005-06-30 08:19:37 +0000 |
| commit | c8e5702127e507e82e6f68a4b8c546803accea9d (patch) | |
| tree | 00583491f40ecc640f2b28452af995e3a63a09d7 /packages/linux/gumstix-2.6.5-gnalm1-gum0 | |
| parent | 87ec8ca4d2e2eb4d1c1e1e1a6b46a395d56805b9 (diff) | |
import clean BK tree at cset 1.3670
Diffstat (limited to 'packages/linux/gumstix-2.6.5-gnalm1-gum0')
3 files changed, 21768 insertions, 0 deletions
diff --git a/packages/linux/gumstix-2.6.5-gnalm1-gum0/.mtn2git_empty b/packages/linux/gumstix-2.6.5-gnalm1-gum0/.mtn2git_empty new file mode 100644 index 0000000000..e69de29bb2 --- /dev/null +++ b/packages/linux/gumstix-2.6.5-gnalm1-gum0/.mtn2git_empty diff --git a/packages/linux/gumstix-2.6.5-gnalm1-gum0/defconfig b/packages/linux/gumstix-2.6.5-gnalm1-gum0/defconfig index e69de29bb2..64020e2cbe 100644 --- a/packages/linux/gumstix-2.6.5-gnalm1-gum0/defconfig +++ b/packages/linux/gumstix-2.6.5-gnalm1-gum0/defconfig @@ -0,0 +1,777 @@ +# +# Automatically generated make config: don't edit +# +CONFIG_ARM=y +CONFIG_MMU=y +CONFIG_UID16=y +CONFIG_RWSEM_GENERIC_SPINLOCK=y + +# +# Code maturity level options +# +CONFIG_EXPERIMENTAL=y +CONFIG_CLEAN_COMPILE=y +CONFIG_STANDALONE=y +CONFIG_BROKEN_ON_SMP=y + +# +# General setup +# +CONFIG_SWAP=y +CONFIG_SYSVIPC=y +# CONFIG_BSD_PROCESS_ACCT is not set +CONFIG_SYSCTL=y +CONFIG_LOG_BUF_SHIFT=14 +# CONFIG_HOTPLUG is not set +CONFIG_IKCONFIG=y +CONFIG_IKCONFIG_PROC=y +# CONFIG_EMBEDDED is not set +CONFIG_KALLSYMS=y +CONFIG_FUTEX=y +CONFIG_EPOLL=y +CONFIG_IOSCHED_NOOP=y +CONFIG_IOSCHED_AS=y +CONFIG_IOSCHED_DEADLINE=y +CONFIG_CC_OPTIMIZE_FOR_SIZE=y + +# +# Loadable module support +# +# CONFIG_MODULES is not set + +# +# System Type +# +# CONFIG_ARCH_ADIFCC is not set +# CONFIG_ARCH_ANAKIN is not set +# CONFIG_ARCH_CLPS7500 is not set +# CONFIG_ARCH_CLPS711X is not set +# CONFIG_ARCH_CO285 is not set +CONFIG_ARCH_PXA=y +# CONFIG_ARCH_EBSA110 is not set +# CONFIG_ARCH_CAMELOT is not set +# CONFIG_ARCH_FOOTBRIDGE is not set +# CONFIG_ARCH_INTEGRATOR is not set +# CONFIG_ARCH_IOP3XX is not set +# CONFIG_ARCH_L7200 is not set +# CONFIG_ARCH_RPC is not set +# CONFIG_ARCH_SA1100 is not set +# CONFIG_ARCH_SHARK is not set + +# +# CLPS711X/EP721X Implementations +# + +# +# Epxa10db +# + +# +# Footbridge Implementations +# + +# +# IOP3xx Implementation Options +# +# CONFIG_ARCH_IOP310 is not set +# CONFIG_ARCH_IOP321 is not set + +# +# IOP3xx Chipset Features +# + +# +# Intel PXA250/210 Implementations +# +CONFIG_ARCH_GUMSTIK=y +# CONFIG_ARCH_LUBBOCK is not set +# CONFIG_ARCH_PXA_IDP is not set + +# +# SA11x0 Implementations +# + +# +# Processor Type +# +CONFIG_CPU_32=y +CONFIG_CPU_XSCALE=y +CONFIG_CPU_32v5=y +CONFIG_CPU_ABRT_EV5T=y +CONFIG_CPU_TLB_V4WBI=y +CONFIG_CPU_MINICACHE=y + +# +# Processor Features +# +# CONFIG_ARM_THUMB is not set +CONFIG_XSCALE_PMU=y + +# +# General setup +# +# CONFIG_ZBOOT_ROM is not set +CONFIG_ZBOOT_ROM_TEXT=0x0 +CONFIG_ZBOOT_ROM_BSS=0x0 +CONFIG_CPU_FREQ=y + +# +# At least one math emulation must be selected +# +CONFIG_FPE_NWFPE=y +# CONFIG_FPE_NWFPE_XP is not set +CONFIG_FPE_FASTFPE=y +CONFIG_BINFMT_ELF=y +CONFIG_BINFMT_AOUT=y +# CONFIG_BINFMT_MISC is not set + +# +# Generic Driver Options +# +CONFIG_PM=y +# CONFIG_PREEMPT is not set +# CONFIG_APM is not set +# CONFIG_ARTHUR is not set +CONFIG_CMDLINE="root=/dev/ram0 console=tty0,115200n8" +CONFIG_ALIGNMENT_TRAP=y + +# +# Parallel port support +# +# CONFIG_PARPORT is not set + +# +# Memory Technology Devices (MTD) +# +CONFIG_MTD=y +# CONFIG_MTD_DEBUG is not set +CONFIG_MTD_PARTITIONS=y +CONFIG_MTD_CONCAT=y +# CONFIG_MTD_REDBOOT_PARTS is not set +CONFIG_MTD_CMDLINE_PARTS=y +# CONFIG_MTD_AFS_PARTS is not set + +# +# User Modules And Translation Layers +# +CONFIG_MTD_CHAR=y +CONFIG_MTD_BLOCK=y +# CONFIG_FTL is not set +# CONFIG_NFTL is not set +# CONFIG_INFTL is not set + +# +# RAM/ROM/Flash chip drivers +# +CONFIG_MTD_CFI=y +# CONFIG_MTD_JEDECPROBE is not set +CONFIG_MTD_GEN_PROBE=y +# CONFIG_MTD_CFI_ADV_OPTIONS is not set +CONFIG_MTD_CFI_INTELEXT=y +# CONFIG_MTD_CFI_AMDSTD is not set +# CONFIG_MTD_CFI_STAA is not set +# CONFIG_MTD_RAM is not set +# CONFIG_MTD_ROM is not set +# CONFIG_MTD_ABSENT is not set +# CONFIG_MTD_OBSOLETE_CHIPS is not set + +# +# Mapping drivers for chip access +# +CONFIG_MTD_COMPLEX_MAPPINGS=y +CONFIG_MTD_PHYSMAP=y +CONFIG_MTD_PHYSMAP_START=0x00180000 +CONFIG_MTD_PHYSMAP_LEN=0x00280000 +CONFIG_MTD_PHYSMAP_BUSWIDTH=2 +CONFIG_MTD_GUMSTIK=y +# CONFIG_MTD_ARM_INTEGRATOR is not set +# CONFIG_MTD_EDB7312 is not set + +# +# Self-contained MTD device drivers +# +# CONFIG_MTD_SLRAM is not set +# CONFIG_MTD_MTDRAM is not set +CONFIG_MTD_BLKMTD=y + +# +# Disk-On-Chip Device Drivers +# +# CONFIG_MTD_DOC2000 is not set +# CONFIG_MTD_DOC2001 is not set +# CONFIG_MTD_DOC2001PLUS is not set + +# +# NAND Flash Device Drivers +# +# CONFIG_MTD_NAND is not set + +# +# Plug and Play support +# + +# +# Block devices +# +# CONFIG_BLK_DEV_FD is not set +CONFIG_BLK_DEV_LOOP=y +# CONFIG_BLK_DEV_CRYPTOLOOP is not set +CONFIG_BLK_DEV_NBD=y +CONFIG_BLK_DEV_RAM=y +CONFIG_BLK_DEV_RAM_SIZE=36000 +CONFIG_BLK_DEV_INITRD=y + +# +# Multi-device support (RAID and LVM) +# +# CONFIG_MD is not set + +# +# Networking support +# +CONFIG_NET=y + +# +# Networking options +# +# CONFIG_PACKET is not set +# CONFIG_NETLINK_DEV is not set +CONFIG_UNIX=y +# CONFIG_NET_KEY is not set +CONFIG_INET=y +# CONFIG_IP_MULTICAST is not set +# CONFIG_IP_ADVANCED_ROUTER is not set +# CONFIG_IP_PNP is not set +# CONFIG_NET_IPIP is not set +# CONFIG_NET_IPGRE is not set +# CONFIG_ARPD is not set +# CONFIG_INET_ECN is not set +# CONFIG_SYN_COOKIES is not set +# CONFIG_INET_AH is not set +# CONFIG_INET_ESP is not set +# CONFIG_INET_IPCOMP is not set +# CONFIG_IPV6 is not set +# CONFIG_DECNET is not set +# CONFIG_BRIDGE is not set +# CONFIG_NETFILTER is not set + +# +# SCTP Configuration (EXPERIMENTAL) +# +CONFIG_IPV6_SCTP__=y +# CONFIG_IP_SCTP is not set +# CONFIG_ATM is not set +# CONFIG_VLAN_8021Q is not set +# CONFIG_LLC2 is not set +# CONFIG_IPX is not set +# CONFIG_ATALK is not set +# CONFIG_X25 is not set +# CONFIG_LAPB is not set +# CONFIG_NET_DIVERT is not set +# CONFIG_ECONET is not set +# CONFIG_WAN_ROUTER is not set +# CONFIG_NET_FASTROUTE is not set +# CONFIG_NET_HW_FLOWCONTROL is not set + +# +# QoS and/or fair queueing +# +# CONFIG_NET_SCHED is not set + +# +# Network testing +# +# CONFIG_NET_PKTGEN is not set +CONFIG_NETDEVICES=y +# CONFIG_DUMMY is not set +# CONFIG_BONDING is not set +# CONFIG_EQUALIZER is not set +# CONFIG_TUN is not set + +# +# Ethernet (10 or 100Mbit) +# +CONFIG_NET_ETHERNET=y +CONFIG_MII=y + +# +# Ethernet (1000 Mbit) +# + +# +# Ethernet (10000 Mbit) +# +CONFIG_PPP=y +# CONFIG_PPP_MULTILINK is not set +# CONFIG_PPP_FILTER is not set +# CONFIG_PPP_ASYNC is not set +# CONFIG_PPP_SYNC_TTY is not set +# CONFIG_PPP_DEFLATE is not set +# CONFIG_PPP_BSDCOMP is not set +# CONFIG_PPPOE is not set +CONFIG_SLIP=y +# CONFIG_SLIP_COMPRESSED is not set +# CONFIG_SLIP_SMART is not set +# CONFIG_SLIP_MODE_SLIP6 is not set + +# +# Wireless LAN (non-hamradio) +# +# CONFIG_NET_RADIO is not set + +# +# Token Ring devices +# +# CONFIG_SHAPER is not set +# CONFIG_NETCONSOLE is not set + +# +# Wan interfaces +# +# CONFIG_WAN is not set + +# +# Amateur Radio support +# +# CONFIG_HAMRADIO is not set + +# +# IrDA (infrared) support +# +# CONFIG_IRDA is not set + +# +# Bluetooth support +# +CONFIG_BT=y +CONFIG_BT_L2CAP=y +CONFIG_BT_SCO=y +CONFIG_BT_RFCOMM=y +CONFIG_BT_RFCOMM_TTY=y +CONFIG_BT_BNEP=y +# CONFIG_BT_BNEP_MC_FILTER is not set +# CONFIG_BT_BNEP_PROTO_FILTER is not set + +# +# Bluetooth device drivers +# +CONFIG_BT_HCIUART=y +CONFIG_BT_HCIUART_H4=y +# CONFIG_BT_HCIUART_BCSP is not set +# CONFIG_BT_HCIVHCI is not set +# CONFIG_NETPOLL is not set +# CONFIG_NET_POLL_CONTROLLER is not set + +# +# ATA/ATAPI/MFM/RLL support +# +# CONFIG_IDE is not set + +# +# SCSI device support +# +# CONFIG_SCSI is not set + +# +# Fusion MPT device support +# + +# +# IEEE 1394 (FireWire) support +# +# CONFIG_IEEE1394 is not set + +# +# I2O device support +# + +# +# ISDN subsystem +# +# CONFIG_ISDN is not set + +# +# Input device support +# +CONFIG_INPUT=y + +# +# Userland interfaces +# +CONFIG_INPUT_MOUSEDEV=y +CONFIG_INPUT_MOUSEDEV_PSAUX=y +CONFIG_INPUT_MOUSEDEV_SCREEN_X=1024 +CONFIG_INPUT_MOUSEDEV_SCREEN_Y=768 +# CONFIG_INPUT_JOYDEV is not set +# CONFIG_INPUT_TSDEV is not set +# CONFIG_INPUT_TSLIBDEV is not set +# CONFIG_INPUT_EVDEV is not set +# CONFIG_INPUT_EVBUG is not set + +# +# Input I/O drivers +# +# CONFIG_GAMEPORT is not set +CONFIG_SOUND_GAMEPORT=y +# CONFIG_SERIO is not set +# CONFIG_SERIO_I8042 is not set + +# +# Input Device Drivers +# +# CONFIG_INPUT_KEYBOARD is not set +# CONFIG_INPUT_MOUSE is not set +# CONFIG_INPUT_JOYSTICK is not set +# CONFIG_INPUT_TOUCHSCREEN is not set +# CONFIG_INPUT_MISC is not set + +# +# Character devices +# +CONFIG_VT=y +CONFIG_VT_CONSOLE=y +CONFIG_HW_CONSOLE=y +# CONFIG_SERIAL_NONSTANDARD is not set + +# +# Serial drivers +# +# CONFIG_SERIAL_8250 is not set + +# +# Non-8250 serial port support +# +CONFIG_SERIAL_PXA=y +CONFIG_SERIAL_PXA_CONSOLE=y +CONFIG_SERIAL_CORE=y +CONFIG_SERIAL_CORE_CONSOLE=y +CONFIG_UNIX98_PTYS=y +CONFIG_LEGACY_PTYS=y +CONFIG_LEGACY_PTY_COUNT=256 +# CONFIG_QIC02_TAPE is not set + +# +# IPMI +# +# CONFIG_IPMI_HANDLER is not set + +# +# Watchdog Cards +# +# CONFIG_WATCHDOG is not set +# CONFIG_NVRAM is not set +# CONFIG_RTC is not set +# CONFIG_GEN_RTC is not set +CONFIG_SA1100_RTC=y +# CONFIG_DTLK is not set +# CONFIG_R3964 is not set +# CONFIG_APPLICOM is not set + +# +# Ftape, the floppy tape device driver +# +# CONFIG_FTAPE is not set +# CONFIG_AGP is not set +# CONFIG_DRM is not set +# CONFIG_RAW_DRIVER is not set + +# +# I2C support +# +CONFIG_I2C=y +CONFIG_I2C_CHARDEV=y + +# +# I2C Algorithms +# +CONFIG_I2C_ALGOBIT=y +# CONFIG_I2C_ALGOPCF is not set +CONFIG_I2C_ALGOPXA=y + +# +# I2C Hardware Bus support +# +# CONFIG_I2C_AMD756 is not set +# CONFIG_I2C_AMD8111 is not set +# CONFIG_I2C_ISA is not set +# CONFIG_I2C_PARPORT_LIGHT is not set +CONFIG_I2C_PXA2XX=y +# CONFIG_SCx200_ACB is not set + +# +# Hardware Sensors Chip support +# +# CONFIG_I2C_SENSOR is not set +# CONFIG_SENSORS_ADM1021 is not set +# CONFIG_SENSORS_ASB100 is not set +# CONFIG_SENSORS_DS1621 is not set +# CONFIG_SENSORS_FSCHER is not set +# CONFIG_SENSORS_GL518SM is not set +# CONFIG_SENSORS_IT87 is not set +# CONFIG_SENSORS_LM75 is not set +# CONFIG_SENSORS_LM78 is not set +# CONFIG_SENSORS_LM80 is not set +# CONFIG_SENSORS_LM83 is not set +# CONFIG_SENSORS_LM85 is not set +# CONFIG_SENSORS_LM90 is not set +# CONFIG_SENSORS_VIA686A is not set +# CONFIG_SENSORS_W83781D is not set +# CONFIG_SENSORS_W83L785TS is not set +# CONFIG_SENSORS_W83627HF is not set + +# +# Other I2C Chip support +# +# CONFIG_SENSORS_EEPROM is not set +# CONFIG_I2C_DEBUG_CORE is not set +# CONFIG_I2C_DEBUG_ALGO is not set +# CONFIG_I2C_DEBUG_BUS is not set +# CONFIG_I2C_DEBUG_CHIP is not set + +# +# Multimedia devices +# +# CONFIG_VIDEO_DEV is not set + +# +# Digital Video Broadcasting Devices +# +# CONFIG_DVB is not set + +# +# MMC/SD Card support +# +CONFIG_MMC=y +# CONFIG_MMC_DEBUG is not set +CONFIG_MMC_BLOCK=y +CONFIG_MMC_PXA=y + +# +# File systems +# +CONFIG_EXT2_FS=y +CONFIG_EXT2_FS_XATTR=y +# CONFIG_EXT2_FS_POSIX_ACL is not set +# CONFIG_EXT2_FS_SECURITY is not set +CONFIG_EXT3_FS=y +CONFIG_EXT3_FS_XATTR=y +# CONFIG_EXT3_FS_POSIX_ACL is not set +# CONFIG_EXT3_FS_SECURITY is not set +CONFIG_JBD=y +# CONFIG_JBD_DEBUG is not set +CONFIG_FS_MBCACHE=y +# CONFIG_REISERFS_FS is not set +# CONFIG_JFS_FS is not set +# CONFIG_XFS_FS is not set +# CONFIG_MINIX_FS is not set +# CONFIG_ROMFS_FS is not set +# CONFIG_QUOTA is not set +# CONFIG_AUTOFS_FS is not set +# CONFIG_AUTOFS4_FS is not set + +# +# CD-ROM/DVD Filesystems +# +# CONFIG_ISO9660_FS is not set +# CONFIG_UDF_FS is not set + +# +# DOS/FAT/NT Filesystems +# +CONFIG_FAT_FS=y +CONFIG_MSDOS_FS=y +CONFIG_VFAT_FS=y +# CONFIG_NTFS_FS is not set + +# +# Pseudo filesystems +# +CONFIG_PROC_FS=y +# CONFIG_DEVFS_FS is not set +CONFIG_DEVPTS_FS_XATTR=y +# CONFIG_DEVPTS_FS_SECURITY is not set +CONFIG_TMPFS=y +# CONFIG_HUGETLB_PAGE is not set +CONFIG_RAMFS=y + +# +# Miscellaneous filesystems +# +# CONFIG_ADFS_FS is not set +# CONFIG_AFFS_FS is not set +# CONFIG_HFS_FS is not set +# CONFIG_HFSPLUS_FS is not set +# CONFIG_BEFS_FS is not set +# CONFIG_BFS_FS is not set +# CONFIG_EFS_FS is not set +# CONFIG_JFFS_FS is not set +CONFIG_JFFS2_FS=y +CONFIG_JFFS2_FS_DEBUG=0 +# CONFIG_JFFS2_FS_NAND is not set +CONFIG_CRAMFS=y +# CONFIG_VXFS_FS is not set +# CONFIG_HPFS_FS is not set +# CONFIG_QNX4FS_FS is not set +# CONFIG_SYSV_FS is not set +# CONFIG_UFS_FS is not set + +# +# Network File Systems +# +CONFIG_NFS_FS=y +# CONFIG_NFS_V3 is not set +# CONFIG_NFS_V4 is not set +# CONFIG_NFS_DIRECTIO is not set +# CONFIG_NFSD is not set +CONFIG_LOCKD=y +# CONFIG_EXPORTFS is not set +CONFIG_SUNRPC=y +# CONFIG_RPCSEC_GSS_KRB5 is not set +# CONFIG_SMB_FS is not set +# CONFIG_CIFS is not set +# CONFIG_NCP_FS is not set +# CONFIG_CODA_FS is not set +# CONFIG_INTERMEZZO_FS is not set +# CONFIG_AFS_FS is not set + +# +# Partition Types +# +CONFIG_PARTITION_ADVANCED=y +# CONFIG_ACORN_PARTITION is not set +# CONFIG_OSF_PARTITION is not set +# CONFIG_AMIGA_PARTITION is not set +# CONFIG_ATARI_PARTITION is not set +# CONFIG_MAC_PARTITION is not set +CONFIG_MSDOS_PARTITION=y +# CONFIG_BSD_DISKLABEL is not set +# CONFIG_MINIX_SUBPARTITION is not set +# CONFIG_SOLARIS_X86_PARTITION is not set +# CONFIG_UNIXWARE_DISKLABEL is not set +CONFIG_LDM_PARTITION=y +# CONFIG_LDM_DEBUG is not set +# CONFIG_NEC98_PARTITION is not set +# CONFIG_SGI_PARTITION is not set +# CONFIG_ULTRIX_PARTITION is not set +# CONFIG_SUN_PARTITION is not set +# CONFIG_EFI_PARTITION is not set + +# +# Native Language Support +# +CONFIG_NLS=y +CONFIG_NLS_DEFAULT="iso8859-1" +# CONFIG_NLS_CODEPAGE_437 is not set +# CONFIG_NLS_CODEPAGE_737 is not set +# CONFIG_NLS_CODEPAGE_775 is not set +# CONFIG_NLS_CODEPAGE_850 is not set +# CONFIG_NLS_CODEPAGE_852 is not set +# CONFIG_NLS_CODEPAGE_855 is not set +# CONFIG_NLS_CODEPAGE_857 is not set +# CONFIG_NLS_CODEPAGE_860 is not set +# CONFIG_NLS_CODEPAGE_861 is not set +# CONFIG_NLS_CODEPAGE_862 is not set +# CONFIG_NLS_CODEPAGE_863 is not set +# CONFIG_NLS_CODEPAGE_864 is not set +# CONFIG_NLS_CODEPAGE_865 is not set +# CONFIG_NLS_CODEPAGE_866 is not set +# CONFIG_NLS_CODEPAGE_869 is not set +# CONFIG_NLS_CODEPAGE_936 is not set +# CONFIG_NLS_CODEPAGE_950 is not set +# CONFIG_NLS_CODEPAGE_932 is not set +# CONFIG_NLS_CODEPAGE_949 is not set +# CONFIG_NLS_CODEPAGE_874 is not set +# CONFIG_NLS_ISO8859_8 is not set +# CONFIG_NLS_CODEPAGE_1250 is not set +# CONFIG_NLS_CODEPAGE_1251 is not set +CONFIG_NLS_ISO8859_1=y +# CONFIG_NLS_ISO8859_2 is not set +# CONFIG_NLS_ISO8859_3 is not set +# CONFIG_NLS_ISO8859_4 is not set +# CONFIG_NLS_ISO8859_5 is not set +# CONFIG_NLS_ISO8859_6 is not set +# CONFIG_NLS_ISO8859_7 is not set +# CONFIG_NLS_ISO8859_9 is not set +# CONFIG_NLS_ISO8859_13 is not set +# CONFIG_NLS_ISO8859_14 is not set +# CONFIG_NLS_ISO8859_15 is not set +# CONFIG_NLS_KOI8_R is not set +# CONFIG_NLS_KOI8_U is not set +# CONFIG_NLS_UTF8 is not set + +# +# Profiling support +# +# CONFIG_PROFILING is not set + +# +# Graphics support +# +# CONFIG_FB is not set + +# +# Console display driver support +# +# CONFIG_VGA_CONSOLE is not set +# CONFIG_MDA_CONSOLE is not set +CONFIG_DUMMY_CONSOLE=y + +# +# Misc devices +# + +# +# Multimedia Capabilities Port drivers +# +# CONFIG_MCP is not set + +# +# Console Switches +# +# CONFIG_SWITCHES is not set + +# +# USB support +# + +# +# USB Gadget Support +# +CONFIG_USB_GADGET=y +# CONFIG_USB_GADGET_NET2280 is not set +CONFIG_USB_GADGET_PXA2XX=y +CONFIG_USB_PXA2XX=y +CONFIG_USB_PXA2XX_SMALL=y +# CONFIG_USB_GADGET_GOKU is not set +# CONFIG_USB_GADGET_SA1100 is not set +# CONFIG_USB_GADGET_DUALSPEED is not set +# CONFIG_USB_ZERO is not set +CONFIG_USB_ETH=y +# CONFIG_USB_GADGETFS is not set +# CONFIG_USB_FILE_STORAGE is not set +# CONFIG_USB_G_SERIAL is not set + +# +# Kernel hacking +# +CONFIG_FRAME_POINTER=y +# CONFIG_DEBUG_USER is not set +# CONFIG_DEBUG_INFO is not set +# CONFIG_DEBUG_KERNEL is not set + +# +# Security options +# +# CONFIG_SECURITY is not set + +# +# Cryptographic options +# +# CONFIG_CRYPTO is not set + +# +# Library routines +# +CONFIG_CRC32=y +CONFIG_ZLIB_INFLATE=y +CONFIG_ZLIB_DEFLATE=y diff --git a/packages/linux/gumstix-2.6.5-gnalm1-gum0/linux-2.6.5-gnalm1.patch b/packages/linux/gumstix-2.6.5-gnalm1-gum0/linux-2.6.5-gnalm1.patch index e69de29bb2..4da2b88285 100644 --- a/packages/linux/gumstix-2.6.5-gnalm1-gum0/linux-2.6.5-gnalm1.patch +++ b/packages/linux/gumstix-2.6.5-gnalm1-gum0/linux-2.6.5-gnalm1.patch @@ -0,0 +1,20991 @@ +--- linux-2.6.5/kernel/printk.c~heh 2004-04-03 22:38:24.000000000 -0500 ++++ linux-2.6.5/kernel/printk.c 2004-04-30 20:57:36.000000000 -0400 +@@ -832,3 +832,25 @@ + printk_ratelimit_burst); + } + EXPORT_SYMBOL(printk_ratelimit); ++ ++#include <linux/sysrq.h> ++ ++static void ++show_msg_info(int key, struct pt_regs *regs, struct tty_struct *tty) ++{ ++ call_console_drivers(log_end - logged_chars, log_end); ++} ++ ++static struct sysrq_key_op msg_info_op = { ++ .handler = show_msg_info, ++ .help_msg = "Dumpmsgs", ++ .action_msg = "Kernel Messages", ++}; ++ ++static int __init dbg_init(void) ++{ ++ register_sysrq_key('d', &msg_info_op); ++ return 0; ++} ++ ++__initcall(dbg_init); +--- linux-2.6.5/kernel/resource.c~heh 2004-04-03 22:37:36.000000000 -0500 ++++ linux-2.6.5/kernel/resource.c 2004-04-30 20:57:36.000000000 -0400 +@@ -179,6 +179,8 @@ + { + struct resource *tmp, **p; + ++ BUG_ON(old->child); ++ + p = &old->parent->child; + for (;;) { + tmp = *p; +@@ -409,6 +411,47 @@ + EXPORT_SYMBOL(adjust_resource); + + /* ++ * Given an existing resource, change its start and size to match the ++ * arguments. Returns -EBUSY if it can't fit. Existing children of ++ * the resource are assumed to be immutable. ++ */ ++int reallocate_resource(struct resource *res, unsigned long start, unsigned long size) ++{ ++ struct resource *tmp, *parent = res->parent; ++ unsigned long end = start + size - 1; ++ int result = -EBUSY; ++ ++ write_lock(&resource_lock); ++ ++ if ((start < parent->start) || (end > parent->end)) ++ goto out; ++ ++ for (tmp = res->child; tmp; tmp = tmp->sibling) { ++ if ((tmp->start < start) || (tmp->end > end)) ++ goto out; ++ } ++ ++ if (res->sibling && (res->sibling->start <= end)) ++ goto out; ++ ++ tmp = parent->child; ++ if (tmp != res) { ++ while (tmp->sibling != res) ++ tmp = tmp->sibling; ++ if (start <= tmp->end) ++ goto out; ++ } ++ ++ res->start = start; ++ res->end = end; ++ result = 0; ++ ++ out: ++ write_unlock(&resource_lock); ++ return result; ++} ++ ++/* + * This is compatibility stuff for IO resources. + * + * Note how this, unlike the above, knows about +--- linux-2.6.5/include/asm-arm/mach/irq.h~heh 2004-04-03 22:36:54.000000000 -0500 ++++ linux-2.6.5/include/asm-arm/mach/irq.h 2004-04-30 20:57:36.000000000 -0400 +@@ -14,6 +14,19 @@ + struct pt_regs; + struct seq_file; + ++/* ++ * Architectures are expected to define NR_IRQ_DEVICES and ++ * NR_IRQ_DEVICE_SHIFT if they wish to use dynamic IRQs. ++ */ ++#ifndef NR_IRQ_DEVICES ++#define NR_IRQ_DEVICES 1 ++#endif ++#define NR_IRQ_PER_DEVICE (1 << (NR_IRQ_DEVICE_SHIFT - 1)) ++ ++#define IRQ_DEVICE(i) ((i) >> NR_IRQ_DEVICE_SHIFT) ++#define IRQ_INDEX(i) ((i) & (NR_IRQ_PER_GROUP - 1)) ++#define TO_IRQ(g,i) (((g) << NR_IRQ_DEVICE_SHIFT) + (i)) ++ + typedef void (*irq_handler_t)(unsigned int, struct irqdesc *, struct pt_regs *); + typedef void (*irq_control_t)(unsigned int); + +--- linux-2.6.5/include/asm-arm/arch-pxa/uncompress.h~heh 2004-04-03 22:36:17.000000000 -0500 ++++ linux-2.6.5/include/asm-arm/arch-pxa/uncompress.h 2004-04-30 20:57:36.000000000 -0400 +@@ -12,6 +12,7 @@ + #define FFUART ((volatile unsigned long *)0x40100000) + #define BTUART ((volatile unsigned long *)0x40200000) + #define STUART ((volatile unsigned long *)0x40700000) ++#define HWUART ((volatile unsigned long *)0x41600000) + + #define UART FFUART + +--- linux-2.6.5/include/asm-arm/arch-pxa/dma.h~heh 2004-04-03 22:38:18.000000000 -0500 ++++ linux-2.6.5/include/asm-arm/arch-pxa/dma.h 2004-04-30 20:57:36.000000000 -0400 +@@ -22,11 +22,11 @@ + * Note: this structure must always be aligned to a 16-byte boundary. + */ + +-typedef struct { +- volatile u32 ddadr; /* Points to the next descriptor + flags */ +- volatile u32 dsadr; /* DSADR value for the current transfer */ +- volatile u32 dtadr; /* DTADR value for the current transfer */ +- volatile u32 dcmd; /* DCMD value for the current transfer */ ++typedef struct pxa_dma_desc { ++ u32 ddadr; /* Points to the next descriptor + flags */ ++ u32 dsadr; /* DSADR value for the current transfer */ ++ u32 dtadr; /* DTADR value for the current transfer */ ++ u32 dcmd; /* DCMD value for the current transfer */ + } pxa_dma_desc; + + /* +--- linux-2.6.5/include/asm-arm/arch-pxa/serial.h~heh 2004-04-03 22:37:06.000000000 -0500 ++++ linux-2.6.5/include/asm-arm/arch-pxa/serial.h 2004-04-30 20:57:36.000000000 -0400 +@@ -43,6 +43,15 @@ + io_type: SERIAL_IO_MEM, \ + irq: IRQ_BTUART, \ + flags: STD_COM_FLAGS, \ ++ }, { \ ++ type: PORT_PXA, \ ++ xmit_fifo_size: 64, \ ++ baud_base: BAUD_BASE, \ ++ iomem_base: &HWUART, \ ++ iomem_reg_shift: 2, \ ++ io_type: SERIAL_IO_MEM, \ ++ irq: IRQ_HWUART, \ ++ flags: STD_COM_FLAGS, \ + } + + #define EXTRA_SERIAL_PORT_DEFNS +--- linux-2.6.5/include/asm-arm/arch-pxa/pxa-regs.h~heh 2004-04-03 22:37:36.000000000 -0500 ++++ linux-2.6.5/include/asm-arm/arch-pxa/pxa-regs.h 2004-04-30 20:57:36.000000000 -0400 +@@ -124,26 +124,26 @@ + #define DRCMR12 __REG(0x40000130) /* Request to Channel Map Register for AC97 audio transmit Request */ + #define DRCMR13 __REG(0x40000134) /* Request to Channel Map Register for SSP receive Request */ + #define DRCMR14 __REG(0x40000138) /* Request to Channel Map Register for SSP transmit Request */ +-#define DRCMR15 __REG(0x4000013c) /* Reserved */ +-#define DRCMR16 __REG(0x40000140) /* Reserved */ ++#define DRCMR15 __REG(0x4000013c) /* Request to Channel Map Register for NSSP receive Request */ ++#define DRCMR16 __REG(0x40000140) /* Request to Channel Map Register for NSSP transmit Request */ + #define DRCMR17 __REG(0x40000144) /* Request to Channel Map Register for ICP receive Request */ + #define DRCMR18 __REG(0x40000148) /* Request to Channel Map Register for ICP transmit Request */ + #define DRCMR19 __REG(0x4000014c) /* Request to Channel Map Register for STUART receive Request */ + #define DRCMR20 __REG(0x40000150) /* Request to Channel Map Register for STUART transmit Request */ + #define DRCMR21 __REG(0x40000154) /* Request to Channel Map Register for MMC receive Request */ + #define DRCMR22 __REG(0x40000158) /* Request to Channel Map Register for MMC transmit Request */ +-#define DRCMR23 __REG(0x4000015c) /* Reserved */ +-#define DRCMR24 __REG(0x40000160) /* Reserved */ ++#define DRCMR23 __REG(0x4000015c) /* Request to Channel Map Register for ASSP receive Request */ ++#define DRCMR24 __REG(0x40000160) /* Request to Channel Map Register for ASSP transmit Request */ + #define DRCMR25 __REG(0x40000164) /* Request to Channel Map Register for USB endpoint 1 Request */ + #define DRCMR26 __REG(0x40000168) /* Request to Channel Map Register for USB endpoint 2 Request */ + #define DRCMR27 __REG(0x4000016C) /* Request to Channel Map Register for USB endpoint 3 Request */ + #define DRCMR28 __REG(0x40000170) /* Request to Channel Map Register for USB endpoint 4 Request */ +-#define DRCMR29 __REG(0x40000174) /* Reserved */ ++#define DRCMR29 __REG(0x40000174) /* Request to Channel Map Register for HWUART receive Request */ + #define DRCMR30 __REG(0x40000178) /* Request to Channel Map Register for USB endpoint 6 Request */ + #define DRCMR31 __REG(0x4000017C) /* Request to Channel Map Register for USB endpoint 7 Request */ + #define DRCMR32 __REG(0x40000180) /* Request to Channel Map Register for USB endpoint 8 Request */ + #define DRCMR33 __REG(0x40000184) /* Request to Channel Map Register for USB endpoint 9 Request */ +-#define DRCMR34 __REG(0x40000188) /* Reserved */ ++#define DRCMR34 __REG(0x40000188) /* Request to Channel Map Register for HWUART transmit Request */ + #define DRCMR35 __REG(0x4000018C) /* Request to Channel Map Register for USB endpoint 11 Request */ + #define DRCMR36 __REG(0x40000190) /* Request to Channel Map Register for USB endpoint 12 Request */ + #define DRCMR37 __REG(0x40000194) /* Request to Channel Map Register for USB endpoint 13 Request */ +@@ -163,12 +163,16 @@ + #define DRCMRTXPCDR DRCMR12 + #define DRCMRRXSSDR DRCMR13 + #define DRCMRTXSSDR DRCMR14 ++#define DRCMRRXNSSPDR DRCMR15 ++#define DRCMRTXNSSPDR DRCMR16 + #define DRCMRRXICDR DRCMR17 + #define DRCMRTXICDR DRCMR18 + #define DRCMRRXSTRBR DRCMR19 + #define DRCMRTXSTTHR DRCMR20 + #define DRCMRRXMMC DRCMR21 + #define DRCMRTXMMC DRCMR22 ++#define DRCMRRXASSPDR DRCMR23 ++#define DRCMRTXASSPDR DRCMR24 + + #define DRCMR_MAPVLD (1 << 7) /* Map Valid (read / write) */ + #define DRCMR_CHLNUM 0x0f /* mask for Channel Number (read / write) */ +@@ -303,6 +307,22 @@ + #define BTDLL __REG(0x40200000) /* Divisor Latch Low Register (DLAB = 1) (read/write) */ + #define BTDLH __REG(0x40200004) /* Divisor Latch High Register (DLAB = 1) (read/write) */ + ++/* Hardware UART (HWUART) */ ++#define HWUART HWRBR ++#define HWRBR __REG(0x41600000) /* Receive Buffer Register (read only) */ ++#define HWTHR __REG(0x41600000) /* Transmit Holding Register (write only) */ ++#define HWIER __REG(0x41600004) /* Interrupt Enable Register (read/write) */ ++#define HWIIR __REG(0x41600008) /* Interrupt ID Register (read only) */ ++#define HWFCR __REG(0x41600008) /* FIFO Control Register (write only) */ ++#define HWLCR __REG(0x4160000C) /* Line Control Register (read/write) */ ++#define HWMCR __REG(0x41600010) /* Modem Control Register (read/write) */ ++#define HWLSR __REG(0x41600014) /* Line Status Register (read only) */ ++#define HWMSR __REG(0x41600018) /* Reserved */ ++#define HWSPR __REG(0x4160001C) /* Scratch Pad Register (read/write) */ ++#define HWISR __REG(0x41600020) /* Infrared Selection Register (read/write) */ ++#define HWDLL __REG(0x41600000) /* Divisor Latch Low Register (DLAB = 1) (read/write) */ ++#define HWDLH __REG(0x41600004) /* Divisor Latch High Register (DLAB = 1) (read/write) */ ++ + /* Standard UART (STUART) */ + #define STUART STRBR + #define STRBR __REG(0x40700000) /* Receive Buffer Register (read only) */ +@@ -1078,6 +1098,111 @@ + + + /* ++ * NSSP Serial Port Registers (Network SSP) ++ */ ++ ++#define NSSCR0 __REG(0x41400000) /* NSSP Control Register 0 */ ++#define NSSCR1 __REG(0x41400004) /* NSSP Control Register 1 */ ++#define NSSSR __REG(0x41400008) /* NSSP Status Register */ ++#define NSSITR __REG(0x4140000C) /* NSSP Interrupt Test Register */ ++#define NSSDR __REG(0x41400010) /* (Write / Read) NSSP Data Write Register/NSSP Data Read Register */ ++#define NSSTO __REG(0x41400028) /* NSSP Time Out Register */ ++#define NSSPSP __REG(0x4140002C) /* NSSP Programable Serial Port Register*/ ++ ++ ++/* ++ * ASSP Serial Port Registers (Audio SSP) ++ */ ++ ++#define ASSCR0 __REG(0x41500000) /* ASSP Control Register 0 */ ++#define ASSCR1 __REG(0x41500004) /* ASSP Control Register 1 */ ++#define ASSSR __REG(0x41500008) /* ASSP Status Register */ ++#define ASSITR __REG(0x4150000C) /* ASSP Interrupt Test Register */ ++#define ASSDR __REG(0x41500010) /* (Write / Read) ASSP Data Write Register/ASSP Data Read Register */ ++#define ASSTO __REG(0x41500028) /* ASSP Time Out Register */ ++#define ASSPSP __REG(0x4150002C) /* ASSP Programable Serial Port Register*/ ++ ++ ++/* ++ * Bit definitions for SSP, NSSP and ASSP registers ++ * - note that some bits are only available on the NSSP and ASSP ++ */ ++ ++#define SSCR0_EDSS (1 << 20) /* ext. data size select */ ++#define SSCR0_SCR_MASK 0x000fff00 /* [19:8] secrial clock rate */ ++#define SSCR0_SCR(x) (((x)<<8) & XSSCR0_SCR_MASK) ++#define SSCR0_SSE (1 << 7) /* sync ser port enable */ ++#define SSCR0_FRF_MASK 0x00000030 /* [5:4] frame format */ ++#define SSCR0_FRF(x) (((x)<<4) & XSSCR0_FRF_MASK) ++#define SSCR0_FRF_SPI 0x00000000 /* ser peripheral i/f */ ++#define SSCR0_FRF_TISSP 0x00000010 /* TI sync ser port */ ++#define SSCR0_FRF_MICROWAVE 0x00000020 /* microwire */ ++#define SSCR0_FRF_PSP 0x00000030 /* prog ser protocol */ ++#define SSCR0_DSS_MASK 0x0000000f /* data size select */ ++#define SSCR0_DSS(x) ((x) & XSSCR0_DSS_MASK) ++ ++#define SSCR1_TTELP (1 << 31) /* tx hi-z later phase */ ++#define SSCR1_TTE (1 << 30) /* tx hi-z enable */ ++#define SSCR1_EBCEI (1 << 29) /* bit count error int mask */ ++#define SSCR1_SCFR (1 << 28) /* slave clock free running */ ++#define SSCR1_SCLKDIR (1 << 25) /* ssp clock direction */ ++#define SSCR1_SFRMDIR (1 << 24) /* ssp frame direction */ ++#define SSCR1_RWOT (1 << 23) /* rx without transmit */ ++#define SSCR1_TSRE (1 << 21) /* tx req enable */ ++#define SSCR1_RSRE (1 << 20) /* rx req enable */ ++#define SSCR1_TINTE (1 << 19) /* timeout int enable */ ++#define SSCR1_STRF (1 << 15) /* select fifo for efwr */ ++#define SSCR1_EFWR (1 << 14) /* fifo write/read enable */ ++#define SSCR1_RFT_MASK 0x00003c00 /* [13:10] rx fifo threshold */ ++#define SSCR1_RFT(x) (((x)<<10) & XSSCR1_RFT_MASK) ++#define SSCR1_TFT_MASK 0x000003c0 /* [9:6] tx fifo threshold */ ++#define SSCR1_TFT(x) (((x)<<6) & XSSCR1_TFT_MASK) ++#define SSCR1_MWDS (1 << 5) /* microwire tx data size */ ++#define SSCR1_SPH (1 << 4) /* SPI SSPSCLK phase */ ++#define SSCR1_SPO (1 << 3) /* motorolla SPI polarity */ ++#define SSCR1_LBM (1 << 2) /* loop-back mode */ ++#define SSCR1_TIE (1 << 1) /* tx fifo int enable */ ++#define SSCR1_RIE (1 << 0) /* rx fifo int enable */ ++ ++#define SSPSP_DMYSTOP_MASK 0x01800000 /* [24:23] dummy stop */ ++#define SSPSP_DMYSTOP(x) (((x)<<23) & XSSPSP_DMYSTOP_MASK) ++#define SSPSP_SFRMWDTH_MASK 0x007f0000 /* [22:16] serial frame width */ ++#define SSPSP_SFRMWDTH(x) (((x)<<16) & XSSPSP_SFRMWDTH_MASK) ++#define SSPSP_SFRMDLY_MASK 0x0000fe00 /* [15:9] serial frame delay */ ++#define SSPSP_SFRMDLY(x) (((x)<<9) & XSSPSP_SFRMDLY_MASK) ++#define SSPSP_DMYSTRT_MASK 0x00000180 /* [8:7] dummy start */ ++#define SSPSP_DMYSTRT(x) (((x)<<7) & XSSPSP_DMYSTRT_MASK) ++#define SSPSP_STRTDLY_MASK 0x00000070 /* [6:4] three-bit start delay */ ++#define SSPSP_STRTDLY(x) (((x)<<4) & XSSPSP_STRTDLY_MASK) ++#define SSPSP_ETDS (1 << 3) /* end of tx data state */ ++#define SSPSP_SFRMP (1 << 2) /* serial frame polarity */ ++#define SSPSP_SCMODE_MASK 0x00000003 /* bit-rate clock mode */ ++#define SSPSP_SCMODE(x) ((x) & XSSPSP_SCMODE_MASK) ++ ++#define SSTO_TIMEOUT_MASK 0x00ffffff /* [23:0] timeout */ ++#define SSTO_TIMEOUT(x) ((x) & XSSTO_TIMEOUT_MASK) ++ ++#define SSITR_TROR (1 << 7) /* test rx fifo overrun */ ++#define SSITR_TRFS (1 << 6) /* test rx fifo serv req */ ++#define SSITR_TTFS (1 << 5) /* test tx fifo serv req */ ++ ++#define SSSR_BCE (1 << 23) /* bit count error */ ++#define SSSR_CSS (1 << 22) /* clock sync stat */ ++#define SSSR_TUR (1 << 21) /* tx fifo underrun */ ++#define SSSR_TINT (1 << 19) /* rx timeout int */ ++#define SSSR_RFL_MASK 0x0000f000 /* rx fifo level */ ++#define SSSR_RFL(x) (((x)<<16) & XSSSR_RFL_MASK) ++#define SSSR_TFL_MASK 0x00000f00 /* tx fifo level */ ++#define SSSR_TFL(x) (((x)<<8) & XSSSR_TFL_MASK) ++#define SSSR_ROR (1 << 7) /* rx fifo overrun */ ++#define SSSR_RFS (1 << 6) /* rx fifo serv request */ ++#define SSSR_TFS (1 << 5) /* tx fifo serv req */ ++#define SSSR_BSY (1 << 4) /* SSP busy */ ++#define SSSR_RNE (1 << 3) /* rx fifo not empty */ ++#define SSSR_TNF (1 << 2) /* tx fifo not full */ ++ ++ ++/* + * MultiMediaCard (MMC) controller + */ + +@@ -1122,6 +1247,7 @@ + #define CKEN7_BTUART (1 << 7) /* BTUART Unit Clock Enable */ + #define CKEN6_FFUART (1 << 6) /* FFUART Unit Clock Enable */ + #define CKEN5_STUART (1 << 5) /* STUART Unit Clock Enable */ ++#define CKEN4_HWUART (1 << 4) /* HWUART Unit Clock Enable */ + #define CKEN3_SSP (1 << 3) /* SSP Unit Clock Enable */ + #define CKEN2_AC97 (1 << 2) /* AC97 Unit Clock Enable */ + #define CKEN1_PWM1 (1 << 1) /* PWM1 Clock Enable */ +--- linux-2.6.5/include/asm-arm/page.h~heh 2004-04-03 22:36:25.000000000 -0500 ++++ linux-2.6.5/include/asm-arm/page.h 2004-04-30 20:57:36.000000000 -0400 +@@ -92,6 +92,14 @@ + # endif + #endif + ++#ifdef CONFIG_CPU_COPY_V6 ++# ifdef _USER ++# define MULTI_USER 1 ++# else ++# define _USER v6 ++# endif ++#endif ++ + #ifndef _USER + #error Unknown user operations model + #endif +--- linux-2.6.5/include/asm-arm/thread_info.h~heh 2004-04-03 22:37:06.000000000 -0500 ++++ linux-2.6.5/include/asm-arm/thread_info.h 2004-04-30 20:57:36.000000000 -0400 +@@ -108,8 +108,8 @@ + #define TI_CPU 20 + #define TI_CPU_DOMAIN 24 + #define TI_CPU_SAVE 28 +-#define TI_USED_MATH 76 +-#define TI_FPSTATE (TI_USED_MATH+16) ++#define TI_USED_CP 76 ++#define TI_FPSTATE (TI_USED_CP+16) + + #endif + +--- /dev/null 2003-09-23 18:19:32.000000000 -0400 ++++ linux-2.6.5/include/asm-arm/rtc.h 2004-04-30 20:57:36.000000000 -0400 +@@ -0,0 +1,45 @@ ++/* ++ * linux/include/asm-arm/rtc.h ++ * ++ * Copyright (C) 2003 Deep Blue Solutions Ltd. ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License version 2 as ++ * published by the Free Software Foundation. ++ */ ++#ifndef ASMARM_RTC_H ++#define ASMARM_RTC_H ++ ++struct module; ++ ++struct rtc_ops { ++ struct module *owner; ++ int (*open)(void); ++ void (*release)(void); ++ int (*ioctl)(unsigned int, unsigned long); ++ ++ void (*read_time)(struct rtc_time *); ++ int (*set_time)(struct rtc_time *); ++ void (*read_alarm)(struct rtc_wkalrm *); ++ int (*set_alarm)(struct rtc_wkalrm *); ++ int (*proc)(char *buf); ++}; ++ ++void rtc_time_to_tm(unsigned long, struct rtc_time *); ++int rtc_tm_to_time(struct rtc_time *, unsigned long *); ++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 *); ++void unregister_rtc(struct rtc_ops *); ++ ++static inline int rtc_periodic_alarm(struct rtc_time *tm) ++{ ++ return (tm->tm_year == -1) || ++ ((unsigned)tm->tm_mon >= 12) || ++ ((unsigned)(tm->tm_mday - 1) >= 31) || ++ ((unsigned)tm->tm_hour > 23) || ++ ((unsigned)tm->tm_min > 59) || ++ ((unsigned)tm->tm_sec > 59); ++} ++ ++#endif +--- linux-2.6.5/include/linux/serial.h~heh 2004-04-03 22:36:26.000000000 -0500 ++++ linux-2.6.5/include/linux/serial.h 2004-04-30 20:57:36.000000000 -0400 +@@ -81,17 +81,6 @@ + #define SERIAL_IO_HUB6 1 + #define SERIAL_IO_MEM 2 + +-struct serial_uart_config { +- char *name; +- int dfl_xmit_fifo_size; +- int flags; +-}; +- +-#define UART_CLEAR_FIFO 0x01 +-#define UART_USE_FIFO 0x02 +-#define UART_STARTECH 0x04 +-#define UART_NATSEMI 0x08 +- + /* + * Definitions for async_struct (and serial_struct) flags field + */ +--- /dev/null 2003-09-23 18:19:32.000000000 -0400 ++++ linux-2.6.5/include/linux/i2c-pxa.h 2004-04-30 20:57:36.000000000 -0400 +@@ -0,0 +1,76 @@ ++/* ++ * i2c_pxa.h ++ * ++ * Copyright (C) 2002 Intrinsyc Software Inc. ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License version 2 as ++ * published by the Free Software Foundation. ++ * ++ */ ++#ifndef _I2C_PXA_H_ ++#define _I2C_PXA_H_ ++ ++struct i2c_algo_pxa_data ++{ ++ void (*write_byte) (u8 value); ++ u8 (*read_byte) (void); ++ void (*start) (void); ++ void (*repeat_start) (void); ++ void (*stop) (void); ++ void (*abort) (void); ++ int (*wait_bus_not_busy) (void); ++ int (*wait_for_interrupt) (int wait_type); ++ void (*transfer) (int lastbyte, int receive, int midbyte); ++ void (*reset) (void); ++ ++ int udelay; ++ int timeout; ++}; ++ ++#define DEF_TIMEOUT 3 ++#define BUS_ERROR (-EREMOTEIO) ++#define ACK_DELAY 0 /* time to delay before checking bus error */ ++#define MAX_MESSAGES 65536 /* maximum number of messages to send */ ++ ++#define I2C_SLEEP_TIMEOUT 2 /* time to sleep for on i2c transactions */ ++#define I2C_RETRY (-2000) /* an error has occurred retry transmit */ ++#define I2C_TRANSMIT 1 ++#define I2C_RECEIVE 0 ++#define I2C_PXA_SLAVE_ADDR 0x1 /* slave pxa unit address */ ++#define I2C_ICR_INIT (ICR_BEIE | ICR_IRFIE | ICR_ITEIE | ICR_GCD | ICR_SCLE) /* ICR initialization value */ ++/* ICR initialize bit values ++* ++* 15. FM 0 (100 Khz operation) ++* 14. UR 0 (No unit reset) ++* 13. SADIE 0 (Disables the unit from interrupting on slave addresses ++* matching its slave address) ++* 12. ALDIE 0 (Disables the unit from interrupt when it loses arbitration ++* in master mode) ++* 11. SSDIE 0 (Disables interrupts from a slave stop detected, in slave mode) ++* 10. BEIE 1 (Enable interrupts from detected bus errors, no ACK sent) ++* 9. IRFIE 1 (Enable interrupts from full buffer received) ++* 8. ITEIE 1 (Enables the I2C unit to interrupt when transmit buffer empty) ++* 7. GCD 1 (Disables i2c unit response to general call messages as a slave) ++* 6. IUE 0 (Disable unit until we change settings) ++* 5. SCLE 1 (Enables the i2c clock output for master mode (drives SCL) ++* 4. MA 0 (Only send stop with the ICR stop bit) ++* 3. TB 0 (We are not transmitting a byte initially) ++* 2. ACKNAK 0 (Send an ACK after the unit receives a byte) ++* 1. STOP 0 (Do not send a STOP) ++* 0. START 0 (Do not send a START) ++* ++*/ ++ ++#define I2C_ISR_INIT 0x7FF /* status register init */ ++/* I2C status register init values ++ * ++ * 10. BED 1 (Clear bus error detected) ++ * 9. SAD 1 (Clear slave address detected) ++ * 7. IRF 1 (Clear IDBR Receive Full) ++ * 6. ITE 1 (Clear IDBR Transmit Empty) ++ * 5. ALD 1 (Clear Arbitration Loss Detected) ++ * 4. SSD 1 (Clear Slave Stop Detected) ++ */ ++ ++#endif +--- linux-2.6.5/include/linux/ioport.h~heh 2004-04-03 22:36:26.000000000 -0500 ++++ linux-2.6.5/include/linux/ioport.h 2004-04-30 20:57:36.000000000 -0400 +@@ -99,6 +99,7 @@ + void (*alignf)(void *, struct resource *, + unsigned long, unsigned long), + void *alignf_data); ++extern int reallocate_resource(struct resource *res, unsigned long start, unsigned long size); + int adjust_resource(struct resource *res, unsigned long start, + unsigned long size); + +--- /dev/null 2003-09-23 18:19:32.000000000 -0400 ++++ linux-2.6.5/include/linux/switches.h 2004-04-30 20:57:36.000000000 -0400 +@@ -0,0 +1,74 @@ ++/* ++ * linux/include/linux/switches.h ++ * ++ * Copyright (C) 2000 John Dorsey ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License version 2 as ++ * published by the Free Software Foundation. ++ * ++ * 23 October 2000 - created. ++ */ ++ ++#if !defined(_LINUX_SWITCHES_H) ++#define _LINUX_SWITCHES_H ++ ++#define SWITCHES_MASK_SIZE (128) ++ ++typedef unsigned long switches_bitfield; ++ ++#define SWITCHES_BITS (sizeof(switches_bitfield) * 8) ++#define SWITCHES_NUM_FIELDS (SWITCHES_MASK_SIZE / SWITCHES_BITS) ++#define SWITCHES_FIELD_SELECT(i) ((i) / SWITCHES_BITS) ++#define SWITCHES_FIELD_MASK(i) ((switches_bitfield)(1 << (i) % \ ++ SWITCHES_BITS)) ++ ++typedef struct switches_mask_t { ++ unsigned int count; ++ switches_bitfield events[SWITCHES_NUM_FIELDS]; ++ switches_bitfield states[SWITCHES_NUM_FIELDS]; ++} switches_mask_t; ++ ++#define SWITCHES_ZERO(m) \ ++do { \ ++ unsigned int sz_i; \ ++ (m)->count = 0; \ ++ for(sz_i = 0; sz_i < SWITCHES_NUM_FIELDS; ++sz_i) \ ++ (m)->events[sz_i] = (m)->states[sz_i] = 0; \ ++} while (0) ++ ++/* `s' is the state of the switch, either 0 or non-zero: */ ++#define SWITCHES_SET(m, i, s) \ ++do { \ ++ ((m)->events[SWITCHES_FIELD_SELECT((i))] |= \ ++ SWITCHES_FIELD_MASK((i))); \ ++ if(s) \ ++ ((m)->states[SWITCHES_FIELD_SELECT((i))] |= \ ++ SWITCHES_FIELD_MASK((i))); \ ++ else \ ++ ((m)->states[SWITCHES_FIELD_SELECT((i))] &= \ ++ ~SWITCHES_FIELD_MASK((i))); \ ++ ++((m)->count); \ ++} while (0) ++ ++/* Should only use to clear an event set by SWITCHES_SET(): */ ++#define SWITCHES_CLEAR(m, i) \ ++do { \ ++ ((m)->events[SWITCHES_FIELD_SELECT((i))] &= \ ++ ~SWITCHES_FIELD_MASK((i))); \ ++ ((m)->states[SWITCHES_FIELD_SELECT((i))] &= \ ++ ~SWITCHES_FIELD_MASK((i))); \ ++ --((m)->count); \ ++} ++ ++#define SWITCHES_COUNT(m) ((m)->count) ++ ++/* Returns 0 or non-zero: */ ++#define SWITCHES_EVENT(m, i) \ ++((m)->events[SWITCHES_FIELD_SELECT((i))] & SWITCHES_FIELD_MASK((i))) ++ ++/* Returns 0 or non-zero: */ ++#define SWITCHES_STATE(m, i) \ ++((m)->states[SWITCHES_FIELD_SELECT((i))] & SWITCHES_FIELD_MASK((i))) ++ ++#endif /* !defined(_LINUX_SWITCHES_H) */ +--- linux-2.6.5/include/linux/serial_reg.h~heh 2004-04-03 22:37:38.000000000 -0500 ++++ linux-2.6.5/include/linux/serial_reg.h 2004-04-30 20:57:36.000000000 -0400 +@@ -121,6 +121,7 @@ + /* + * These are the definitions for the Modem Control Register + */ ++#define UART_MCR_AFE 0x20 /* Enable auto-RTS/CTS (TI16C750) */ + #define UART_MCR_LOOP 0x10 /* Enable loopback test mode */ + #define UART_MCR_OUT2 0x08 /* Out2 complement */ + #define UART_MCR_OUT1 0x04 /* Out1 complement */ +@@ -156,6 +157,21 @@ + #define UART_FCR_PXAR32 0xc0 /* receive FIFO treshold = 32 */ + + /* ++ * The Intel PXA2xx chip defines those bits ++ */ ++#define UART_IER_DMAE 0x80 /* DMA Requests Enable */ ++#define UART_IER_UUE 0x40 /* UART Unit Enable */ ++#define UART_IER_NRZE 0x20 /* NRZ coding Enable */ ++#define UART_IER_RTOIE 0x10 /* Receiver Time Out Interrupt Enable */ ++ ++#define UART_IIR_TOD 0x08 /* Character Timeout Indication Detected */ ++ ++#define UART_FCR_PXAR1 0x00 /* receive FIFO treshold = 1 */ ++#define UART_FCR_PXAR8 0x40 /* receive FIFO treshold = 8 */ ++#define UART_FCR_PXAR16 0x80 /* receive FIFO treshold = 16 */ ++#define UART_FCR_PXAR32 0xc0 /* receive FIFO treshold = 32 */ ++ ++/* + * These are the definitions for the Extended Features Register + * (StarTech 16C660 only, when DLAB=1) + */ +--- /dev/null 2003-09-23 18:19:32.000000000 -0400 ++++ linux-2.6.5/include/linux/mmc/card.h 2004-04-30 20:57:36.000000000 -0400 +@@ -0,0 +1,83 @@ ++/* ++ * linux/include/linux/mmc/card.h ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License version 2 as ++ * published by the Free Software Foundation. ++ * ++ * Card driver specific definitions. ++ */ ++#ifndef LINUX_MMC_CARD_H ++#define LINUX_MMC_CARD_H ++ ++#include <linux/mmc/mmc.h> ++ ++struct mmc_cid { ++ unsigned int manfid; ++ unsigned int serial; ++ char prod_name[8]; ++ unsigned char hwrev; ++ unsigned char fwrev; ++ unsigned char month; ++ unsigned char year; ++}; ++ ++struct mmc_csd { ++ unsigned char mmc_prot; ++ unsigned short cmdclass; ++ unsigned short tacc_clks; ++ unsigned int tacc_ns; ++ unsigned int max_dtr; ++ unsigned int read_blkbits; ++ unsigned int capacity; ++}; ++ ++struct mmc_host; ++ ++/* ++ * MMC device ++ */ ++struct mmc_card { ++ struct list_head node; /* node in hosts devices list */ ++ struct mmc_host *host; /* the host this device belongs to */ ++ struct device dev; /* the device */ ++ unsigned int rca; /* relative card address of device */ ++ unsigned int state; /* (our) card state */ ++#define MMC_STATE_PRESENT (1<<0) ++#define MMC_STATE_DEAD (1<<1) ++ struct mmc_cid cid; /* card identification */ ++ struct mmc_csd csd; /* card specific */ ++}; ++ ++#define mmc_card_dead(c) ((c)->state & MMC_STATE_DEAD) ++#define mmc_card_present(c) ((c)->state & MMC_STATE_PRESENT) ++ ++#define mmc_card_name(c) ((c)->cid.prod_name) ++#define mmc_card_id(c) ((c)->dev.bus_id) ++ ++#define mmc_list_to_card(l) container_of(l, struct mmc_card, node) ++#define mmc_get_drvdata(c) dev_get_drvdata(&(c)->dev) ++#define mmc_set_drvdata(c,d) dev_set_drvdata(&(c)->dev, d) ++ ++/* ++ * MMC device driver (e.g., Flash card, I/O card...) ++ */ ++struct mmc_driver { ++ struct device_driver drv; ++ int (*probe)(struct mmc_card *); ++ void (*remove)(struct mmc_card *); ++ int (*suspend)(struct mmc_card *, u32); ++ int (*resume)(struct mmc_card *); ++}; ++ ++extern int mmc_register_driver(struct mmc_driver *); ++extern void mmc_unregister_driver(struct mmc_driver *); ++ ++static inline int mmc_card_claim_host(struct mmc_card *card) ++{ ++ return __mmc_claim_host(card->host, card); ++} ++ ++#define mmc_card_release_host(c) mmc_release_host((c)->host) ++ ++#endif +--- /dev/null 2003-09-23 18:19:32.000000000 -0400 ++++ linux-2.6.5/include/linux/mmc/mmc.h 2004-04-30 20:57:36.000000000 -0400 +@@ -0,0 +1,88 @@ ++/* ++ * linux/include/linux/mmc/mmc.h ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License version 2 as ++ * published by the Free Software Foundation. ++ */ ++#ifndef MMC_H ++#define MMC_H ++ ++#include <linux/list.h> ++#include <linux/interrupt.h> ++#include <linux/device.h> ++ ++struct request; ++struct mmc_data; ++struct mmc_request; ++ ++struct mmc_command { ++ u32 opcode; ++ u32 arg; ++ u32 resp[4]; ++ unsigned int flags; /* expected response type */ ++#define MMC_RSP_NONE (0 << 0) ++#define MMC_RSP_SHORT (1 << 0) ++#define MMC_RSP_LONG (2 << 0) ++#define MMC_RSP_MASK (3 << 0) ++#define MMC_RSP_CRC (1 << 3) /* expect valid crc */ ++#define MMC_RSP_BUSY (1 << 4) /* card may send busy */ ++ ++ unsigned int retries; /* max number of retries */ ++ unsigned int error; /* command error */ ++ ++#define MMC_ERR_NONE 0 ++#define MMC_ERR_TIMEOUT 1 ++#define MMC_ERR_BADCRC 2 ++#define MMC_ERR_FIFO 3 ++#define MMC_ERR_FAILED 4 ++#define MMC_ERR_INVALID 5 ++ ++ struct mmc_data *data; /* data segment associated with cmd */ ++ struct mmc_request *req; /* assoicated request */ ++}; ++ ++struct mmc_data { ++ unsigned int timeout_ns; /* data timeout (in ns, max 80ms) */ ++ unsigned int timeout_clks; /* data timeout (in clocks) */ ++ unsigned int blksz_bits; /* data block size */ ++ unsigned int blocks; /* number of blocks */ ++ struct request *rq; /* request structure */ ++ unsigned int error; /* data error */ ++ unsigned int flags; ++ ++#define MMC_DATA_WRITE (1 << 8) ++#define MMC_DATA_READ (1 << 9) ++#define MMC_DATA_STREAM (1 << 10) ++ ++ unsigned int bytes_xfered; ++ ++ struct mmc_command *stop; /* stop command */ ++ struct mmc_request *req; /* assoicated request */ ++}; ++ ++struct mmc_request { ++ struct mmc_command *cmd; ++ struct mmc_data *data; ++ struct mmc_command *stop; ++ ++ void *done_data; /* completion data */ ++ void (*done)(struct mmc_request *);/* completion function */ ++}; ++ ++struct mmc_host; ++struct mmc_card; ++ ++extern int mmc_wait_for_req(struct mmc_host *, struct mmc_request *); ++extern int mmc_wait_for_cmd(struct mmc_host *, struct mmc_command *, int); ++ ++extern int __mmc_claim_host(struct mmc_host *host, struct mmc_card *card); ++ ++static inline void mmc_claim_host(struct mmc_host *host) ++{ ++ __mmc_claim_host(host, (struct mmc_card *)-1); ++} ++ ++extern void mmc_release_host(struct mmc_host *host); ++ ++#endif +--- /dev/null 2003-09-23 18:19:32.000000000 -0400 ++++ linux-2.6.5/include/linux/mmc/host.h 2004-04-30 20:57:36.000000000 -0400 +@@ -0,0 +1,67 @@ ++/* ++ * linux/include/linux/mmc/host.h ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License version 2 as ++ * published by the Free Software Foundation. ++ * ++ * Host driver specific definitions. ++ */ ++#ifndef LINUX_MMC_HOST_H ++#define LINUX_MMC_HOST_H ++ ++#include <linux/mmc/mmc.h> ++ ++struct mmc_ios { ++ unsigned int clock; /* clock rate */ ++ unsigned short vdd; /* supply (units of 10mV) */ ++ unsigned char bus_mode; /* command output mode */ ++ ++#define MMC_BUSMODE_OPENDRAIN 1 ++#define MMC_BUSMODE_PUSHPULL 2 ++ ++ unsigned char power_mode; /* power supply mode */ ++ ++#define MMC_POWER_OFF 0 ++#define MMC_POWER_UP 1 ++#define MMC_POWER_ON 2 ++}; ++ ++struct mmc_host_ops { ++ void (*request)(struct mmc_host *host, struct mmc_request *req); ++ void (*set_ios)(struct mmc_host *host, struct mmc_ios *ios); ++}; ++ ++struct mmc_card; ++ ++struct mmc_host { ++ struct device *dev; ++ struct mmc_host_ops *ops; ++ unsigned int f_min; ++ unsigned int f_max; ++ u32 ocr_avail; ++ ++ /* private data */ ++ unsigned int host_num; /* host number */ ++ struct mmc_ios ios; /* current io bus settings */ ++ u32 ocr; /* the current OCR setting */ ++ ++ struct list_head cards; /* devices attached to this host */ ++ ++ wait_queue_head_t wq; ++ spinlock_t lock; /* card_busy lock */ ++ struct mmc_card *card_busy; /* the MMC card claiming host */ ++ struct mmc_card *card_selected; /* the selected MMC card */ ++}; ++ ++extern int mmc_init_host(struct mmc_host *); ++extern int mmc_add_host(struct mmc_host *); ++extern void mmc_remove_host(struct mmc_host *); ++extern int mmc_suspend_host(struct mmc_host *, u32); ++extern int mmc_resume_host(struct mmc_host *); ++ ++extern void mmc_detect_change(struct mmc_host *); ++extern void mmc_request_done(struct mmc_host *, struct mmc_request *); ++ ++#endif ++ +--- /dev/null 2003-09-23 18:19:32.000000000 -0400 ++++ linux-2.6.5/include/linux/mmc/protocol.h 2004-04-30 20:57:36.000000000 -0400 +@@ -0,0 +1,203 @@ ++/* ++ * Header for MultiMediaCard (MMC) ++ * ++ * Copyright 2002 Hewlett-Packard Company ++ * ++ * Use consistent with the GNU GPL is permitted, ++ * provided that this copyright notice is ++ * preserved in its entirety in all copies and derived works. ++ * ++ * HEWLETT-PACKARD COMPANY MAKES NO WARRANTIES, EXPRESSED OR IMPLIED, ++ * AS TO THE USEFULNESS OR CORRECTNESS OF THIS CODE OR ITS ++ * FITNESS FOR ANY PARTICULAR PURPOSE. ++ * ++ * Many thanks to Alessandro Rubini and Jonathan Corbet! ++ * ++ * Based strongly on code by: ++ * ++ * Author: Yong-iL Joh <tolkien@mizi.com> ++ * Date : $Date: 2002/06/18 12:37:30 $ ++ * ++ * Author: Andrew Christian ++ * 15 May 2002 ++ */ ++ ++#ifndef MMC_MMC_PROTOCOL_H ++#define MMC_MMC_PROTOCOL_H ++ ++/* Standard MMC commands (3.1) type argument response */ ++ /* class 1 */ ++#define MMC_GO_IDLE_STATE 0 /* bc */ ++#define MMC_SEND_OP_COND 1 /* bcr [31:0] OCR R3 */ ++#define MMC_ALL_SEND_CID 2 /* bcr R2 */ ++#define MMC_SET_RELATIVE_ADDR 3 /* ac [31:16] RCA R1 */ ++#define MMC_SET_DSR 4 /* bc [31:16] RCA */ ++#define MMC_SELECT_CARD 7 /* ac [31:16] RCA R1 */ ++#define MMC_SEND_CSD 9 /* ac [31:16] RCA R2 */ ++#define MMC_SEND_CID 10 /* ac [31:16] RCA R2 */ ++#define MMC_READ_DAT_UNTIL_STOP 11 /* adtc [31:0] dadr R1 */ ++#define MMC_STOP_TRANSMISSION 12 /* ac R1b */ ++#define MMC_SEND_STATUS 13 /* ac [31:16] RCA R1 */ ++#define MMC_GO_INACTIVE_STATE 15 /* ac [31:16] RCA */ ++ ++ /* class 2 */ ++#define MMC_SET_BLOCKLEN 16 /* ac [31:0] block len R1 */ ++#define MMC_READ_SINGLE_BLOCK 17 /* adtc [31:0] data addr R1 */ ++#define MMC_READ_MULTIPLE_BLOCK 18 /* adtc [31:0] data addr R1 */ ++ ++ /* class 3 */ ++#define MMC_WRITE_DAT_UNTIL_STOP 20 /* adtc [31:0] data addr R1 */ ++ ++ /* class 4 */ ++#define MMC_SET_BLOCK_COUNT 23 /* adtc [31:0] data addr R1 */ ++#define MMC_WRITE_BLOCK 24 /* adtc [31:0] data addr R1 */ ++#define MMC_WRITE_MULTIPLE_BLOCK 25 /* adtc R1 */ ++#define MMC_PROGRAM_CID 26 /* adtc R1 */ ++#define MMC_PROGRAM_CSD 27 /* adtc R1 */ ++ ++ /* class 6 */ ++#define MMC_SET_WRITE_PROT 28 /* ac [31:0] data addr R1b */ ++#define MMC_CLR_WRITE_PROT 29 /* ac [31:0] data addr R1b */ ++#define MMC_SEND_WRITE_PROT 30 /* adtc [31:0] wpdata addr R1 */ ++ ++ /* class 5 */ ++#define MMC_ERASE_GROUP_START 35 /* ac [31:0] data addr R1 */ ++#define MMC_ERASE_GROUP_END 36 /* ac [31:0] data addr R1 */ ++#define MMC_ERASE 37 /* ac R1b */ ++ ++ /* class 9 */ ++#define MMC_FAST_IO 39 /* ac <Complex> R4 */ ++#define MMC_GO_IRQ_STATE 40 /* bcr R5 */ ++ ++ /* class 7 */ ++#define MMC_LOCK_UNLOCK 42 /* adtc R1b */ ++ ++ /* class 8 */ ++#define MMC_APP_CMD 55 /* ac [31:16] RCA R1 */ ++#define MMC_GEN_CMD 56 /* adtc [0] RD/WR R1b */ ++ ++/* ++ MMC status in R1 ++ Type ++ e : error bit ++ s : status bit ++ r : detected and set for the actual command response ++ x : detected and set during command execution. the host must poll ++ the card by sending status command in order to read these bits. ++ Clear condition ++ a : according to the card state ++ b : always related to the previous command. Reception of ++ a valid command will clear it (with a delay of one command) ++ c : clear by read ++ */ ++ ++#define R1_OUT_OF_RANGE (1 << 31) /* er, c */ ++#define R1_ADDRESS_ERROR (1 << 30) /* erx, c */ ++#define R1_BLOCK_LEN_ERROR (1 << 29) /* er, c */ ++#define R1_ERASE_SEQ_ERROR (1 << 28) /* er, c */ ++#define R1_ERASE_PARAM (1 << 27) /* ex, c */ ++#define R1_WP_VIOLATION (1 << 26) /* erx, c */ ++#define R1_CARD_IS_LOCKED (1 << 25) /* sx, a */ ++#define R1_LOCK_UNLOCK_FAILED (1 << 24) /* erx, c */ ++#define R1_COM_CRC_ERROR (1 << 23) /* er, b */ ++#define R1_ILLEGAL_COMMAND (1 << 22) /* er, b */ ++#define R1_CARD_ECC_FAILED (1 << 21) /* ex, c */ ++#define R1_CC_ERROR (1 << 20) /* erx, c */ ++#define R1_ERROR (1 << 19) /* erx, c */ ++#define R1_UNDERRUN (1 << 18) /* ex, c */ ++#define R1_OVERRUN (1 << 17) /* ex, c */ ++#define R1_CID_CSD_OVERWRITE (1 << 16) /* erx, c, CID/CSD overwrite */ ++#define R1_WP_ERASE_SKIP (1 << 15) /* sx, c */ ++#define R1_CARD_ECC_DISABLED (1 << 14) /* sx, a */ ++#define R1_ERASE_RESET (1 << 13) /* sr, c */ ++#define R1_STATUS(x) (x & 0xFFFFE000) ++#define R1_CURRENT_STATE(x) ((x & 0x00001E00) >> 9) /* sx, b (4 bits) */ ++#define R1_READY_FOR_DATA (1 << 8) /* sx, a */ ++#define R1_APP_CMD (1 << 7) /* sr, c */ ++ ++/* These are unpacked versions of the actual responses */ ++ ++struct _mmc_csd { ++ u8 csd_structure; ++ u8 spec_vers; ++ u8 taac; ++ u8 nsac; ++ u8 tran_speed; ++ u16 ccc; ++ u8 read_bl_len; ++ u8 read_bl_partial; ++ u8 write_blk_misalign; ++ u8 read_blk_misalign; ++ u8 dsr_imp; ++ u16 c_size; ++ u8 vdd_r_curr_min; ++ u8 vdd_r_curr_max; ++ u8 vdd_w_curr_min; ++ u8 vdd_w_curr_max; ++ u8 c_size_mult; ++ union { ++ struct { /* MMC system specification version 3.1 */ ++ u8 erase_grp_size; ++ u8 erase_grp_mult; ++ } v31; ++ struct { /* MMC system specification version 2.2 */ ++ u8 sector_size; ++ u8 erase_grp_size; ++ } v22; ++ } erase; ++ u8 wp_grp_size; ++ u8 wp_grp_enable; ++ u8 default_ecc; ++ u8 r2w_factor; ++ u8 write_bl_len; ++ u8 write_bl_partial; ++ u8 file_format_grp; ++ u8 copy; ++ u8 perm_write_protect; ++ u8 tmp_write_protect; ++ u8 file_format; ++ u8 ecc; ++}; ++ ++#define MMC_VDD_145_150 0x00000001 /* VDD voltage 1.45 - 1.50 */ ++#define MMC_VDD_150_155 0x00000002 /* VDD voltage 1.50 - 1.55 */ ++#define MMC_VDD_155_160 0x00000004 /* VDD voltage 1.55 - 1.60 */ ++#define MMC_VDD_160_165 0x00000008 /* VDD voltage 1.60 - 1.65 */ ++#define MMC_VDD_165_170 0x00000010 /* VDD voltage 1.65 - 1.70 */ ++#define MMC_VDD_17_18 0x00000020 /* VDD voltage 1.7 - 1.8 */ ++#define MMC_VDD_18_19 0x00000040 /* VDD voltage 1.8 - 1.9 */ ++#define MMC_VDD_19_20 0x00000080 /* VDD voltage 1.9 - 2.0 */ ++#define MMC_VDD_20_21 0x00000100 /* VDD voltage 2.0 ~ 2.1 */ ++#define MMC_VDD_21_22 0x00000200 /* VDD voltage 2.1 ~ 2.2 */ ++#define MMC_VDD_22_23 0x00000400 /* VDD voltage 2.2 ~ 2.3 */ ++#define MMC_VDD_23_24 0x00000800 /* VDD voltage 2.3 ~ 2.4 */ ++#define MMC_VDD_24_25 0x00001000 /* VDD voltage 2.4 ~ 2.5 */ ++#define MMC_VDD_25_26 0x00002000 /* VDD voltage 2.5 ~ 2.6 */ ++#define MMC_VDD_26_27 0x00004000 /* VDD voltage 2.6 ~ 2.7 */ ++#define MMC_VDD_27_28 0x00008000 /* VDD voltage 2.7 ~ 2.8 */ ++#define MMC_VDD_28_29 0x00010000 /* VDD voltage 2.8 ~ 2.9 */ ++#define MMC_VDD_29_30 0x00020000 /* VDD voltage 2.9 ~ 3.0 */ ++#define MMC_VDD_30_31 0x00040000 /* VDD voltage 3.0 ~ 3.1 */ ++#define MMC_VDD_31_32 0x00080000 /* VDD voltage 3.1 ~ 3.2 */ ++#define MMC_VDD_32_33 0x00100000 /* VDD voltage 3.2 ~ 3.3 */ ++#define MMC_VDD_33_34 0x00200000 /* VDD voltage 3.3 ~ 3.4 */ ++#define MMC_VDD_34_35 0x00400000 /* VDD voltage 3.4 ~ 3.5 */ ++#define MMC_VDD_35_36 0x00800000 /* VDD voltage 3.5 ~ 3.6 */ ++#define MMC_CARD_BUSY 0x80000000 /* Card Power up status bit */ ++ ++ ++/* ++ * CSD field definitions ++ */ ++ ++#define CSD_STRUCT_VER_1_0 0 /* Valid for system specification 1.0 - 1.2 */ ++#define CSD_STRUCT_VER_1_1 1 /* Valid for system specification 1.4 - 2.2 */ ++#define CSD_STRUCT_VER_1_2 2 /* Valid for system specification 3.1 */ ++ ++#define CSD_SPEC_VER_0 0 /* Implements system specification 1.0 - 1.2 */ ++#define CSD_SPEC_VER_1 1 /* Implements system specification 1.4 */ ++#define CSD_SPEC_VER_2 2 /* Implements system specification 2.0 - 2.2 */ ++#define CSD_SPEC_VER_3 3 /* Implements system specification 3.1 */ ++ ++#endif /* MMC_MMC_PROTOCOL_H */ ++ +--- /dev/null 2003-09-23 18:19:32.000000000 -0400 ++++ linux-2.6.5/include/linux/l3/algo-bit.h 2004-04-30 20:57:36.000000000 -0400 +@@ -0,0 +1,39 @@ ++/* ++ * linux/include/linux/l3/algo-bit.h ++ * ++ * Copyright (C) 2001 Russell King, All Rights Reserved. ++ * ++ * 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. ++ * ++ * L3 Bus bit-banging algorithm. Derived from i2c-algo-bit.h by ++ * Simon G. Vogl. ++ */ ++#ifndef L3_ALGO_BIT_H ++#define L3_ALGO_BIT_H 1 ++ ++#include <linux/l3/l3.h> ++ ++struct l3_algo_bit_data { ++ void (*setdat) (void *data, int state); ++ void (*setclk) (void *data, int state); ++ void (*setmode)(void *data, int state); ++ void (*setdir) (void *data, int in); /* set data direction */ ++ int (*getdat) (void *data); ++ ++ void *data; ++ ++ /* bus timings (us) */ ++ int data_hold; ++ int data_setup; ++ int clock_high; ++ int mode_hold; ++ int mode_setup; ++ int mode; ++}; ++ ++int l3_bit_add_bus(struct l3_adapter *); ++int l3_bit_del_bus(struct l3_adapter *); ++ ++#endif +--- /dev/null 2003-09-23 18:19:32.000000000 -0400 ++++ linux-2.6.5/include/linux/l3/l3.h 2004-04-30 20:57:36.000000000 -0400 +@@ -0,0 +1,95 @@ ++/* ++ * linux/include/linux/l3/l3.h ++ * ++ * Copyright (C) 2001 Russell King, All Rights Reserved. ++ * ++ * 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. ++ * ++ * Derived from i2c.h by Simon G. Vogl ++ */ ++#ifndef L3_H ++#define L3_H ++ ++struct l3_msg { ++ unsigned char addr; /* slave address */ ++ unsigned char flags; ++#define L3_M_RD 0x01 ++#define L3_M_NOADDR 0x02 ++ unsigned short len; /* msg length */ ++ unsigned char *buf; /* pointer to msg data */ ++}; ++ ++#ifdef __KERNEL__ ++ ++#include <linux/types.h> ++#include <linux/list.h> ++ ++struct l3_adapter; ++ ++struct l3_algorithm { ++ /* textual description */ ++ char name[32]; ++ ++ /* perform bus transactions */ ++ int (*xfer)(struct l3_adapter *, struct l3_msg msgs[], int num); ++}; ++ ++struct semaphore; ++ ++/* ++ * l3_adapter is the structure used to identify a physical L3 bus along ++ * with the access algorithms necessary to access it. ++ */ ++struct l3_adapter { ++ /* ++ * This name is used to uniquely identify the adapter. ++ * It should be the same as the module name. ++ */ ++ char name[32]; ++ ++ /* ++ * the algorithm to access the bus ++ */ ++ struct l3_algorithm *algo; ++ ++ /* ++ * Algorithm specific data ++ */ ++ void *algo_data; ++ ++ /* ++ * This may be NULL, or should point to the module struct ++ */ ++ struct module *owner; ++ ++ /* ++ * private data for the adapter ++ */ ++ void *data; ++ ++ /* ++ * Our lock. Unlike the i2c layer, we allow this to be used for ++ * other stuff, like the i2c layer lock. Some people implement ++ * i2c stuff using the same signals as the l3 bus. ++ */ ++ struct semaphore *lock; ++ ++ /* ++ * List of all adapters. ++ */ ++ struct list_head adapters; ++}; ++ ++extern int l3_add_adapter(struct l3_adapter *); ++extern int l3_del_adapter(struct l3_adapter *); ++extern void l3_put_adapter(struct l3_adapter *); ++extern struct l3_adapter *l3_get_adapter(const char *name); ++ ++extern int l3_write(struct l3_adapter *, int, const char *, int); ++extern int l3_read(struct l3_adapter *, int, char *, int); ++ ++#endif ++ ++#endif /* L3_H */ +--- /dev/null 2003-09-23 18:19:32.000000000 -0400 ++++ linux-2.6.5/include/linux/l3/uda1341.h 2004-04-30 20:57:36.000000000 -0400 +@@ -0,0 +1,61 @@ ++/* ++ * linux/include/linux/l3/uda1341.h ++ * ++ * Philips UDA1341 mixer device driver ++ * ++ * Copyright (c) 2000 Nicolas Pitre <nico@cam.org> ++ * ++ * This program is free software; you can redistribute it and/or ++ * modify it under the terms of the GNU General Public License. ++ */ ++ ++#define UDA1341_NAME "uda1341" ++ ++struct uda1341_cfg { ++ unsigned int fs:16; ++ unsigned int format:3; ++}; ++ ++#define FMT_I2S 0 ++#define FMT_LSB16 1 ++#define FMT_LSB18 2 ++#define FMT_LSB20 3 ++#define FMT_MSB 4 ++#define FMT_LSB16MSB 5 ++#define FMT_LSB18MSB 6 ++#define FMT_LSB20MSB 7 ++ ++#define L3_UDA1341_CONFIGURE 0x13410001 ++ ++struct l3_gain { ++ unsigned int left:8; ++ unsigned int right:8; ++ unsigned int unused:8; ++ unsigned int channel:8; ++}; ++ ++#define L3_SET_VOLUME 0x13410002 ++#define L3_SET_TREBLE 0x13410003 ++#define L3_SET_BASS 0x13410004 ++#define L3_SET_GAIN 0x13410005 ++ ++struct l3_agc { ++ unsigned int level:8; ++ unsigned int enable:1; ++ unsigned int attack:7; ++ unsigned int decay:8; ++ unsigned int channel:8; ++}; ++ ++#define L3_INPUT_AGC 0x13410006 ++ ++struct uda1341; ++ ++int uda1341_configure(struct uda1341 *uda, struct uda1341_cfg *conf); ++int uda1341_mixer_ctl(struct uda1341 *uda, int cmd, void *arg); ++int uda1341_open(struct uda1341 *uda); ++void uda1341_close(struct uda1341 *uda); ++ ++struct uda1341 *uda1341_attach(const char *adapter); ++void uda1341_detach(struct uda1341 *uda); ++ +--- linux-2.6.5/include/linux/i2c-id.h~heh 2004-04-03 22:36:16.000000000 -0500 ++++ linux-2.6.5/include/linux/i2c-id.h 2004-04-30 20:57:36.000000000 -0400 +@@ -187,6 +187,7 @@ + #define I2C_ALGO_BITHS 0x130000 /* enhanced bit style adapters */ + #define I2C_ALGO_OCP_IOP3XX 0x140000 /* XSCALE IOP3XX On-chip I2C alg */ + ++#define I2C_ALGO_PXA 0x200000 /* Intel PXA I2C algorithm */ + #define I2C_ALGO_EXP 0x800000 /* experimental */ + + #define I2C_ALGO_MASK 0xff0000 /* Mask for algorithms */ +--- linux-2.6.5/include/linux/serial_core.h~heh 2004-04-03 22:36:18.000000000 -0500 ++++ linux-2.6.5/include/linux/serial_core.h 2004-04-30 20:57:36.000000000 -0400 +@@ -17,7 +17,7 @@ + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * +- * $Id: serial_core.h,v 1.49 2002/07/20 18:06:32 rmk Exp $ ++ * $Id: serial_core.h,v 1.53 2002/08/02 12:55:08 rmk Exp $ + */ + + /* +@@ -159,8 +159,6 @@ + spinlock_t lock; /* port lock */ + unsigned int iobase; /* in/out[bwl] */ + char *membase; /* read/write[bwl] */ +- unsigned int irq; /* irq number */ +- unsigned int uartclk; /* base uart clock */ + unsigned char fifosize; /* tx fifo size */ + unsigned char x_char; /* xon/xoff char */ + unsigned char regshift; /* reg offset shift */ +@@ -172,6 +170,7 @@ + + unsigned int read_status_mask; /* driver specific */ + unsigned int ignore_status_mask; /* driver specific */ ++ + struct uart_info *info; /* pointer to parent info */ + struct uart_icount icount; /* statistics */ + +@@ -182,7 +181,6 @@ + + unsigned int flags; + +-#define UPF_HUP_NOTIFY (1 << 0) + #define UPF_FOURPORT (1 << 1) + #define UPF_SAK (1 << 2) + #define UPF_SPD_MASK (0x1030) +@@ -212,9 +210,12 @@ + unsigned int timeout; /* character-based timeout */ + unsigned int type; /* port type */ + struct uart_ops *ops; ++ unsigned int uartclk; /* base uart clock */ + unsigned int custom_divisor; ++ unsigned int irq; /* irq number */ + unsigned int line; /* port index */ + unsigned long mapbase; /* for ioremap */ ++ struct device *dev; /* parent device */ + unsigned char hub6; /* this should be in the 8250 driver */ + unsigned char unused[3]; + }; +--- linux-2.6.5/include/linux/vmalloc.h~heh 2004-04-03 22:38:23.000000000 -0500 ++++ linux-2.6.5/include/linux/vmalloc.h 2004-04-30 20:57:36.000000000 -0400 +@@ -35,6 +35,8 @@ + * Lowlevel-APIs (not for driver use!) + */ + extern struct vm_struct *get_vm_area(unsigned long size, unsigned long flags); ++extern struct vm_struct *__get_vm_area(unsigned long size, unsigned long flags, ++ unsigned long start, unsigned long end); + extern struct vm_struct *remove_vm_area(void *addr); + extern int map_vm_area(struct vm_struct *area, pgprot_t prot, + struct page ***pages); +--- linux-2.6.5/include/linux/mm.h~heh 2004-04-03 22:36:15.000000000 -0500 ++++ linux-2.6.5/include/linux/mm.h 2004-04-30 20:57:36.000000000 -0400 +@@ -655,5 +655,12 @@ + int in_gate_area(struct task_struct *task, unsigned long addr); + #endif + ++#ifndef __arm__ ++#define memc_update_addr(x,y,z) ++#define memc_update_mm(x) ++#define memc_clear(x,y) ++#endif ++ + #endif /* __KERNEL__ */ + #endif /* _LINUX_MM_H */ ++ +--- linux-2.6.5/init/do_mounts.c~heh 2004-04-03 22:36:56.000000000 -0500 ++++ linux-2.6.5/init/do_mounts.c 2004-04-30 20:57:36.000000000 -0400 +@@ -391,7 +391,7 @@ + root_device_name += 5; + } + +- is_floppy = MAJOR(ROOT_DEV) == FLOPPY_MAJOR; ++ is_floppy = MAJOR(ROOT_DEV) == FLOPPY_MAJOR || MAJOR(ROOT_DEV) == 31; + + if (initrd_load()) + goto out; +--- linux-2.6.5/fs/binfmt_aout.c~heh 2004-04-03 22:36:26.000000000 -0500 ++++ linux-2.6.5/fs/binfmt_aout.c 2004-04-30 20:57:36.000000000 -0400 +@@ -432,7 +432,11 @@ + else + send_sig(SIGTRAP, current, 0); + } ++#ifndef __arm__ + return 0; ++#else ++ return regs->ARM_r0; ++#endif + } + + static int load_aout_library(struct file *file) +@@ -462,8 +466,11 @@ + + /* For QMAGIC, the starting address is 0x20 into the page. We mask + this off to get the starting address for the page */ +- +- start_addr = ex.a_entry & 0xfffff000; ++#ifndef __arm__ ++ start_addr = ex.a_entry & 0xfffff000; ++#else ++ start_addr = ex.a_entry & 0xffff8000; ++#endif + + if ((N_TXTOFF(ex) & ~PAGE_MASK) != 0) { + static unsigned long error_time; +--- linux-2.6.5/mm/slab.c~heh 2004-04-03 22:37:41.000000000 -0500 ++++ linux-2.6.5/mm/slab.c 2004-04-30 20:57:36.000000000 -0400 +@@ -2115,12 +2115,12 @@ + * + * Called with disabled ints. + */ +-static inline void __cache_free (kmem_cache_t *cachep, void* objp) ++static inline void __cache_free (kmem_cache_t *cachep, void* objp, void *caller) + { + struct array_cache *ac = ac_data(cachep); + + check_irq_off(); +- objp = cache_free_debugcheck(cachep, objp, __builtin_return_address(0)); ++ objp = cache_free_debugcheck(cachep, objp, caller /*__builtin_return_address(0)*/); + + if (likely(ac->avail < ac->limit)) { + STATS_INC_FREEHIT(cachep); +@@ -2289,7 +2289,7 @@ + unsigned long flags; + + local_irq_save(flags); +- __cache_free(cachep, objp); ++ __cache_free(cachep, objp, __builtin_return_address(0)); + local_irq_restore(flags); + } + +@@ -2312,7 +2312,7 @@ + local_irq_save(flags); + kfree_debugcheck(objp); + c = GET_PAGE_CACHE(virt_to_page(objp)); +- __cache_free(c, (void*)objp); ++ __cache_free(c, (void*)objp, __builtin_return_address(0)); + local_irq_restore(flags); + } + +--- /dev/null 2003-09-23 18:19:32.000000000 -0400 ++++ linux-2.6.5/Documentation/l3/structure 2004-04-30 20:57:36.000000000 -0400 +@@ -0,0 +1,36 @@ ++L3 Bus Driver ++------------- ++ ++The structure of the driver is as follows: ++ ++ +----------+ +----------+ +----------+ ++ | client 1 | | client 2 | | client 3 | ++ +-----^----+ +----^-----+ +----^-----+ ++ | | | ++ +-----v--------------v---------------v-----+ ++ | | ++ +-----^-------+ +-------^-----+ ++ | | core | | ++ +-----v----+ | | +----v-----+ ++ | device | | | | device | ++ | driver 1 | | | | driver 2 | ++ +-----^----+ | | +----^-----+ ++ | | services | | ++ +-----v-------+ +-------v-----+ ++ | | ++ +-----------------^----^-------------------+ ++ | | ++ | +-v---------+ ++ | | algorithm | ++ | | driver | ++ | +-v---------+ ++ | | ++ +-v----v-+ ++ | bus | ++ | driver | ++ +--------+ ++ ++Clients talk to the core to attach device drivers and bus adapters, and ++to instruct device drivers to perform actions. Device drivers then talk ++to the core to perform L3 bus transactions via the algorithm driver and ++ultimately bus driver. +--- linux-2.6.5/arch/arm/kernel/debug.S~heh 2004-04-03 22:36:55.000000000 -0500 ++++ linux-2.6.5/arch/arm/kernel/debug.S 2004-04-30 20:57:36.000000000 -0400 +@@ -192,6 +192,20 @@ + + @ if all ports are inactive, then there is nothing we can do + moveq pc, lr ++ ldr r1, [\rx, #UTCR2] ++ teq r1, #5 ++ movne r1, #0 ++ strne r1, [\rx, #UTCR3] ++ movne r1, #8 ++ strne r1, [\rx, #UTCR0] ++ movne r1, #5 ++ strne r1, [\rx, #UTCR2] ++ movne r1, #0 ++ strne r1, [\rx, #UTCR1] ++ movne r1, #3 ++ strne r1, [\rx, #UTCR3] ++ movne r1, #255 ++ strne r1, [\rx, #UTSR0] + .endm + + .macro senduart,rd,rx +@@ -287,7 +301,7 @@ + + #elif defined(CONFIG_ARCH_INTEGRATOR) + +-#include <asm/hardware/serial_amba.h> ++#include <asm/hardware/amba_serial.h> + + .macro addruart,rx + mrc p15, 0, \rx, c1, c0 +@@ -298,7 +312,7 @@ + .endm + + .macro senduart,rd,rx +- strb \rd, [\rx, #AMBA_UARTDR] ++ strb \rd, [\rx, #UART01x_DR] + .endm + + .macro waituart,rd,rx +--- linux-2.6.5/arch/arm/kernel/entry-armv.S~heh 2004-04-03 22:36:54.000000000 -0500 ++++ linux-2.6.5/arch/arm/kernel/entry-armv.S 2004-04-30 20:57:36.000000000 -0400 +@@ -1181,6 +1181,9 @@ + * get out of that mode without clobbering one register. + */ + vector_FIQ: disable_fiq ++ mrs r13, spsr ++ orr r13, r13, #PSR_F_BIT ++ msr spsr, r13 + subs pc, lr, #4 + + /*============================================================================= +--- linux-2.6.5/arch/arm/kernel/irq.c~heh 2004-04-03 22:36:12.000000000 -0500 ++++ linux-2.6.5/arch/arm/kernel/irq.c 2004-04-30 20:57:36.000000000 -0400 +@@ -47,12 +47,36 @@ + #define MAX_IRQ_CNT 100000 + + static volatile unsigned long irq_err_count; +-static spinlock_t irq_controller_lock; + static LIST_HEAD(irq_pending); + + struct irqdesc irq_desc[NR_IRQS]; + void (*init_arch_irq)(void) __initdata = NULL; + ++#if NR_IRQ_DEVICES > 1 ++struct irq_device { ++ spinlock_t lock; ++ int nr_irqs; ++ struct irq_desc *irqs; ++}; ++ ++static struct irq_device irq_devices[NR_IRQ_DEVICES] = { ++ [0] = { ++ .lock = SPIN_LOCK_UNLOCKED, ++ .nr_irqs = NR_IRQS, ++ .irqs = irq_desc, ++ }, ++}; ++#define IRQ_LOCK(irq) (&irq_devices[IRQ_DEVICE(irq)].lock) ++#define IRQ_DESC(irq) (&irq_devices[IRQ_DEVICE(irq)].irqs[IRQ_INDEX(irq)]) ++#define IRQ_VALID(irq) (IRQ_DEVICE(irq) < NR_IRQ_DEVICES && \ ++ IRQ_INDEX(irq) < irq_devices[IRQ_DEVICE(irq)].nr_irqs) ++#else ++static spinlock_t irq_controller_lock = SPIN_LOCK_UNLOCKED; ++#define IRQ_LOCK(irq) (&irq_controller_lock) ++#define IRQ_DESC(irq) (&irq_desc[irq]) ++#define IRQ_VALID(irq) ((irq) < NR_IRQS) ++#endif ++ + /* + * Dummy mask/unmask handler + */ +@@ -95,13 +119,13 @@ + */ + void disable_irq(unsigned int irq) + { +- struct irqdesc *desc = irq_desc + irq; ++ struct irqdesc *desc = IRQ_DESC(irq); + unsigned long flags; + +- spin_lock_irqsave(&irq_controller_lock, flags); ++ spin_lock_irqsave(IRQ_LOCK(irq), flags); + desc->disable_depth++; + list_del_init(&desc->pend); +- spin_unlock_irqrestore(&irq_controller_lock, flags); ++ spin_unlock_irqrestore(IRQ_LOCK(irq), flags); + } + + /** +@@ -116,10 +140,10 @@ + */ + void enable_irq(unsigned int irq) + { +- struct irqdesc *desc = irq_desc + irq; ++ struct irqdesc *desc = IRQ_DESC(irq); + unsigned long flags; + +- spin_lock_irqsave(&irq_controller_lock, flags); ++ spin_lock_irqsave(IRQ_LOCK(irq), flags); + if (unlikely(!desc->disable_depth)) { + printk("enable_irq(%u) unbalanced from %p\n", irq, + __builtin_return_address(0)); +@@ -140,7 +164,7 @@ + list_add(&desc->pend, &irq_pending); + } + } +- spin_unlock_irqrestore(&irq_controller_lock, flags); ++ spin_unlock_irqrestore(IRQ_LOCK(irq), flags); + } + + /* +@@ -148,24 +172,24 @@ + */ + void enable_irq_wake(unsigned int irq) + { +- struct irqdesc *desc = irq_desc + irq; ++ struct irqdesc *desc = IRQ_DESC(irq); + unsigned long flags; + +- spin_lock_irqsave(&irq_controller_lock, flags); ++ spin_lock_irqsave(IRQ_LOCK(irq), flags); + if (desc->chip->wake) + desc->chip->wake(irq, 1); +- spin_unlock_irqrestore(&irq_controller_lock, flags); ++ spin_unlock_irqrestore(IRQ_LOCK(irq), flags); + } + + void disable_irq_wake(unsigned int irq) + { +- struct irqdesc *desc = irq_desc + irq; ++ struct irqdesc *desc = IRQ_DESC(irq); + unsigned long flags; + +- spin_lock_irqsave(&irq_controller_lock, flags); ++ spin_lock_irqsave(IRQ_LOCK(irq), flags); + if (desc->chip->wake) + desc->chip->wake(irq, 0); +- spin_unlock_irqrestore(&irq_controller_lock, flags); ++ spin_unlock_irqrestore(IRQ_LOCK(irq), flags); + } + + int show_interrupts(struct seq_file *p, void *v) +@@ -175,8 +199,8 @@ + unsigned long flags; + + if (i < NR_IRQS) { +- spin_lock_irqsave(&irq_controller_lock, flags); +- action = irq_desc[i].action; ++ spin_lock_irqsave(IRQ_LOCK(irq), flags); ++ action = IRQ_DESC(i)->action; + if (!action) + goto unlock; + +@@ -187,7 +211,7 @@ + + seq_putc(p, '\n'); + unlock: +- spin_unlock_irqrestore(&irq_controller_lock, flags); ++ spin_unlock_irqrestore(IRQ_LOCK(irq), flags); + } else if (i == NR_IRQS) { + #ifdef CONFIG_ARCH_ACORN + show_fiq_list(p, v); +@@ -259,7 +283,7 @@ + unsigned int status; + int retval = 0; + +- spin_unlock(&irq_controller_lock); ++ spin_unlock(IRQ_LOCK(irq)); + + if (!(action->flags & SA_INTERRUPT)) + local_irq_enable(); +@@ -274,7 +298,7 @@ + if (status & SA_SAMPLE_RANDOM) + add_interrupt_randomness(irq); + +- spin_lock_irq(&irq_controller_lock); ++ spin_lock_irq(IRQ_LOCK(irq)); + + return retval; + } +@@ -455,7 +479,7 @@ + desc = &bad_irq_desc; + + irq_enter(); +- spin_lock(&irq_controller_lock); ++ spin_lock(IRQ_LOCK(irq)); + desc->handle(irq, desc, regs); + + /* +@@ -464,7 +488,7 @@ + if (!list_empty(&irq_pending)) + do_pending_irqs(regs); + +- spin_unlock(&irq_controller_lock); ++ spin_unlock(IRQ_LOCK(irq)); + irq_exit(); + } + +@@ -473,7 +497,7 @@ + struct irqdesc *desc; + unsigned long flags; + +- if (irq >= NR_IRQS) { ++ if (!IRQ_VALID(irq)) { + printk(KERN_ERR "Trying to install handler for IRQ%d\n", irq); + return; + } +@@ -481,12 +505,12 @@ + if (handle == NULL) + handle = do_bad_IRQ; + +- desc = irq_desc + irq; ++ desc = IRQ_DESC(irq); + + if (is_chained && desc->chip == &bad_chip) + printk(KERN_WARNING "Trying to install chained handler for IRQ%d\n", irq); + +- spin_lock_irqsave(&irq_controller_lock, flags); ++ spin_lock_irqsave(IRQ_LOCK(irq), flags); + if (handle == do_bad_IRQ) { + desc->chip->mask(irq); + desc->chip->ack(irq); +@@ -499,7 +523,7 @@ + desc->disable_depth = 0; + desc->chip->unmask(irq); + } +- spin_unlock_irqrestore(&irq_controller_lock, flags); ++ spin_unlock_irqrestore(IRQ_LOCK(irq), flags); + } + + void set_irq_chip(unsigned int irq, struct irqchip *chip) +@@ -507,7 +531,7 @@ + struct irqdesc *desc; + unsigned long flags; + +- if (irq >= NR_IRQS) { ++ if (!IRQ_VALID(irq)) { + printk(KERN_ERR "Trying to install chip for IRQ%d\n", irq); + return; + } +@@ -515,10 +539,10 @@ + if (chip == NULL) + chip = &bad_chip; + +- desc = irq_desc + irq; +- spin_lock_irqsave(&irq_controller_lock, flags); ++ desc = IRQ_DESC(irq); ++ spin_lock_irqsave(IRQ_LOCK(irq), flags); + desc->chip = chip; +- spin_unlock_irqrestore(&irq_controller_lock, flags); ++ spin_unlock_irqrestore(IRQ_LOCK(irq), flags); + } + + int set_irq_type(unsigned int irq, unsigned int type) +@@ -527,16 +551,21 @@ + unsigned long flags; + int ret = -ENXIO; + +- if (irq >= NR_IRQS) { ++ if (!IRQ_VALID(irq)) { + printk(KERN_ERR "Trying to set irq type for IRQ%d\n", irq); + return -ENODEV; + } + +- desc = irq_desc + irq; ++ desc = IRQ_DESC(irq); ++ if (!desc->action && desc->handle != do_bad_IRQ) { ++ printk(KERN_ERR "Setting type of unclaimed IRQ%d from ", irq); ++ print_symbol("%s\n", (unsigned long)__builtin_return_address(0)); ++ } ++ + if (desc->chip->type) { +- spin_lock_irqsave(&irq_controller_lock, flags); ++ spin_lock_irqsave(IRQ_LOCK(irq), flags); + ret = desc->chip->type(irq, type); +- spin_unlock_irqrestore(&irq_controller_lock, flags); ++ spin_unlock_irqrestore(IRQ_LOCK(irq), flags); + } + + return ret; +@@ -547,17 +576,17 @@ + struct irqdesc *desc; + unsigned long flags; + +- if (irq >= NR_IRQS) { ++ if (!IRQ_VALID(irq)) { + printk(KERN_ERR "Trying to set irq flags for IRQ%d\n", irq); + return; + } + +- desc = irq_desc + irq; +- spin_lock_irqsave(&irq_controller_lock, flags); ++ desc = IRQ_DESC(irq); ++ spin_lock_irqsave(IRQ_LOCK(irq), flags); + desc->valid = (iflags & IRQF_VALID) != 0; + desc->probe_ok = (iflags & IRQF_PROBE) != 0; + desc->noautoenable = (iflags & IRQF_NOAUTOEN) != 0; +- spin_unlock_irqrestore(&irq_controller_lock, flags); ++ spin_unlock_irqrestore(IRQ_LOCK(irq), flags); + } + + int setup_irq(unsigned int irq, struct irqaction *new) +@@ -587,13 +616,13 @@ + /* + * The following block of code has to be executed atomically + */ +- desc = irq_desc + irq; +- spin_lock_irqsave(&irq_controller_lock, flags); ++ desc = IRQ_DESC(irq); ++ spin_lock_irqsave(IRQ_LOCK(irq), flags); + p = &desc->action; + if ((old = *p) != NULL) { + /* Can't share interrupts unless both agree to */ + if (!(old->flags & new->flags & SA_SHIRQ)) { +- spin_unlock_irqrestore(&irq_controller_lock, flags); ++ spin_unlock_irqrestore(IRQ_LOCK(irq), flags); + return -EBUSY; + } + +@@ -618,7 +647,7 @@ + } + } + +- spin_unlock_irqrestore(&irq_controller_lock, flags); ++ spin_unlock_irqrestore(IRQ_LOCK(irq), flags); + return 0; + } + +@@ -659,7 +688,7 @@ + unsigned long retval; + struct irqaction *action; + +- if (irq >= NR_IRQS || !irq_desc[irq].valid || !handler || ++ if (!IRQ_VALID(irq) || !IRQ_DESC(irq)->valid || !handler || + (irq_flags & SA_SHIRQ && !dev_id)) + return -EINVAL; + +@@ -700,14 +729,14 @@ + struct irqaction * action, **p; + unsigned long flags; + +- if (irq >= NR_IRQS || !irq_desc[irq].valid) { ++ if (!IRQ_VALID(irq) || !IRQ_DESC(irq)->valid) { + printk(KERN_ERR "Trying to free IRQ%d\n",irq); + dump_stack(); + return; + } + +- spin_lock_irqsave(&irq_controller_lock, flags); +- for (p = &irq_desc[irq].action; (action = *p) != NULL; p = &action->next) { ++ spin_lock_irqsave(IRQ_LOCK(irq), flags); ++ for (p = &IRQ_DESC(irq)->action; (action = *p) != NULL; p = &action->next) { + if (action->dev_id != dev_id) + continue; + +@@ -715,7 +744,7 @@ + *p = action->next; + break; + } +- spin_unlock_irqrestore(&irq_controller_lock, flags); ++ spin_unlock_irqrestore(IRQ_LOCK(irq), flags); + + if (!action) { + printk(KERN_ERR "Trying to free free IRQ%d\n",irq); +@@ -747,19 +776,18 @@ + * first snaffle up any unassigned but + * probe-able interrupts + */ +- spin_lock_irq(&irq_controller_lock); + for (i = 0; i < NR_IRQS; i++) { +- if (!irq_desc[i].probe_ok || irq_desc[i].action) +- continue; +- +- irq_desc[i].probing = 1; +- irq_desc[i].triggered = 0; +- if (irq_desc[i].chip->type) +- irq_desc[i].chip->type(i, IRQT_PROBE); +- irq_desc[i].chip->unmask(i); +- irqs += 1; ++ spin_lock_irq(IRQ_LOCK(i)); ++ if (irq_desc[i].probe_ok && !irq_desc[i].action) { ++ irq_desc[i].probing = 1; ++ irq_desc[i].triggered = 0; ++ if (irq_desc[i].chip->type) ++ irq_desc[i].chip->type(i, IRQT_PROBE); ++ irq_desc[i].chip->unmask(i); ++ irqs += 1; ++ } ++ spin_unlock_irq(IRQ_LOCK(i)); + } +- spin_unlock_irq(&irq_controller_lock); + + /* + * wait for spurious interrupts to mask themselves out again +@@ -770,14 +798,14 @@ + /* + * now filter out any obviously spurious interrupts + */ +- spin_lock_irq(&irq_controller_lock); + for (i = 0; i < NR_IRQS; i++) { ++ spin_lock_irq(IRQ_LOCK(i)); + if (irq_desc[i].probing && irq_desc[i].triggered) { + irq_desc[i].probing = 0; + irqs -= 1; + } ++ spin_unlock_irq(IRQ_LOCK(i)); + } +- spin_unlock_irq(&irq_controller_lock); + + return irqs; + } +@@ -788,11 +816,13 @@ + { + unsigned int mask = 0, i; + +- spin_lock_irq(&irq_controller_lock); +- for (i = 0; i < 16 && i < NR_IRQS; i++) +- if (irq_desc[i].probing && irq_desc[i].triggered) ++ for (i = 0; i < 16 && i < NR_IRQS; i++) { ++ struct irqdesc *desc = IRQ_DESC(i); ++ spin_lock_irq(IRQ_LOCK(i)); ++ if (desc->probing && desc->triggered) + mask |= 1 << i; +- spin_unlock_irq(&irq_controller_lock); ++ spin_unlock_irq(IRQ_LOCK(i)); ++ } + + up(&probe_sem); + +@@ -813,23 +843,21 @@ + * look at the interrupts, and find exactly one + * that we were probing has been triggered + */ +- spin_lock_irq(&irq_controller_lock); + for (i = 0; i < NR_IRQS; i++) { +- if (irq_desc[i].probing && +- irq_desc[i].triggered) { ++ struct irqdesc *desc = IRQ_DESC(i); ++ ++ spin_lock_irq(IRQ_LOCK(i)); ++ if (desc->probing && desc->triggered) { + if (irq_found != NO_IRQ) { ++ spin_unlock_irq(IRQ_LOCK(i)); + irq_found = NO_IRQ; +- goto out; ++ break; + } + irq_found = i; + } ++ spin_unlock_irq(IRQ_LOCK(i)); + } + +- if (irq_found == -1) +- irq_found = NO_IRQ; +-out: +- spin_unlock_irq(&irq_controller_lock); +- + up(&probe_sem); + + return irq_found; +--- linux-2.6.5/arch/arm/kernel/bios32.c~heh 2004-04-03 22:36:56.000000000 -0500 ++++ linux-2.6.5/arch/arm/kernel/bios32.c 2004-04-30 20:57:36.000000000 -0400 +@@ -565,8 +565,6 @@ + if (hw->postinit) + hw->postinit(); + +- pci_fixup_irqs(pcibios_swizzle, pcibios_map_irq); +- + list_for_each_entry(sys, &hw->buses, node) { + struct pci_bus *bus = sys->bus; + +@@ -581,6 +579,11 @@ + pci_bus_assign_resources(bus); + + /* ++ * Fixup IRQs. ++ */ ++ pci_bus_fixup_irqs(bus, pcibios_swizzle, pcibios_map_irq); ++ ++ /* + * Tell drivers about devices found. + */ + pci_bus_add_devices(bus); +--- linux-2.6.5/arch/arm/kernel/traps.c~heh 2004-04-03 22:36:57.000000000 -0500 ++++ linux-2.6.5/arch/arm/kernel/traps.c 2004-04-30 20:57:36.000000000 -0400 +@@ -206,33 +206,43 @@ + c_backtrace(fp, 0x10); + } + +-spinlock_t die_lock = SPIN_LOCK_UNLOCKED; +- +-/* +- * This function is protected against re-entrancy. +- */ +-NORET_TYPE void die(const char *str, struct pt_regs *regs, int err) ++static void __die(const char *str, int err, struct thread_info *thread, struct pt_regs *regs) + { +- struct task_struct *tsk = current; ++ struct task_struct *tsk = thread->task; + static int die_counter; + +- console_verbose(); +- spin_lock_irq(&die_lock); +- bust_spinlocks(1); +- + printk("Internal error: %s: %x [#%d]\n", str, err, ++die_counter); + print_modules(); + printk("CPU: %d\n", smp_processor_id()); + show_regs(regs); + printk("Process %s (pid: %d, stack limit = 0x%p)\n", +- tsk->comm, tsk->pid, tsk->thread_info + 1); ++ tsk->comm, tsk->pid, thread + 1); + + if (!user_mode(regs) || in_interrupt()) { + dump_mem("Stack: ", regs->ARM_sp, 8192+(unsigned long)tsk->thread_info); + dump_backtrace(regs, tsk); + dump_instr(regs); + } ++} ++ ++void nmi_watchdog(struct thread_info *thread, struct pt_regs *regs) ++{ ++ __die("NMI watchdog", 0, thread, regs); ++} + ++spinlock_t die_lock = SPIN_LOCK_UNLOCKED; ++ ++/* ++ * This function is protected against re-entrancy. ++ */ ++NORET_TYPE void die(const char *str, struct pt_regs *regs, int err) ++{ ++ struct thread_info *thread = current_thread_info(); ++ ++ console_verbose(); ++ spin_lock_irq(&die_lock); ++ bust_spinlocks(1); ++ __die(str, err, thread, regs); + bust_spinlocks(0); + spin_unlock_irq(&die_lock); + do_exit(SIGSEGV); +--- linux-2.6.5/arch/arm/Kconfig~heh 2004-04-03 22:37:07.000000000 -0500 ++++ linux-2.6.5/arch/arm/Kconfig 2004-04-30 20:57:36.000000000 -0400 +@@ -297,7 +297,7 @@ + + config CPU_FREQ + bool "Support CPU clock change (EXPERIMENTAL)" +- depends on (ARCH_SA1100 || ARCH_INTEGRATOR) && EXPERIMENTAL ++ depends on (ARCH_SA1100 || ARCH_INTEGRATOR || ARCH_PXA) && EXPERIMENTAL + help + CPU clock scaling allows you to change the clock speed of the + running CPU on the fly. This is a nice method to save battery power, +--- /dev/null 2003-09-23 18:19:32.000000000 -0400 ++++ linux-2.6.5/arch/arm/fastfpe/entry.S 2004-04-30 20:57:36.000000000 -0400 +@@ -0,0 +1,294 @@ ++/* ++At entry the registers contain the following information: ++ ++r14 return address for undefined exception return ++r9 return address for return from exception ++r13 user registers on stack, offset 0 up to offset 4*15 contains ++ registers r0..15, then the psr ++r10 FP workspace 35 words (init, reg[8][4], fpsr, fpcr) ++ ++*/ ++ ++/*---------------------------------------------------------------------------*/ ++ ++ .data ++fp_const: ++ .word 0, 0x00000000, 0, 0x80000000 @ 0 ++ .word 0, 0x80000000, 0, 0 @ 1 ++ .word 0, 0x80000000, 0, 1 @ 2 ++ .word 0, 0xc0000000, 0, 1 @ 3 ++ .word 0, 0x80000000, 0, 2 @ 4 ++ .word 0, 0xa0000000, 0, 2 @ 5 ++ .word 0, 0x80000000, 0, -1 @ 0.5 ++ .word 0, 0xa0000000, 0, 3 @ 10 ++fp_undef: ++ .word 0 ++fp_cond: ++ .word 0xf0f0 @ eq ++ .word 0x0f0f @ ne ++ .word 0xcccc @ cs ++ .word 0x3333 @ cc ++ .word 0xff00 @ mi ++ .word 0x00ff @ pl ++ .word 0xaaaa @ vs ++ .word 0x5555 @ vc ++ .word 0x0c0c @ hi ++ .word 0xf3f3 @ ls ++ .word 0xaa55 @ ge ++ .word 0x55aa @ lt ++ .word 0x0a05 @ gt ++ .word 0xf5fa @ le ++ .word 0xffff @ al ++ .word 0x0000 @ nv ++ ++/*---------------------------------------------------------------------------*/ ++ ++ .text ++ .globl fastfpe_enter ++fastfpe_enter: ++ ldr r4,=fp_undef ++ str r14,[r4] @ to free one register ++ add r10,r10,#4 @ to make the code simpler ++ mov r4, r0 @ r4=trapped instruction ++ and r1,r4,#0x00000f00 @ r1=coprocessor << 8 ++next_enter: ++ cmp r1,#1<<8 @ copro 1 ? ++ beq copro_1 ++ cmp r1,#2<<8 ++ movne pc,r14 ++ ++copro_2: ++ and r1,r4,#0x0f000000 ++ cmp r1,#0x0c000000 @ CPDT with post indexing ++ cmpne r1,#0x0d000000 @ CPDT with pre indexing ++ beq CPDT_M_enter ++ mov pc,r14 ++ ++copro_1: ++ and r1,r4,#0x0f000000 ++ cmp r1,#0x0e000000 @ CPDO ++ beq CPDO_CPRT_enter ++ cmp r1,#0x0c000000 @ CPDT with post indexing ++ cmpne r1,#0x0d000000 @ CPDT with pre indexing ++ beq CPDT_1_enter ++ mov pc,r14 ++ ++/*---------------------------------------------------------------------------*/ ++ ++ .globl fastfpe_next ++fastfpe_next: ++ ldr r5,[r13,#60] ++next_after_cond: ++__x1: ++ ldrt r4,[r5],#4 ++ ++ ldr r0,=fp_cond @ check condition of next instruction ++ ldr r1,[r13,#64] @ psr containing flags ++ mov r2,r4,lsr#28 ++ mov r1,r1,lsr#28 ++ ldr r0,[r0,r2,lsl#2] ++ mov r0,r0,lsr r1 ++ tst r0,#1 ++ beq next_after_cond @ must not necessarily have been an ++ @ FP instruction ! ++ and r1,r4,#0x0f000000 @ Test for copro instruction ++ cmp r1,#0x0c000000 ++ rsbgts r0,r1,#0x0e000000 @ cmpgt #0x0e000000,r1 ++ movlt pc,r9 @ next is no copro instruction, return ++ ++ ands r1,r4,#0x00000f00 @ r1 = coprocessor << 8 ++ cmpne r1,#3<<8 ++ movge pc,r9 @ copro = 0 or >=3, return ++ ++ str r5,[r13,#60] @ save updated pc ++ b next_enter ++ ++/*---------------------------------------------------------------------------*/ ++ ++undefined: ++ ldr r4,=fp_undef ++ ldr pc,[r4] ++ ++/*---------------------------------------------------------------------------*/ ++ ++CPDT_1_enter: ++ and r5,r4,#0x000f0000 @ r5=base register number << 16 ++ ldr r6,[r13,r5,lsr#14] @ r6=base address ++ cmp r5,#0x000f0000 @ base register = pc ? ++ addeq r6,r6,#4 ++ and r7,r4,#0x000000ff @ r7=offset value ++ ++ tst r4,#0x00800000 @ up or down? ++ addne r7,r6,r7,lsl#2 ++ subeq r7,r6,r7,lsl#2 @ r6=base address +/- offset ++ tst r4,#0x01000000 @ preindexing ? ++ movne r6,r7 ++ tst r4,#0x00200000 @ write back ? ++ cmpne r5,#0x000f0000 @ base register = pc ? ++ strne r7,[r13,r5,lsr#14] ++ ++ and r0,r4,#0x00007000 @ r0=fp register number << 12 ++ add r0,r10,r0,lsr#8 @ r0=address of fp register ++ mov r1,#0 ++ tst r4,#0x00008000 ++ orrne r1,r1,#1 @ T0 ++ tst r4,#0x00400000 ++ orrne r1,r1,#2 @ T1 ++ tst r4,#0x00100000 ++ orrne r1,r1,#4 @ L/S ++ ++ add pc,pc,r1,lsl#2 ++ mov r0,r0 ++ b CPDT_store_single @ these functions get ++ b CPDT_store_double @ r0=address of fp register ++ b CPDT_store_extended @ r6=address of data ++ b undefined @ CPDT_store_decimal ++ b CPDT_load_single ++ b CPDT_load_double ++ b CPDT_load_extended ++ b undefined @ CPDT_load_decimal ++ ++/*---------------------------------------------------------------------------*/ ++ ++CPDT_M_enter: ++ and r5,r4,#0x000f0000 @ r5=base register number << 16 ++ ldr r6,[r13,r5,lsr#14] @ r6=base address ++ cmp r5,#0x000f0000 @ base register = pc ? ++ addeq r6,r6,#4 ++ and r7,r4,#0x000000ff @ r7=offset value ++ ++ tst r4,#0x00800000 @ up or down? ++ addne r7,r6,r7,lsl#2 ++ subeq r7,r6,r7,lsl#2 @ r7=base address +/- offset ++ tst r4,#0x01000000 @ preindexing ? ++ movne r6,r7 ++ tst r4,#0x00200000 @ write back ? ++ cmpne r5,#0x000f0000 @ base register = pc ? ++ strne r7,[r13,r5,lsr#14] ++ ++ and r0,r4,#0x00007000 @ r0=fp register number << 12 ++ and r1,r4,#0x00008000 ++ mov r1,r1,lsr#15 @ N0 ++ and r2,r4,#0x00400000 ++ orrs r1,r1,r2,lsr#21 @ N1 ++ addeq r1,r1,#4 @ r1=register count ++ ++ tst r4,#0x00100000 @ load/store ++ beq CPDT_sfm ++ b CPDT_lfm ++ ++/*---------------------------------------------------------------------------*/ ++ ++CPDO_CPRT_enter: ++ tst r4,#0x00000010 ++ bne CPRT_enter ++ ++ and r0,r4,#0x00007000 ++ add r0,r10,r0,lsr#8 @ r0=address of Fd ++ and r1,r4,#0x00070000 ++ add r1,r10,r1,lsr#12 @ r1=address of Fn ++ tst r4,#0x00000008 ++ bne CPDO_const ++ and r2,r4,#0x00000007 ++ add r2,r10,r2,lsl#4 @ r2=address of Fm ++ ++CPDO_constback: ++ and r3,r4,#0x00f00000 ++ tst r4,#0x00008000 ++ orrne r3,r3,#0x01000000 ++ ++ add pc,pc,r3,lsr#18 ++ mov r0,r0 ++ b CPDO_adf ++ b CPDO_muf ++ b CPDO_suf ++ b CPDO_rsf ++ b CPDO_dvf ++ b CPDO_rdf ++ b undefined ++ b undefined ++ b undefined @ CPDO_rmf ++ b CPDO_muf ++ b CPDO_dvf ++ b CPDO_rdf ++ b undefined ++ b undefined ++ b undefined ++ b undefined ++ b CPDO_mvf ++ b CPDO_mnf ++ b CPDO_abs ++ b CPDO_rnd ++ b CPDO_sqt ++ b undefined ++ b undefined ++ b undefined ++ b undefined ++ b undefined ++ b undefined ++ b undefined ++ b undefined ++ b undefined ++ b CPDO_rnd ++ b fastfpe_next ++ ++CPDO_const: ++ ldr r2,=fp_const ++ and r3,r4,#0x00000007 ++ add r2,r2,r3,lsl#4 ++ b CPDO_constback ++ ++/*---------------------------------------------------------------------------*/ ++ ++CPRT_enter: ++ and r0,r4,#0x0000f000 @ r0=Rd<<12 ++ and r1,r4,#0x00070000 ++ add r1,r10,r1,lsr#12 @ r1=address of Fn ++ tst r4,#0x00000008 ++ bne CPRT_const ++ and r2,r4,#0x00000007 ++ add r2,r10,r2,lsl#4 @ r2=address of Fm ++ ++CPRT_constback: ++ and r3,r4,#0x00f00000 ++ ++ add pc,pc,r3,lsr#18 ++ mov r0,r0 ++ b CPRT_flt ++ b CPRT_fix ++ b CPRT_wfs ++ b CPRT_rfs ++ b undefined ++ b undefined ++ b undefined ++ b undefined ++ b undefined ++ b CPRT_cmf ++ b undefined ++ b CPRT_cnf ++ b undefined ++ b CPRT_cmf ++ b undefined ++ b CPRT_cnf ++ ++CPRT_const: ++ ldr r2,=fp_const ++ and r3,r4,#0x00000007 ++ add r2,r2,r3,lsl#4 ++ b CPRT_constback ++ ++/*---------------------------------------------------------------------------*/ ++ ++ @ The fetch of the next instruction to emulate could fault ++ ++ .section .fixup,"ax" ++ .align ++__f1: ++ mov pc,r9 ++ .previous ++ .section __ex_table,"a" ++ .align 3 ++ .long __x1,__f1 ++ .previous ++ ++/*---------------------------------------------------------------------------*/ +--- /dev/null 2003-09-23 18:19:32.000000000 -0400 ++++ linux-2.6.5/arch/arm/fastfpe/module.c 2004-04-30 20:57:36.000000000 -0400 +@@ -0,0 +1,62 @@ ++/* ++ Fast Floating Point Emulator ++ (c) Peter Teichmann <mail@peter-teichmann.de> ++ ++ 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., 675 Mass Ave, Cambridge, MA 02139, USA. ++*/ ++ ++#include <linux/module.h> ++#include <linux/types.h> ++#include <linux/kernel.h> ++#include <linux/signal.h> ++#include <linux/sched.h> ++#include <linux/init.h> ++#include <linux/errno.h> ++ ++#ifndef MODULE ++#define kern_fp_enter fp_enter ++ ++extern char fpe_type[]; ++#endif ++ ++static void (*orig_fp_enter)(void); /* old kern_fp_enter value */ ++extern void (*kern_fp_enter)(void); /* current FP handler */ ++extern void fastfpe_enter(void); /* forward declarations */ ++ ++static int __init fpe_init(void) ++{ ++ if (fpe_type[0] && strcmp(fpe_type, "fastfpe")) ++ return 0; ++ ++ printk("Fast Floating Point Emulator V0.9 (c) Peter Teichmann.\n"); ++ ++ /* Save pointer to the old FP handler and then patch ourselves in */ ++ orig_fp_enter = kern_fp_enter; ++ kern_fp_enter = fastfpe_enter; ++ ++ return 0; ++} ++ ++static void __exit fpe_exit(void) ++{ ++ /* Restore the values we saved earlier. */ ++ kern_fp_enter = orig_fp_enter; ++} ++ ++module_init(fpe_init); ++module_exit(fpe_exit); ++ ++MODULE_AUTHOR("Peter Teichmann <mail@peter-teichmann.de>"); ++MODULE_DESCRIPTION("Fast floating point emulator with full precision"); +--- /dev/null 2003-09-23 18:19:32.000000000 -0400 ++++ linux-2.6.5/arch/arm/fastfpe/CPDO.S 2004-04-30 20:57:36.000000000 -0400 +@@ -0,0 +1,682 @@ ++/* ++The FP structure has 4 words reserved for each register, the first is used just ++for the sign in bit 31, the second and third are for the mantissa (unsigned ++integer, high 32 bit first) and the fourth is the exponent (signed integer). ++The mantissa is always normalized. ++ ++If the exponent is 0x80000000, that is the most negative value, the number ++represented is 0 and both mantissa words are also 0. ++ ++If the exponent is 0x7fffffff, that is the biggest positive value, the number ++represented is infinity if the high 32 mantissa bit are also 0, otherwise it is ++a NaN. The low 32 mantissa bit are 0 if the number represented is infinity. ++ ++Decimal and packed decimal numbers are not supported yet. ++ ++The parameters to these functions are r0=destination pointer, r1 and r2 ++source pointers. r4 is the instruction. They may use r0-r8 and r14. They return ++to fastfpe_next, except CPDO_rnf_core which expects the return address in r14. ++*/ ++ ++/*---------------------------------------------------------------------------*/ ++ ++ .globl CPDO_adf ++CPDO_adf: ++ ldmia r1,{r1,r3,r5,r7} ++ ldmia r2,{r2,r4,r6,r8} ++ ++ cmp r7,#0x7fffffff ++ cmpne r8,#0x7fffffff ++ beq CPDO_adf_extra ++ ++ cmp r1,r2 ++ bne CPDO_suf_s ++ ++CPDO_adf_s: ++ subs r2,r7,r8 ++ bge CPDO_adf_2nd ++ ++ mov r7,r8 ++ rsb r2,r2,#0 ++ cmp r2,#32 ++ ble CPDO_adf_1st2 ++ ++ sub r2,r2,#32 ++ cmp r2,#32 ++ movgt r2,#32 ++ mov r5,r3,lsr r2 ++ mov r3,#0 ++ b CPDO_adf_add ++ ++CPDO_adf_1st2: ++ rsb r8,r2,#32 ++ mov r5,r5,lsr r2 ++ orr r5,r5,r3,lsl r8 ++ mov r3,r3,lsr r2 @ 1. op normalized ++ b CPDO_adf_add ++ ++CPDO_adf_2nd: ++ cmp r2,#32 ++ ble CPDO_adf_2nd2 ++ ++ sub r2,r2,#32 ++ cmp r2,#32 ++ movgt r2,#32 ++ mov r6,r4,lsr r2 ++ mov r4,#0 ++ b CPDO_adf_add ++ ++CPDO_adf_2nd2: ++ rsb r8,r2,#32 ++ mov r6,r6,lsr r2 ++ orr r6,r6,r4,lsl r8 ++ mov r4,r4,lsr r2 @ 2. op normalized ++ ++CPDO_adf_add: ++ adds r5,r5,r6 ++ adcs r3,r3,r4 @ do addition ++ bcc CPDO_adf_end ++ ++ add r7,r7,#1 ++ movs r3,r3,rrx ++ mov r5,r5,rrx @ correct for overflow ++ ++CPDO_adf_end: ++ cmp r7,#0x20000000 ++ bge CPDO_inf ++ ++ stmia r0,{r1,r3,r5,r7} ++ b fastfpe_next ++ ++CPDO_adf_extra: ++ cmp r7,#0x7fffffff @ was it the 1st ? ++ bne CPDO_infnan_2 @ no it was the 2nd ++ cmp r8,#0x7fffffff @ if 1st, 2nd too ? ++ bne CPDO_infnan_1 @ no only 1st ++ cmp r3,#0 ++ cmpeq r4,#0 ++ bne CPDO_nan_12 ++ b CPDO_inf ++ ++/*---------------------------------------------------------------------------*/ ++ ++CPDO_infnan_1: ++ stmia r0,{r1,r3,r5,r7} ++ b fastfpe_next ++ ++CPDO_infnan_2: ++ stmia r0,{r2,r4,r6,r8} ++ b fastfpe_next ++ ++CPDO_nan_12: ++ orr r2,r3,r4 ++ b CPDO_inf_1 ++ ++CPDO_nan: ++ mov r2,#0x40000000 @ create non signalling NaN ++ b CPDO_inf_1 ++ ++CPDO_inf: ++ mov r2,#0 ++CPDO_inf_1: ++ mov r3,#0 ++ mov r4,#0x7fffffff ++CPDO_store_1234: ++ stmia r0,{r1,r2,r3,r4} ++ b fastfpe_next ++ ++CPDO_zero: ++ mov r1,#0 ++CPDO_zero_1: ++ mov r2,#0 ++ mov r3,#0 ++ mov r4,#0x80000000 ++ stmia r0,{r1,r2,r3,r4} ++ b fastfpe_next ++ ++/*---------------------------------------------------------------------------*/ ++ ++ .globl CPDO_suf ++CPDO_suf: ++ ldmia r1,{r1,r3,r5,r7} ++ ldmia r2,{r2,r4,r6,r8} ++ ++CPDO_suf_l: ++ cmp r7,#0x7fffffff ++ cmpne r8,#0x7fffffff ++ beq CPDO_suf_extra ++ ++ cmp r1,r2 ++ bne CPDO_adf_s ++ ++CPDO_suf_s: ++ subs r2,r7,r8 @ determine greater number ++ bgt CPDO_suf_2nd @ first number is greater ++ blt CPDO_suf_1st @ second number is greater ++ cmp r3,r4 @ also mantissa is important ++ cmpeq r5,r6 ++ bhi CPDO_suf_2nd @ first number is greater ++ beq CPDO_zero ++ ++CPDO_suf_1st: ++ eor r1,r1,#0x80000000 @ second number is greater, invert sign ++ mov r7,r8 ++ rsb r2,r2,#0 ++ cmp r2,#32 ++ ble CPDO_suf_1st2 ++ ++ sub r2,r2,#32 ++ cmp r2,#32 ++ movgt r2,#32 ++ mov r5,r3,lsr r2 ++ mov r3,#0 ++ b CPDO_suf_1st_sub ++ ++CPDO_suf_1st2: ++ rsb r8,r2,#32 ++ mov r5,r5,lsr r2 ++ orr r5,r5,r3,lsl r8 ++ mov r3,r3,lsr r2 @ 1. op normalized ++ ++CPDO_suf_1st_sub: ++ subs r5,r6,r5 @ do subtraction ++ sbc r3,r4,r3 ++ b CPDO_suf_norm ++ ++CPDO_suf_2nd: ++ cmp r2,#32 ++ ble CPDO_suf_2nd2 ++ ++ sub r2,r2,#32 ++ cmp r2,#32 ++ movgt r2,#32 ++ mov r6,r4,lsr r2 ++ mov r4,#0 ++ b CPDO_suf_2nd_sub ++ ++CPDO_suf_2nd2: ++ rsb r8,r2,#32 ++ mov r6,r6,lsr r2 ++ orr r6,r6,r4,lsl r8 ++ mov r4,r4,lsr r2 @ 2. op normalized ++ ++CPDO_suf_2nd_sub: ++ subs r5,r5,r6 ++ sbc r3,r3,r4 @ do subtraction ++ ++CPDO_suf_norm: ++ teq r3,#0 @ normalize 32bit ++ moveq r3,r5 ++ moveq r5,#0 ++ subeq r7,r7,#32 ++ ++ cmp r3,#0x00010000 @ 16bit ++ movcc r3,r3,lsl#16 ++ orrcc r3,r3,r5,lsr#16 ++ movcc r5,r5,lsl#16 ++ subcc r7,r7,#16 ++ ++ cmp r3,#0x01000000 @ 8bit ++ movcc r3,r3,lsl#8 ++ orrcc r3,r3,r5,lsr#24 ++ movcc r5,r5,lsl#8 ++ subcc r7,r7,#8 ++ ++ cmp r3,#0x10000000 @ 4bit ++ movcc r3,r3,lsl#4 ++ orrcc r3,r3,r5,lsr#28 ++ movcc r5,r5,lsl#4 ++ subcc r7,r7,#4 ++ ++ cmp r3,#0x40000000 @ 2bit ++ movcc r3,r3,lsl#2 ++ orrcc r3,r3,r5,lsr#30 ++ movcc r5,r5,lsl#2 ++ subcc r7,r7,#2 ++ ++ cmp r3,#0x80000000 @ 1bit ++ movcc r3,r3,lsl#1 ++ orrcc r3,r3,r5,lsr#31 ++ movcc r5,r5,lsl#1 ++ subcc r7,r7,#1 ++ ++ cmp r7,#0xe0000000 ++ ble CPDO_zero_1 ++ ++ stmia r0,{r1,r3,r5,r7} ++ b fastfpe_next ++ ++CPDO_suf_extra: ++ cmp r7,#0x7fffffff @ was it the 1st ? ++ eorne r2,r2,#0x80000000 @ change sign, might have been INF ++ bne CPDO_infnan_2 @ no it was the 2nd ++ cmp r8,#0x7fffffff @ if 1st, 2nd too ? ++ bne CPDO_infnan_1 @ no only 1st ++ cmp r3,#0 ++ cmpeq r4,#0 ++ bne CPDO_nan_12 ++ b CPDO_nan @ here is difference with adf ! ++ ++/*---------------------------------------------------------------------------*/ ++ ++ .globl CPDO_rsf ++CPDO_rsf: ++ mov r3,r2 ++ ldmia r1,{r2,r4,r6,r8} ++ ldmia r3,{r1,r3,r5,r7} ++ b CPDO_suf_l ++ ++/*---------------------------------------------------------------------------*/ ++ ++ .globl CPDO_muf ++CPDO_muf: ++ ldmia r1,{r1,r3,r5,r7} ++ ldmia r2,{r2,r4,r6,r8} ++ ++ cmp r7,#0x7fffffff ++ cmpne r8,#0x7fffffff ++ beq CPDO_muf_extra ++ ++ eor r1,r1,r2 ++ adds r8,r7,r8 ++ bvs CPDO_zero_1 ++ ++ umull r7,r2,r3,r4 ++ umull r14,r3,r6,r3 ++ adds r7,r7,r3 @ r2|r7|r14 = r2|r7|#0 + #0|r3|r14 ++ adc r2,r2,#0 ++ umull r4,r3,r5,r4 ++ adds r14,r14,r4 @ r2|r7|r14 += #0|r3|r4 ++ adcs r7,r7,r3 ++ adc r2,r2,#0 ++ umull r4,r3,r5,r6 ++ adds r14,r14,r3 @ r2|r7|r14 += #0|#0|r3 ++ adcs r7,r7,#0 ++ adcs r2,r2,#0 ++ ++ bpl CPDO_muf_norm ++ ++ add r8,r8,#1 ++ b CPDO_muf_end ++ ++CPDO_muf_norm: ++ adds r14,r14,r14 ++ adcs r7,r7,r7 ++ adcs r2,r2,r2 ++ ++CPDO_muf_end: ++ cmp r8,#0x20000000 ++ bge CPDO_inf ++ cmp r8,#0xe0000000 ++ ble CPDO_zero_1 ++ stmia r0,{r1,r2,r7,r8} ++ b fastfpe_next ++ ++CPDO_muf_extra: ++ cmp r7,#0x7fffffff @ was it the first? ++ bne CPDO_muf_extra_2nd @ no, so it was the second ++ cmp r8,#0x7fffffff @ yes, second too? ++ bne CPDO_muf_extra_1st @ no, only first ++ orr r3,r3,r4 @ if both inf -> inf, otherwise nan ++ eor r1,r1,r2 @ sign for the inf case ++ b CPDO_infnan_1 ++ ++CPDO_muf_extra_1st: ++ cmp r3,#0 @ is it a nan? ++ bne CPDO_infnan_1 ++ cmp r8,#0x80000000 @ is the second 0? ++ beq CPDO_nan ++ eor r1,r1,r2 @ correct sign for inf ++ b CPDO_inf ++ ++CPDO_muf_extra_2nd: ++ cmp r4,#0 @ is it a nan? ++ bne CPDO_infnan_2 ++ cmp r7,#0x80000000 @ is the first 0? ++ beq CPDO_nan ++ eor r1,r1,r2 @ correct sign for inf ++ b CPDO_inf ++ ++/*---------------------------------------------------------------------------*/ ++ ++ .globl CPDO_dvf ++CPDO_dvf: ++ ldmia r1,{r1,r3,r5,r7} ++ ldmia r2,{r2,r4,r6,r8} ++ ++CPDO_dvf_l: ++ cmp r7,#0x7fffffff ++ cmpne r8,#0x7fffffff ++ beq CPDO_dvf_extra ++ cmp r8,#0x80000000 ++ beq CPDO_dvf_by0 ++ ++ eor r1,r1,r2 ++ cmp r7,#0x80000000 ++ beq CPDO_zero_1 ++ ++ sub r8,r7,r8 ++ ++ mov r2,#0 ++ mov r7,#1 ++ ++ cmp r3,r4 ++ cmpeq r5,r6 ++ bcs CPDO_dvf_loop_ ++ ++ sub r8,r8,#1 ++ ++CPDO_dvf_loop: ++ adds r5,r5,r5 ++ adcs r3,r3,r3 ++ bcs CPDO_dvf_anyway ++CPDO_dvf_loop_: ++ subs r5,r5,r6 ++ sbcs r3,r3,r4 ++ bcs CPDO_dvf_okay ++ ++ adds r5,r5,r6 ++ adc r3,r3,r4 ++ adds r7,r7,r7 ++ adcs r2,r2,r2 ++ bcc CPDO_dvf_loop ++ b CPDO_dvf_end ++ ++CPDO_dvf_anyway: ++ adcs r7,r7,r7 ++ adcs r2,r2,r2 ++ bcs CPDO_dvf_end ++ subs r5,r5,r6 ++ sbc r3,r3,r4 ++ b CPDO_dvf_loop ++ ++CPDO_dvf_okay: ++ adcs r7,r7,r7 ++ adcs r2,r2,r2 ++ bcc CPDO_dvf_loop ++ ++CPDO_dvf_end: ++ b CPDO_muf_end ++ ++CPDO_dvf_by0: ++ cmp R7,#0x80000000 ++ beq CPDO_nan @ first also 0 -> nan ++ eor r1,r1,r2 @ otherwise calculatesign for inf ++ b CPDO_inf ++ ++CPDO_dvf_extra: ++ cmp r7,#0x7fffffff @ was it the first? ++ bne CPDO_dvf_extra_2nd @ no, so it was the second ++ cmp r8,#0x7fffffff @ yes, second too? ++ bne CPDO_dvf_extra_1st @ no, only first ++ orrs r3,r3,r4 ++ beq CPDO_nan @ if both inf -> create nan ++ b CPDO_nan_12 @ otherwise keep nan ++ ++CPDO_dvf_extra_1st: ++ eor r1,r1,r2 @ correct sign for inf ++ b CPDO_infnan_1 ++ ++CPDO_dvf_extra_2nd: ++ cmp r4,#0 @ is it a nan? ++ bne CPDO_infnan_2 ++ eor r1,r1,r2 @ correct sign for zero ++ b CPDO_zero_1 ++ ++/*---------------------------------------------------------------------------*/ ++ ++ .globl CPDO_rdf ++CPDO_rdf: ++ mov r3,r2 ++ ldmia r1,{r2,r4,r6,r8} ++ ldmia r3,{r1,r3,r5,r7} ++ b CPDO_dvf_l ++ ++/*---------------------------------------------------------------------------*/ ++ ++ .globl CPDO_rmf ++CPDO_rmf: ++ b fastfpe_next ++ ++/*---------------------------------------------------------------------------*/ ++ ++ ++ ++/*---------------------------------------------------------------------------*/ ++ ++ .globl CPDO_mvf ++CPDO_mvf: ++ ldmia r2,{r1,r2,r3,r4} ++ stmia r0,{r1,r2,r3,r4} ++ b fastfpe_next ++ ++/*---------------------------------------------------------------------------*/ ++ ++ .globl CPDO_mnf ++CPDO_mnf: ++ ldmia r2,{r1,r2,r3,r4} ++ eor r1,r1,#0x80000000 ++ stmia r0,{r1,r2,r3,r4} ++ b fastfpe_next ++ ++/*---------------------------------------------------------------------------*/ ++ ++ .globl CPDO_abs ++CPDO_abs: ++ ldmia r2,{r1,r2,r3,r4} ++ bic r1,r1,#0x80000000 ++ stmia r0,{r1,r2,r3,r4} ++ b fastfpe_next ++ ++/*---------------------------------------------------------------------------*/ ++ ++ .globl CPDO_sqt ++CPDO_sqt: ++ ldmia r2,{r1,r2,r3,r4} ++ cmp r1,#0 ++ bne CPDO_nan ++ cmp r4,#0x7fffffff ++ beq CPDO_store_1234 ++ ++ tst r4,r4,lsr#1 @carry=exponent bit 0 ++ bcc CPDO_sqt_exponenteven ++ adds r3,r3,r3 ++ adcs r2,r2,r2 @carry is needed in loop! ++CPDO_sqt_exponenteven: ++ mov r4,r4,asr #1 ++ str r4,[r0,#12] ++ ++ mov r4,#0x80000000 ++ mov r5,#0 ++ sub r2,r2,#0x80000000 ++ ++ mov r8,#0x40000000 ++ mov r14,#0x80000000 ++ ++ mov r1,#1 ++ b CPDO_sqt_loop1_first ++CPDO_sqt_loop1: ++ adds r3,r3,r3 ++ adcs r2,r2,r2 ++CPDO_sqt_loop1_first: ++ add r6,r4,r8,lsr r1 @r7 const = r5 ++ bcs CPDO_sqt_loop1_1 ++ cmp r2,r6 ++ cmpeq r3,r5 @r5 for r7 ++ bcc CPDO_sqt_loop1_0 ++CPDO_sqt_loop1_1: ++ orr r4,r4,r14,lsr r1 ++ subs r3,r3,r5 @r5 for r7 ++ sbc r2,r2,r6 ++CPDO_sqt_loop1_0: ++ add r1,r1,#1 ++ cmp r1,#30 ++ ble CPDO_sqt_loop1 ++ ++ adds r3,r3,r3 ++ adcs r2,r2,r2 ++ bcs CPDO_sqt_between_1 ++ adds r7,r5,#0x80000000 ++ adc r6,r4,#0 ++ cmp r2,r6 ++ cmpeq r3,r7 ++ bcc CPDO_sqt_between_0 ++CPDO_sqt_between_1: ++ orr r4,r4,#0x00000001 ++ subs r3,r3,r5 ++ sbc r2,r2,r4 ++ subs r3,r3,#0x80000000 ++ sbc r2,r2,#0 ++CPDO_sqt_between_0: ++ mov r1,#0 ++ ++CPDO_sqt_loop2: ++ adds r3,r3,r3 ++ adcs r2,r2,r2 ++ bcs CPDO_sqt_loop2_1 ++ adds r7,r5,r8,lsr r1 ++ adc r6,r4,#0 ++ cmp r2,r6 ++ cmpeq r3,r7 ++ bcc CPDO_sqt_loop2_0 ++CPDO_sqt_loop2_1: ++ orr r5,r5,r14,lsr r1 ++ subs r3,r3,r5 ++ sbc r2,r2,r4 ++ subs r3,r3,r8,lsr r1 ++ sbc r2,r2,#0 ++CPDO_sqt_loop2_0: ++ add r1,r1,#1 ++ cmp r1,#30 ++ ble CPDO_sqt_loop2 ++ ++ adds r3,r3,r3 ++ adcs r2,r2,r2 ++ bcs CPDO_sqt_after_1 ++ cmp r2,r6 ++ cmpeq r3,r7 ++ bcc CPDO_sqt_after_0 ++CPDO_sqt_after_1: ++ orr r5,r5,#0x00000001 ++CPDO_sqt_after_0: ++ ++ mov r1,#0 ++ stmia r0,{r1,r4,r5} ++ b fastfpe_next ++ ++/*---------------------------------------------------------------------------*/ ++ ++ .globl CPDO_rnd ++CPDO_rnd: ++ ldmia r2,{r1,r2,r3,r5} ++ bl CPDO_rnd_core ++ ++CPDO_rnd_store: ++ stmia r0,{r1,r2,r3,r5} ++ b fastfpe_next ++ ++/*---------------------------------------------------------------------------*/ ++ ++ .globl CPDO_rnd_core ++CPDO_rnd_core: ++ and r4,r4,#0x00000060 ++ add pc,pc,r4,lsr#3 ++ mov r0,r0 ++ b CPDO_rnd_N ++ b CPDO_rnd_P ++ b CPDO_rnd_M ++ b CPDO_rnd_Z ++ ++CPDO_rnd_N: ++ cmp r5,#-1 ++ blt CPDO_rnd_zero ++ cmp r5,#63 ++ movge pc,r14 ++ mov r4,#0x40000000 ++ cmp r5,#31 ++ bge CPDO_rnd_N_2 ++ ++ adds r2,r2,r4,lsr r5 ++ bcc CPDO_rnd_end ++ b CPDO_rnd_end_norm ++ ++CPDO_rnd_N_2: ++CPDO_rnd_P_2: ++ sub r6,r5,#32 ++ adds r3,r3,r4,ror r6 @ror ist needed to handle a -1 correctly ++ adcs r2,r2,#0 ++ bcc CPDO_rnd_end ++ b CPDO_rnd_end_norm ++ ++CPDO_rnd_P: ++ tst r1,#0x80000000 ++ bne CPDO_rnd_M_entry ++CPDO_rnd_P_entry: ++ cmp r5,#0 ++ blt CPDO_rnd_P_small ++ cmp r5,#63 ++ movge pc,r14 ++ mov r4,#0x7fffffff ++ cmp r5,#32 ++ bge CPDO_rnd_P_2 ++ ++ adds r3,r3,#0xffffffff ++ adcs r2,r2,r4,lsr r5 ++ bcc CPDO_rnd_end ++ b CPDO_rnd_end_norm ++ ++CPDO_rnd_P_small: ++ cmp r5,#0x80000000 ++ moveq pc,r14 ++ b CPDO_rnd_one ++ ++CPDO_rnd_M: ++ tst r1,#0x80000000 ++ bne CPDO_rnd_P_entry ++CPDO_rnd_M_entry: ++ cmp r5,#0 ++ blt CPDO_rnd_zero ++ cmp r5,#63 ++ movge pc,r14 ++ ++ b CPDO_rnd_end ++ ++CPDO_rnd_Z: ++ cmp r5,#0 ++ blt CPDO_rnd_zero ++ cmp r5,#63 ++ movge pc,r14 ++ b CPDO_rnd_end ++ ++CPDO_rnd_end_norm: ++ add r5,r5,#1 ++ movs r2,r2,rrx ++ mov r3,r3,rrx ++CPDO_rnd_end: ++ rsbs r4,r5,#31 ++ bmi CPDO_rnd_end_2 ++ mov r3,#0 ++ mov r2,r2,lsr r4 ++ mov r2,r2,lsl r4 ++ mov pc,r14 ++ ++CPDO_rnd_end_2: ++ rsb r4,r5,#63 ++ mov r3,r3,lsr r4 ++ mov r3,r3,lsl r4 ++ mov pc,r14 ++ ++CPDO_rnd_one: ++ mov r2,#0x80000000 ++ mov r3,#0 ++ mov r5,#0 ++ mov pc,r14 ++ ++CPDO_rnd_zero: ++ mov r1,#0 ++ mov r2,#0 ++ mov r3,#0 ++ mov r5,#0x80000000 ++ mov pc,r14 ++ ++/*---------------------------------------------------------------------------*/ +--- /dev/null 2003-09-23 18:19:32.000000000 -0400 ++++ linux-2.6.5/arch/arm/fastfpe/CPRT.S 2004-04-30 20:57:36.000000000 -0400 +@@ -0,0 +1,185 @@ ++/* ++The FP structure has 4 words reserved for each register, the first is used ++just ++for the sign in bit 31, the second and third are for the mantissa (unsigned ++integer, high 32 bit first) and the fourth is the exponent (signed integer). ++The mantissa is always normalized. ++ ++If the exponent is 0x80000000, that is the most negative value, the number ++represented is 0 and both mantissa words are also 0. ++ ++If the exponent is 0x7fffffff, that is the biggest positive value, the ++number ++represented is infinity if the high 32 mantissa bit are also 0, otherwise it ++is ++a NaN. The low 32 mantissa bit are 0 if the number represented is infinity. ++ ++Decimal and packed decimal numbers are not supported yet. ++*/ ++ ++/*---------------------------------------------------------------------------*/ ++ ++ .text ++ .globl CPRT_flt ++CPRT_flt: ++ add r0,r13,r0,lsr#10 ++ ldr r2,[r0] ++ mov r3,#0 ++ cmp r2,#0 ++ beq CPRT_flt_zero ++ ++ ands r0,r2,#0x80000000 ++ rsbne r2,r2,#0 ++ mov r4,#31 ++ ++ cmp r2,#0x00010000 ++ movcc r2,r2,lsl#16 ++ subcc r4,r4,#16 ++ ++ cmp r2,#0x01000000 ++ movcc r2,r2,lsl#8 ++ subcc r4,r4,#8 ++ ++ cmp r2,#0x10000000 ++ movcc r2,r2,lsl#4 ++ subcc r4,r4,#4 ++ ++ cmp r2,#0x40000000 ++ movcc r2,r2,lsl#2 ++ subcc r4,r4,#2 ++ ++ cmp r2,#0x80000000 ++ movcc r2,r2,lsl#1 ++ subcc r4,r4,#1 ++ ++ stmia r1,{r0,r2,r3,r4} ++ b fastfpe_next ++ ++CPRT_flt_zero: ++ mov r0,#0 ++ mov r4,#0x80000000 ++ stmia r1,{r0,r2,r3,r4} ++ b fastfpe_next ++ ++/*---------------------------------------------------------------------------*/ ++ ++ .globl CPRT_fix ++CPRT_fix: ++ ldmia r2,{r1,r2,r3,r5} ++ bl CPDO_rnd_core ++ ++CPRT_back: ++ add r0,r13,r0,lsr#10 ++ cmp r5,#0 ++ blt CPRT_int_zero ++ cmp r5,#30 ++ bgt CPRT_overflow ++ ++ rsb r5,r5,#31 ++ mov r2,r2,lsr r5 ++ tst r1,#0x80000000 ++ rsbne r2,r2,#0 ++ ++ str r2,[r0] ++ b fastfpe_next ++ ++CPRT_int_zero: ++ mov r2,#0 ++ str r2,[r0] ++ b fastfpe_next ++ ++CPRT_overflow: ++ mov r2,#0x80000000 ++ tst r1,#0x80000000 ++ subeq r2,r2,#1 ++ str r2,[r0] ++ b fastfpe_next ++ ++/*---------------------------------------------------------------------------*/ ++ ++ .globl CPRT_wfs ++CPRT_wfs: ++ b fastfpe_next ++ ++/*---------------------------------------------------------------------------*/ ++ ++ .globl CPRT_rfs ++CPRT_rfs: ++ add r0,r13,r0,lsr#10 ++ mov r1,#0x02000000 @ Software Emulation, not Acorn FPE ++ str r1,[r0] ++ b fastfpe_next ++ ++/*---------------------------------------------------------------------------*/ ++ ++ .globl CPRT_cmf ++CPRT_cmf: ++ ldmia r1,{r1,r3,r5,r7} ++ ldmia r2,{r2,r4,r6,r8} ++ ++CPRT_cmf_e: ++ ldr r0,[r13,#16*4] ++ ++ cmp r7,#0x7fffffff ++ bic r0,r0,#0xf0000000 ++ ++ cmpeq r3,#0xffffffff ++ beq CPRT_cmf_unordered ++ cmp r8,#0x7fffffff ++ cmpeq r4,#0xffffffff ++ beq CPRT_cmf_unordered ++ ++ cmp r1,r2 ++ beq CPRT_cmf_equalsign ++ b CPRT_cmf_sign ++ ++CPRT_cmf_equalsign: ++ cmp r7,r8 ++ beq CPRT_cmf_equalexponent ++ bgt CPRT_cmf_sign ++ b CPRT_cmf_signb ++ ++CPRT_cmf_equalexponent: ++ cmp r3,r4 ++ cmpeq r5,r6 ++ beq CPRT_cmf_equal ++ bhi CPRT_cmf_sign ++ b CPRT_cmf_signb ++ ++CPRT_cmf_sign: ++ cmp r7,#0x80000000 @ (0.0 == -0.0)? ++ cmpeq r7,r8 ++ beq CPRT_cmf_equal ++ tst r1,#0x80000000 ++ orreq r0,r0,#0x20000000 ++ orrne r0,r0,#0x80000000 ++ str r0,[r13,#16*4] ++ b fastfpe_next ++ ++CPRT_cmf_signb: ++ tst r1,#0x80000000 ++ orrne r0,r0,#0x20000000 ++ orreq r0,r0,#0x80000000 ++ str r0,[r13,#16*4] ++ b fastfpe_next ++ ++CPRT_cmf_equal: ++ orr r0,r0,#0x60000000 ++ str r0,[r13,#16*4] ++ b fastfpe_next ++ ++CPRT_cmf_unordered: ++ orr r0,r0,#0x10000000 ++ str r0,[r13,#16*4] ++ b fastfpe_next ++ ++/*---------------------------------------------------------------------------*/ ++ ++ .globl CPRT_cnf ++CPRT_cnf: ++ ldmia r1,{r1,r3,r5,r7} ++ ldmia r2,{r2,r4,r6,r8} ++ eor r2,r2,#0x80000000 ++ b CPRT_cmf_e ++ ++/*---------------------------------------------------------------------------*/ +--- /dev/null 2003-09-23 18:19:32.000000000 -0400 ++++ linux-2.6.5/arch/arm/fastfpe/CPDT.S 2004-04-30 20:57:36.000000000 -0400 +@@ -0,0 +1,430 @@ ++/* ++The FP structure has 4 words reserved for each register, the first is used just ++for the sign in bit 31, the second and third are for the mantissa (unsigned ++integer, high 32 bit first) and the fourth is the exponent (signed integer). ++The mantissa is always normalized. ++ ++If the exponent is 0x80000000, that is the most negative value, the number ++represented is 0 and both mantissa words are also 0. ++ ++If the exponent is 0x7fffffff, that is the biggest positive value, the number ++represented is infinity if the high 32 mantissa bit are also 0, otherwise it is ++a NaN. The low 32 mantissa bit are 0 if the number represented is infinity. ++ ++Decimal and packed decimal numbers are not supported yet. ++*/ ++ ++/*---------------------------------------------------------------------------*/ ++ ++ .globl CPDT_load_single ++CPDT_load_single: ++ ldr r1,[r6] ++ ++ and r2,r1,#0x80000000 @ r2 = sign ++ ++ mov r5,r1,lsr#23 ++ bics r5,r5,#0x100 ++ beq CPDT_ls_e0 @ exponent = 0; zero/denormalized ++ teq r5,#255 ++ beq CPDT_ls_e255 @ exponent = 255; infinity/NaN ++ ++ sub r5,r5,#127 @ r5 = exponent, remove normalized bias ++ ++ mov r3,r1,lsl#8 ++ orr r3,r3,#0x80000000 ++ mov r4,#0 @ r3,r4 = mantissa ++ ++ stmia r0,{r2-r5} ++ b fastfpe_next ++ ++CPDT_ls_e0: ++ movs r3,r1,lsl#9 ++ beq CPDT_load_zero ++ ++ mov r5,#-127 ++ ++CPDT_ls_e0_norm: ++ tst r3,#0x80000000 ++ subeq r5,r5,#1 ++ moveq r3,r3,lsl#1 ++ beq CPDT_ls_e0_norm ++ ++ mov r4,#0 ++ stmia r0,{r2-r5} ++ b fastfpe_next ++ ++CPDT_ls_e255: ++ mov r3,r1,lsl#9 ++ mov r4,#0 ++ mov r5,#0x7fffffff ++ stmia r0,{r2-r5} ++ b fastfpe_next ++ ++CPDT_load_zero: ++ mov r3,#0 ++ mov r4,#0 ++ mov r5,#0x80000000 ++ stmia r0,{r2-r5} ++ b fastfpe_next ++ ++/*---------------------------------------------------------------------------*/ ++ ++ .globl CPDT_load_double ++CPDT_load_double: ++ ldr r1,[r6] ++ ldr r6,[r6,#4] ++ ++ and r2,r1,#0x80000000 @ r2 = sign ++ ++ mov r5,r1,lsr#20 ++ bics r5,r5,#0x800 ++ beq CPDT_ld_e0 @ exponent = 0; zero/denormalized ++ add r4,r5,#1 ++ teq r4,#2048 ++ beq CPDT_ld_e2047 @ exponent = 2047; infinity/NaN ++ ++ add r5,r5,#1 ++ sub r5,r5,#1024 @ r5 = exponent, remove normalized bias ++ ++ mov r3,r1,lsl#11 ++ orr r3,r3,#0x80000000 ++ orr r3,r3,r6,lsr #21 ++ mov r4,r6,lsl#11 @ r3,r4 = mantissa ++ ++ stmia r0,{r2-r5} ++ b fastfpe_next ++ ++CPDT_ld_e0: ++ mov r3,r1,lsl#12 ++ orr r3,r3,r6,lsr#20 ++ movs r4,r6,lsl#12 ++ teqeq r3,#0 ++ beq CPDT_load_zero ++ ++ mov r5,#1 ++ sub r5,r5,#1024 ++ ++CPDT_ld_e0_norm: ++ tst r3,#0x80000000 ++ subeq r5,r5,#1 ++ moveqs r4,r4,lsl#1 ++ adceq r3,r3,r3 ++ beq CPDT_ld_e0_norm ++ ++ stmia r0,{r2-r5} ++ b fastfpe_next ++ ++CPDT_ld_e2047: ++ mov r3,r1,lsl#12 ++ orr r3,r3,r6,lsr#1 ++ bic r6,r6,#0x80000000 ++ orr r3,r3,r6 @ to get all fraction bits ! ++ mov r4,#0 ++ mov r5,#0x7fffffff ++ stmia r0,{r2-r5} ++ b fastfpe_next ++ ++/*---------------------------------------------------------------------------*/ ++ ++ .globl CPDT_load_extended ++CPDT_load_extended: ++ ldr r1,[r6] ++ ldr r3,[r6,#4] ++ ldr r4,[r6,#8] ++ ++ and r2,r1,#0x80000000 ++ bics r5,r1,#0x80000000 ++ beq CPDT_le_e0 ++ add r1,r5,#1 ++ teq r4,#32768 ++ beq CPDT_le_e32767 ++ ++ add r5,r5,#1 ++ sub r5,r5,#16384 ++ ++ stmia r0,{r2-r5} ++ b fastfpe_next ++ ++CPDT_le_e0: ++ teq r3,#0 ++ teqeq r4,#0 ++ beq CPDT_load_zero ++ ++ mov r5,#2 ++ sub r5,r5,#16384 ++ b CPDT_ld_e0_norm ++ ++CPDT_le_e32767: ++ mov r3,r3,lsl#1 ++ orr r3,r3,r4,lsr#1 ++ bic r4,r4,#0x80000000 ++ orr r3,r3,r4 ++ mov r5,#0x7fffffff ++ stmia r0,{r2-r5} ++ b fastfpe_next ++ ++/*---------------------------------------------------------------------------*/ ++ ++ .globl CPDT_load_decimal ++CPDT_load_decimal: ++ ++ b fastfpe_next ++ ++/*---------------------------------------------------------------------------*/ ++ ++ .globl CPDT_store_single ++CPDT_store_single: ++ ldmia r0,{r1-r4} ++ ++ cmp r4,#-127 ++ ble CPDT_ss_e0 ++ cmp r4,#128 ++ bge CPDT_ss_e255 ++ ++ adds r2,r2,#1<<7 @ round to nearest ++ bcs CPDT_ss_rnd_ovfl @ very very seldom taken ++ ++CPDT_ss_store: ++ add r4,r4,#127 ++ orr r1,r1,r4,lsl#23 ++ ++ bic r2,r2,#0x80000000 ++ orr r1,r1,r2,lsr#8 ++ ++ str r1,[r6] ++ b fastfpe_next ++ ++CPDT_ss_rnd_ovfl: ++ add r4,r4,#1 ++ cmp r4,#128 ++ bge CPDT_ss_e255 ++ ++ mov r2,#0x80000000 ++ mov r3,#0 ++ b CPDT_ss_store ++ ++CPDT_ss_e0: ++ cmp r4,#-150 ++ ble CPDT_ss_zero ++ ++ add r4,r4,#126 ++CPDT_ss_unnormalize: ++ mov r2,r2,lsr#1 ++ adds r4,r4,#1 ++ bne CPDT_ss_unnormalize ++ ++ orr r1,r1,r2,lsr#8 ++ ++CPDT_ss_zero: ++ str r1,[r6] ++ b fastfpe_next ++ ++CPDT_ss_e255: ++ cmp r4,#0x7fffffff ++ bne CPDT_ss_inf ++ cmp r2,#0 ++ beq CPDT_ss_inf ++ ++ orr r1,r1,#0x00200000 @ for safety so that it is not INF ++ orr r1,r1,r2,lsr#9 @ get highest bit of mantissa ++ ++CPDT_ss_inf: ++ orr r1,r1,#0x7f000000 ++ orr r1,r1,#0x00800000 ++ str r1,[r6] ++ b fastfpe_next ++ ++/*---------------------------------------------------------------------------*/ ++ ++ .globl CPDT_store_double ++CPDT_store_double: ++ ldmia r0,{r1-r4} ++ ++ cmp r4,#1024 @ this check has to be first, or ++ bge CPDT_sd_e2047 @ overflow can occur on second ! ++ add r0,r4,#3 ++ cmp r0,#-1023+3 @ cmp with -1023 ++ ble CPDT_sd_e0 ++ ++ adds r3,r3,#1<<10 @ round to nearest ++ adcs r2,r2,#0 ++ bcs CPDT_sd_rnd_ovfl @ very very seldom taken ++ ++CPDT_sd_store: ++ sub r4,r4,#1 ++ add r4,r4,#1024 ++ orr r1,r1,r4,lsl#20 ++ ++ bic r2,r2,#0x80000000 ++ orr r1,r1,r2,lsr#11 ++ ++ mov r2,r2,lsl#21 ++ orr r2,r2,r3,lsr#11 ++ ++ stmia r6,{r1,r2} ++ b fastfpe_next ++ ++CPDT_sd_rnd_ovfl: ++ add r4,r4,#1 ++ cmp r4,#1024 ++ bge CPDT_sd_e2047 ++ ++ mov r2,#0x80000000 ++ mov r3,#0 ++ b CPDT_sd_store ++ ++CPDT_sd_e0: ++ add r0,r4,#1075-1024 ++ cmp r0,#-1024 ++ ble CPDT_sd_zero ++ ++ add r4,r4,#1024 ++ sub r4,r4,#2 ++CPDT_sd_unnormalize: ++ movs r2,r2,lsr#1 ++ mov r3,r3,rrx ++ adds r4,r4,#1 ++ bne CPDT_sd_unnormalize ++ ++ orr r1,r1,r2,lsr#11 ++ mov r2,r2,lsl#21 ++ orr r2,r2,r3,lsr#11 ++ ++ stmia r6,{r1,r2} ++ b fastfpe_next ++ ++CPDT_sd_zero: ++ mov r2,#0 ++ stmia r6,{r1,r2} ++ b fastfpe_next ++ ++CPDT_sd_e2047: ++ cmp r4,#0x7fffffff ++ bne CPDT_sd_inf ++ cmp r2,#0 ++ beq CPDT_sd_inf ++ ++ orr r1,r1,#0x00040000 @ for safety so that it is not INF ++ orr r1,r1,r2,lsr#12 @ get highest bit of mantissa ++ ++CPDT_sd_inf: ++ orr r1,r1,#0x7f000000 ++ orr r1,r1,#0x00f00000 ++ stmia r6,{r1,r2} ++ b fastfpe_next ++ ++/*---------------------------------------------------------------------------*/ ++ ++ .globl CPDT_store_extended ++CPDT_store_extended: ++ ldmia r0,{r1-r4} ++ ++ cmp r4,#16384 @ this check has to be first, or ++ bge CPDT_se_e32767 @ overflow can occur with second ! ++ add r0,r4,#63 ++ cmp r0,#-16383+63 ++ ble CPDT_se_e0 ++ ++ sub r4,r4,#1 ++ add r4,r4,#16384 ++ orr r1,r1,r4 ++ ++ stmia r6,{r1-r3} ++ b fastfpe_next ++ ++CPDT_se_e0: ++ add r0,r4,#16446-16384 ++ cmp r0,#-16384 ++ ble CPDT_se_zero ++ ++ add r4,r4,#16384 ++ sub r4,r4,#2 ++CPDT_se_unnormalize: ++ movs r2,r2,lsr#1 ++ mov r3,r3,rrx ++ adds r4,r4,#1 ++ bne CPDT_se_unnormalize ++ ++ stmia r6,{r1-r3} ++ b fastfpe_next ++ ++CPDT_se_zero: ++ mov r2,#0 ++ mov r3,#0 ++ stmia r6,{r1-r3} ++ b fastfpe_next ++ ++CPDT_se_e32767: ++ cmp r4,#0x7fffffff ++ bne CPDT_se_inf ++ cmp r2,#0 ++ beq CPDT_se_inf ++ ++ mov r2,r2,lsl#1 ++ orr r2,r2,#0x20000000 ++ ++CPDT_se_inf: ++ orr r1,r1,#0x00007f00 ++ orr r1,r1,#0x000000ff ++ stmia r6,{r1-r3} ++ b fastfpe_next ++ ++/*---------------------------------------------------------------------------*/ ++ ++ .globl CPDT_store_decimal ++CPDT_store_decimal: ++ ++ b fastfpe_next ++ ++/*---------------------------------------------------------------------------*/ ++ ++ .globl CPDT_sfm ++CPDT_sfm: ++ add r2,r10,r0,lsr#8 ++ ldr r4,[r2,#0] ++ ldr r3,[r2,#4] ++ bic r3,r3,#0x80000000 ++ orr r3,r3,r4 ++ str r3,[r6],#4 ++ ldr r3,[r2,#8] ++ str r3,[r6],#4 ++ ldr r3,[r2,#12] ++ str r3,[r6],#4 ++ ++ add r0,r0,#1<<12 ++ and r0,r0,#7<<12 ++ subs r1,r1,#1 ++ bne CPDT_sfm ++ b fastfpe_next ++ ++/*---------------------------------------------------------------------------*/ ++ ++ .globl CPDT_lfm ++CPDT_lfm: ++ add r2,r10,r0,lsr#8 ++ ldr r4,[r6],#4 ++ and r3,r4,#0x80000000 ++ str r3,[r2,#0] ++ ldr r3,[r6],#4 ++ str r3,[r2,#8] ++ ldr r3,[r6],#4 ++ str r3,[r2,#12] ++ ++ cmp r3,#0x80000000 @ does the exp indicate zero? ++ biceq r4,r4,#0x80000000 @ if so, indicate 'denormalized' ++ beq CPDT_lfm_storer4 ++ cmp r3,#0x7fffffff @ does the exp indicate inf or NaN? ++ biceq r4,r4,#0x80000000 @ if so, indicate 'denormalized' ++ beq CPDT_lfm_storer4 ++ orrne r4,r4,#0x80000000 @ otherwise, set normalized bit ++ ++CPDT_lfm_storer4: ++ str r4,[r2,#4] ++ ++ add r0,r0,#1<<12 ++ and r0,r0,#7<<12 ++ subs r1,r1,#1 ++ bne CPDT_lfm ++ b fastfpe_next ++ ++/*---------------------------------------------------------------------------*/ +--- /dev/null 2003-09-23 18:19:32.000000000 -0400 ++++ linux-2.6.5/arch/arm/fastfpe/Makefile 2004-04-30 20:57:36.000000000 -0400 +@@ -0,0 +1,14 @@ ++# ++# linux/arch/arm/fastfpe/Makefile ++# ++# Copyright (C) Peter Teichmann ++# ++ ++obj-y := ++obj-m := ++obj-n := ++obj- := ++ ++fastfpe-objs := module.o entry.o CPDO.o CPRT.o CPDT.o ++ ++obj-$(CONFIG_FPE_FASTFPE) += fastfpe.o +--- /dev/null 2003-09-23 18:19:32.000000000 -0400 ++++ linux-2.6.5/arch/arm/common/rtctime.c 2004-04-30 20:57:36.000000000 -0400 +@@ -0,0 +1,482 @@ ++/* ++ * linux/arch/arm/common/rtctime.c ++ * ++ * Copyright (C) 2003 Deep Blue Solutions Ltd. ++ * Based on sa1100-rtc.c, Nils Faerber, CIH, Nicolas Pitre. ++ * Based on rtc.c by Paul Gortmaker ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License version 2 as ++ * published by the Free Software Foundation. ++ */ ++#include <linux/module.h> ++#include <linux/kernel.h> ++#include <linux/time.h> ++#include <linux/rtc.h> ++#include <linux/poll.h> ++#include <linux/proc_fs.h> ++#include <linux/miscdevice.h> ++#include <linux/spinlock.h> ++#include <linux/device.h> ++ ++#include <asm/rtc.h> ++#include <asm/semaphore.h> ++ ++static DECLARE_WAIT_QUEUE_HEAD(rtc_wait); ++static struct fasync_struct *rtc_async_queue; ++ ++/* ++ * rtc_lock protects rtc_irq_data ++ */ ++static spinlock_t rtc_lock = SPIN_LOCK_UNLOCKED; ++static unsigned long rtc_irq_data; ++ ++/* ++ * rtc_sem protects rtc_inuse and rtc_ops ++ */ ++static DECLARE_MUTEX(rtc_sem); ++static unsigned long rtc_inuse; ++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; ++} ++ ++/* ++ * Convert Gregorian date to seconds since 01-01-1970 00:00:00. ++ */ ++int rtc_tm_to_time(struct rtc_time *tm, unsigned long *time) ++{ ++ unsigned int yrs = tm->tm_year + 1900; ++ ++ *time = 0; ++ ++ if (yrs < 1970 || ++ tm->tm_mon >= 12 || ++ tm->tm_mday < 1 || ++ tm->tm_mday > month_days(tm->tm_mon, yrs) || ++ tm->tm_hour >= 24 || ++ tm->tm_min >= 60 || ++ tm->tm_sec >= 60) ++ return -EINVAL; ++ ++ *time = mktime(yrs, tm->tm_mon + 1, tm->tm_mday, ++ tm->tm_hour, tm->tm_min, tm->tm_sec); ++ ++ return 0; ++} ++ ++/* ++ * Calculate the next alarm time given the requested alarm time mask ++ * and the current time. ++ * ++ * FIXME: for now, we just copy the alarm time because we're lazy (and ++ * is therefore buggy - setting a 10am alarm at 8pm will not result in ++ * the alarm triggering.) ++ */ ++void rtc_next_alarm_time(struct rtc_time *next, struct rtc_time *now, struct rtc_time *alrm) ++{ ++ next->tm_year = now->tm_year; ++ next->tm_mon = now->tm_mon; ++ next->tm_mday = now->tm_mday; ++ next->tm_hour = alrm->tm_hour; ++ next->tm_min = alrm->tm_min; ++ next->tm_sec = alrm->tm_sec; ++} ++ ++static inline void rtc_read_time(struct rtc_ops *ops, struct rtc_time *tm) ++{ ++ memset(tm, 0, sizeof(struct rtc_time)); ++ ops->read_time(tm); ++} ++ ++static inline int rtc_set_time(struct rtc_ops *ops, struct rtc_time *tm) ++{ ++ return ops->set_time(tm); ++} ++ ++static inline void rtc_read_alarm(struct rtc_ops *ops, struct rtc_wkalrm *alrm) ++{ ++ memset(alrm, 0, sizeof(struct rtc_wkalrm)); ++ ops->read_alarm(alrm); ++} ++ ++static inline int rtc_set_alarm(struct rtc_ops *ops, struct rtc_wkalrm *alrm) ++{ ++ return ops->set_alarm(alrm); ++} ++ ++void rtc_update(unsigned long num, unsigned long events) ++{ ++ spin_lock(&rtc_lock); ++ rtc_irq_data = (rtc_irq_data + (num << 8)) | events; ++ spin_unlock(&rtc_lock); ++ ++ wake_up_interruptible(&rtc_wait); ++ kill_fasync(&rtc_async_queue, SIGIO, POLL_IN); ++} ++ ++ ++static ssize_t ++rtc_read(struct file *file, char *buf, size_t count, loff_t *ppos) ++{ ++ DECLARE_WAITQUEUE(wait, current); ++ unsigned long data; ++ ssize_t ret; ++ ++ if (count < sizeof(unsigned long)) ++ return -EINVAL; ++ ++ add_wait_queue(&rtc_wait, &wait); ++ do { ++ __set_current_state(TASK_INTERRUPTIBLE); ++ ++ spin_lock_irq(&rtc_lock); ++ data = rtc_irq_data; ++ rtc_irq_data = 0; ++ spin_unlock_irq(&rtc_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_wait, &wait); ++ ++ if (ret == 0) { ++ ret = put_user(data, (unsigned long *)buf); ++ if (ret == 0) ++ ret = sizeof(unsigned long); ++ } ++ return ret; ++} ++ ++static unsigned int rtc_poll(struct file *file, poll_table *wait) ++{ ++ unsigned long data; ++ ++ poll_wait(file, &rtc_wait, wait); ++ ++ spin_lock_irq(&rtc_lock); ++ data = rtc_irq_data; ++ spin_unlock_irq(&rtc_lock); ++ ++ return data != 0 ? POLLIN | POLLRDNORM : 0; ++} ++ ++static int rtc_ioctl(struct inode *inode, struct file *file, unsigned int cmd, ++ unsigned long arg) ++{ ++ struct rtc_ops *ops = file->private_data; ++ struct rtc_time tm; ++ struct rtc_wkalrm alrm; ++ int ret; ++ ++ switch (cmd) { ++ case RTC_ALM_READ: ++ rtc_read_alarm(ops, &alrm); ++ ret = copy_to_user((void *)arg, &alrm.time, sizeof(tm)); ++ if (ret) ++ ret = -EFAULT; ++ break; ++ ++ case RTC_ALM_SET: ++ ret = copy_from_user(&alrm.time, (void *)arg, sizeof(tm)); ++ alrm.enabled = 0; ++ alrm.pending = 0; ++ alrm.time.tm_mday = -1; ++ alrm.time.tm_mon = -1; ++ alrm.time.tm_year = -1; ++ alrm.time.tm_wday = -1; ++ alrm.time.tm_yday = -1; ++ alrm.time.tm_isdst = -1; ++ if (ret == 0) ++ ret = rtc_set_alarm(ops, &alrm); ++ else ++ ret = -EFAULT; ++ break; ++ ++ case RTC_RD_TIME: ++ rtc_read_time(ops, &tm); ++ ret = copy_to_user((void *)arg, &tm, sizeof(tm)); ++ if (ret) ++ ret = -EFAULT; ++ break; ++ ++ case RTC_SET_TIME: ++ if (!capable(CAP_SYS_TIME)) { ++ ret = -EACCES; ++ break; ++ } ++ ret = copy_from_user(&tm, (void *)arg, sizeof(tm)); ++ if (ret == 0) ++ ret = rtc_set_time(ops, &tm); ++ else ++ ret = -EFAULT; ++ break; ++ ++#ifndef rtc_epoch ++ case RTC_EPOCH_SET: ++ /* ++ * There were no RTC clocks before 1900. ++ */ ++ if (arg < 1900) { ++ ret = -EINVAL; ++ break; ++ } ++ if (!capable(CAP_SYS_TIME)) { ++ ret = -EACCES; ++ break; ++ } ++ rtc_epoch = arg; ++ ret = 0; ++ break; ++#endif ++ ++ case RTC_EPOCH_READ: ++ ret = put_user(rtc_epoch, (unsigned long *)arg); ++ break; ++ ++ case RTC_WKALM_SET: ++ ret = copy_from_user(&alrm, (void *)arg, sizeof(alrm)); ++ if (ret == 0) ++ ret = rtc_set_alarm(ops, &alrm); ++ else ++ ret = -EFAULT; ++ break; ++ ++ case RTC_WKALM_RD: ++ rtc_read_alarm(ops, &alrm); ++ ret = copy_to_user((void *)arg, &alrm, sizeof(alrm)); ++ if (ret) ++ ret = -EFAULT; ++ break; ++ ++ default: ++ ret = ops->ioctl(cmd, arg); ++ } ++ return ret; ++} ++ ++static int rtc_open(struct inode *inode, struct file *file) ++{ ++ int ret; ++ ++ down(&rtc_sem); ++ ++ if (rtc_inuse) { ++ ret = -EBUSY; ++ } else if (!rtc_ops || !try_module_get(rtc_ops->owner)) { ++ ret = -ENODEV; ++ } else { ++ file->private_data = rtc_ops; ++ ++ ret = rtc_ops->open ? rtc_ops->open() : 0; ++ if (ret == 0) { ++ spin_lock_irq(&rtc_lock); ++ rtc_irq_data = 0; ++ spin_unlock_irq(&rtc_lock); ++ ++ rtc_inuse = 1; ++ } ++ } ++ up(&rtc_sem); ++ ++ return ret; ++} ++ ++static int rtc_release(struct inode *inode, struct file *file) ++{ ++ struct rtc_ops *ops = file->private_data; ++ ++ if (ops->release) ++ ops->release(); ++ ++ spin_lock_irq(&rtc_lock); ++ rtc_irq_data = 0; ++ spin_unlock_irq(&rtc_lock); ++ ++ module_put(rtc_ops->owner); ++ rtc_inuse = 0; ++ ++ return 0; ++} ++ ++static int rtc_fasync(int fd, struct file *file, int on) ++{ ++ return fasync_helper(fd, file, on, &rtc_async_queue); ++} ++ ++static struct file_operations rtc_fops = { ++ .owner = THIS_MODULE, ++ .llseek = no_llseek, ++ .read = rtc_read, ++ .poll = rtc_poll, ++ .ioctl = rtc_ioctl, ++ .open = rtc_open, ++ .release = rtc_release, ++ .fasync = rtc_fasync, ++}; ++ ++static struct miscdevice rtc_miscdev = { ++ .minor = RTC_MINOR, ++ .name = "rtc", ++ .fops = &rtc_fops, ++}; ++ ++ ++static int rtc_read_proc(char *page, char **start, off_t off, int count, int *eof, void *data) ++{ ++ struct rtc_ops *ops = data; ++ struct rtc_wkalrm alrm; ++ struct rtc_time tm; ++ char *p = page; ++ int len; ++ ++ rtc_read_time(ops, &tm); ++ ++ p += sprintf(p, ++ "rtc_time\t: %02d:%02d:%02d\n" ++ "rtc_date\t: %04d-%02d-%02d\n" ++ "rtc_epoch\t: %04lu\n", ++ tm.tm_hour, tm.tm_min, tm.tm_sec, ++ tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday, ++ rtc_epoch); ++ ++ rtc_read_alarm(ops, &alrm); ++ p += sprintf(p, "alrm_time\t: "); ++ if ((unsigned int)alrm.time.tm_hour <= 24) ++ p += sprintf(p, "%02d:", alrm.time.tm_hour); ++ else ++ p += sprintf(p, "**:"); ++ if ((unsigned int)alrm.time.tm_min <= 59) ++ p += sprintf(p, "%02d:", alrm.time.tm_min); ++ else ++ p += sprintf(p, "**:"); ++ if ((unsigned int)alrm.time.tm_sec <= 59) ++ p += sprintf(p, "%02d\n", alrm.time.tm_sec); ++ else ++ p += sprintf(p, "**\n"); ++ ++ p += sprintf(p, "alrm_date\t: "); ++ if ((unsigned int)alrm.time.tm_year <= 200) ++ p += sprintf(p, "%04d-", alrm.time.tm_year + 1900); ++ else ++ p += sprintf(p, "****-"); ++ if ((unsigned int)alrm.time.tm_mon <= 11) ++ p += sprintf(p, "%02d-", alrm.time.tm_mon + 1); ++ else ++ p += sprintf(p, "**-"); ++ if ((unsigned int)alrm.time.tm_mday <= 31) ++ p += sprintf(p, "%02d\n", alrm.time.tm_mday); ++ else ++ p += sprintf(p, "**\n"); ++ p += sprintf(p, "alrm_wakeup\t: %s\n", alrm.enabled ? "yes" : "no"); ++ p += sprintf(p, "alrm_pending\t: %s\n", alrm.pending ? "yes" : "no"); ++ ++ if (ops->proc) ++ p += ops->proc(p); ++ ++ len = (p - page) - off; ++ if (len < 0) ++ len = 0; ++ *eof = len <= count; ++ *start = page + off; ++ ++ return len; ++} ++ ++int register_rtc(struct rtc_ops *ops) ++{ ++ int ret = -EBUSY; ++ ++ down(&rtc_sem); ++ if (rtc_ops == NULL) { ++ rtc_ops = ops; ++ ++ ret = misc_register(&rtc_miscdev); ++ if (ret == 0) ++ create_proc_read_entry("driver/rtc", 0, 0, ++ rtc_read_proc, ops); ++ } ++ up(&rtc_sem); ++ ++ return ret; ++} ++ ++void unregister_rtc(struct rtc_ops *rtc) ++{ ++ down(&rtc_sem); ++ if (rtc == rtc_ops) { ++ remove_proc_entry("driver/rtc", NULL); ++ misc_deregister(&rtc_miscdev); ++ rtc_ops = NULL; ++ } ++ up(&rtc_sem); ++} ++ ++EXPORT_SYMBOL(rtc_time_to_tm); ++EXPORT_SYMBOL(rtc_tm_to_time); ++EXPORT_SYMBOL(rtc_update); ++EXPORT_SYMBOL(register_rtc); ++EXPORT_SYMBOL(unregister_rtc); +--- linux-2.6.5/arch/arm/common/Makefile~heh 2004-04-03 22:36:57.000000000 -0500 ++++ linux-2.6.5/arch/arm/common/Makefile 2004-04-30 20:57:36.000000000 -0400 +@@ -2,7 +2,7 @@ + # Makefile for the linux kernel. + # + +-obj-y += platform.o ++obj-y += platform.o rtctime.o + obj-$(CONFIG_ARM_AMBA) += amba.o + obj-$(CONFIG_ICST525) += icst525.o + obj-$(CONFIG_SA1111) += sa1111.o sa1111-pcibuf.o +--- linux-2.6.5/arch/arm/mach-pxa/generic.c~heh 2004-04-03 22:36:53.000000000 -0500 ++++ linux-2.6.5/arch/arm/mach-pxa/generic.c 2004-04-30 20:57:36.000000000 -0400 +@@ -132,7 +132,7 @@ + /* virtual physical length type */ + { 0xf6000000, 0x20000000, 0x01000000, MT_DEVICE }, /* PCMCIA0 IO */ + { 0xf7000000, 0x30000000, 0x01000000, MT_DEVICE }, /* PCMCIA1 IO */ +- { 0xf8000000, 0x40000000, 0x01400000, MT_DEVICE }, /* Devs */ ++ { 0xf8000000, 0x40000000, 0x01800000, MT_DEVICE }, /* Devs */ + { 0xfa000000, 0x44000000, 0x00100000, MT_DEVICE }, /* LCD */ + { 0xfc000000, 0x48000000, 0x00100000, MT_DEVICE }, /* Mem Ctl */ + { 0xff000000, 0x00000000, 0x00100000, MT_DEVICE } /* UNCACHED_PHYS_0 */ +--- /dev/null 2003-09-23 18:19:32.000000000 -0400 ++++ linux-2.6.5/arch/arm/mach-pxa/cpu-pxa.c 2004-04-30 20:57:36.000000000 -0400 +@@ -0,0 +1,322 @@ ++/* ++ * linux/arch/arm/mach-pxa/cpu-pxa.c ++ * ++ * Copyright (C) 2002,2003 Intrinsyc Software ++ * ++ * 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 ++ * ++ * History: ++ * 31-Jul-2002 : Initial version [FB] ++ * 29-Jan-2003 : added PXA255 support [FB] ++ * 20-Apr-2003 : ported to v2.5 (Dustin McIntire, Sensoria Corp.) ++ * ++ * Note: ++ * This driver may change the memory bus clock rate, but will not do any ++ * platform specific access timing changes... for example if you have flash ++ * memory connected to CS0, you will need to register a platform specific ++ * notifier which will adjust the memory access strobes to maintain a ++ * minimum strobe width. ++ * ++ */ ++ ++#include <linux/kernel.h> ++#include <linux/module.h> ++#include <linux/sched.h> ++#include <linux/init.h> ++#include <linux/cpufreq.h> ++ ++#include <asm/hardware.h> ++ ++#define DEBUG 0 ++ ++#ifdef DEBUG ++ static unsigned int freq_debug = DEBUG; ++ MODULE_PARM(freq_debug, "i"); ++ MODULE_PARM_DESC(freq_debug, "Set the debug messages to on=1/off=0"); ++#else ++ #define freq_debug 0 ++#endif ++ ++typedef struct ++{ ++ unsigned int khz; ++ unsigned int membus; ++ unsigned int cccr; ++ unsigned int div2; ++} pxa_freqs_t; ++ ++/* Define the refresh period in mSec for the SDRAM and the number of rows */ ++#define SDRAM_TREF 64 /* standard 64ms SDRAM */ ++#define SDRAM_ROWS 4096 /* 64MB=8192 32MB=4096 */ ++#define MDREFR_DRI(x) ((x*SDRAM_TREF)/(SDRAM_ROWS*32)) ++ ++#define CCLKCFG_TURBO 0x1 ++#define CCLKCFG_FCS 0x2 ++#define PXA25x_MIN_FREQ 99500 ++#define PXA25x_MAX_FREQ 398100 ++#define MDREFR_DB2_MASK (MDREFR_K2DB2 | MDREFR_K1DB2) ++#define MDREFR_DRI_MASK 0xFFF ++ ++ ++/* Use the run mode frequencies for the CPUFREQ_POLICY_PERFORMANCE policy */ ++static pxa_freqs_t pxa255_run_freqs[] = ++{ ++ /* CPU MEMBUS CCCR DIV2*/ ++ { 99500, 99500, 0x121, 1}, /* run= 99, turbo= 99, PXbus=50, SDRAM=50 */ ++ {132700, 132700, 0x123, 1}, /* run=133, turbo=133, PXbus=66, SDRAM=66 */ ++ {199100, 99500, 0x141, 0}, /* run=199, turbo=199, PXbus=99, SDRAM=99 */ ++ {265400, 132700, 0x143, 1}, /* run=265, turbo=265, PXbus=133, SDRAM=66 */ ++ {331800, 165900, 0x145, 1}, /* run=331, turbo=331, PXbus=166, SDRAM=83 */ ++ {398100, 99500, 0x161, 0}, /* run=398, turbo=398, PXbus=196, SDRAM=99 */ ++ {0,} ++}; ++#define NUM_RUN_FREQS (sizeof(pxa255_run_freqs)/sizeof(pxa_freqs_t)) ++ ++static struct cpufreq_frequency_table pxa255_run_freq_table[NUM_RUN_FREQS+1]; ++ ++/* Use the turbo mode frequencies for the CPUFREQ_POLICY_POWERSAVE policy */ ++static pxa_freqs_t pxa255_turbo_freqs[] = ++{ ++ /* CPU MEMBUS CCCR DIV2*/ ++ { 99500, 99500, 0x121, 1}, /* run=99, turbo= 99, PXbus=50, SDRAM=50 */ ++ {199100, 99500, 0x221, 0}, /* run=99, turbo=199, PXbus=50, SDRAM=99 */ ++ {298500, 99500, 0x321, 0}, /* run=99, turbo=287, PXbus=50, SDRAM=99 */ ++ {298600, 99500, 0x1c1, 0}, /* run=199, turbo=287, PXbus=99, SDRAM=99 */ ++ {398100, 99500, 0x241, 0}, /* run=199, turbo=398, PXbus=99, SDRAM=99 */ ++ {0,} ++}; ++#define NUM_TURBO_FREQS (sizeof(pxa255_turbo_freqs)/sizeof(pxa_freqs_t)) ++ ++static struct cpufreq_frequency_table pxa255_turbo_freq_table[NUM_TURBO_FREQS+1]; ++ ++/* find a valid frequency point */ ++static int pxa_verify_policy(struct cpufreq_policy *policy) ++{ ++ int ret; ++ struct cpufreq_frequency_table *pxa_freqs_table; ++ ++ if(policy->policy == CPUFREQ_POLICY_PERFORMANCE) { ++ pxa_freqs_table = pxa255_run_freq_table; ++ } else if (policy->policy == CPUFREQ_POLICY_POWERSAVE) { ++ pxa_freqs_table = pxa255_turbo_freq_table; ++ } else if (policy->policy == CPUFREQ_POLICY_GOVERNOR) { ++ pxa_freqs_table = pxa255_run_freq_table; ++ } else { ++ printk("CPU PXA: Unknown policy found. " ++ "Using CPUFREQ_POLICY_PERFORMANCE\n"); ++ pxa_freqs_table = pxa255_run_freq_table; ++ } ++ ret=cpufreq_frequency_table_verify(policy, pxa_freqs_table); ++ ++ if(freq_debug) { ++ printk("Verified CPU policy: %dKhz min to %dKhz max\n", ++ policy->min, policy->max); ++ } ++ ++ return ret; ++} ++ ++static int pxa_set_target(struct cpufreq_policy *policy, ++ unsigned int target_freq, ++ unsigned int relation) ++{ ++ int idx; ++ unsigned long cpus_allowed; ++ int cpu = policy->cpu; ++ struct cpufreq_freqs freqs; ++ pxa_freqs_t *pxa_freq_settings; ++ struct cpufreq_frequency_table *pxa_freqs_table; ++ unsigned long flags; ++ unsigned int unused; ++ unsigned int preset_mdrefr, postset_mdrefr; ++ ++ /* ++ * Save this threads cpus_allowed mask. ++ */ ++ cpus_allowed = current->cpus_allowed; ++ ++ /* ++ * Bind to the specified CPU. When this call returns, ++ * we should be running on the right CPU. ++ */ ++ set_cpus_allowed(current, 1 << cpu); ++ BUG_ON(cpu != smp_processor_id()); ++ ++ /* Get the current policy */ ++ if(policy->policy == CPUFREQ_POLICY_PERFORMANCE) { ++ pxa_freq_settings = pxa255_run_freqs; ++ pxa_freqs_table = pxa255_run_freq_table; ++ }else if (policy->policy == CPUFREQ_POLICY_POWERSAVE) { ++ pxa_freq_settings = pxa255_turbo_freqs; ++ pxa_freqs_table = pxa255_turbo_freq_table; ++ }else if (policy->policy == CPUFREQ_POLICY_GOVERNOR) { ++ pxa_freq_settings = pxa255_run_freqs; ++ pxa_freqs_table = pxa255_run_freq_table; ++ }else { ++ printk("CPU PXA: Unknown policy found. " ++ "Using CPUFREQ_POLICY_PERFORMANCE\n"); ++ pxa_freq_settings = pxa255_run_freqs; ++ pxa_freqs_table = pxa255_run_freq_table; ++ } ++ ++ /* Lookup the next frequency */ ++ if (cpufreq_frequency_table_target(policy, pxa_freqs_table, ++ target_freq, relation, &idx)) { ++ return -EINVAL; ++ } ++ ++ freqs.old = policy->cur; ++ freqs.new = pxa_freq_settings[idx].khz; ++ freqs.cpu = policy->cpu; ++ if(freq_debug) { ++ printk(KERN_INFO "Changing CPU frequency to %d Mhz, (SDRAM %d Mhz)\n", ++ freqs.new/1000, (pxa_freq_settings[idx].div2) ? ++ (pxa_freq_settings[idx].membus/2000) : ++ (pxa_freq_settings[idx].membus/1000)); ++ } ++ ++ void *ramstart = phys_to_virt(0xa0000000); ++ ++ /* ++ * Tell everyone what we're about to do... ++ * you should add a notify client with any platform specific ++ * Vcc changing capability ++ */ ++ cpufreq_notify_transition(&freqs, CPUFREQ_PRECHANGE); ++ ++ /* Calculate the next MDREFR. If we're slowing down the SDRAM clock ++ * we need to preset the smaller DRI before the change. If we're speeding ++ * up we need to set the larger DRI value after the change. ++ */ ++ preset_mdrefr = postset_mdrefr = MDREFR; ++ if((MDREFR & MDREFR_DRI_MASK) > MDREFR_DRI(pxa_freq_settings[idx].membus)) { ++ preset_mdrefr = (preset_mdrefr & ~MDREFR_DRI_MASK) | ++ MDREFR_DRI(pxa_freq_settings[idx].membus); ++ } ++ postset_mdrefr = (postset_mdrefr & ~MDREFR_DRI_MASK) | ++ MDREFR_DRI(pxa_freq_settings[idx].membus); ++ ++ /* If we're dividing the memory clock by two for the SDRAM clock, this ++ * must be set prior to the change. Clearing the divide must be done ++ * after the change. ++ */ ++ if(pxa_freq_settings[idx].div2) { ++ preset_mdrefr |= MDREFR_DB2_MASK; ++ postset_mdrefr |= MDREFR_DB2_MASK; ++ } else { ++ postset_mdrefr &= ~MDREFR_DB2_MASK; ++ } ++ ++ local_irq_save(flags); ++ ++ /* Set new the CCCR */ ++ CCCR = pxa_freq_settings[idx].cccr; ++ ++ __asm__ __volatile__(" \ ++ ldr r4, [%1] ; /* load MDREFR */ \ ++ b 2f ; \ ++ .align 5 ; \ ++1: \ ++ str %4, [%1] ; /* preset the MDREFR */ \ ++ mcr p14, 0, %2, c6, c0, 0 ; /* set CCLKCFG[FCS] */ \ ++ str %5, [%1] ; /* postset the MDREFR */ \ ++ \ ++ b 3f ; \ ++2: b 1b ; \ ++3: nop ; \ ++ " ++ : "=&r" (unused) ++ : "r" (&MDREFR), "r" (CCLKCFG_TURBO|CCLKCFG_FCS), "r" (ramstart), \ ++ "r" (preset_mdrefr), "r" (postset_mdrefr) ++ : "r4", "r5"); ++ local_irq_restore(flags); ++ ++ /* ++ * Restore the CPUs allowed mask. ++ */ ++ set_cpus_allowed(current, cpus_allowed); ++ ++ /* ++ * Tell everyone what we've just done... ++ * you should add a notify client with any platform specific ++ * SDRAM refresh timer adjustments ++ */ ++ cpufreq_notify_transition(&freqs, CPUFREQ_POSTCHANGE); ++ ++ return 0; ++} ++ ++static int pxa_cpufreq_init(struct cpufreq_policy *policy) ++{ ++ unsigned long cpus_allowed; ++ unsigned int cpu = policy->cpu; ++ int i; ++ ++ cpus_allowed = current->cpus_allowed; ++ ++ set_cpus_allowed(current, 1 << cpu); ++ BUG_ON(cpu != smp_processor_id()); ++ ++ /* set default policy and cpuinfo */ ++ policy->policy = CPUFREQ_POLICY_PERFORMANCE; ++ policy->cpuinfo.max_freq = PXA25x_MAX_FREQ; ++ policy->cpuinfo.min_freq = PXA25x_MIN_FREQ; ++ policy->cpuinfo.transition_latency = 1000; /* FIXME: 1 ms, assumed */ ++ policy->cur = get_clk_frequency_khz(0); /* current freq */ ++ policy->min = policy->max = policy->cur; ++ ++ /* Generate the run cpufreq_frequency_table struct */ ++ for(i=0;i<NUM_RUN_FREQS;i++) { ++ pxa255_run_freq_table[i].frequency = pxa255_run_freqs[i].khz; ++ pxa255_run_freq_table[i].index = i; ++ } ++ pxa255_run_freq_table[i].frequency = CPUFREQ_TABLE_END; ++ /* Generate the turbo cpufreq_frequency_table struct */ ++ for(i=0;i<NUM_TURBO_FREQS;i++) { ++ pxa255_turbo_freq_table[i].frequency = pxa255_turbo_freqs[i].khz; ++ pxa255_turbo_freq_table[i].index = i; ++ } ++ pxa255_turbo_freq_table[i].frequency = CPUFREQ_TABLE_END; ++ ++ set_cpus_allowed(current, cpus_allowed); ++ printk(KERN_INFO "PXA CPU frequency change support initialized\n"); ++ ++ return 0; ++} ++ ++static struct cpufreq_driver pxa_cpufreq_driver = { ++ .verify = pxa_verify_policy, ++ .target = pxa_set_target, ++ .init = pxa_cpufreq_init, ++ .name = "PXA25x", ++}; ++ ++static int __init pxa_cpu_init(void) ++{ ++ return cpufreq_register_driver(&pxa_cpufreq_driver); ++} ++ ++static void __exit pxa_cpu_exit(void) ++{ ++ cpufreq_unregister_driver(&pxa_cpufreq_driver); ++} ++ ++ ++MODULE_AUTHOR ("Intrinsyc Software Inc."); ++MODULE_DESCRIPTION ("CPU frequency changing driver for the PXA architecture"); ++MODULE_LICENSE("GPL"); ++module_init(pxa_cpu_init); ++module_exit(pxa_cpu_exit); ++ +--- linux-2.6.5/arch/arm/boot/compressed/misc.c~heh 2004-04-03 22:37:37.000000000 -0500 ++++ linux-2.6.5/arch/arm/boot/compressed/misc.c 2004-04-30 20:57:36.000000000 -0400 +@@ -113,7 +113,7 @@ + * gzip delarations + */ + #define OF(args) args +-#define STATIC static ++#define STATIC + + typedef unsigned char uch; + typedef unsigned short ush; +@@ -122,12 +122,12 @@ + #define WSIZE 0x8000 /* Window size must be at least 32k, */ + /* and a power of two */ + +-static uch *inbuf; /* input buffer */ +-static uch window[WSIZE]; /* Sliding window buffer */ ++unsigned char *inbuf; /* input buffer */ ++unsigned char window[WSIZE]; /* Sliding window buffer */ + +-static unsigned insize; /* valid bytes in inbuf */ +-static unsigned inptr; /* index of next byte to be processed in inbuf */ +-static unsigned outcnt; /* bytes in output buffer */ ++unsigned int insize; /* valid bytes in inbuf */ ++unsigned int inptr; /* index of next byte to be processed in inbuf */ ++unsigned int outcnt; /* bytes in output buffer */ + + /* gzip flag byte */ + #define ASCII_FLAG 0x01 /* bit 0 set: file probably ascii text */ +@@ -166,9 +166,9 @@ + extern char input_data[]; + extern char input_data_end[]; + +-static uch *output_data; +-static ulg output_ptr; +-static ulg bytes_out; ++unsigned char *output_data; ++unsigned long output_ptr; ++unsigned long bytes_out; + + static void *malloc(int size); + static void free(void *where); +@@ -179,8 +179,8 @@ + static void puts(const char *); + + extern int end; +-static ulg free_mem_ptr; +-static ulg free_mem_ptr_end; ++unsigned long free_mem_ptr; ++unsigned long free_mem_ptr_end; + + #define HEAP_SIZE 0x2000 + +--- linux-2.6.5/arch/arm/mm/ioremap.c~heh 2004-04-03 22:37:36.000000000 -0500 ++++ linux-2.6.5/arch/arm/mm/ioremap.c 2004-04-30 20:57:36.000000000 -0400 +@@ -13,15 +13,18 @@ + * virtual space. One should *only* use readl, writel, memcpy_toio and + * so on with such remapped areas. + * +- * Because the ARM only has a 32-bit address space we can't address the +- * whole of the (physical) PCI space at once. PCI huge-mode addressing +- * allows us to circumvent this restriction by splitting PCI space into +- * two 2GB chunks and mapping only one at a time into processor memory. +- * We use MMU protection domains to trap any attempt to access the bank +- * that is not currently mapped. (This isn't fully implemented yet.) ++ * ioremap support tweaked to allow support for large page mappings. We ++ * have several issues that needs to be resolved first however: ++ * ++ * 1. We need set_pte, or something like set_pte to understand large ++ * page mappings. ++ * ++ * 2. we need the unmap_* functions to likewise understand large page ++ * mappings. + */ + #include <linux/errno.h> + #include <linux/mm.h> ++#include <linux/slab.h> + #include <linux/vmalloc.h> + + #include <asm/page.h> +@@ -29,31 +32,162 @@ + #include <asm/io.h> + #include <asm/tlbflush.h> + +-static inline void remap_area_pte(pte_t * pte, unsigned long address, unsigned long size, +- unsigned long phys_addr, pgprot_t pgprot) ++extern rwlock_t vmlist_lock; ++extern struct vm_struct *vmlist; ++ ++static struct vm_struct * ++get_io_vm_area(unsigned long size, unsigned long align, unsigned long flags) + { ++ struct vm_struct **p, *tmp, *area; ++ unsigned long addr; ++ ++ area = (struct vm_struct *)kmalloc(sizeof(*area), GFP_KERNEL); ++ if (!area) ++ return NULL; ++ ++ align -= 1; ++ ++ size += PAGE_SIZE; ++ addr = VMALLOC_START; ++ write_lock(&vmlist_lock); ++ for (p = &vmlist; (tmp = *p); p = &tmp->next) { ++ if ((unsigned long)tmp->addr < addr) ++ continue; ++ if ((size + addr) < addr) ++ goto out; ++ if (size + addr <= (unsigned long) tmp->addr) ++ break; ++ addr = tmp->size + (unsigned long) tmp->addr; ++ if ((addr + align) < addr) ++ goto out; ++ addr = (addr + align) & ~align; ++ if (addr > VMALLOC_END - size) ++ goto out; ++ } ++ area->flags = flags; ++ area->addr = (void *)addr; ++ area->size = size; ++ area->next = *p; ++ *p = area; ++ write_unlock(&vmlist_lock); ++ return area; ++ ++out: ++ write_unlock(&vmlist_lock); ++ kfree(area); ++ return NULL; ++} ++ ++static inline void unmap_area_pte(pmd_t *pmd, unsigned long address, unsigned long size) ++{ ++ pte_t *ptep; + unsigned long end; + ++ if (pmd_none(*pmd)) ++ return; ++ if (pmd_bad(*pmd)) { ++ pmd_ERROR(*pmd); ++ pmd_clear(pmd); ++ return; ++ } ++ ptep = pte_offset_kernel(pmd, address); + address &= ~PMD_MASK; + end = address + size; + if (end > PMD_SIZE) + end = PMD_SIZE; +- if (address >= end) +- BUG(); + do { +- if (!pte_none(*pte)) { +- printk("remap_area_pte: page already exists\n"); +- BUG(); ++ pte_t pte; ++ pte = ptep_get_and_clear(ptep); ++ address += PAGE_SIZE; ++ ptep++; ++ if (pte_none(pte)) ++ continue; ++ if (pte_present(pte)) { ++ unsigned long pfn = pte_pfn(pte); ++ struct page *page; ++ ++ if (!pfn_valid(pfn)) ++ continue; ++ page = pfn_to_page(pfn); ++ if (!PageReserved(page)) ++ __free_page(page); ++ continue; + } +- set_pte(pte, pfn_pte(phys_addr >> PAGE_SHIFT, pgprot)); ++ printk(KERN_CRIT "Whee.. Swapped out page in kernel page table\n"); ++ } while (address < end); ++} ++ ++static inline void unmap_area_pmd(pgd_t *dir, unsigned long address, unsigned long size) ++{ ++ pmd_t *pmd; ++ unsigned long end; ++ ++ if (pgd_none(*dir)) ++ return; ++ if (pgd_bad(*dir)) { ++ pgd_ERROR(*dir); ++ pgd_clear(dir); ++ return; ++ } ++ pmd = pmd_offset(dir, address); ++ address &= ~PGDIR_MASK; ++ end = address + size; ++ if (end > PGDIR_SIZE) ++ end = PGDIR_SIZE; ++ do { ++ unmap_area_pte(pmd, address, end - address); ++ address = (address + PMD_SIZE) & PMD_MASK; ++ pmd++; ++ } while (address < end); ++} ++ ++static void ++unmap_area_pages(unsigned long address, unsigned long size) ++{ ++ unsigned long start = address; ++ unsigned long end = address + size; ++ pgd_t *dir; ++ ++ dir = pgd_offset_k(address); ++ flush_cache_vunmap(start, end); ++ do { ++ unmap_area_pmd(dir, address, end - address); ++ address = (address + PGDIR_SIZE) & PGDIR_MASK; ++ dir++; ++ } while (address && (address < end)); ++ flush_tlb_kernel_range(start, end); ++} ++ ++static inline void ++remap_area_pte(pte_t * pte, unsigned long address, unsigned long size, ++ unsigned long pfn, pgprot_t pgprot) ++{ ++ unsigned long end; ++ ++ address &= ~PMD_MASK; ++ end = address + size; ++ if (end > PMD_SIZE) ++ end = PMD_SIZE; ++ BUG_ON(address >= end); ++ do { ++ if (!pte_none(*pte)) ++ goto bad; ++ ++ set_pte(pte, pfn_pte(pfn, pgprot)); + address += PAGE_SIZE; +- phys_addr += PAGE_SIZE; ++ pfn++; + pte++; + } while (address && (address < end)); ++ return; ++ ++ bad: ++ printk("remap_area_pte: page already exists\n"); ++ BUG(); + } + +-static inline int remap_area_pmd(pmd_t * pmd, unsigned long address, unsigned long size, +- unsigned long phys_addr, unsigned long flags) ++static inline int ++remap_area_pmd(pmd_t * pmd, unsigned long address, unsigned long size, ++ unsigned long pfn, unsigned long flags) + { + unsigned long end; + pgprot_t pgprot; +@@ -64,51 +198,53 @@ + if (end > PGDIR_SIZE) + end = PGDIR_SIZE; + +- phys_addr -= address; +- if (address >= end) +- BUG(); ++ pfn -= address >> PAGE_SHIFT; ++ BUG_ON(address >= end); + + pgprot = __pgprot(L_PTE_PRESENT | L_PTE_YOUNG | L_PTE_DIRTY | L_PTE_WRITE | flags); + do { + pte_t * pte = pte_alloc_kernel(&init_mm, pmd, address); + if (!pte) + return -ENOMEM; +- remap_area_pte(pte, address, end - address, address + phys_addr, pgprot); ++ remap_area_pte(pte, address, end - address, pfn + (address >> PAGE_SHIFT), pgprot); + address = (address + PMD_SIZE) & PMD_MASK; + pmd++; + } while (address && (address < end)); + return 0; + } + +-static int remap_area_pages(unsigned long address, unsigned long phys_addr, +- unsigned long size, unsigned long flags) ++static int ++remap_area_pages(unsigned long start, unsigned long pfn, ++ unsigned long size, unsigned long flags) + { +- int error; ++ unsigned long address = start; ++ unsigned long end = start + size; ++ int err = 0; + pgd_t * dir; +- unsigned long end = address + size; + +- phys_addr -= address; ++ pfn -= address >> PAGE_SHIFT; + dir = pgd_offset(&init_mm, address); +- flush_cache_all(); +- if (address >= end) +- BUG(); ++ BUG_ON(address >= end); + spin_lock(&init_mm.page_table_lock); + do { +- pmd_t *pmd; +- pmd = pmd_alloc(&init_mm, dir, address); +- error = -ENOMEM; +- if (!pmd) ++ pmd_t *pmd = pmd_alloc(&init_mm, dir, address); ++ if (!pmd) { ++ err = -ENOMEM; + break; ++ } + if (remap_area_pmd(pmd, address, end - address, +- phys_addr + address, flags)) ++ pfn + (address >> PAGE_SHIFT), flags)) { ++ err = -ENOMEM; + break; +- error = 0; ++ } ++ + address = (address + PGDIR_SIZE) & PGDIR_MASK; + dir++; + } while (address && (address < end)); ++ + spin_unlock(&init_mm.page_table_lock); +- flush_tlb_all(); +- return error; ++ flush_cache_vmap(start, end); ++ return err; + } + + /* +@@ -146,11 +282,11 @@ + /* + * Ok, go for it.. + */ +- area = get_vm_area(size, VM_IOREMAP); ++ area = get_io_vm_area(size, align, VM_IOREMAP); + if (!area) + return NULL; + addr = area->addr; +- if (remap_area_pages((unsigned long) addr, phys_addr, size, flags)) { ++ if (remap_area_pages((unsigned long) addr, phys_addr >> PAGE_SHIFT, size, flags)) { + vfree(addr); + return NULL; + } +@@ -159,5 +295,26 @@ + + void __iounmap(void *addr) + { +- vfree((void *) (PAGE_MASK & (unsigned long) addr)); ++ struct vm_struct **p, *tmp; ++ ++ if (!addr) ++ return; ++ ++ if ((PAGE_SIZE - 1) & (unsigned long)addr) { ++ printk(KERN_ERR "Trying to iounmap() bad address (%p)\n", addr); ++ return; ++ } ++ ++ write_lock(&vmlist_lock); ++ for (p = &vmlist; (tmp = *p); p = &tmp->next) { ++ if (tmp->addr == addr) { ++ *p = tmp->next; ++ unmap_area_pages((unsigned long) tmp->addr, tmp->size); ++ write_unlock(&vmlist_lock); ++ kfree(tmp); ++ return; ++ } ++ } ++ write_unlock(&vmlist_lock); ++ printk(KERN_ERR "Trying to iounmap nonexistent area (%p)\n", addr); + } +--- linux-2.6.5/arch/arm/mm/proc-xscale.S~heh 2004-04-03 22:38:05.000000000 -0500 ++++ linux-2.6.5/arch/arm/mm/proc-xscale.S 2004-04-30 20:57:36.000000000 -0400 +@@ -563,11 +563,62 @@ + movne r2, #0 @ no -> fault + + str r2, [r0] @ hardware version ++ ++ @ We try to map 64K page entries when possible. ++ @ We do that for kernel space only since the usage pattern from ++ @ the setting of VM area is quite simple. User space is not worth ++ @ the implied complexity because of ever randomly changing PTEs ++ @ (page aging, swapout, etc) requiring constant coherency checks. ++ @ Since PTEs are usually set in increasing order, we test the ++ @ possibility for a large page only when given the last PTE of a ++ @ 64K boundary. ++ tsteq r1, #L_PTE_USER ++ andeq r1, r0, #(15 << 2) ++ teqeq r1, #(15 << 2) ++ beq 1f ++ + mov ip, #0 + mcr p15, 0, r0, c7, c10, 1 @ Clean D cache line + mcr p15, 0, ip, c7, c10, 4 @ Drain Write (& Fill) Buffer + mov pc, lr + ++ @ See if we have 16 identical PTEs but with consecutive base addresses ++1: bic r3, r2, #0x0000f000 ++ mov r1, #0x0000f000 ++2: eor r2, r2, r3 ++ teq r2, r1 ++ bne 4f ++ subs r1, r1, #0x00001000 ++ ldr r2, [r0, #-4]! ++ bne 2b ++ eors r2, r2, r3 ++ bne 4f ++ ++ @ Now create our LARGE PTE from the current EXT one. ++ bic r3, r3, #PTE_TYPE_MASK ++ orr r3, r3, #PTE_TYPE_LARGE ++ and r2, r3, #0x30 @ EXT_AP --> LARGE_AP0 ++ orr r2, r2, r2, lsl #2 @ add LARGE_AP1 ++ orr r2, r2, r2, lsl #4 @ add LARGE_AP3 + LARGE_AP2 ++ and r1, r3, #0x3c0 @ EXT_TEX ++ bic r3, r3, #0x3c0 ++ orr r2, r2, r1, lsl #(12 - 6) @ --> LARGE_TEX ++ orr r2, r2, r3 @ add remaining bits ++ ++ @ then put it in the pagetable ++ mov r3, r2 ++3: strd r2, [r0], #8 ++ tst r0, #(15 << 2) ++ bne 3b ++ ++ @ Then sync the 2 corresponding cache lines ++ sub r0, r0, #(16 << 2) ++ mcr p15, 0, r0, c7, c10, 1 @ Clean D cache line ++4: orr r0, r0, #(15 << 2) ++ mcr p15, 0, r0, c7, c10, 1 @ Clean D cache line ++ mov ip, #0 ++ mcr p15, 0, ip, c7, c10, 4 @ Drain Write (& Fill) Buffer ++ mov pc, lr + + .ltorg + +--- linux-2.6.5/arch/arm/mach-sa1100/Makefile~heh 2004-04-03 22:38:26.000000000 -0500 ++++ linux-2.6.5/arch/arm/mach-sa1100/Makefile 2004-04-30 20:57:36.000000000 -0400 +@@ -3,7 +3,7 @@ + # + + # Common support +-obj-y := generic.o irq.o dma.o ++obj-y := generic.o irq.o dma.o nmi-oopser.o + obj-m := + obj-n := + obj- := +@@ -88,7 +88,7 @@ + obj-$(CONFIG_LEDS) += $(led-y) + + # SA1110 USB client support +-#obj-$(CONFIG_SA1100_USB) += usb/ ++obj-$(CONFIG_SA1100_USB) += usb/ + + # Miscelaneous functions + obj-$(CONFIG_PM) += pm.o sleep.o +--- /dev/null 2003-09-23 18:19:32.000000000 -0400 ++++ linux-2.6.5/arch/arm/mach-sa1100/usb/strings.h 2004-04-30 20:57:36.000000000 -0400 +@@ -0,0 +1,43 @@ ++/* ++ * usb/strings.h ++ * ++ * Copyright (C) 2002 Russell King. ++ * ++ * USB device string handling, built upon usb buffers. ++ */ ++#ifndef USBDEV_STRINGS_H ++#define USBDEV_STRINGS_H ++ ++#include <linux/spinlock.h> ++ ++struct usb_buf; ++ ++#define NR_STRINGS 8 ++ ++struct usb_string_descriptor; ++ ++struct usbc_strs { ++ spinlock_t lock; ++ struct usb_buf *buf[NR_STRINGS]; ++}; ++ ++#define usbc_string_desc(buf) ((struct usb_string_descriptor *)(buf)->data) ++ ++void usbc_string_from_cstr(struct usb_buf *buf, const char *str); ++struct usb_buf *usbc_string_alloc(int len); ++void usbc_string_free(struct usb_buf *buf); ++ ++int usbc_string_add(struct usbc_strs *table, struct usb_buf *buf); ++void usbc_string_del(struct usbc_strs *table, int nr); ++ ++/* ++ * Note: usbc_string_find() increments the buffer use count. ++ * You must call usbb_put() after use. ++ */ ++struct usb_buf * ++usbc_string_find(struct usbc_strs *table, unsigned int lang, unsigned int idx); ++ ++void usbc_string_free_all(struct usbc_strs *table); ++void usbc_string_init(struct usbc_strs *table); ++ ++#endif +--- /dev/null 2003-09-23 18:19:32.000000000 -0400 ++++ linux-2.6.5/arch/arm/mach-sa1100/usb/usb_ctl.h 2004-04-30 20:57:36.000000000 -0400 +@@ -0,0 +1,114 @@ ++/* ++ * Copyright (C) Compaq Computer Corporation, 1998, 1999 ++ * Copyright (C) Extenex Corporation 2001 ++ * ++ * usb_ctl.h ++ * ++ * PRIVATE interface used to share info among components of the SA-1100 USB ++ * core: usb_ctl, usb_ep0, usb_recv and usb_send. Clients of the USB core ++ * should use sa1100_usb.h. ++ * ++ */ ++ ++#ifndef _USB_CTL_H ++#define _USB_CTL_H ++ ++#include <asm/dma.h> /* dmach_t */ ++ ++struct usb_client; ++ ++struct usb_stats_t { ++ unsigned long ep0_fifo_write_failures; ++ unsigned long ep0_bytes_written; ++ unsigned long ep0_fifo_read_failures; ++ unsigned long ep0_bytes_read; ++}; ++ ++struct usb_info_t ++{ ++ struct usb_client *client; ++ dma_regs_t *dmach_tx, *dmach_rx; ++ int state; ++ unsigned char address; ++ struct usb_stats_t stats; ++}; ++ ++/* in usb_ctl.c */ ++extern struct usb_info_t usbd_info; ++ ++/* ++ * Function Prototypes ++ */ ++enum { kError=-1, kEvSuspend=0, kEvReset=1, ++ kEvResume=2, kEvAddress=3, kEvConfig=4, kEvDeConfig=5 }; ++int usbctl_next_state_on_event( int event ); ++ ++/* endpoint zero */ ++void ep0_reset(void); ++void ep0_int_hndlr(void); ++ ++/* receiver */ ++int ep1_recv(void); ++int ep1_init(dma_regs_t *dma); ++void ep1_int_hndlr(int status); ++void ep1_reset(void); ++void ep1_stall(void); ++ ++/* xmitter */ ++void ep2_reset(void); ++int ep2_init(dma_regs_t *dma); ++void ep2_int_hndlr(int status); ++void ep2_stall(void); ++ ++#define UDC_write(reg, val) { \ ++ int i = 10000; \ ++ do { \ ++ (reg) = (val); \ ++ if (i-- <= 0) { \ ++ printk( "%s [%d]: write %#x to %p (%#x) failed\n", \ ++ __FUNCTION__, __LINE__, (val), &(reg), (reg)); \ ++ break; \ ++ } \ ++ } while((reg) != (val)); \ ++} ++ ++#define UDC_set(reg, val) { \ ++ int i = 10000; \ ++ do { \ ++ (reg) |= (val); \ ++ if (i-- <= 0) { \ ++ printk( "%s [%d]: set %#x of %p (%#x) failed\n", \ ++ __FUNCTION__, __LINE__, (val), &(reg), (reg)); \ ++ break; \ ++ } \ ++ } while(!((reg) & (val))); \ ++} ++ ++#define UDC_clear(reg, val) { \ ++ int i = 10000; \ ++ do { \ ++ (reg) &= ~(val); \ ++ if (i-- <= 0) { \ ++ printk( "%s [%d]: clear %#x of %p (%#x) failed\n", \ ++ __FUNCTION__, __LINE__, (val), &(reg), (reg)); \ ++ break; \ ++ } \ ++ } while((reg) & (val)); \ ++} ++ ++#define UDC_flip(reg, val) { \ ++ int i = 10000; \ ++ (reg) = (val); \ ++ do { \ ++ (reg) = (val); \ ++ if (i-- <= 0) { \ ++ printk( "%s [%d]: flip %#x of %p (%#x) failed\n", \ ++ __FUNCTION__, __LINE__, (val), &(reg), (reg)); \ ++ break; \ ++ } \ ++ } while(((reg) & (val))); \ ++} ++ ++ ++#define CHECK_ADDRESS { if ( Ser0UDCAR == 1 ) { printk("%s:%d I lost my address!!!\n",__FUNCTION__, __LINE__);}} ++#endif /* _USB_CTL_H */ +--- /dev/null 2003-09-23 18:19:32.000000000 -0400 ++++ linux-2.6.5/arch/arm/mach-sa1100/usb/usb_send.c 2004-04-30 20:57:36.000000000 -0400 +@@ -0,0 +1,302 @@ ++/* ++ * Generic xmit layer for the SA1100 USB client function ++ * Copyright (c) 2001 by Nicolas Pitre ++ * ++ * This code was loosely inspired by the original version which was ++ * Copyright (c) Compaq Computer Corporation, 1998-1999 ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License version 2 as ++ * published by the Free Software Foundation. ++ * ++ * This is still work in progress... ++ * ++ * Please see linux/Documentation/arm/SA1100/SA1100_USB for details. ++ * 15/03/2001 - ep2_start now sets UDCAR to overcome something that is hardware ++ * bug, I think. green@iXcelerator.com ++ */ ++ ++#include <linux/module.h> ++#include <linux/pci.h> ++#include <linux/errno.h> ++#include <linux/delay.h> // for the massive_attack hack 28Feb01ww ++#include <linux/usb_ch9.h> ++ ++#include <asm/dma.h> ++ ++#include "usbdev.h" ++#include "sa1100_usb.h" ++#include "sa1100usb.h" ++ ++static unsigned int ep2_curdmalen; ++static unsigned int ep2_remain; ++ ++static struct sausb_dev *ep2_dev; ++ ++static void udc_set_cs2(u32 val, u32 mask, u32 check) ++{ ++ int i = 0; ++ ++ do { ++ Ser0UDCCS2 = val; ++ udelay(1); ++ if ((Ser0UDCCS2 & mask) == check) ++ return; ++ } while (i++ < 10000); ++ ++ printk("UDC: UDCCS2 write timed out: val=0x%08x\n", val); ++} ++ ++/* set feature stall executing, async */ ++static void ep2_start(struct sausb_dev *usb) ++{ ++ ep2_curdmalen = min(ep2_remain, usb->ep[1].maxpktsize); ++ if (ep2_curdmalen == 0) ++ return; ++ ++ /* ++ * must do this _before_ queue buffer.. ++ * stop NAKing IN tokens ++ */ ++ udc_set_cs2(usb->ep[1].udccs | UDCCS2_TPC, UDCCS2_TPC, 0); ++ ++ UDC_write(Ser0UDCIMP, ep2_curdmalen - 1); ++ ++ /* Remove if never seen...8Mar01ww */ ++ { ++ int massive_attack = 20; ++ while (Ser0UDCIMP != ep2_curdmalen - 1 && massive_attack--) { ++ printk("usbsnd: Oh no you don't! Let me spin..."); ++ udelay(500); ++ printk("and try again...\n"); ++ UDC_write(Ser0UDCIMP, ep2_curdmalen - 1); ++ } ++ if (massive_attack != 20) { ++ if (Ser0UDCIMP != ep2_curdmalen - 1) ++ printk("usbsnd: Massive attack FAILED. %d\n", ++ 20 - massive_attack); ++ else ++ printk("usbsnd: Massive attack WORKED. %d\n", ++ 20 - massive_attack); ++ } ++ } ++ /* End remove if never seen... 8Mar01ww */ ++ ++ /* ++ * fight stupid silicon bug ++ */ ++ Ser0UDCAR = usb->ctl->address; ++ ++ sa1100_start_dma(usb->ep[1].dmach, usb->ep[1].pktdma, ep2_curdmalen); ++} ++ ++static void udc_ep2_done(struct sausb_dev *usb, int flag) ++{ ++ int size = usb->ep[1].buflen - ep2_remain; ++ ++ if (!usb->ep[1].buflen) ++ return; ++ ++ dma_unmap_single(usb->dev, usb->ep[1].bufdma, usb->ep[1].buflen, ++ DMA_TO_DEVICE); ++ ++ usb->ep[1].bufdma = 0; ++ usb->ep[1].buflen = 0; ++ usb->ep[1].pktdma = 0; ++ ++ if (usb->ep[1].cb_func) ++ usb->ep[1].cb_func(usb->ep[1].cb_data, flag, size); ++} ++ ++/* ++ * Initialisation. Clear out the status. ++ */ ++void udc_ep2_init(struct sausb_dev *usb) ++{ ++ ep2_dev = usb; ++ ++ usb->ep[1].udccs = UDCCS2_FST; ++ ++ BUG_ON(usb->ep[1].buflen); ++ BUG_ON(usb->ep[1].pktlen); ++ ++ sa1100_reset_dma(usb->ep[1].dmach); ++} ++ ++/* ++ * Note: rev A0-B2 chips don't like FST ++ */ ++void udc_ep2_halt(struct sausb_dev *usb, int halt) ++{ ++ usb->ep[1].host_halt = halt; ++ ++ if (halt) { ++ usb->ep[1].udccs |= UDCCS2_FST; ++ udc_set_cs2(UDCCS2_FST, UDCCS2_FST, UDCCS2_FST); ++ } else { ++ sa1100_clear_dma(usb->ep[1].dmach); ++ ++ udc_set_cs2(UDCCS2_FST, UDCCS2_FST, UDCCS2_FST); ++ udc_set_cs2(0, UDCCS2_FST, 0); ++ udc_set_cs2(UDCCS2_SST, UDCCS2_SST, 0); ++ ++ usb->ep[1].udccs &= ~UDCCS2_FST; ++ ++ udc_ep2_done(usb, -EINTR); ++ } ++} ++ ++/* ++ * This gets called when we receive a SET_CONFIGURATION packet to EP0. ++ * We were configured. We can now send packets to the host. ++ */ ++void udc_ep2_config(struct sausb_dev *usb, unsigned int maxpktsize) ++{ ++ /* ++ * We shouldn't be transmitting anything... ++ */ ++ BUG_ON(usb->ep[1].buflen); ++ BUG_ON(usb->ep[1].pktlen); ++ ++ /* ++ * Set our configuration. ++ */ ++ usb->ep[1].maxpktsize = maxpktsize; ++ usb->ep[1].configured = 1; ++ ++ /* ++ * Clear any pending TPC status. ++ */ ++ udc_set_cs2(UDCCS2_TPC, UDCCS2_TPC, 0); ++ ++ /* ++ * Enable EP2 interrupts. ++ */ ++ usb->udccr &= ~UDCCR_TIM; ++ UDC_write(Ser0UDCCR, usb->udccr); ++ ++ usb->ep[1].udccs = 0; ++} ++ ++/* ++ * We saw a reset from the attached hub, or were deconfigured. ++ * This means we are no longer configured. ++ */ ++void udc_ep2_reset(struct sausb_dev *usb) ++{ ++ /* ++ * Disable EP2 interrupts. ++ */ ++ usb->udccr |= UDCCR_TIM; ++ UDC_write(Ser0UDCCR, usb->udccr); ++ ++ usb->ep[1].configured = 0; ++ usb->ep[1].maxpktsize = 0; ++ ++ sa1100_reset_dma(usb->ep[1].dmach); ++ udc_ep2_done(usb, -EINTR); ++} ++ ++void udc_ep2_int_hndlr(struct sausb_dev *usb) ++{ ++ u32 status = Ser0UDCCS2; ++ ++ // check for stupid silicon bug. ++ if (Ser0UDCAR != usb->ctl->address) ++ Ser0UDCAR = usb->ctl->address; ++ ++ udc_set_cs2(usb->ep[1].udccs | UDCCS2_SST, UDCCS2_SST, 0); ++ ++ if (!(status & UDCCS2_TPC)) { ++ printk("usb_send: Not TPC: UDCCS2 = %x\n", status); ++ return; ++ } ++ ++ sa1100_stop_dma(usb->ep[1].dmach); ++ ++ if (status & (UDCCS2_TPE | UDCCS2_TUR)) { ++ printk("usb_send: transmit error %x\n", status); ++ usb->ep[1].fifo_errs ++; ++ udc_ep2_done(usb, -EIO); ++ } else { ++ unsigned int imp; ++#if 1 // 22Feb01ww/Oleg ++ imp = ep2_curdmalen; ++#else ++ // this is workaround for case when setting ++ // of Ser0UDCIMP was failed ++ imp = Ser0UDCIMP + 1; ++#endif ++ usb->ep[1].pktdma += imp; ++ ep2_remain -= imp; ++ ++ usb->ep[1].bytes += imp; ++ usb->ep[1].packets++; ++ ++ sa1100_clear_dma(usb->ep[1].dmach); ++ ++ if (ep2_remain != 0) { ++ ep2_start(usb); ++ } else { ++ udc_ep2_done(usb, 0); ++ } ++ } ++} ++ ++int udc_ep2_send(struct sausb_dev *usb, char *buf, int len) ++{ ++ unsigned long flags; ++ dma_addr_t dma; ++ int ret; ++ ++ if (!buf || len == 0) ++ return -EINVAL; ++ ++ dma = dma_map_single(usb->dev, buf, len, DMA_TO_DEVICE); ++ ++ spin_lock_irqsave(&usb->lock, flags); ++ do { ++ if (!usb->ep[1].configured) { ++ ret = -ENODEV; ++ break; ++ } ++ ++ if (usb->ep[1].buflen) { ++ ret = -EBUSY; ++ break; ++ } ++ ++ usb->ep[1].bufdma = dma; ++ usb->ep[1].buflen = len; ++ usb->ep[1].pktdma = dma; ++ ep2_remain = len; ++ ++ sa1100_clear_dma(usb->ep[1].dmach); ++ ++ ep2_start(usb); ++ ret = 0; ++ } while (0); ++ spin_unlock_irqrestore(&usb->lock, flags); ++ ++ if (ret) ++ dma_unmap_single(usb->dev, dma, len, DMA_TO_DEVICE); ++ ++ return ret; ++} ++ ++void udc_ep2_send_reset(struct sausb_dev *usb) ++{ ++ sa1100_reset_dma(usb->ep[1].dmach); ++ udc_ep2_done(usb, -EINTR); ++} ++ ++int udc_ep2_idle(struct sausb_dev *usb) ++{ ++ if (!usb->ep[1].configured) ++ return -ENODEV; ++ ++ if (usb->ep[1].buflen) ++ return -EBUSY; ++ ++ return 0; ++} +--- /dev/null 2003-09-23 18:19:32.000000000 -0400 ++++ linux-2.6.5/arch/arm/mach-sa1100/usb/usb-char.c 2004-04-30 20:57:36.000000000 -0400 +@@ -0,0 +1,709 @@ ++/* ++ * (C) Copyright 2000-2001 Extenex Corporation ++ * ++ * 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., 675 Mass Ave, Cambridge, MA 02139, USA. ++ * ++ * usb-char.c ++ * ++ * Miscellaneous character device interface for SA1100 USB function ++ * driver. ++ * ++ * Background: ++ * The SA1100 function driver ported from the Compaq Itsy project ++ * has an interface, usb-eth.c, to feed network packets over the ++ * usb wire and into the Linux TCP/IP stack. ++ * ++ * This file replaces that one with a simple character device ++ * interface that allows unstructured "byte pipe" style reads and ++ * writes over the USB bulk endpoints by userspace programs. ++ * ++ * A new define, CONFIG_SA1100_USB_NETLINK, has been created that, ++ * when set, (the default) causes the ethernet interface to be used. ++ * When not set, this more pedestrian character interface is linked ++ * in instead. ++ * ++ * Please see linux/Documentation/arm/SA1100/SA1100_USB for details. ++ * ++ * ward.willats@extenex.com ++ * ++ * To do: ++ * - Can't dma into ring buffer directly with dma_map/unmap usb_recv ++ * uses and get bytes out at the same time DMA is going on. Investigate: ++ * a) changing usb_recv to use alloc_consistent() at client request; or ++ * b) non-ring-buffer based data structures. In the meantime, I am using ++ * a bounce buffer. Simple, but wasteful. ++ */ ++ ++#include <linux/module.h> ++#include <linux/config.h> ++#include <linux/miscdevice.h> ++#include <linux/slab.h> ++#include <linux/init.h> ++#include <linux/cache.h> ++#include <linux/poll.h> ++#include <linux/circ_buf.h> ++#include <linux/timer.h> ++#include <linux/usb_ch9.h> ++ ++#include <asm/io.h> ++#include <asm/semaphore.h> ++#include <asm/page.h> ++#include <asm/mach-types.h> ++ ++#include "usb-char.h" ++#include "client.h" ++ ++ ++ ++////////////////////////////////////////////////////////////////////////////// ++// Driver Options ++////////////////////////////////////////////////////////////////////////////// ++ ++#define VERSION "0.4" ++ ++ ++#define VERBOSITY 1 ++ ++#if VERBOSITY ++# define PRINTK(x, a...) printk (x, ## a) ++#else ++# define PRINTK(x, a...) /**/ ++#endif ++ ++////////////////////////////////////////////////////////////////////////////// ++// Globals - Macros - Enums - Structures ++////////////////////////////////////////////////////////////////////////////// ++#ifndef MIN ++#define MIN( a, b ) ((a)<(b)?(a):(b)) ++#endif ++ ++typedef int bool; enum { false = 0, true = 1 }; ++ ++static const char pszMe[] = "usbchr: "; ++ ++static wait_queue_head_t wq_read; ++static wait_queue_head_t wq_write; ++static wait_queue_head_t wq_poll; ++ ++/* Serialze multiple writers onto the transmit hardware ++.. since we sleep the writer during transmit to stay in ++.. sync. (Multiple writers don't make much sense, but..) */ ++static DECLARE_MUTEX( xmit_sem ); ++ ++// size of usb DATA0/1 packets. 64 is standard maximum ++// for bulk transport, though most hosts seem to be able ++// to handle larger. ++#define TX_PACKET_SIZE 64 ++#define RX_PACKET_SIZE 64 ++#define RBUF_SIZE (4*PAGE_SIZE) ++ ++static struct wcirc_buf { ++ char *buf; ++ int in; ++ int out; ++} rx_ring = { NULL, 0, 0 }; ++ ++static struct { ++ unsigned long cnt_rx_complete; ++ unsigned long cnt_rx_errors; ++ unsigned long bytes_rx; ++ unsigned long cnt_tx_timeouts; ++ unsigned long cnt_tx_errors; ++ unsigned long bytes_tx; ++} charstats; ++ ++ ++static char * tx_buf = NULL; ++static char * packet_buffer = NULL; ++static int sending = 0; ++static int usb_ref_count = 0; ++static int last_tx_result = 0; ++static int last_rx_result = 0; ++static int last_tx_size = 0; ++static struct timer_list tx_timer; ++ ++////////////////////////////////////////////////////////////////////////////// ++// Prototypes ++////////////////////////////////////////////////////////////////////////////// ++static char * what_the_f( int e ); ++static void free_txrx_buffers( void ); ++static void twiddle_descriptors(struct usb_client *client); ++static int usbc_open( struct inode *pInode, struct file *pFile ); ++static void rx_done_callback_packet_buffer(void *data, int flag, int size ); ++ ++static void tx_timeout( unsigned long ); ++static void tx_done_callback(void *data, int flag, int size ); ++ ++static ssize_t usbc_read( struct file *, char *, size_t, loff_t * ); ++static ssize_t usbc_write( struct file *, const char *, size_t, loff_t * ); ++static unsigned int usbc_poll( struct file *pFile, poll_table * pWait ); ++static int usbc_ioctl( struct inode *pInode, struct file *pFile, ++ unsigned int nCmd, unsigned long argument ); ++static int usbc_close( struct inode *pInode, struct file *pFile ); ++ ++#ifdef CONFIG_SA1100_EXTENEX1 ++static void extenex_configured_notify_proc( void ); ++#endif ++////////////////////////////////////////////////////////////////////////////// ++// Private Helpers ++////////////////////////////////////////////////////////////////////////////// ++ ++static char * what_the_f( int e ) ++{ ++ char * p; ++ switch( e ) { ++ case 0: ++ p = "noErr"; ++ break; ++ case -ENODEV: ++ p = "ENODEV - usb not in config state"; ++ break; ++ case -EBUSY: ++ p = "EBUSY - another request on the hardware"; ++ break; ++ case -EAGAIN: ++ p = "EAGAIN"; ++ break; ++ case -EINTR: ++ p = "EINTR - interrupted\n"; ++ break; ++ case -EPIPE: ++ p = "EPIPE - zero length xfer\n"; ++ break; ++ default: ++ p = "????"; ++ break; ++ } ++ return p; ++} ++ ++static void free_txrx_buffers( void ) ++{ ++ if ( rx_ring.buf != NULL ) { ++ kfree( rx_ring.buf ); ++ rx_ring.buf = NULL; ++ } ++ if ( packet_buffer != NULL ) { ++ kfree( packet_buffer ); ++ packet_buffer = NULL; ++ } ++ if ( tx_buf != NULL ) { ++ kfree( tx_buf ); ++ tx_buf = NULL; ++ } ++} ++ ++/* twiddle_descriptors() ++ * It is between open() and start(). Setup descriptors. ++ */ ++static void twiddle_descriptors(struct usb_client *client) ++{ ++ struct cdb *cdb = sa1100_usb_get_descriptor_ptr(); ++ ++ cdb->ep1.wMaxPacketSize = cpu_to_le16(RX_PACKET_SIZE); ++ cdb->ep2.wMaxPacketSize = cpu_to_le16(TX_PACKET_SIZE); ++ ++#ifdef CONFIG_SA1100_EXTENEX1 ++ if (machine_is_extenex1()) { ++ int nr; ++ ++ cdb->cfg.bmAttributes = USB_CONFIG_SELFPOWERED; ++ cdb->cfg.MaxPower = 0; ++ ++ nr = sa1100_usb_add_string(client->ctl, "HHT Bulk Transfer"); ++ ++ if (nr > 0) ++ cdb->intf.iInterface = nr; ++ } ++#endif ++} ++ ++////////////////////////////////////////////////////////////////////////////// ++// ASYNCHRONOUS ++////////////////////////////////////////////////////////////////////////////// ++static void kick_start_rx( void ) ++{ ++ if ( usb_ref_count ) { ++ int total_space = CIRC_SPACE( rx_ring.in, rx_ring.out, RBUF_SIZE ); ++ if ( total_space >= RX_PACKET_SIZE ) { ++ sa1100_usb_recv_set_callback(rx_done_callback_packet_buffer, NULL); ++ sa1100_usb_recv( packet_buffer, RX_PACKET_SIZE); ++ } ++ } ++} ++/* ++ * rx_done_callback_packet_buffer() ++ * We have completed a DMA xfer into the temp packet buffer. ++ * Move to ring. ++ * ++ * flag values: ++ * on init, -EAGAIN ++ * on reset, -EINTR ++ * on RPE, -EIO ++ * on short packet -EPIPE ++ */ ++static void ++rx_done_callback_packet_buffer(void *data, int flag, int size ) ++{ ++ charstats.cnt_rx_complete++; ++ ++ if ( flag == 0 || flag == -EPIPE ) { ++ size_t n; ++ ++ charstats.bytes_rx += size; ++ ++ n = CIRC_SPACE_TO_END( rx_ring.in, rx_ring.out, RBUF_SIZE ); ++ n = MIN( n, size ); ++ size -= n; ++ ++ memcpy( &rx_ring.buf[ rx_ring.in ], packet_buffer, n ); ++ rx_ring.in = (rx_ring.in + n) & (RBUF_SIZE-1); ++ memcpy( &rx_ring.buf[ rx_ring.in ], packet_buffer + n, size ); ++ rx_ring.in = (rx_ring.in + size) & (RBUF_SIZE-1); ++ ++ wake_up_interruptible( &wq_read ); ++ wake_up_interruptible( &wq_poll ); ++ ++ last_rx_result = 0; ++ ++ kick_start_rx(); ++ ++ } else if ( flag != -EAGAIN ) { ++ charstats.cnt_rx_errors++; ++ last_rx_result = flag; ++ wake_up_interruptible( &wq_read ); ++ wake_up_interruptible( &wq_poll ); ++ } ++ else /* init, start a read */ ++ kick_start_rx(); ++} ++ ++ ++static void tx_timeout( unsigned long unused ) ++{ ++ printk( "%stx timeout\n", pszMe ); ++ sa1100_usb_send_reset(); ++ charstats.cnt_tx_timeouts++; ++} ++ ++ ++// on init, -EAGAIN ++// on reset, -EINTR ++// on TPE, -EIO ++static void tx_done_callback(void *data, int flags, int size ) ++{ ++ if ( flags == 0 ) ++ charstats.bytes_tx += size; ++ else ++ charstats.cnt_tx_errors++; ++ last_tx_size = size; ++ last_tx_result = flags; ++ sending = 0; ++ wake_up_interruptible( &wq_write ); ++ wake_up_interruptible( &wq_poll ); ++} ++ ++ ++static struct usb_client usbc_client = { ++ .name = "usb-char", ++ ++ /* ++ * USB client identification for host use in CPU endian. ++ */ ++ .vendor = 0, ++ .product = 0, ++ .version = 0, ++ .class = 0xff, ++ .subclass = 0, ++ .protocol = 0, ++}; ++ ++#ifdef CONFIG_SA1100_EXTENEX1 ++#include "../../../drivers/char/ex_gpio.h" ++static void extenex_state_change(void *data, int state, int oldstate) ++{ ++ if (exgpio_play_string( "440,1:698,1") == -EAGAIN) ++ printk( "%sWanted to BEEP but ex_gpio not open\n", pszMe ); ++} ++#endif ++ ++////////////////////////////////////////////////////////////////////////////// ++// Workers ++////////////////////////////////////////////////////////////////////////////// ++ ++static int usbc_open(struct inode *pInode, struct file *pFile) ++{ ++ int retval = 0; ++ ++ PRINTK( KERN_DEBUG "%sopen()\n", pszMe ); ++ ++#ifdef CONFIG_SA1100_EXTENEX1 ++ if (machine_is_extenex1()) { ++ usbc_client.vendor = 0x0c9f; ++ usbc_client.product = 0x0100; ++ usbc_client.version = 0x0001; ++ usbc_client.manufacturer_str = "Extenex"; ++ usbc_client.product_str = "Handheld Theater"; ++ usbc_client.serial_str = "00000000"; ++ usbc_client.state_change = extenex_state_change; ++ } ++#endif ++ ++ /* start usb core */ ++ retval = usbctl_open(&usbc_client); ++ if (retval) ++ return retval; ++ ++ /* allocate memory */ ++ if ( usb_ref_count == 0 ) { ++ tx_buf = (char*) kmalloc( TX_PACKET_SIZE, GFP_KERNEL | GFP_DMA ); ++ if ( tx_buf == NULL ) { ++ printk( "%sARGHH! COULD NOT ALLOCATE TX BUFFER\n", pszMe ); ++ goto malloc_fail; ++ } ++ rx_ring.buf = ++ (char*) kmalloc( RBUF_SIZE, GFP_KERNEL ); ++ ++ if ( rx_ring.buf == NULL ) { ++ printk( "%sARGHH! COULD NOT ALLOCATE RX BUFFER\n", pszMe ); ++ goto malloc_fail; ++ } ++ ++ packet_buffer = ++ (char*) kmalloc( RX_PACKET_SIZE, GFP_KERNEL | GFP_DMA ); ++ ++ if ( packet_buffer == NULL ) { ++ printk( "%sARGHH! COULD NOT ALLOCATE RX PACKET BUFFER\n", pszMe ); ++ goto malloc_fail; ++ } ++ rx_ring.in = rx_ring.out = 0; ++ memset( &charstats, 0, sizeof( charstats ) ); ++ sending = 0; ++ last_tx_result = 0; ++ last_tx_size = 0; ++ } ++ ++ /* modify default descriptors */ ++ twiddle_descriptors(&usbc_client); ++ ++ retval = usbctl_start(&usbc_client); ++ if ( retval ) { ++ printk( "%sAGHH! Could not USB core\n", pszMe ); ++ free_txrx_buffers(); ++ return retval; ++ } ++ usb_ref_count++; /* must do _before_ kick_start() */ ++ MOD_INC_USE_COUNT; ++ kick_start_rx(); ++ return 0; ++ ++ malloc_fail: ++ free_txrx_buffers(); ++ return -ENOMEM; ++} ++ ++/* ++ * Read endpoint. Note that you can issue a read to an ++ * unconfigured endpoint. Eventually, the host may come along ++ * and configure underneath this module and data will appear. ++ */ ++static ssize_t usbc_read( struct file *pFile, char *pUserBuffer, ++ size_t stCount, loff_t *pPos ) ++{ ++ ssize_t retval; ++ unsigned long flags; ++ DECLARE_WAITQUEUE( wait, current ); ++ ++ PRINTK( KERN_DEBUG "%sread()\n", pszMe ); ++ ++ local_irq_save(flags); ++ if ( last_rx_result == 0 ) { ++ local_irq_restore( flags ); ++ } else { /* an error happended and receiver is paused */ ++ local_irq_restore( flags ); ++ last_rx_result = 0; ++ kick_start_rx(); ++ } ++ ++ add_wait_queue( &wq_read, &wait ); ++ while( 1 ) { ++ ssize_t bytes_avail; ++ ssize_t bytes_to_end; ++ ++ set_current_state( TASK_INTERRUPTIBLE ); ++ ++ /* snap ring buf state */ ++ local_irq_save( flags ); ++ bytes_avail = CIRC_CNT( rx_ring.in, rx_ring.out, RBUF_SIZE ); ++ bytes_to_end = CIRC_CNT_TO_END( rx_ring.in, rx_ring.out, RBUF_SIZE ); ++ local_irq_restore( flags ); ++ ++ if ( bytes_avail != 0 ) { ++ ssize_t bytes_to_move = MIN( stCount, bytes_avail ); ++ retval = 0; // will be bytes transfered ++ if ( bytes_to_move != 0 ) { ++ size_t n = MIN( bytes_to_end, bytes_to_move ); ++ if ( copy_to_user( pUserBuffer, ++ &rx_ring.buf[ rx_ring.out ], ++ n ) ) { ++ retval = -EFAULT; ++ break; ++ } ++ bytes_to_move -= n; ++ retval += n; ++ // might go 1 char off end, so wrap ++ rx_ring.out = ( rx_ring.out + n ) & (RBUF_SIZE-1); ++ if ( copy_to_user( pUserBuffer + n, ++ &rx_ring.buf[ rx_ring.out ], ++ bytes_to_move ) ++ ) { ++ retval = -EFAULT; ++ break; ++ } ++ rx_ring.out += bytes_to_move; // cannot wrap ++ retval += bytes_to_move; ++ kick_start_rx(); ++ } ++ break; ++ } ++ else if ( last_rx_result ) { ++ retval = last_rx_result; ++ break; ++ } ++ else if ( pFile->f_flags & O_NONBLOCK ) { // no data, can't sleep ++ retval = -EAGAIN; ++ break; ++ } ++ else if ( signal_pending( current ) ) { // no data, can sleep, but signal ++ retval = -ERESTARTSYS; ++ break; ++ } ++ schedule(); // no data, can sleep ++ } ++ set_current_state( TASK_RUNNING ); ++ remove_wait_queue( &wq_read, &wait ); ++ ++ if ( retval < 0 ) ++ printk( "%sread error %d - %s\n", pszMe, retval, what_the_f( retval ) ); ++ return retval; ++} ++ ++/* ++ * Write endpoint. This routine attempts to break the passed in buffer ++ * into usb DATA0/1 packet size chunks and send them to the host. ++ * (The lower-level driver tries to do this too, but easier for us ++ * to manage things here.) ++ * ++ * We are at the mercy of the host here, in that it must send an IN ++ * token to us to pull this data back, so hopefully some higher level ++ * protocol is expecting traffic to flow in that direction so the host ++ * is actually polling us. To guard against hangs, a 5 second timeout ++ * is used. ++ * ++ * This routine takes some care to only report bytes sent that have ++ * actually made it across the wire. Thus we try to stay in lockstep ++ * with the completion routine and only have one packet on the xmit ++ * hardware at a time. Multiple simultaneous writers will get ++ * "undefined" results. ++ * ++ */ ++static ssize_t usbc_write( struct file *pFile, const char * pUserBuffer, ++ size_t stCount, loff_t *pPos ) ++{ ++ ssize_t retval = 0; ++ ssize_t stSent = 0; ++ ++ DECLARE_WAITQUEUE( wait, current ); ++ ++ PRINTK( KERN_DEBUG "%swrite() %d bytes\n", pszMe, stCount ); ++ ++ down( &xmit_sem ); // only one thread onto the hardware at a time ++ ++ while( stCount != 0 && retval == 0 ) { ++ int nThisTime = MIN( TX_PACKET_SIZE, stCount ); ++ copy_from_user( tx_buf, pUserBuffer, nThisTime ); ++ sending = nThisTime; ++ sa1100_usb_send_set_callback(tx_done_callback, NULL); ++ retval = sa1100_usb_send( tx_buf, nThisTime); ++ if ( retval < 0 ) { ++ char * p = what_the_f( retval ); ++ printk( "%sCould not queue xmission. rc=%d - %s\n", ++ pszMe, retval, p ); ++ sending = 0; ++ break; ++ } ++ /* now have something on the diving board */ ++ add_wait_queue( &wq_write, &wait ); ++ tx_timer.expires = jiffies + ( HZ * 5 ); ++ add_timer( &tx_timer ); ++ while( 1 ) { ++ set_current_state( TASK_INTERRUPTIBLE ); ++ if ( sending == 0 ) { /* it jumped into the pool */ ++ del_timer( &tx_timer ); ++ retval = last_tx_result; ++ if ( retval == 0 ) { ++ stSent += last_tx_size; ++ pUserBuffer += last_tx_size; ++ stCount -= last_tx_size; ++ } ++ else ++ printk( "%sxmission error rc=%d - %s\n", ++ pszMe, retval, what_the_f(retval) ); ++ break; ++ } ++ else if ( signal_pending( current ) ) { ++ del_timer( &tx_timer ); ++ printk( "%ssignal\n", pszMe ); ++ retval = -ERESTARTSYS; ++ break; ++ } ++ schedule(); ++ } ++ set_current_state( TASK_RUNNING ); ++ remove_wait_queue( &wq_write, &wait ); ++ } ++ ++ up( &xmit_sem ); ++ ++ if ( 0 == retval ) ++ retval = stSent; ++ return retval; ++} ++ ++static unsigned int usbc_poll( struct file *pFile, poll_table * pWait ) ++{ ++ unsigned int retval = 0; ++ ++ PRINTK( KERN_DEBUG "%poll()\n", pszMe ); ++ ++ poll_wait( pFile, &wq_poll, pWait ); ++ ++ if ( CIRC_CNT( rx_ring.in, rx_ring.out, RBUF_SIZE ) ) ++ retval |= POLLIN | POLLRDNORM; ++ if ( sa1100_usb_xmitter_avail() ) ++ retval |= POLLOUT | POLLWRNORM; ++ return retval; ++} ++ ++static int usbc_ioctl( struct inode *pInode, struct file *pFile, ++ unsigned int nCmd, unsigned long argument ) ++{ ++ int retval = 0; ++ ++ switch( nCmd ) { ++ ++ case USBC_IOC_FLUSH_RECEIVER: ++ sa1100_usb_recv_reset(); ++ rx_ring.in = rx_ring.out = 0; ++ break; ++ ++ case USBC_IOC_FLUSH_TRANSMITTER: ++ sa1100_usb_send_reset(); ++ break; ++ ++ case USBC_IOC_FLUSH_ALL: ++ sa1100_usb_recv_reset(); ++ rx_ring.in = rx_ring.out = 0; ++ sa1100_usb_send_reset(); ++ break; ++ ++ default: ++ retval = -ENOIOCTLCMD; ++ break; ++ ++ } ++ return retval; ++} ++ ++ ++static int usbc_close( struct inode *pInode, struct file * pFile ) ++{ ++ PRINTK( KERN_DEBUG "%sclose()\n", pszMe ); ++ if ( --usb_ref_count == 0 ) { ++ down( &xmit_sem ); ++ usbctl_stop(&usbc_client); ++ free_txrx_buffers(); ++ del_timer( &tx_timer ); ++ usbctl_close(&usbc_client); ++ up(&xmit_sem); ++ } ++ MOD_DEC_USE_COUNT; ++ return 0; ++} ++ ++////////////////////////////////////////////////////////////////////////////// ++// Initialization ++////////////////////////////////////////////////////////////////////////////// ++ ++static struct file_operations usbc_fops = { ++ owner: THIS_MODULE, ++ open: usbc_open, ++ read: usbc_read, ++ write: usbc_write, ++ poll: usbc_poll, ++ ioctl: usbc_ioctl, ++ release: usbc_close, ++}; ++ ++static struct miscdevice usbc_misc_device = { ++ USBC_MINOR, ++ "usb_char", ++ &usbc_fops ++}; ++ ++/* ++ * usbc_init() ++ */ ++ ++static int __init usbc_init( void ) ++{ ++ int rc; ++ ++#if !defined( CONFIG_ARCH_SA1100 ) ++ return -ENODEV; ++#endif ++ ++ if ( (rc = misc_register( &usbc_misc_device )) != 0 ) { ++ printk( KERN_WARNING "%sCould not register device 10, " ++ "%d. (%d)\n", pszMe, USBC_MINOR, rc ); ++ return -EBUSY; ++ } ++ ++ // initialize wait queues ++ init_waitqueue_head( &wq_read ); ++ init_waitqueue_head( &wq_write ); ++ init_waitqueue_head( &wq_poll ); ++ ++ // initialize tx timeout timer ++ init_timer( &tx_timer ); ++ tx_timer.function = tx_timeout; ++ ++ printk( KERN_INFO "USB Function Character Driver Interface" ++ " - %s, (C) 2001, Extenex Corp.\n", VERSION ++ ); ++ ++ return rc; ++} ++ ++static void __exit usbc_exit( void ) ++{ ++} ++ ++module_init(usbc_init); ++module_exit(usbc_exit); ++ ++// end: usb-char.c ++ ++MODULE_LICENSE("GPL"); +--- /dev/null 2003-09-23 18:19:32.000000000 -0400 ++++ linux-2.6.5/arch/arm/mach-sa1100/usb/usb-eth.c 2004-04-30 20:57:36.000000000 -0400 +@@ -0,0 +1,535 @@ ++/* ++ * Network driver for the SA1100 USB client function ++ * Copyright (c) 2001 by Nicolas Pitre ++ * ++ * This code was loosely inspired by the original initial ethernet test driver ++ * Copyright (c) Compaq Computer Corporation, 1999 ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License version 2 as ++ * published by the Free Software Foundation. ++ * ++ * Issues: ++ * - DMA needs 8 byte aligned buffer, but causes inefficiencies ++ * in the IP code. ++ * - stall endpoint operations appeared to be very unstable. ++ */ ++ ++/* ++ * Define RX_NO_COPY if you want data to arrive directly into the ++ * receive network buffers, instead of arriving into bounce buffer ++ * and then get copied to network buffer. ++ * ++ * Since the SA1100 DMA engine is unable to cope with unaligned ++ * buffer addresses, we need to use bounce buffers or suffer the ++ * alignment trap performance hit. ++ */ ++#undef RX_NO_COPY ++ ++#include <linux/module.h> ++#include <linux/init.h> ++#include <linux/kernel.h> ++#include <linux/errno.h> ++#include <linux/netdevice.h> ++#include <linux/etherdevice.h> ++#include <linux/skbuff.h> ++#include <linux/random.h> ++#include <linux/usb_ch9.h> ++ ++#include "client.h" ++ ++ ++#define ETHERNET_VENDOR_ID 0x049f ++#define ETHERNET_PRODUCT_ID 0x505A ++#define MAX_PACKET 32768 ++ ++/* ++ * This is our usb "packet size", and must match the host "packet size". ++ */ ++static int usb_rsize = 64; ++static int usb_wsize = 64; ++ ++struct usbe_info { ++ struct net_device dev; ++ struct usb_client client; ++ struct sk_buff *cur_tx_skb; ++ struct sk_buff *next_tx_skb; ++ struct sk_buff *cur_rx_skb; ++ struct sk_buff *next_rx_skb; ++#ifndef RX_NO_COPY ++ char *dmabuf; // dma expects it's buffers to be aligned on 8 bytes boundary ++#endif ++ struct net_device_stats stats; ++}; ++ ++ ++static int usbeth_change_mtu(struct net_device *dev, int new_mtu) ++{ ++ if (new_mtu <= sizeof(struct ethhdr) || new_mtu > MAX_PACKET) ++ return -EINVAL; ++ ++ // no second zero-length packet read wanted after mtu-sized packets ++ if (((new_mtu + sizeof(struct ethhdr)) % usb_rsize) == 0) ++ return -EDOM; ++ ++ dev->mtu = new_mtu; ++ return 0; ++} ++ ++static struct sk_buff *usb_new_recv_skb(struct usbe_info *usbe) ++{ ++ struct sk_buff *skb; ++ ++ skb = alloc_skb(2 + sizeof(struct ethhdr) + usbe->dev.mtu, ++ GFP_ATOMIC); ++ ++ if (skb) ++ skb_reserve(skb, 2); ++ ++ return skb; ++} ++ ++static void usbeth_recv_callback(void *data, int flag, int len) ++{ ++ struct usbe_info *usbe = data; ++ struct sk_buff *skb; ++ unsigned int size; ++ char *buf; ++ ++ skb = usbe->cur_rx_skb; ++ ++ /* flag validation */ ++ if (flag != 0) ++ goto error; ++ ++ /* ++ * Make sure we have enough room left in the buffer. ++ */ ++ if (len > skb_tailroom(skb)) { ++ usbe->stats.rx_over_errors++; ++ usbe->stats.rx_errors++; ++ goto oversize; ++ } ++ ++ /* ++ * If the packet is smaller than usb_rsize bytes, the packet ++ * is complete, and we need to use the next receive buffer. ++ */ ++ if (len != usb_rsize) ++ usbe->cur_rx_skb = usbe->next_rx_skb; ++ ++ /* ++ * Put the data onto the socket buffer and resume USB receive. ++ */ ++#ifndef RX_NO_COPY ++ memcpy(skb_put(skb, len), usbe->dmabuf, len); ++ buf = usbe->dmabuf; ++ size = usb_rsize; ++#else ++ skb_put(skb, len); ++ buf = usbe->cur_rx_skb->tail; ++ size = skb_tailroom(usbe->cur_rx_skb); ++#endif ++ usbctl_ep_queue_buffer(usbe->client.ctl, 1, buf, size); ++ ++ if (len == usb_rsize) ++ return; ++ ++ /* ++ * A frame must contain at least an ethernet header. ++ */ ++ if (skb->len < sizeof(struct ethhdr)) { ++ usbe->stats.rx_length_errors++; ++ usbe->stats.rx_errors++; ++ goto recycle; ++ } ++ ++ /* ++ * MAC must match our address or the broadcast address. ++ * Really, we should let any packet through, otherwise ++ * things that rely on multicast won't work. ++ */ ++ if (memcmp(skb->data, usbe->dev.dev_addr, ETH_ALEN) && ++ memcmp(skb->data, usbe->dev.broadcast, ETH_ALEN)) { ++ usbe->stats.rx_frame_errors++; ++ usbe->stats.rx_errors++; ++ goto recycle; ++ } ++ ++ /* ++ * We're going to consume this SKB. Get a new skb to ++ * replace it with. IF this fails, we'd better recycle ++ * the one we have. ++ */ ++ usbe->next_rx_skb = usb_new_recv_skb(usbe); ++ if (!usbe->next_rx_skb) { ++ if (net_ratelimit()) ++ printk(KERN_ERR "%s: can't allocate new rx skb\n", ++ usbe->dev.name); ++ usbe->stats.rx_dropped++; ++ goto recycle; ++ } ++ ++// FIXME: eth_copy_and_csum "small" packets to new SKB (small < ~200 bytes) ? ++ ++ usbe->stats.rx_packets++; ++ usbe->stats.rx_bytes += skb->len; ++ usbe->dev.last_rx = jiffies; ++ ++ skb->dev = &usbe->dev; ++ skb->protocol = eth_type_trans(skb, &usbe->dev); ++ skb->ip_summed = CHECKSUM_NONE; ++ ++ if (netif_rx(skb) == NET_RX_DROP) ++ usbe->stats.rx_dropped++; ++ return; ++ ++ error: ++ /* ++ * Oops, IO error, or stalled. ++ */ ++ switch (flag) { ++ case -EIO: /* aborted transfer */ ++ usbe->stats.rx_errors++; ++ break; ++ ++ case -EPIPE: /* fifo screwed/no data */ ++ usbe->stats.rx_fifo_errors++; ++ usbe->stats.rx_errors++; ++ break; ++ ++ case -EINTR: /* reset */ ++ break; ++ ++ case -EAGAIN: /* initialisation */ ++ break; ++ } ++ ++ oversize: ++ skb_trim(skb, 0); ++ ++#ifndef RX_NO_COPY ++ buf = usbe->dmabuf; ++ size = usb_rsize; ++#else ++ buf = skb->tail; ++ size = skb_tailroom(skb); ++#endif ++ usbctl_ep_queue_buffer(usbe->client.ctl, 1, buf, size); ++ return; ++ ++ recycle: ++ skb_trim(skb, 0); ++ usbe->next_rx_skb = skb; ++ return; ++} ++ ++/* ++ * Send a skb. ++ * ++ * Note that the receiver expects the last packet to be a non-multiple ++ * of its rsize. If the packet length is a muliple of wsize (and ++ * therefore the remote rsize) tweak the length. ++ */ ++static void usbeth_send(struct sk_buff *skb, struct usbe_info *usbe) ++{ ++ unsigned int len = skb->len; ++ int ret; ++ ++ if ((len % usb_wsize) == 0) ++ len++; ++ ++ ret = usbctl_ep_queue_buffer(usbe->client.ctl, 2, skb->data, len); ++ if (ret) { ++ printk(KERN_ERR "%s: tx dropping packet: %d\n", ++ usbe->dev.name, ret); ++ ++ /* ++ * If the USB core can't accept the packet, we drop it. ++ */ ++ dev_kfree_skb_irq(skb); ++ ++ usbe->cur_tx_skb = NULL; ++ usbe->stats.tx_carrier_errors++; ++ } else { ++ usbe->dev.trans_start = jiffies; ++ } ++} ++ ++static void usbeth_send_callback(void *data, int flag, int size) ++{ ++ struct usbe_info *usbe = data; ++ struct sk_buff *skb = usbe->cur_tx_skb; ++ ++ switch (flag) { ++ case 0: ++ usbe->stats.tx_packets++; ++ usbe->stats.tx_bytes += skb->len; ++ break; ++ case -EIO: ++ usbe->stats.tx_errors++; ++ break; ++ default: ++ usbe->stats.tx_dropped++; ++ break; ++ } ++ ++ dev_kfree_skb_irq(skb); ++ ++ skb = usbe->cur_tx_skb = usbe->next_tx_skb; ++ usbe->next_tx_skb = NULL; ++ ++ if (skb) ++ usbeth_send(skb, usbe); ++ ++ netif_wake_queue(&usbe->dev); ++} ++ ++static int usbeth_xmit(struct sk_buff *skb, struct net_device *dev) ++{ ++ struct usbe_info *usbe = dev->priv; ++ unsigned long flags; ++ ++ if (usbe->next_tx_skb) { ++ printk(KERN_ERR "%s: called with next_tx_skb != NULL\n", ++ usbe->dev.name); ++ return 1; ++ } ++ ++ local_irq_save(flags); ++ if (usbe->cur_tx_skb) { ++ usbe->next_tx_skb = skb; ++ netif_stop_queue(dev); ++ } else { ++ usbe->cur_tx_skb = skb; ++ ++ usbeth_send(skb, usbe); ++ } ++ local_irq_restore(flags); ++ return 0; ++} ++ ++/* ++ * Transmit timed out. Reset the endpoint, and re-queue the pending ++ * packet. If we have a free transmit slot, wake the transmit queue. ++ */ ++static void usbeth_xmit_timeout(struct net_device *dev) ++{ ++ struct usbe_info *usbe = dev->priv; ++ unsigned long flags; ++ ++ usbctl_ep_reset(usbe->client.ctl, 2); ++ ++ local_irq_save(flags); ++ if (usbe->cur_tx_skb) ++ usbeth_send(usbe->cur_tx_skb, usbe); ++ ++ if (usbe->next_tx_skb == NULL) ++ netif_wake_queue(dev); ++ ++ usbe->stats.tx_errors++; ++ local_irq_restore(flags); ++} ++ ++static int usbeth_open(struct net_device *dev) ++{ ++ struct usbe_info *usbe = dev->priv; ++ unsigned char *buf; ++ unsigned int size; ++ ++ usbctl_ep_set_callback(usbe->client.ctl, 2, usbeth_send_callback, usbe); ++ usbctl_ep_set_callback(usbe->client.ctl, 1, usbeth_recv_callback, usbe); ++ ++ usbe->cur_tx_skb = usbe->next_tx_skb = NULL; ++ usbe->cur_rx_skb = usb_new_recv_skb(usbe); ++ usbe->next_rx_skb = usb_new_recv_skb(usbe); ++ if (!usbe->cur_rx_skb || !usbe->next_rx_skb) { ++ printk(KERN_ERR "%s: can't allocate new skb\n", ++ usbe->dev.name); ++ if (usbe->cur_rx_skb) ++ kfree_skb(usbe->cur_rx_skb); ++ if (usbe->next_rx_skb) ++ kfree_skb(usbe->next_rx_skb); ++ return -ENOMEM;; ++ } ++#ifndef RX_NO_COPY ++ buf = usbe->dmabuf; ++ size = usb_rsize; ++#else ++ buf = usbe->cur_rx_skb->tail; ++ size = skb_tailroom(usbe->cur_rx_skb); ++#endif ++ usbctl_ep_queue_buffer(usbe->client.ctl, 1, buf, size); ++ ++ if (netif_carrier_ok(dev)) ++ netif_start_queue(dev); ++ ++ return 0; ++} ++ ++static int usbeth_close(struct net_device *dev) ++{ ++ struct usbe_info *usbe = dev->priv; ++ ++ netif_stop_queue(dev); ++ ++ usbctl_ep_set_callback(usbe->client.ctl, 2, NULL, NULL); ++ usbctl_ep_set_callback(usbe->client.ctl, 1, NULL, NULL); ++ usbctl_ep_reset(usbe->client.ctl, 2); ++ usbctl_ep_reset(usbe->client.ctl, 1); ++ ++ if (usbe->cur_tx_skb) ++ kfree_skb(usbe->cur_tx_skb); ++ if (usbe->next_tx_skb) ++ kfree_skb(usbe->next_tx_skb); ++ if (usbe->cur_rx_skb) ++ kfree_skb(usbe->cur_rx_skb); ++ if (usbe->next_rx_skb) ++ kfree_skb(usbe->next_rx_skb); ++ ++ return 0; ++} ++ ++static struct net_device_stats *usbeth_stats(struct net_device *dev) ++{ ++ struct usbe_info *usbe = dev->priv; ++ ++ return &usbe->stats; ++} ++ ++static int __init usbeth_probe(struct net_device *dev) ++{ ++ u8 node_id[ETH_ALEN]; ++ ++ SET_MODULE_OWNER(dev); ++ ++ /* ++ * Assign the hardware address of the board: ++ * generate it randomly, as there can be many such ++ * devices on the bus. ++ */ ++ get_random_bytes(node_id, sizeof node_id); ++ node_id[0] &= 0xfe; // clear multicast bit ++ memcpy(dev->dev_addr, node_id, sizeof node_id); ++ ++ ether_setup(dev); ++ dev->flags &= ~IFF_MULTICAST; ++ dev->flags &= ~IFF_BROADCAST; ++ //dev->flags |= IFF_NOARP; ++ ++ return 0; ++} ++ ++/* ++ * This is called when something in the upper usb client layers ++ * changes that affects the endpoint connectivity state (eg, ++ * connection or disconnection from the host.) We probably want ++ * to do some more handling here, like kicking off a pending ++ * transmission if we're running? ++ */ ++static void usbeth_state_change(void *data, int state, int oldstate) ++{ ++ struct usbe_info *usbe = data; ++ ++ if (state == USB_STATE_CONFIGURED) { ++ netif_carrier_on(&usbe->dev); ++ if (netif_running(&usbe->dev)) ++ netif_wake_queue(&usbe->dev); ++ } else { ++ if (netif_running(&usbe->dev)) ++ netif_stop_queue(&usbe->dev); ++ netif_carrier_off(&usbe->dev); ++ } ++} ++ ++static struct usbe_info usbe_info = { ++ .dev = { ++ .name = "usbf", ++ .init = usbeth_probe, ++ .get_stats = usbeth_stats, ++ .watchdog_timeo = 1 * HZ, ++ .open = usbeth_open, ++ .stop = usbeth_close, ++ .hard_start_xmit = usbeth_xmit, ++ .change_mtu = usbeth_change_mtu, ++ .tx_timeout = usbeth_xmit_timeout, ++ .priv = &usbe_info, ++ }, ++ .client = { ++ .name = "usbeth", ++ .priv = &usbe_info, ++ .state_change = usbeth_state_change, ++ ++ /* ++ * USB client identification for host use in CPU endian. ++ */ ++ .vendor = ETHERNET_VENDOR_ID, ++ .product = ETHERNET_PRODUCT_ID, ++ .version = 0, ++ .class = 0xff, /* vendor specific */ ++ .subclass = 0, ++ .protocol = 0, ++ ++ .product_str = "SA1100 USB NIC", ++ }, ++}; ++ ++static int __init usbeth_init(void) ++{ ++ int rc; ++ ++#ifndef RX_NO_COPY ++ usbe_info.dmabuf = kmalloc(usb_rsize, GFP_KERNEL | GFP_DMA); ++ if (!usbe_info.dmabuf) ++ return -ENOMEM; ++#endif ++ ++ if (register_netdev(&usbe_info.dev) != 0) { ++#ifndef RX_NO_COPY ++ kfree(usbe_info.dmabuf); ++#endif ++ return -EIO; ++ } ++ ++ rc = usbctl_open(&usbe_info.client); ++ if (rc == 0) { ++ struct cdb *cdb = sa1100_usb_get_descriptor_ptr(); ++ ++ cdb->ep1.wMaxPacketSize = cpu_to_le16(usb_rsize); ++ cdb->ep2.wMaxPacketSize = cpu_to_le16(usb_wsize); ++ ++ rc = usbctl_start(&usbe_info.client); ++ if (rc) ++ usbctl_close(&usbe_info.client); ++ } ++ ++ if (rc) { ++ unregister_netdev(&usbe_info.dev); ++#ifndef RX_NO_COPY ++ kfree(usbe_info.dmabuf); ++#endif ++ } ++ ++ return rc; ++} ++ ++static void __exit usbeth_cleanup(void) ++{ ++ usbctl_stop(&usbe_info.client); ++ usbctl_close(&usbe_info.client); ++ ++ unregister_netdev(&usbe_info.dev); ++#ifndef RX_NO_COPY ++ kfree(usbe_info.dmabuf); ++#endif ++} ++ ++module_init(usbeth_init); ++module_exit(usbeth_cleanup); ++ ++MODULE_DESCRIPTION("USB client ethernet driver"); ++MODULE_PARM(usb_rsize, "1i"); ++MODULE_PARM_DESC(usb_rsize, "number of bytes in packets from host to sa11x0"); ++MODULE_PARM(usb_wsize, "1i"); ++MODULE_PARM_DESC(usb_wsize, "number of bytes in packets from sa11x0 to host"); ++MODULE_LICENSE("GPL"); +--- /dev/null 2003-09-23 18:19:32.000000000 -0400 ++++ linux-2.6.5/arch/arm/mach-sa1100/usb/usb_recv.c 2004-04-30 20:57:36.000000000 -0400 +@@ -0,0 +1,318 @@ ++/* ++ * Generic receive layer for the SA1100 USB client function ++ * Copyright (c) 2001 by Nicolas Pitre ++ * ++ * This code was loosely inspired by the original version which was ++ * Copyright (c) Compaq Computer Corporation, 1998-1999 ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License version 2 as ++ * published by the Free Software Foundation. ++ * ++ * This is still work in progress... ++ * ++ * Please see linux/Documentation/arm/SA1100/SA1100_USB for details. ++ */ ++ ++#include <linux/module.h> ++#include <linux/pci.h> ++#include <linux/errno.h> ++#include <linux/usb_ch9.h> ++ ++#include <asm/byteorder.h> ++#include <asm/dma.h> ++ ++#include "sa1100_usb.h" ++#include "sa1100usb.h" ++ ++static int naking; ++ ++#if 1 ++static void dump_buf(struct sausb_dev *usb, const char *prefix) ++{ ++ printk("%s: buf [dma=%08x len=%3d] pkt [cpu=%08x dma=%08x len=%3d rem=%3d]\n", ++ prefix, ++ usb->ep[0].bufdma, ++ usb->ep[0].buflen, ++ (unsigned int)usb->ep[0].pktcpu, ++ usb->ep[0].pktdma, ++ usb->ep[0].pktlen, ++ usb->ep[0].pktrem); ++} ++#endif ++ ++static void udc_ep1_done(struct sausb_dev *usb, int flag, int size) ++{ ++// printk("UDC: rxd: %3d %3d\n", flag, size); ++ dump_buf(usb, "UDC: rxd"); ++ ++ if (!usb->ep[0].buflen) ++ return; ++ ++ dma_unmap_single(usb->dev, usb->ep[0].bufdma, usb->ep[0].buflen, ++ DMA_FROM_DEVICE); ++ ++ usb->ep[0].bufdma = 0; ++ usb->ep[0].buflen = 0; ++ usb->ep[0].pktcpu = NULL; ++ usb->ep[0].pktdma = 0; ++ usb->ep[0].pktlen = 0; ++ usb->ep[0].pktrem = 0; ++ ++ if (usb->ep[0].cb_func) ++ usb->ep[0].cb_func(usb->ep[0].cb_data, flag, size); ++} ++ ++/* ++ * Initialisation. Clear out the status, and set FST. ++ */ ++void udc_ep1_init(struct sausb_dev *usb) ++{ ++ sa1100_reset_dma(usb->ep[0].dmach); ++ ++ UDC_clear(Ser0UDCCS1, UDCCS1_FST | UDCCS1_RPE | UDCCS1_RPC); ++ ++ BUG_ON(usb->ep[0].buflen); ++ BUG_ON(usb->ep[0].pktlen); ++} ++ ++void udc_ep1_halt(struct sausb_dev *usb, int halt) ++{ ++ if (halt) { ++ /* force stall at UDC */ ++ UDC_set(Ser0UDCCS1, UDCCS1_FST); ++ } else { ++ sa1100_reset_dma(usb->ep[0].dmach); ++ ++ UDC_clear(Ser0UDCCS1, UDCCS1_FST); ++ ++ udc_ep1_done(usb, -EINTR, 0); ++ } ++} ++ ++/* ++ * This gets called when we receive a SET_CONFIGURATION packet to EP0. ++ * We were configured. We can now accept packets from the host. ++ */ ++void udc_ep1_config(struct sausb_dev *usb, unsigned int maxpktsize) ++{ ++ usb->ep[0].maxpktsize = maxpktsize; ++ usb->ep[0].configured = 1; ++ ++ Ser0UDCOMP = maxpktsize - 1; ++ ++ sa1100_reset_dma(usb->ep[0].dmach); ++ udc_ep1_done(usb, -EINTR, 0); ++ ++ /* ++ * Enable EP1 interrupts. ++ */ ++ usb->udccr &= ~UDCCR_RIM; ++ UDC_write(Ser0UDCCR, usb->udccr); ++} ++ ++/* ++ * We saw a reset from the attached hub. This means we are no ++ * longer configured, and as far as the rest of the world is ++ * concerned, we don't exist. ++ */ ++void udc_ep1_reset(struct sausb_dev *usb) ++{ ++ /* ++ * Disable EP1 interrupts. ++ */ ++ usb->udccr |= UDCCR_RIM; ++ UDC_write(Ser0UDCCR, usb->udccr); ++ ++ usb->ep[0].configured = 0; ++ usb->ep[0].maxpktsize = 0; ++ ++ sa1100_reset_dma(usb->ep[0].dmach); ++ udc_ep1_done(usb, -EINTR, 0); ++} ++ ++void udc_ep1_int_hndlr(struct sausb_dev *usb) ++{ ++ dma_addr_t dma_addr; ++ unsigned int len; ++ u32 status = Ser0UDCCS1; ++ ++ dump_buf(usb, "UDC: int"); ++ ++ if (naking) { ++ printk("UDC: usbrx: in ISR but naking [0x%02x]\n", status); ++ return; ++ } ++ ++ if (!(status & UDCCS1_RPC)) ++ /* you can get here if we are holding NAK */ ++ return; ++ ++ if (!usb->ep[0].buflen) { ++ printk("UDC: usb_recv: RPC for non-existent buffer [0x%02x]\n", status); ++ naking = 1; ++ return; ++ } ++ ++ sa1100_stop_dma(usb->ep[0].dmach); ++ ++ dma_addr = sa1100_get_dma_pos(usb->ep[0].dmach); ++ ++ /* ++ * We've finished with the DMA for this packet. ++ */ ++ sa1100_clear_dma(usb->ep[0].dmach); ++ ++ if (status & UDCCS1_SST) { ++ printk("UDC: usb_recv: stall sent\n"); ++ UDC_flip(Ser0UDCCS1, UDCCS1_SST); ++ ++ /* ++ * UDC aborted current transfer, so we do. ++ * ++ * It would be better to re-queue this buffer IMHO. It ++ * hasn't gone anywhere yet. --rmk ++ */ ++ UDC_flip(Ser0UDCCS1, UDCCS1_RPC); ++ udc_ep1_done(usb, -EIO, 0); ++ return; ++ } ++ ++ if (status & UDCCS1_RPE) { ++ printk("UDC: usb_recv: RPError %x\n", status); ++ UDC_flip(Ser0UDCCS1, UDCCS1_RPC); ++ udc_ep1_done(usb, -EIO, 0); ++ return; ++ } ++ ++ len = dma_addr - usb->ep[0].pktdma; ++ if (len < 0) { ++ printk("UDC: usb_recv: dma_addr (%x) < pktdma (%x)\n", ++ dma_addr, usb->ep[0].pktdma); ++ len = 0; ++ } ++ ++ if (len > usb->ep[0].pktlen) ++ len = usb->ep[0].pktlen; ++ ++ /* ++ * If our transfer was smaller, and we have bytes left in ++ * the FIFO, we need to read them out manually. ++ */ ++ if (len < usb->ep[0].pktlen && (Ser0UDCCS1 & UDCCS1_RNE)) { ++ char *buf; ++ ++ dma_sync_single(usb->dev, usb->ep[0].pktdma + len, ++ usb->ep[0].pktlen - len, DMA_FROM_DEVICE); ++ ++ buf = (char *)usb->ep[0].pktcpu + len; ++ ++ do { ++ *buf++ = Ser0UDCDR; ++ len++; ++ } while (len < usb->ep[0].pktlen && (Ser0UDCCS1 & UDCCS1_RNE)); ++ ++ /* ++ * Note: knowing the internals of this macro is BAD, but we ++ * need this to cause the data to be written back to memory. ++ */ ++ dma_sync_single(usb->dev, usb->ep[0].pktdma + len, ++ usb->ep[0].pktlen - len, DMA_TO_DEVICE); ++ } ++ ++ /* ++ * If the FIFO still contains data, something's definitely wrong. ++ */ ++ if (Ser0UDCCS1 & UDCCS1_RNE) { ++ printk("UDC: usb_recv: fifo screwed, shouldn't contain data\n"); ++ usb->ep[0].fifo_errs++; ++ naking = 1; ++ udc_ep1_done(usb, -EPIPE, 0); ++ return; ++ } ++ ++ /* ++ * Do statistics. ++ */ ++ if (len) { ++ usb->ep[0].bytes += len; ++ usb->ep[0].packets ++; ++ } ++ ++ /* ++ * Update remaining byte count for this buffer. ++ */ ++ usb->ep[0].pktrem -= len; ++ ++ /* ++ * If we received a full-sized packet, and there's more ++ * data remaining, th, queue up another receive. ++ */ ++ if (len == usb->ep[0].pktlen && usb->ep[0].pktrem != 0) { ++ usb->ep[0].pktcpu += len; ++ usb->ep[0].pktdma += len; ++ usb->ep[0].pktlen = min(usb->ep[0].pktrem, usb->ep[0].maxpktsize); ++ sa1100_start_dma(usb->ep[0].dmach, usb->ep[0].pktdma, usb->ep[0].pktlen); ++ /* ++ * Clear RPC to receive next packet. ++ */ ++ UDC_flip(Ser0UDCCS1, UDCCS1_RPC); ++ dump_buf(usb, "UDC: req"); ++ return; ++ } ++ ++ naking = 1; ++ udc_ep1_done(usb, 0, usb->ep[0].buflen - usb->ep[0].pktrem); ++} ++ ++int udc_ep1_queue_buffer(struct sausb_dev *usb, char *buf, unsigned int len) ++{ ++ unsigned long flags; ++ dma_addr_t dma; ++ int ret; ++ ++ if (!buf || len == 0) ++ return -EINVAL; ++ ++ dma = dma_map_single(usb->dev, buf, len, DMA_FROM_DEVICE); ++ ++ spin_lock_irqsave(&usb->lock, flags); ++ do { ++ if (usb->ep[0].buflen) { ++ ret = -EBUSY; ++ break; ++ } ++ ++ sa1100_clear_dma(usb->ep[0].dmach); ++ ++ usb->ep[0].bufdma = dma; ++ usb->ep[0].buflen = len; ++ usb->ep[0].pktcpu = buf; ++ usb->ep[0].pktdma = dma; ++ usb->ep[0].pktlen = min(len, usb->ep[0].maxpktsize); ++ usb->ep[0].pktrem = len; ++ ++ sa1100_start_dma(usb->ep[0].dmach, usb->ep[0].bufdma, usb->ep[0].buflen); ++ dump_buf(usb, "UDC: que"); ++ ++ if (naking) { ++ /* turn off NAK of OUT packets, if set */ ++ UDC_flip(Ser0UDCCS1, UDCCS1_RPC); ++ naking = 0; ++ } ++ ++ ret = 0; ++ } while (0); ++ spin_unlock_irqrestore(&usb->lock, flags); ++ ++ if (ret) ++ dma_unmap_single(usb->dev, dma, len, DMA_FROM_DEVICE); ++ ++ return 0; ++} ++ ++void udc_ep1_recv_reset(struct sausb_dev *usb) ++{ ++ sa1100_reset_dma(usb->ep[0].dmach); ++ udc_ep1_done(usb, -EINTR, 0); ++} +--- /dev/null 2003-09-23 18:19:32.000000000 -0400 ++++ linux-2.6.5/arch/arm/mach-sa1100/usb/buffer.c 2004-04-30 20:57:36.000000000 -0400 +@@ -0,0 +1,63 @@ ++/* ++ * usb/buffer.c ++ * ++ * Copyright (C) 2002 Russell King. ++ */ ++#include <linux/module.h> ++#include <linux/slab.h> ++#include <linux/init.h> ++ ++#include "buffer.h" ++ ++static LIST_HEAD(buffers); ++ ++struct usb_buf *usbb_alloc(int size, int gfp) ++{ ++ unsigned long flags; ++ struct usb_buf *buf; ++ ++ buf = kmalloc(sizeof(struct usb_buf) + size, gfp); ++ if (buf) { ++ atomic_set(&buf->users, 1); ++ local_irq_save(flags); ++ list_add(&buf->list, &buffers); ++ local_irq_restore(flags); ++ buf->len = 0; ++ buf->data = (unsigned char *) (buf + 1); ++ buf->head = (unsigned char *) (buf + 1); ++ } ++ ++ return buf; ++} ++ ++void __usbb_free(struct usb_buf *buf) ++{ ++ unsigned long flags; ++ local_irq_save(flags); ++ list_del(&buf->list); ++ local_irq_restore(flags); ++ kfree(buf); ++} ++ ++EXPORT_SYMBOL(usbb_alloc); ++EXPORT_SYMBOL(__usbb_free); ++ ++static void __exit usbb_exit(void) ++{ ++ if (!list_empty(&buffers)) { ++ struct list_head *l, *n; ++ printk("usbb: buffers not freed:\n"); ++ ++ list_for_each_safe(l, n, &buffers) { ++ struct usb_buf *b = list_entry(l, struct usb_buf, list); ++ ++ printk(" %p: alloced from %p count %d\n", ++ b, b->alloced_by, atomic_read(&b->users)); ++ ++ __usbb_free(b); ++ } ++ } ++} ++ ++module_exit(usbb_exit); ++ +--- /dev/null 2003-09-23 18:19:32.000000000 -0400 ++++ linux-2.6.5/arch/arm/mach-sa1100/usb/usb-char.h 2004-04-30 20:57:36.000000000 -0400 +@@ -0,0 +1,34 @@ ++/* ++ * Copyright (C) 2001 Extenex Corporation ++ * ++ * usb-char.h ++ * ++ * Character device emulation client for SA-1100 client usb core. ++ * ++ * ++ * ++ */ ++#ifndef _USB_CHAR_H ++#define _USB_CHAR_H ++ ++#define USBC_MAJOR 10 /* miscellaneous character device */ ++#define USBC_MINOR 240 /* in the "reserved for local use" range */ ++ ++#define USBC_MAGIC 0x8E ++ ++/* zap everything in receive ring buffer */ ++#define USBC_IOC_FLUSH_RECEIVER _IO( USBC_MAGIC, 0x01 ) ++ ++/* reset transmitter */ ++#define USBC_IOC_FLUSH_TRANSMITTER _IO( USBC_MAGIC, 0x02 ) ++ ++/* do both of above */ ++#define USBC_IOC_FLUSH_ALL _IO( USBC_MAGIC, 0x03 ) ++ ++ ++ ++ ++ ++ ++#endif /* _USB_CHAR_H */ ++ +--- /dev/null 2003-09-23 18:19:32.000000000 -0400 ++++ linux-2.6.5/arch/arm/mach-sa1100/usb/buffer.h 2004-04-30 20:57:36.000000000 -0400 +@@ -0,0 +1,45 @@ ++/* ++ * usb/buffer.h: USB client buffers ++ * ++ * Copyright (C) 2002 Russell King. ++ * ++ * Loosely based on linux/skbuff.h ++ */ ++#ifndef USBDEV_BUFFER_H ++#define USBDEV_BUFFER_H ++ ++#include <linux/list.h> ++ ++struct usb_buf { ++ atomic_t users; ++ struct list_head list; ++ void *alloced_by; ++ unsigned char *data; ++ unsigned char *head; ++ unsigned int len; ++}; ++ ++extern struct usb_buf *usbb_alloc(int size, int gfp); ++extern void __usbb_free(struct usb_buf *); ++ ++static inline struct usb_buf *usbb_get(struct usb_buf *buf) ++{ ++ atomic_inc(&buf->users); ++ return buf; ++} ++ ++static inline void usbb_put(struct usb_buf *buf) ++{ ++ if (atomic_dec_and_test(&buf->users)) ++ __usbb_free(buf); ++} ++ ++static inline void *usbb_push(struct usb_buf *buf, int len) ++{ ++ unsigned char *b = buf->head; ++ buf->head += len; ++ buf->len += len; ++ return b; ++} ++ ++#endif +--- /dev/null 2003-09-23 18:19:32.000000000 -0400 ++++ linux-2.6.5/arch/arm/mach-sa1100/usb/sa1100usb.c 2004-04-30 20:57:36.000000000 -0400 +@@ -0,0 +1,1160 @@ ++#include <linux/module.h> ++#include <linux/delay.h> ++#include <linux/interrupt.h> ++#include <linux/usb_ch9.h> ++#include <linux/init.h> ++#include <linux/proc_fs.h> ++#include <linux/spinlock.h> ++#include <linux/device.h> ++ ++#include <asm/mach-types.h> ++#include <asm/io.h> ++#include <asm/dma.h> ++#include <asm/irq.h> ++ ++#include "buffer.h" ++#include "usbdev.h" ++#include "sa1100_usb.h" ++#include "sa1100usb.h" ++ ++#ifdef DEBUG ++#define DPRINTK(fmt, args...) printk( fmt , ## args) ++#else ++#define DPRINTK(fmt, args...) ++#endif ++ ++static inline void pcs(const char *prefix) ++{ ++#ifdef DEBUG ++ __u32 foo = Ser0UDCCS0; ++ ++ DPRINTK("%s UDCAR: %d\n", prefix, Ser0UDCAR); ++ ++ printk("UDC: %s: %08x [ %s%s%s%s%s%s]\n", prefix, ++ foo, ++ foo & UDCCS0_SE ? "SE " : "", ++ foo & UDCCS0_DE ? "DE " : "", ++ foo & UDCCS0_FST ? "FST " : "", ++ foo & UDCCS0_SST ? "SST " : "", ++ foo & UDCCS0_IPR ? "IPR " : "", ++ foo & UDCCS0_OPR ? "OPR " : ""); ++#endif ++} ++ ++/* ++ * soft_connect_hook() ++ * ++ * Some devices have platform-specific circuitry to make USB ++ * not seem to be plugged in, even when it is. This allows ++ * software to control when a device 'appears' on the USB bus ++ * (after Linux has booted and this driver has loaded, for ++ * example). If you have such a circuit, control it here. ++ */ ++static inline void soft_connect_hook(int enable) ++{ ++#ifdef CONFIG_SA1100_EXTENEX1 ++ if (machine_is_extenex1()) { ++ if (enable) { ++ PPDR |= PPC_USB_SOFT_CON; ++ PPSR |= PPC_USB_SOFT_CON; ++ } else { ++ PPSR &= ~PPC_USB_SOFT_CON; ++ PPDR &= ~PPC_USB_SOFT_CON; ++ } ++ } ++#endif ++} ++ ++/* ++ * disable the UDC at the source ++ */ ++static inline void udc_disable(struct sausb_dev *usb) ++{ ++ soft_connect_hook(0); ++ ++ usb->udccr = UDCCR_UDD | UDCCR_SUSIM; ++ ++ UDC_write(Ser0UDCCR, usb->udccr); ++} ++ ++/* ++ * Clear any pending write from the EP0 write buffer. ++ */ ++static void ep0_clear_write(struct sausb_dev *usb) ++{ ++ struct usb_buf *buf; ++ ++ buf = usb->wrbuf; ++ usb->wrint = NULL; ++ usb->wrbuf = NULL; ++ usb->wrptr = NULL; ++ usb->wrlen = 0; ++ ++ if (buf) ++ usbb_put(buf); ++} ++ ++static int udc_start(void *priv) ++{ ++ struct sausb_dev *usb = priv; ++ ++ usb->ep[0].maxpktsize = 0; ++ usb->ep[1].maxpktsize = 0; ++ ++ /* ++ * start UDC internal machinery running, but mask interrupts. ++ */ ++ usb->udccr = UDCCR_SUSIM | UDCCR_TIM | UDCCR_RIM | UDCCR_EIM | ++ UDCCR_RESIM; ++ UDC_write(Ser0UDCCR, usb->udccr); ++ ++ udelay(100); ++ ++ /* ++ * clear all interrupt sources ++ */ ++ Ser0UDCSR = UDCSR_RSTIR | UDCSR_RESIR | UDCSR_EIR | ++ UDCSR_RIR | UDCSR_TIR | UDCSR_SUSIR; ++ ++ /* ++ * flush DMA and fire through some -EAGAINs ++ */ ++ udc_ep1_init(usb); ++ udc_ep2_init(usb); ++ ++ /* ++ * enable any platform specific hardware ++ */ ++ soft_connect_hook(1); ++ ++ /* ++ * Enable resume, suspend and endpoint 0 interrupts. Leave ++ * endpoint 1 and 2 interrupts masked. ++ * ++ * If you are unplugged you will immediately get a suspend ++ * interrupt. If you are plugged and have a soft connect-circuit, ++ * you will get a reset. If you are plugged without a soft-connect, ++ * I think you also get suspend. ++ */ ++ usb->udccr &= ~(UDCCR_SUSIM | UDCCR_EIM | UDCCR_RESIM); ++ UDC_write(Ser0UDCCR, usb->udccr); ++ ++ return 0; ++} ++ ++static int udc_stop(void *priv) ++{ ++ struct sausb_dev *usb = priv; ++ ++ ep0_clear_write(usb); ++ ++ /* mask everything */ ++ Ser0UDCCR = 0xFC; ++ ++ udc_ep1_reset(usb); ++ udc_ep2_reset(usb); ++ ++ udc_disable(usb); ++ ++ return 0; ++} ++ ++ ++ ++ ++ ++/* ++ * some voodo I am adding, since the vanilla macros just aren't doing it ++ * 1Mar01ww ++ */ ++ ++#define ABORT_BITS (UDCCS0_SST | UDCCS0_SE) ++#define OK_TO_WRITE (!(Ser0UDCCS0 & ABORT_BITS)) ++#define BOTH_BITS (UDCCS0_IPR | UDCCS0_DE) ++ ++static void set_de(void) ++{ ++ int i = 1; ++ ++ while (1) { ++ if (OK_TO_WRITE) { ++ Ser0UDCCS0 |= UDCCS0_DE; ++ } else { ++ DPRINTK("UDC: quitting set DE because SST or SE set\n"); ++ break; ++ } ++ if (Ser0UDCCS0 & UDCCS0_DE) ++ break; ++ udelay(i); ++ if (++i == 50) { ++ printk("UDC: Dangnabbbit! Cannot set DE! (DE=%8.8X CCS0=%8.8X)\n", ++ UDCCS0_DE, Ser0UDCCS0); ++ break; ++ } ++ } ++} ++ ++static void set_ipr(void) ++{ ++ int i = 1; ++ ++ while (1) { ++ if (OK_TO_WRITE) { ++ Ser0UDCCS0 |= UDCCS0_IPR; ++ } else { ++ DPRINTK("UDC: Quitting set IPR because SST or SE set\n"); ++ break; ++ } ++ if (Ser0UDCCS0 & UDCCS0_IPR) ++ break; ++ udelay(i); ++ if (++i == 50) { ++ printk("UDC: Dangnabbbit! Cannot set IPR! (IPR=%8.8X CCS0=%8.8X)\n", ++ UDCCS0_IPR, Ser0UDCCS0); ++ break; ++ } ++ } ++} ++ ++static void set_ipr_and_de(void) ++{ ++ int i = 1; ++ ++ while (1) { ++ if (OK_TO_WRITE) { ++ Ser0UDCCS0 |= BOTH_BITS; ++ } else { ++ DPRINTK("UDC: Quitting set IPR/DE because SST or SE set\n"); ++ break; ++ } ++ if ((Ser0UDCCS0 & BOTH_BITS) == BOTH_BITS) ++ break; ++ udelay(i); ++ if (++i == 50) { ++ printk("UDC: Dangnabbbit! Cannot set DE/IPR! (DE=%8.8X IPR=%8.8X CCS0=%8.8X)\n", ++ UDCCS0_DE, UDCCS0_IPR, Ser0UDCCS0); ++ break; ++ } ++ } ++} ++ ++static inline void set_cs_bits(__u32 bits) ++{ ++ if (bits & (UDCCS0_SO | UDCCS0_SSE | UDCCS0_FST | UDCCS0_SST)) ++ Ser0UDCCS0 = bits; ++ else if ((bits & BOTH_BITS) == BOTH_BITS) ++ set_ipr_and_de(); ++ else if (bits & UDCCS0_IPR) ++ set_ipr(); ++ else if (bits & UDCCS0_DE) ++ set_de(); ++} ++ ++/* ++ * udc_ep0_write_fifo() ++ * ++ * Stick bytes in the 8 bytes endpoint zero FIFO. This version uses a ++ * variety of tricks to make sure the bytes are written correctly: ++ * 1. The count register is checked to see if the byte went in, ++ * and the write is attempted again if not. ++ * 2. An overall counter is used to break out so we don't hang in ++ * those (rare) cases where the UDC reverses direction of the ++ * FIFO underneath us without notification (in response to host ++ * aborting a setup transaction early). ++ */ ++static void udc_ep0_write_fifo(struct sausb_dev *usb) ++{ ++ unsigned int bytes_this_time = min(usb->wrlen, 8U); ++ int bytes_written = 0; ++ ++ DPRINTK("WF=%d: ", bytes_this_time); ++ ++ while (bytes_this_time--) { ++ unsigned int cwc; ++ int i; ++ ++ DPRINTK("%2.2X ", *usb->wrptr); ++ ++ cwc = Ser0UDCWC & 15; ++ ++ i = 10; ++ do { ++ Ser0UDCD0 = *usb->wrptr; ++ udelay(20); /* voodo 28Feb01ww */ ++ } while ((Ser0UDCWC & 15) == cwc && --i); ++ ++ if (i == 0) { ++ printk("UDC: udc_ep0_write_fifo: write failure\n"); ++ usb->ep0_wr_fifo_errs++; ++ } ++ ++ usb->wrptr++; ++ bytes_written++; ++ } ++ usb->wrlen -= bytes_written; ++ ++ /* following propagation voodo so maybe caller writing IPR in ++ ..a moment might actually get it to stick 28Feb01ww */ ++ udelay(300); ++ ++ usb->ep0_wr_bytes += bytes_written; ++ DPRINTK("L=%d WCR=%8.8X\n", usb->wrlen, Ser0UDCWC); ++} ++ ++/* ++ * read_fifo() ++ * ++ * Read 1-8 bytes out of FIFO and put in request. Called to do the ++ * initial read of setup requests from the host. Return number of ++ * bytes read. ++ * ++ * Like write fifo above, this driver uses multiple reads checked ++ * against the count register with an overall timeout. ++ */ ++static int ++udc_ep0_read_fifo(struct sausb_dev *usb, struct usb_ctrlrequest *request, int sz) ++{ ++ unsigned char *pOut = (unsigned char *) request; ++ unsigned int fifo_count, bytes_read = 0; ++ ++ fifo_count = Ser0UDCWC & 15; ++ ++ DPRINTK("RF=%d ", fifo_count); ++ BUG_ON(fifo_count > sz); ++ ++ while (fifo_count--) { ++ unsigned int cwc; ++ int i; ++ ++ cwc = Ser0UDCWC & 15; ++ ++ i = 10; ++ do { ++ *pOut = (unsigned char) Ser0UDCD0; ++ udelay(20); ++ } while ((Ser0UDCWC & 15) == cwc && --i); ++ ++ if (i == 0) { ++ printk(KERN_ERR "UDC: udc_ep0_read_fifo: read failure\n"); ++ usb->ep0_rd_fifo_errs++; ++ break; ++ } ++ pOut++; ++ bytes_read++; ++ } ++ ++ DPRINTK("fc=%d\n", bytes_read); ++ usb->ep0_rd_bytes += bytes_read; ++ usb->ep0_rd_packets ++; ++ return bytes_read; ++} ++ ++static void ep0_sh_write_data(struct sausb_dev *usb) ++{ ++ /* ++ * If bytes left is zero, we are coming in on the ++ * interrupt after the last packet went out. And ++ * we know we don't have to empty packet this ++ * transfer so just set DE and we are done ++ */ ++ set_cs_bits(UDCCS0_DE); ++} ++ ++static void ep0_sh_write_with_empty_packet(struct sausb_dev *usb) ++{ ++ /* ++ * If bytes left is zero, we are coming in on the ++ * interrupt after the last packet went out. ++ * We must do short packet suff, so set DE and IPR ++ */ ++ set_cs_bits(UDCCS0_IPR | UDCCS0_DE); ++ DPRINTK("UDC: sh_write_empty: Sent empty packet\n"); ++} ++ ++static int udc_clear_opr(void) ++{ ++ int i = 10000; ++ int is_clear; ++ ++ /*FIXME*/ ++ do { ++ Ser0UDCCS0 = UDCCS0_SO; ++ is_clear = !(Ser0UDCCS0 & UDCCS0_OPR); ++ if (i-- <= 0) ++ break; ++ } while (!is_clear); ++ ++ return is_clear; ++} ++ ++static int udc_ep0_queue(void *priv, struct usb_buf *buf, ++ unsigned int req_len) ++{ ++ struct sausb_dev *usb = priv; ++ __u32 cs_reg_bits = UDCCS0_IPR; ++ ++ DPRINTK("a=%d r=%d\n", buf->len, req_len); ++ ++ /* ++ * thou shalt not enter data phase until ++ * Out Packet Ready is clear ++ */ ++ if (!udc_clear_opr()) { ++ printk("UDC: SO did not clear OPR\n"); ++ set_cs_bits(UDCCS0_DE | UDCCS0_SO); ++ usbb_put(buf); ++ return 1; ++ } ++ ++ usb->ep0_wr_packets++; ++ ++ usb->wrbuf = buf; ++ usb->wrptr = buf->data; ++ usb->wrlen = min(buf->len, req_len); ++ ++ udc_ep0_write_fifo(usb); ++ ++ if (usb->wrlen == 0) { ++ /* ++ * out in one, so data end ++ */ ++ cs_reg_bits |= UDCCS0_DE; ++ ep0_clear_write(usb); ++ } else if (buf->len < req_len) { ++ /* ++ * we are going to short-change host ++ * so need nul to not stall ++ */ ++ usb->wrint = ep0_sh_write_with_empty_packet; ++ } else { ++ /* ++ * we have as much or more than requested ++ */ ++ usb->wrint = ep0_sh_write_data; ++ } ++ ++ /* ++ * note: IPR was set uncondtionally at start of routine ++ */ ++ set_cs_bits(cs_reg_bits); ++ return 0; ++} ++ ++/* ++ * When SO and DE sent, UDC will enter status phase and ack, propagating ++ * new address to udc core. Next control transfer will be on the new ++ * address. ++ * ++ * You can't see the change in a read back of CAR until then (about 250us ++ * later, on my box). The original Intel driver sets S0 and DE and code ++ * to check that address has propagated here. I tried this, but it would ++ * only sometimes work! The rest of the time it would never propagate and ++ * we'd spin forever. So now I just set it and pray... ++ */ ++static void udc_set_address(void *priv, unsigned int addr) ++{ ++ Ser0UDCAR = addr; ++} ++ ++static void udc_set_config(void *priv, struct cdb *cdb) ++{ ++ struct sausb_dev *usb = priv; ++ ++ if (cdb) { ++ udc_ep1_config(usb, le16_to_cpu(cdb->ep1.wMaxPacketSize)); ++ udc_ep2_config(usb, le16_to_cpu(cdb->ep2.wMaxPacketSize)); ++ } else { ++ udc_ep1_reset(usb); ++ udc_ep2_reset(usb); ++ } ++} ++ ++static unsigned int udc_ep_get_status(void *priv, unsigned int ep) ++{ ++ unsigned int status; ++ ++ switch (ep) { ++ case 0: ++ status = (Ser0UDCCS0 & UDCCS0_FST) ? 1 : 0; ++ break; ++ ++ case 1: ++ status = (Ser0UDCCS1 & UDCCS1_FST) ? 1 : 0; ++ break; ++ ++ case 2: ++ status = (Ser0UDCCS2 & UDCCS2_FST) ? 1 : 0; ++ break; ++ ++ default: ++ printk(KERN_ERR "UDC: get_status: bad end point %d\n", ep); ++ status = 0; ++ break; ++ } ++ ++ return status; ++} ++ ++static void udc_ep_halt(void *priv, unsigned int ep, int halt) ++{ ++ struct sausb_dev *usb = priv; ++ ++ printk("UDC: ep%d %s halt\n", ep, halt ? "set" : "clear"); ++ ++ switch (ep) { ++ case 1: ++ udc_ep1_halt(usb, halt); ++ break; ++ ++ case 2: ++ udc_ep2_halt(usb, halt); ++ break; ++ } ++} ++ ++static int udc_ep_queue(void *priv, unsigned int ep, char *buf, unsigned int len) ++{ ++ struct sausb_dev *usb = priv; ++ int ret = -EINVAL; ++ ++ switch (ep) { ++ case 1: ++ ret = udc_ep1_queue_buffer(usb, buf, len); ++ break; ++ case 2: ++ ret = udc_ep2_send(usb, buf, len); ++ break; ++ } ++ ++ return ret; ++} ++ ++static void udc_ep_reset(void *priv, unsigned int ep) ++{ ++ struct sausb_dev *usb = priv; ++ ++ switch (ep) { ++ case 1: ++ udc_ep1_recv_reset(usb); ++ break; ++ case 2: ++ udc_ep2_send_reset(usb); ++ break; ++ } ++} ++ ++static void udc_ep_callback(void *priv, unsigned int ep, usb_callback_t cb, void *data) ++{ ++ struct sausb_dev *usb = priv; ++ unsigned long flags; ++ ++ if (ep == 1 || ep == 2) { ++ ep -= 1; ++ ++ spin_lock_irqsave(&usb->lock, flags); ++ usb->ep[ep].cb_func = cb; ++ usb->ep[ep].cb_data = data; ++ spin_unlock_irqrestore(&usb->lock, flags); ++ } ++} ++ ++static int udc_ep_idle(void *priv, unsigned int ep) ++{ ++ struct sausb_dev *usb = priv; ++ int ret = -EINVAL; ++ ++ switch (ep) { ++ case 1: ++ break; ++ case 2: ++ ret = udc_ep2_idle(usb); ++ break; ++ } ++ ++ return ret; ++} ++ ++static struct usbc_driver usb_sa1100_drv = { ++ .owner = THIS_MODULE, ++ .name = "SA1100", ++ .start = udc_start, ++ .stop = udc_stop, ++ .ep0_queue = udc_ep0_queue, ++ .set_address = udc_set_address, ++ .set_config = udc_set_config, ++ .ep_get_status = udc_ep_get_status, ++ .ep_halt = udc_ep_halt, ++ .ep_queue = udc_ep_queue, ++ .ep_reset = udc_ep_reset, ++ .ep_callback = udc_ep_callback, ++ .ep_idle = udc_ep_idle, ++}; ++ ++ ++/* ++ * udc_ep0_read_packet() ++ * ++ * This setup handler is the "idle" state of endpoint zero. It looks for ++ * OPR (OUT packet ready) to see if a setup request has been been received ++ * from the host. Requests without a return data phase are immediately ++ * handled. Otherwise, the handler may be set to one of the sh_write_xxxx ++ * data pumpers if more than 8 bytes need to get back to the host. ++ */ ++static void udc_ep0_read_packet(struct sausb_dev *usb, u32 cs_reg_in) ++{ ++ struct usb_ctrlrequest req; ++ int n, ret = RET_NOACTION; ++ ++ /* ++ * A control request has been received by EP0. ++ * Read the request. ++ */ ++ n = udc_ep0_read_fifo(usb, &req, sizeof(req)); ++ ++ if (n == sizeof(req)) { ++ ret = usbctl_parse_request(usb->ctl, &req); ++ } else { ++ /* ++ * The request wasn't fully received. Force a ++ * stall. ++ */ ++ set_cs_bits(UDCCS0_FST | UDCCS0_SO); ++ printk("UDC: fifo read error: wanted %d bytes got %d\n", ++ sizeof(req), n); ++ } ++ ++ switch (ret) { ++ case RET_ERROR: ++ case RET_NOACTION: ++ break; ++ ++ case RET_ACK: ++ set_cs_bits(UDCCS0_DE | UDCCS0_SO); ++ break; ++ ++ case RET_REQERROR: ++ /* ++ * Send stall PID to host. ++ */ ++ set_cs_bits(UDCCS0_DE | UDCCS0_SO | UDCCS0_FST); ++ break; ++ } ++} ++ ++/* ++ * HACK DEBUG 3Mar01ww ++ * Well, maybe not, it really seems to help! 08Mar01ww ++ */ ++static void core_kicker(struct sausb_dev *usb) ++{ ++ __u32 car = Ser0UDCAR; ++ __u32 imp = Ser0UDCIMP; ++ __u32 omp = Ser0UDCOMP; ++ ++ UDC_set(Ser0UDCCR, UDCCR_UDD); ++ udelay(300); ++ UDC_clear(Ser0UDCCR, UDCCR_UDD); ++ ++ Ser0UDCAR = car; ++ Ser0UDCIMP = imp; ++ Ser0UDCOMP = omp; ++} ++ ++static void enable_resume_mask_suspend(struct sausb_dev *usb) ++{ ++ int i; ++ ++ usb->udccr |= UDCCR_SUSIM; ++ ++ i = 1; ++ do { ++ Ser0UDCCR = usb->udccr; ++ udelay(i); ++ if (Ser0UDCCR == usb->udccr) ++ break; ++ if (Ser0UDCSR & UDCSR_RSTIR) ++ break; ++ } while (i++ < 50); ++ ++ if (i == 50) ++ printk("UDC: enable_resume: could not set SUSIM 0x%08x\n", ++ Ser0UDCCR); ++ ++ usb->udccr &= ~UDCCR_RESIM; ++ ++ i = 1; ++ do { ++ Ser0UDCCR = usb->udccr; ++ udelay(i); ++ if (Ser0UDCCR == usb->udccr) ++ break; ++ if (Ser0UDCSR & UDCSR_RSTIR) ++ break; ++ } while (i++ < 50); ++ ++ if (i == 50) ++ printk("UDC: enable_resume: could not clear RESIM 0x%08x\n", ++ Ser0UDCCR); ++} ++ ++static void enable_suspend_mask_resume(struct sausb_dev *usb) ++{ ++ int i; ++ ++ usb->udccr |= UDCCR_RESIM; ++ ++ i = 1; ++ do { ++ Ser0UDCCR = usb->udccr; ++ udelay(i); ++ if (Ser0UDCCR == usb->udccr) ++ break; ++ if (Ser0UDCSR & UDCSR_RSTIR) ++ break; ++ } while (i++ < 50); ++ ++ if (i == 50) ++ printk("UDC: enable_resume: could not set RESIM 0x%08x\n", ++ Ser0UDCCR); ++ ++ usb->udccr &= ~UDCCR_SUSIM; ++ ++ i = 1; ++ do { ++ Ser0UDCCR = usb->udccr; ++ udelay(i); ++ if (Ser0UDCCR == usb->udccr) ++ break; ++ if (Ser0UDCSR & UDCSR_RSTIR) ++ break; ++ } while (i++ < 50); ++ ++ if (i == 50) ++ printk("UDC: enable_resume: could not clear SUSIM 0x%08x\n", ++ Ser0UDCCR); ++} ++ ++/* ++ * Reset received from HUB (or controller just went nuts and reset by ++ * itself!) so UDC core has been reset, track this state here ++ */ ++static void udc_reset(struct sausb_dev *usb) ++{ ++ if (usbctl_reset(usb->ctl)) { ++ ep0_clear_write(usb); ++ ++ /* ++ * Clean up endpoints. ++ */ ++ udc_ep1_reset(usb); ++ udc_ep2_reset(usb); ++ } ++ ++ /* ++ * mask reset ints, they flood during sequence, enable ++ * suspend and resume ++ */ ++ usb->udccr = (usb->udccr & ~(UDCCR_SUSIM | UDCCR_RESIM)) | UDCCR_REM; ++ Ser0UDCCR = usb->udccr; ++} ++ ++/* ++ * handle interrupt for endpoint zero ++ */ ++static void udc_ep0_int_hndlr(struct sausb_dev *usb) ++{ ++ u32 cs_reg_in; ++ ++ pcs("-->"); ++ ++ cs_reg_in = Ser0UDCCS0; ++ ++ /* ++ * If "setup end" has been set, the usb controller has terminated ++ * a setup transaction before we set DE. This happens during ++ * enumeration with some hosts. For example, the host will ask for ++ * our device descriptor and specify a return of 64 bytes. When we ++ * hand back the first 8, the host will know our max packet size ++ * and turn around and issue a new setup immediately. This causes ++ * the UDC to auto-ack the new setup and set SE. We must then ++ * "unload" (process) the new setup, which is what will happen ++ * after this preamble is finished executing. ++ */ ++ if (cs_reg_in & UDCCS0_SE) { ++ DPRINTK("UDC: early termination of setup\n"); ++ ++ /* ++ * Clear setup end ++ */ ++ set_cs_bits(UDCCS0_SSE); ++ ++ /* ++ * Clear any pending write. ++ */ ++ ep0_clear_write(usb); ++ } ++ ++ /* ++ * UDC sent a stall due to a protocol violation. ++ */ ++ if (cs_reg_in & UDCCS0_SST) { ++ usb->ep0_stall_sent++; ++ ++ DPRINTK("UDC: write_preamble: UDC sent stall\n"); ++ ++ /* ++ * Clear sent stall ++ */ ++ set_cs_bits(UDCCS0_SST); ++ ++ /* ++ * Clear any pending write. ++ */ ++ ep0_clear_write(usb); ++ } ++ ++ switch (cs_reg_in & (UDCCS0_OPR | UDCCS0_IPR)) { ++ case UDCCS0_OPR | UDCCS0_IPR: ++ DPRINTK("UDC: write_preamble: see OPR. Stopping write to " ++ "handle new SETUP\n"); ++ ++ /* ++ * very rarely, you can get OPR and ++ * leftover IPR. Try to clear ++ */ ++ UDC_clear(Ser0UDCCS0, UDCCS0_IPR); ++ ++ /* ++ * Clear any pending write. ++ */ ++ ep0_clear_write(usb); ++ ++ /*FALLTHROUGH*/ ++ case UDCCS0_OPR: ++ /* ++ * A new setup request is pending. Handle ++ * it. Note that we don't try to read a ++ * packet if SE was set and OPR is clear. ++ */ ++ udc_ep0_read_packet(usb, cs_reg_in); ++ break; ++ ++ case 0: ++ if (usb->wrint) { ++ if (usb->wrlen != 0) { ++ /* ++ * More data to go ++ */ ++ udc_ep0_write_fifo(usb); ++ set_ipr(); ++ } ++ ++ if (usb->wrlen == 0) { ++ /* ++ * All data sent. ++ */ ++ usb->wrint(usb); ++ ++ ep0_clear_write(usb); ++ } ++ } ++ break; ++ ++ case UDCCS0_IPR: ++ DPRINTK("UDC: IPR set, not writing\n"); ++ usb->ep0_early_irqs++; ++ break; ++ } ++ ++ pcs("<--"); ++} ++ ++static irqreturn_t udc_interrupt(int irq, void *dev_id, struct pt_regs *regs) ++{ ++ struct sausb_dev *usb = dev_id; ++ u32 status = Ser0UDCSR; ++ ++ /* ++ * ReSeT Interrupt Request - UDC has been reset ++ */ ++ if (status & UDCSR_RSTIR) { ++ udc_reset(usb); ++ ++ /* ++ * clear all pending sources ++ */ ++ UDC_flip(Ser0UDCSR, status); ++ return IRQ_HANDLED; ++ } ++ ++ /* ++ * else we have done something other than reset, ++ * so be sure reset enabled ++ */ ++ usb->udccr &= ~UDCCR_REM; ++ UDC_write(Ser0UDCCR, usb->udccr); ++ ++ /* ++ * RESume Interrupt Request ++ */ ++ if (status & UDCSR_RESIR) { ++ usbctl_resume(usb->ctl); ++ core_kicker(usb); ++ enable_suspend_mask_resume(usb); ++ } ++ ++ /* ++ * SUSpend Interrupt Request ++ */ ++ if (status & UDCSR_SUSIR) { ++ usbctl_suspend(usb->ctl); ++ enable_resume_mask_suspend(usb); ++ } ++ ++ /* ++ * clear all pending sources ++ */ ++ UDC_flip(Ser0UDCSR, status); ++ ++ if (status & UDCSR_EIR) ++ udc_ep0_int_hndlr(usb); ++ ++ if (status & UDCSR_RIR) ++ udc_ep1_int_hndlr(usb); ++ ++ if (status & UDCSR_TIR) ++ udc_ep2_int_hndlr(usb); ++ ++ return IRQ_HANDLED; ++} ++ ++#ifdef CONFIG_PROC_FS ++ ++#define SAY( fmt, args... ) p += sprintf(p, fmt, ## args ) ++#define SAYV( num ) p += sprintf(p, num_fmt, "Value", num ) ++#define SAYC( label, yn ) p += sprintf(p, yn_fmt, label, yn ) ++#define SAYS( label, v ) p += sprintf(p, cnt_fmt, label, v ) ++ ++static int ++udc_read_proc(char *page, char **start, off_t off, int cnt, int *eof, ++ void *data) ++{ ++ struct sausb_dev *usb = data; ++ char *p = page; ++ u32 v; ++ int len, i; ++ ++ p += usbctl_proc_info(usb->ctl, p); ++ p += sprintf(p, "\nUDC:\n"); ++ v = Ser0UDCAR; ++ p += sprintf(p, "Address\t: %d (0x%02x)\n", v, v); ++ v = Ser0UDCIMP; ++ p += sprintf(p, "IN max\t: %d (0x%02x)\n", v + 1, v); ++ v = Ser0UDCOMP; ++ p += sprintf(p, "OUT max\t: %d (0x%02x)\n", v + 1, v); ++ v = Ser0UDCCR; ++ p += sprintf(p, "UDCCR\t: 0x%02x " ++ "[ %cSUSIM %cTIM %cRIM %cEIM %cRESIM %cUDA %cUDD ] " ++ "(0x%02x)\n", ++ v, ++ v & UDCCR_SUSIM ? '+' : '-', v & UDCCR_TIM ? '+' : '-', ++ v & UDCCR_RIM ? '+' : '-', v & UDCCR_EIM ? '+' : '-', ++ v & UDCCR_RESIM ? '+' : '-', v & UDCCR_UDA ? '+' : '-', ++ v & UDCCR_UDD ? '+' : '-', usb->udccr); ++ v = Ser0UDCCS0; ++ p += sprintf(p, "UDCCS0\t: 0x%02x " ++ "[ %cSO %cSE %cDE %cFST %cSST %cIPR %cOPR ]\n", ++ v, ++ v & UDCCS0_SO ? '+' : '-', v & UDCCS0_SE ? '+' : '-', ++ v & UDCCS0_DE ? '+' : '-', v & UDCCS0_FST ? '+' : '-', ++ v & UDCCS0_SST ? '+' : '-', v & UDCCS0_IPR ? '+' : '-', ++ v & UDCCS0_OPR ? '+' : '-'); ++ v = Ser0UDCCS1; ++ p += sprintf(p, "UDCCS1\t: 0x%02x " ++ "[ %cRNE %cFST %cSST %cRPE %cRPC %cRFS ]\n", ++ v, ++ v & UDCCS1_RNE ? '+' : '-', v & UDCCS1_FST ? '+' : '-', ++ v & UDCCS1_SST ? '+' : '-', v & UDCCS1_RPE ? '+' : '-', ++ v & UDCCS1_RPC ? '+' : '-', v & UDCCS1_RFS ? '+' : '-'); ++ v = Ser0UDCCS2; ++ p += sprintf(p, "UDCCS2\t: 0x%02x " ++ "[ %cFST %cSST %cTUR %cTPE %cTPC %cTFS ]\n", ++ v, ++ v & UDCCS2_FST ? '+' : '-', v & UDCCS2_SST ? '+' : '-', ++ v & UDCCS2_TUR ? '+' : '-', v & UDCCS2_TPE ? '+' : '-', ++ v & UDCCS2_TPC ? '+' : '-', v & UDCCS2_TFS ? '+' : '-'); ++ ++ p += sprintf(p, "\n"); ++ p += sprintf(p, " Bytes Packets FIFO errs Max Sz\n"); ++ p += sprintf(p, "EP0 Rd: %10ld %10ld %10ld -\n", ++ usb->ep0_rd_bytes, ++ usb->ep0_rd_packets, ++ usb->ep0_rd_fifo_errs); ++ p += sprintf(p, "EP0 Wr: %10ld %10ld %10ld -\n", ++ usb->ep0_wr_bytes, ++ usb->ep0_wr_packets, ++ usb->ep0_wr_fifo_errs); ++ ++ for (i = 0; i < 2; i++) ++ p += sprintf(p, "EP%d : %10ld %10ld %10ld %6d\n", ++ i + 1, ++ usb->ep[i].bytes, ++ usb->ep[i].packets, ++ usb->ep[i].fifo_errs, ++ usb->ep[i].maxpktsize); ++ ++ p += sprintf(p, "Stalls sent\t: %ld\n", usb->ep0_stall_sent); ++ p += sprintf(p, "Early ints\t: %ld\n", usb->ep0_early_irqs); ++ ++#if 0 ++ v = Ser0UDCSR; ++ SAY("\nUDC Interrupt Request Register\n"); ++ SAYV(v); ++ SAYC("Reset pending", (v & UDCSR_RSTIR) ? yes : no); ++ SAYC("Suspend pending", (v & UDCSR_SUSIR) ? yes : no); ++ SAYC("Resume pending", (v & UDCSR_RESIR) ? yes : no); ++ SAYC("ep0 pending", (v & UDCSR_EIR) ? yes : no); ++ SAYC("receiver pending", (v & UDCSR_RIR) ? yes : no); ++ SAYC("tramsitter pending", (v & UDCSR_TIR) ? yes : no); ++ ++#ifdef CONFIG_SA1100_EXTENEX1 ++ SAYC("\nSoft connect", ++ (PPSR & PPC_USB_SOFT_CON) ? "Visible" : "Hidden"); ++#endif ++#endif ++ ++ len = (p - page) - off; ++ if (len < 0) ++ len = 0; ++ *eof = (len <= cnt) ? 1 : 0; ++ *start = page + off; ++ ++ return len; ++} ++ ++#endif ++ ++extern struct usbctl usbctl; ++ ++static int __devinit udc_probe(struct device *dev) ++{ ++ struct sausb_dev *usb; ++ int retval; ++ ++ if (!request_mem_region(0x80000000, 0x10000, "sa11x0-udc")) ++ return -EBUSY; ++ ++ usb = kmalloc(sizeof(struct sausb_dev), GFP_KERNEL); ++ if (!usb) ++ return -ENOMEM; ++ ++ memset(usb, 0, sizeof(struct sausb_dev)); ++ dev_set_drvdata(dev, usb); ++ ++ usb_sa1100_drv.priv = usb; ++ ++ usb->dev = dev; ++ usb->ctl = &usbctl; ++ ++ spin_lock_init(&usb->lock); ++ ++ udc_disable(usb); ++ ++ usbctl_init(usb->ctl, &usb_sa1100_drv); ++ ++#ifdef CONFIG_PROC_FS ++ create_proc_read_entry("sausb", 0, NULL, udc_read_proc, usb); ++#endif ++ ++ /* setup rx dma */ ++ retval = sa1100_request_dma(DMA_Ser0UDCRd, "USB receive", ++ NULL, NULL, &usb->ep[0].dmach); ++ if (retval) { ++ printk("UDC: unable to register for rx dma rc=%d\n", ++ retval); ++ goto err; ++ } ++ ++ /* setup tx dma */ ++ retval = sa1100_request_dma(DMA_Ser0UDCWr, "USB transmit", ++ NULL, NULL, &usb->ep[1].dmach); ++ if (retval) { ++ printk("UDC: unable to register for tx dma rc=%d\n", ++ retval); ++ goto err; ++ } ++ ++ /* now allocate the IRQ. */ ++ retval = request_irq(IRQ_Ser0UDC, udc_interrupt, SA_INTERRUPT, ++ "SA USB core", usb); ++ if (retval) { ++ printk("UDC: couldn't request USB irq rc=%d\n", retval); ++ goto err; ++ } ++ ++ return retval; ++ ++ err: ++ if (usb->ep[2].dmach) { ++ sa1100_free_dma(usb->ep[2].dmach); ++ usb->ep[2].dmach = NULL; ++ } ++ if (usb->ep[1].dmach) { ++ sa1100_free_dma(usb->ep[1].dmach); ++ usb->ep[1].dmach = NULL; ++ } ++#ifdef CONFIG_PROC_FS ++ remove_proc_entry("sausb", NULL); ++#endif ++ release_mem_region(0x80000000, 0x10000); ++ return retval; ++} ++ ++/* ++ * Release DMA and interrupt resources ++ */ ++static int __devexit udc_remove(struct device *dev) ++{ ++ struct sausb_dev *usb = dev_get_drvdata(dev); ++ ++ dev_set_drvdata(dev, NULL); ++ ++#ifdef CONFIG_PROC_FS ++ remove_proc_entry("sausb", NULL); ++#endif ++ ++ udc_disable(usb); ++ ++ free_irq(IRQ_Ser0UDC, usb); ++ sa1100_free_dma(usb->ep[1].dmach); ++ sa1100_free_dma(usb->ep[0].dmach); ++ ++ usbctl_exit(usb->ctl); ++ ++ release_mem_region(0x80000000, 0x10000); ++ ++ return 0; ++} ++ ++static struct device_driver sa11x0usb_driver = { ++ .name = "sa11x0-udc", ++ .bus = &platform_bus_type, ++ .probe = udc_probe, ++ .remove = __devexit_p(udc_remove), ++}; ++ ++static int __init udc_init(void) ++{ ++ return driver_register(&sa11x0usb_driver); ++} ++ ++static void __exit udc_exit(void) ++{ ++ driver_unregister(&sa11x0usb_driver); ++} ++ ++module_init(udc_init); ++module_exit(udc_exit); ++ ++MODULE_LICENSE("GPL"); ++MODULE_DESCRIPTION("SA1100 USB Gadget driver"); +--- /dev/null 2003-09-23 18:19:32.000000000 -0400 ++++ linux-2.6.5/arch/arm/mach-sa1100/usb/control.c 2004-04-30 20:57:36.000000000 -0400 +@@ -0,0 +1,933 @@ ++/* ++ * usb/control.c ++ * ++ * This parses and handles all the control messages to/from endpoint 0. ++ */ ++#include <linux/module.h> ++#include <linux/kernel.h> ++#include <linux/errno.h> ++#include <linux/usb_ch9.h> ++#include <linux/gfp.h> ++#include <linux/init.h> ++ ++#include "buffer.h" ++#include "client.h" ++#include "usbdev.h" ++ ++#include "sa1100_usb.h" ++ ++#define USB_ENDPOINT_HALT 0 ++#define USB_DEVICE_REMOTE_WAKEUP 1 ++ ++#undef DEBUG ++ ++#ifdef DEBUG ++#define DPRINTK(fmt, args...) printk(KERN_DEBUG fmt , ## args) ++#else ++#define DPRINTK(fmt, args...) ++#endif ++ ++/* ++ * print string descriptor ++ */ ++static char * __attribute__((unused)) ++psdesc(char *str, int len, struct usb_string_descriptor *desc) ++{ ++ char *start = str; ++ int nchars = (desc->bLength - 2) / sizeof(__u16) + 2; ++ int i; ++ ++ if (nchars >= len) ++ nchars = len - 1; ++ ++ nchars -= 2; ++ ++ *str++ = '"'; ++ for(i = 0; i < nchars; i++) ++ *str++ = le16_to_cpu(desc->wData[i]); ++ *str++ = '"'; ++ *str = '\0'; ++ ++ return start; ++} ++ ++enum { ++ kError = -1, ++ kEvSuspend = 0, ++ kEvReset = 1, ++ kEvResume = 2, ++ kEvAddress = 3, ++ kEvConfig = 4, ++ kEvDeConfig = 5 ++}; ++ ++enum { ++ kStateZombie = 0, ++ kStateZombieSuspend = 1, ++ kStateDefault = 2, ++ kStateDefaultSuspend = 3, ++ kStateAddr = 4, ++ kStateAddrSuspend = 5, ++ kStateConfig = 6, ++ kStateConfigSuspend = 7 ++}; ++ ++#define kE kError ++#define kSZ kStateZombie ++#define kSZS kStateZombieSuspend ++#define kSD kStateDefault ++#define kSDS kStateDefaultSuspend ++#define kSA kStateAddr ++#define kSAS kStateAddrSuspend ++#define kSC kStateConfig ++#define kSCS kStateConfigSuspend ++ ++/* ++ * Fig 9-1 P192 ++ * Zombie == Attached | Powered ++ */ ++static int device_state_machine[8][6] = { ++// suspend reset resume addr config deconfig ++{ kSZS, kSD, kE, kE, kE, kE }, /* zombie */ ++{ kE, kSD, kSZ, kE, kE, kE }, /* zom sus */ ++{ kSDS, kError, kSD, kSA, kE, kE }, /* default */ ++{ kE, kSD, kSD, kE, kE, kE }, /* def sus */ ++{ kSAS, kSD, kE, kE, kSC, kE }, /* addr */ ++{ kE, kSD, kSA, kE, kE, kE }, /* addr sus */ ++{ kSCS, kSD, kE, kE, kE, kSA }, /* config */ ++{ kE, kSD, kSC, kE, kE, kE } /* cfg sus */ ++}; ++ ++/* ++ * "device state" is the usb device framework state, as opposed to the ++ * "state machine state" which is whatever the driver needs and is much ++ * more fine grained ++ */ ++static int sm_state_to_device_state[8] = { ++ USB_STATE_POWERED, /* zombie */ ++ USB_STATE_SUSPENDED, /* zombie suspended */ ++ USB_STATE_DEFAULT, /* default */ ++ USB_STATE_SUSPENDED, /* default suspended */ ++ USB_STATE_ADDRESS, /* address */ ++ USB_STATE_SUSPENDED, /* address suspended */ ++ USB_STATE_CONFIGURED, /* config */ ++ USB_STATE_SUSPENDED /* config suspended */ ++}; ++ ++static char * state_names[8] = { ++ "zombie", ++ "zombie suspended", ++ "default", ++ "default suspended", ++ "address", ++ "address suspended", ++ "configured", ++ "config suspended" ++}; ++ ++static char * event_names[6] = { ++ "suspend", ++ "reset", ++ "resume", ++ "address assigned", ++ "configure", ++ "de-configure" ++}; ++ ++static char * device_state_names[] = { ++ "not attached", ++ "attached", ++ "powered", ++ "default", ++ "address", ++ "configured", ++ "suspended" ++}; ++ ++static void usbctl_callbacks(struct usbctl *ctl, int state, int oldstate) ++{ ++ struct usb_client *clnt = ctl->clnt; ++ ++ /* ++ * Inform any clients currently attached ++ * that the connectivity state changed. ++ */ ++ if (clnt && clnt->state_change) ++ clnt->state_change(clnt->priv, state, oldstate); ++} ++ ++/* ++ * called by the interrupt handler here and the two endpoint ++ * files when interesting .."events" happen ++ */ ++static int usbctl_next_state_on_event(struct usbctl *ctl, int event) ++{ ++ int next_state, next_dev_state, old_dev_state; ++ ++ printk(KERN_DEBUG "usbctl: %s --[%s]--> ", state_names[ctl->sm_state], ++ event_names[event]); ++ ++ next_state = device_state_machine[ctl->sm_state][event]; ++ if (next_state != kError) { ++ next_dev_state = sm_state_to_device_state[next_state]; ++ ++ printk("%s. Device in %s state.\n", ++ state_names[next_state], ++ device_state_names[next_dev_state]); ++ ++ old_dev_state = ctl->state; ++ ctl->sm_state = next_state; ++ ctl->state = next_dev_state; ++ ++ if (old_dev_state != next_dev_state) ++ usbctl_callbacks(ctl, next_dev_state, old_dev_state); ++ } else ++ printk("(error)\n"); ++ ++ return next_state; ++} ++ ++/* ++ * Driver detected USB HUB reset. ++ */ ++int usbctl_reset(struct usbctl *ctl) ++{ ++ int ret; ++ ++ ret = usbctl_next_state_on_event(ctl, kEvReset) == kError; ++ ++ if (!ret) { ++ ctl->address = 0; ++ } ++ return ret; ++} ++ ++EXPORT_SYMBOL(usbctl_reset); ++ ++void usbctl_suspend(struct usbctl *ctl) ++{ ++ usbctl_next_state_on_event(ctl, kEvSuspend); ++} ++ ++EXPORT_SYMBOL(usbctl_suspend); ++ ++void usbctl_resume(struct usbctl *ctl) ++{ ++ usbctl_next_state_on_event(ctl, kEvResume); ++} ++ ++EXPORT_SYMBOL(usbctl_resume); ++ ++static struct usb_interface_descriptor * ++usbctl_get_interface_descriptor(struct usbctl *ctl, unsigned int interface) ++{ ++ /*FIXME*/ ++ struct cdb *cdb = sa1100_usb_get_descriptor_ptr(); ++ ++ return (struct usb_interface_descriptor *)&cdb->intf; ++} ++ ++static inline int ++__usbctl_queue(struct usbctl *ctl, struct usb_ctrlrequest *req, ++ struct usb_buf *buf) ++{ ++ unsigned int reqlen = le16_to_cpu(req->wLength); ++ ++ return ctl->driver->ep0_queue(ctl->driver->priv, buf, reqlen) ? ++ RET_ERROR : RET_QUEUED; ++} ++ ++static int ++usbctl_queue(struct usbctl *ctl, struct usb_ctrlrequest *req, ++ void *data, unsigned int len) ++{ ++ struct usb_buf *buf; ++ ++ buf = usbb_alloc(len, GFP_ATOMIC); ++ if (!buf) { ++ printk(KERN_ERR "usb: out of memory\n"); ++ return RET_ERROR; ++ } ++ ++ if (data) ++ memcpy(usbb_push(buf, len), data, len); ++ ++ return __usbctl_queue(ctl, req, buf); ++} ++ ++/* ++ * 9.4.5: Get Status (device) ++ */ ++static int ++usbctl_parse_dev_get_status(struct usbctl *ctl, struct usb_ctrlrequest *req) ++{ ++ u16 status; ++ ++ status = /* self_powered_hook() ? 1 : 0 */1; ++ ++ status = cpu_to_le16(status); ++ ++ return usbctl_queue(ctl, req, &status, 2); ++} ++ ++/* ++ * Send USB device description to the host. ++ */ ++static int ++usbctl_desc_device(struct usbctl *ctl, struct usb_ctrlrequest *req) ++{ ++ return __usbctl_queue(ctl, req, usbb_get(ctl->dev_desc_buf)); ++} ++ ++/* ++ * Send USB configuration information to the host. ++ */ ++static int ++usbctl_desc_config(struct usbctl *ctl, struct usb_ctrlrequest *req) ++{ ++ /*FIXME*/ ++ struct cdb *cdb = sa1100_usb_get_descriptor_ptr(); ++ ++ return usbctl_queue(ctl, req, cdb, sizeof(struct cdb)); ++} ++ ++/* ++ * Send a string to the host from the string table. ++ */ ++static int ++usbctl_desc_string(struct usbctl *ctl, struct usb_ctrlrequest *req, ++ unsigned int idx) ++{ ++ struct usb_buf *buf; ++ unsigned int lang = le16_to_cpu(req->wIndex); ++ char string[32] __attribute__((unused)); ++ int ret; ++ ++ DPRINTK("usbctl: desc_string (index %u, lang 0x%04x): ", idx, lang); ++ ++ buf = usbc_string_find(&ctl->strings, lang, idx); ++ if (buf) { ++ DPRINTK("%s\n", idx == 0 ? "language" : ++ psdesc(string, sizeof(string), usbc_string_desc(buf))); ++ ++ ret = __usbctl_queue(ctl, req, buf); ++ } else { ++ DPRINTK("not found -> stall\n"); ++ ret = RET_REQERROR; ++ } ++ return ret; ++} ++ ++/* ++ * Send an interface description (and endpoints) to the host. ++ */ ++static int ++usbctl_desc_interface(struct usbctl *ctl, struct usb_ctrlrequest *req, ++ unsigned int idx) ++{ ++ struct usb_interface_descriptor *desc; ++ int ret; ++ ++ DPRINTK("usbctl: desc_interface (index %d)\n", idx); ++ ++ desc = usbctl_get_interface_descriptor(ctl, idx); ++ ++ if (desc) { ++ ret = usbctl_queue(ctl, req, desc, desc->bLength); ++ } else { ++ printk("usbctl: unknown interface %d\n", idx); ++ ret = RET_REQERROR; ++ } ++ ++ return ret; ++} ++ ++/* ++ * Send an endpoint (1 .. n) to the host. ++ */ ++static int ++usbctl_desc_endpoint(struct usbctl *ctl, struct usb_ctrlrequest *req, ++ unsigned int idx) ++{ ++ int ret; ++ ++ DPRINTK("usbctl: desc_endpoint (index %d)\n", idx); ++ ++ if (idx >= 1 && idx <= ctl->nr_ep) { ++ struct usb_endpoint_descriptor *ep = ctl->ep_desc[idx - 1]; ++ ++ ret = usbctl_queue(ctl, req, ep, ep->bLength); ++ } else { ++ printk("usbctl: unknown endpoint %d\n", idx); ++ ret = RET_REQERROR; ++ } ++ ++ return ret; ++} ++ ++/* ++ * 9.4.3: Parse a request for a descriptor. ++ * Unspecified conditions: ++ * None ++ * Valid states: default, address, configured. ++ */ ++static int ++usbctl_parse_dev_descriptor(struct usbctl *ctl, struct usb_ctrlrequest *req) ++{ ++ unsigned int idx = le16_to_cpu(req->wValue) & 255; ++ unsigned int type = le16_to_cpu(req->wValue) >> 8; ++ int ret; ++ ++ switch (type) { ++ case USB_DT_DEVICE: /* check if idx matters */ ++ ret = usbctl_desc_device(ctl, req); ++ break; ++ ++ case USB_DT_CONFIG: /* check if idx matters */ ++ ret = usbctl_desc_config(ctl, req); ++ break; ++ ++ case USB_DT_STRING: ++ ret = usbctl_desc_string(ctl, req, idx); ++ break; ++ ++ case USB_DT_INTERFACE: ++ ret = usbctl_desc_interface(ctl, req, idx); ++ break; ++ ++ case USB_DT_ENDPOINT: ++ ret = usbctl_desc_endpoint(ctl, req, idx); ++ break; ++ ++ case USB_DT_DEVICE_QUALIFIER: ++ case USB_DT_OTHER_SPEED_CONFIG: ++ case USB_DT_INTERFACE_POWER: ++ default: ++ printk(KERN_ERR "usbctl: unknown descriptor: " ++ "wValue = 0x%04x wIndex = 0x%04x\n", ++ le16_to_cpu(req->wValue), le16_to_cpu(req->wIndex)); ++ ret = RET_REQERROR; ++ break; ++ } ++ ++ return ret; ++} ++ ++/* ++ * 9.4.6: Set Address ++ * The USB1.1 spec says the response to SetAddress() with value 0 ++ * is undefined. It then goes on to define the response. We ++ * acknowledge addresses of zero, but take no further action. ++ */ ++static int ++usbctl_parse_dev_set_address(struct usbctl *ctl, struct usb_ctrlrequest *req) ++{ ++ unsigned int address = le16_to_cpu(req->wValue) & 0x7f; ++ ++ if (ctl->state == USB_STATE_CONFIGURED) ++ return RET_REQERROR; ++ ++ if (address != 0) { ++ ctl->address = address; ++ ++ usbctl_next_state_on_event(ctl, kEvAddress); ++ ++ ctl->driver->set_address(ctl->driver->priv, address); ++ } ++ ++ return RET_ACK; ++} ++ ++/* ++ * 9.4.2: Get Configuration. ++ * Unspecified conditions: ++ * - non-zero wIndex, wValue or wLength (ignored) ++ * - default state (request error) ++ * Valid states: address, configured. ++ */ ++static int ++usbctl_parse_dev_get_config(struct usbctl *ctl, struct usb_ctrlrequest *req) ++{ ++ u8 status = 0; ++ ++ if (ctl->state == USB_STATE_CONFIGURED) ++ status = 1; ++ ++ return usbctl_queue(ctl, req, &status, 1); ++} ++ ++/* ++ * 9.4.7: Set Configuration. ++ * Unspecified conditions: ++ * - default state (request error) ++ */ ++static int ++usbctl_parse_dev_set_config(struct usbctl *ctl, struct usb_ctrlrequest *req) ++{ ++ unsigned int cfg = le16_to_cpu(req->wValue); ++ int ret = RET_REQERROR; ++ ++ if (ctl->state == USB_STATE_DEFAULT) ++ return ret; ++ ++ if (cfg == 0) { ++ /* enter address state, or remain in address state */ ++ usbctl_next_state_on_event(ctl, kEvDeConfig); ++ ++ ctl->driver->set_config(ctl->driver->priv, NULL); ++ ++ ret = RET_ACK; ++ } else if (cfg == 1) { ++ /* enter configured state, and set configuration */ ++ /*FIXME*/ ++ struct cdb *cdb = sa1100_usb_get_descriptor_ptr(); ++ ++ usbctl_next_state_on_event(ctl, kEvConfig); ++ ++ ctl->driver->set_config(ctl->driver->priv, cdb); ++ ret = RET_ACK; ++ } ++ ++ return ret; ++} ++ ++/* ++ * Interface handling ++ */ ++ ++/* ++ * 9.4.5: Get Status (interface) ++ */ ++static int ++usbctl_parse_int_get_status(struct usbctl *ctl, struct usb_ctrlrequest *req) ++{ ++ unsigned int interface = le16_to_cpu(req->wIndex) & 255; ++ u16 status; ++ ++ switch (ctl->state) { ++ case USB_STATE_DEFAULT: ++ return RET_REQERROR; ++ ++ case USB_STATE_ADDRESS: ++ if (interface != 0) ++ return RET_REQERROR; ++ break; ++ ++ case USB_STATE_CONFIGURED: ++ if (interface != 1) ++ return RET_REQERROR; ++ break; ++ } ++ ++ status = cpu_to_le16(0); ++ ++ return usbctl_queue(ctl, req, &status, 2); ++} ++ ++/* ++ * 9.4.4: Get Interface ++ * Unspecified conditions: ++ * - ++ * States: Default (unspecified), Address (Request Error), Configured (ok) ++ */ ++static int ++usbctl_parse_int_get_interface(struct usbctl *ctl, struct usb_ctrlrequest *req) ++{ ++ unsigned int interface = le16_to_cpu(req->wIndex) & 255; ++ u8 null = 0; ++ ++ if (ctl->state != USB_STATE_CONFIGURED) ++ return RET_REQERROR; ++ ++ /* ++ * If the interface doesn't exist, respond with request error ++ */ ++ if (interface != 1) ++ return RET_REQERROR; ++ ++ printk("usbctl: get interface %d not supported\n", interface); ++ ++ return usbctl_queue(ctl, req, &null, 1); ++} ++ ++static int ++usbctl_parse_int_set_interface(struct usbctl *ctl, struct usb_ctrlrequest *req) ++{ ++ unsigned int interface = le16_to_cpu(req->wIndex) & 255; ++ ++ if (interface != 0) ++ printk("usbctl: set interface %d not supported (ignored)\n", ++ interface); ++ ++ return RET_ACK; ++} ++ ++/* ++ * Endpoint handling ++ */ ++ ++/* ++ * 9.4.5: Get Status (endpoint) ++ */ ++static int ++usbctl_parse_ep_get_status(struct usbctl *ctl, struct usb_ctrlrequest *req) ++{ ++ unsigned int ep = le16_to_cpu(req->wIndex) & 15; ++ u16 status; ++ ++ if ((ep != 0 && ctl->state != USB_STATE_CONFIGURED) || ++ ep <= ctl->nr_ep) ++ return RET_REQERROR; ++ ++ status = ctl->driver->ep_get_status(ctl->driver->priv, ep); ++ status = cpu_to_le16(status); ++ ++ return usbctl_queue(ctl, req, &status, 2); ++} ++ ++/* ++ * 9.4.1: Clear an endpoint feature. We only support ENDPOINT_HALT. ++ * Unspecified conditions: ++ * - non-zero wLength is not specified (ignored) ++ * Valid states: Address, Configured. ++ */ ++static int ++usbctl_parse_ep_clear_feature(struct usbctl *ctl, struct usb_ctrlrequest *req) ++{ ++ unsigned int feature = le16_to_cpu(req->wValue); ++ unsigned int ep = le16_to_cpu(req->wIndex) & 15; ++ int ret; ++ ++ if ((ep != 0 && ctl->state != USB_STATE_CONFIGURED) || ++ ep <= ctl->nr_ep) ++ return RET_REQERROR; ++ ++ if (feature == USB_ENDPOINT_HALT) { ++ ctl->driver->ep_halt(ctl->driver->priv, ep, 0); ++ ret = RET_ACK; ++ } else { ++ printk(KERN_ERR "usbctl: unsupported clear feature: " ++ "wValue = 0x%04x wIndex = 0x%04x\n", ++ feature, ep); ++ ++ ret = RET_REQERROR; ++ } ++ return ret; ++} ++ ++/* ++ * 9.4.9: Set Feature (endpoint) ++ */ ++static int ++usbctl_parse_ep_set_feature(struct usbctl *ctl, struct usb_ctrlrequest *req) ++{ ++ unsigned int feature = le16_to_cpu(req->wValue); ++ unsigned int ep = le16_to_cpu(req->wIndex) & 15; ++ int ret; ++ ++ if ((ep != 0 && ctl->state != USB_STATE_CONFIGURED) || ++ ep <= ctl->nr_ep) ++ return RET_REQERROR; ++ ++ if (feature == USB_ENDPOINT_HALT) { ++ ctl->driver->ep_halt(ctl->driver->priv, ep, 1); ++ ret = RET_ACK; ++ } else { ++ printk(KERN_ERR "usbctl: unsupported set feature " ++ "wValue = 0x%04x wIndex = 0x%04x\n", ++ feature, ep); ++ ++ ret = RET_REQERROR; ++ } ++ return ret; ++} ++ ++/* ++ * This reflects Table 9.3 (p186) in the USB1.1 spec. ++ * ++ * Some notes: ++ * - USB1.1 specifies remote wakeup feature, so we don't implement ++ * USB_RECIP_DEVICE USB_REQ_{SET,CLEAR}_FEATURE ++ * - USB1.1 doesn't actually specify any interface features, so we ++ * don't implement USB_RECIP_INTERFACE USB_REQ_{SET,CLEAR}_FEATURE ++ */ ++static int (*request_fns[4][16])(struct usbctl *, struct usb_ctrlrequest *) = { ++ [USB_RECIP_DEVICE] = { ++ [USB_REQ_GET_STATUS] = usbctl_parse_dev_get_status, ++ [USB_REQ_CLEAR_FEATURE] = NULL, ++ [USB_REQ_SET_FEATURE] = NULL, ++ [USB_REQ_SET_ADDRESS] = usbctl_parse_dev_set_address, ++ [USB_REQ_GET_DESCRIPTOR] = usbctl_parse_dev_descriptor, ++ [USB_REQ_SET_DESCRIPTOR] = NULL, ++ [USB_REQ_GET_CONFIGURATION] = usbctl_parse_dev_get_config, ++ [USB_REQ_SET_CONFIGURATION] = usbctl_parse_dev_set_config, ++ }, ++ ++ [USB_RECIP_INTERFACE] = { ++ [USB_REQ_GET_STATUS] = usbctl_parse_int_get_status, ++ [USB_REQ_CLEAR_FEATURE] = NULL, ++ [USB_REQ_SET_FEATURE] = NULL, ++ [USB_REQ_GET_INTERFACE] = usbctl_parse_int_get_interface, ++ [USB_REQ_SET_INTERFACE] = usbctl_parse_int_set_interface, ++ }, ++ ++ [USB_RECIP_ENDPOINT] = { ++ [USB_REQ_GET_STATUS] = usbctl_parse_ep_get_status, ++ [USB_REQ_CLEAR_FEATURE] = usbctl_parse_ep_clear_feature, ++ [USB_REQ_SET_FEATURE] = usbctl_parse_ep_set_feature, ++ }, ++}; ++ ++static void __attribute__((unused)) ++usbctl_dump_request(const char *prefix, const struct usb_ctrlrequest *req) ++{ ++ printk("%sbRequestType=0x%02x bRequest=0x%02x " ++ "wValue=0x%04x wIndex=0x%04x wLength=0x%04x\n", ++ prefix, req->bRequestType, req->bRequest, ++ le16_to_cpu(req->wValue), le16_to_cpu(req->wIndex), ++ le16_to_cpu(req->wLength)); ++} ++ ++int usbctl_parse_request(struct usbctl *ctl, struct usb_ctrlrequest *req) ++{ ++ unsigned int type; ++ int (*fn)(struct usbctl *, struct usb_ctrlrequest *) = NULL; ++ int ret = RET_REQERROR; ++ ++ //usbctl_dump_request("usbctl: ", req); ++ ++ type = req->bRequestType & USB_TYPE_MASK; ++ if (type == USB_TYPE_STANDARD) { ++ unsigned int recip; ++ ++ recip = req->bRequestType & USB_RECIP_MASK; ++ if (recip < ARRAY_SIZE(request_fns) && ++ req->bRequest < ARRAY_SIZE(request_fns[0])) ++ fn = request_fns[recip][req->bRequest]; ++ } ++ ++ if (fn) ++ ret = fn(ctl, req); ++ else ++ usbctl_dump_request(KERN_ERR "usbctl: unknown request: ", ++ req); ++ ++ /* ++ * Make sure we're doing the right thing. ++ */ ++ if (req->bRequestType & USB_DIR_IN) { ++ if (ret != RET_QUEUED && ret != RET_REQERROR) ++ printk("Error: device to host transfer expected\n"); ++ } else { ++ if (ret == RET_QUEUED) ++ printk("Error: no device to host transfer expected\n"); ++ } ++ ++ return ret; ++} ++ ++EXPORT_SYMBOL(usbctl_parse_request); ++ ++/* Start running. Must have called usb_open (above) first */ ++int usbctl_start(struct usb_client *client) ++{ ++ struct usbctl *ctl = client->ctl; ++ ++ if (ctl == NULL || ctl->clnt != client) { ++ printk("usbctl: start: no client registered\n"); ++ return -EPERM; ++ } ++ ++ ctl->sm_state = kStateZombie; ++ ctl->state = USB_STATE_POWERED; ++ ++ /* ++ * Notify the client as to our state. ++ */ ++ usbctl_callbacks(ctl, USB_STATE_POWERED, USB_STATE_SUSPENDED); ++ ++ return ctl->driver->start(ctl->driver->priv); ++} ++ ++EXPORT_SYMBOL(usbctl_start); ++ ++/* ++ * Stop USB core from running ++ */ ++void usbctl_stop(struct usb_client *client) ++{ ++ struct usbctl *ctl = client->ctl; ++ ++ if (ctl == NULL || ctl->clnt != client) { ++ printk("USBDEV: stop: no client/driver registered\n"); ++ return; ++ } ++ ++ ctl->driver->stop(ctl->driver->priv); ++} ++ ++EXPORT_SYMBOL(usbctl_stop); ++ ++struct usbctl usbctl; ++ ++EXPORT_SYMBOL(usbctl); ++ ++/* Open SA usb core on behalf of a client, but don't start running */ ++ ++int usbctl_open(struct usb_client *client) ++{ ++ struct usbctl *ctl = &usbctl; ++ int ret; ++printk("usbctl_open: ctl %p driver %p\n", ctl, ctl->driver); ++ if (!ctl->driver || !try_module_get(ctl->driver->owner)) ++ return -ENODEV; ++ ++ if (ctl->clnt != NULL) { ++ ret = -EBUSY; ++ goto err; ++ } ++ ++ ctl->clnt = client; ++ ctl->state = USB_STATE_SUSPENDED; ++ ctl->nr_ep = 2; ++ /* start in zombie suspended state */ ++ ctl->sm_state = kStateZombieSuspend; ++ ctl->state = USB_STATE_SUSPENDED; ++ client->ctl = ctl; ++ ++ ctl->dev_desc_buf = usbb_alloc(sizeof(struct usb_device_descriptor), ++ GFP_KERNEL); ++ if (!ctl->dev_desc_buf) { ++ ret = -ENOMEM; ++ goto err; ++ } ++ ++ ctl->dev_desc = usbb_push(ctl->dev_desc_buf, ++ sizeof(struct usb_device_descriptor)); ++ ++ /* create descriptors for enumeration */ ++ initialize_descriptors(ctl); ++ ++ return 0; ++ ++ err: ++ module_put(ctl->driver->owner); ++ return ret; ++} ++ ++EXPORT_SYMBOL(usbctl_open); ++ ++/* Tell SA core client is through using it */ ++void usbctl_close(struct usb_client *client) ++{ ++ struct usbctl *ctl = client->ctl; ++ ++ if (ctl == NULL || ctl->clnt != client) { ++ printk("usbctl: close: no client registered\n"); ++ return; ++ } ++ ++ usbb_put(ctl->dev_desc_buf); ++ ++ client->ctl = NULL; ++ ctl->clnt = NULL; ++ ctl->dev_desc = NULL; ++ ctl->dev_desc_buf = NULL; ++ /* reset to zombie suspended state */ ++ ctl->sm_state = kStateZombieSuspend; ++ ctl->state = USB_STATE_SUSPENDED; ++ ++ usbc_string_free_all(&ctl->strings); ++ ++ if (ctl->driver->owner) ++ module_put(ctl->driver->owner); ++} ++ ++EXPORT_SYMBOL(usbctl_close); ++ ++int usbctl_proc_info(struct usbctl *ctl, char *buf) ++{ ++ char *p = buf; ++ ++ p += sprintf(p, "USB Gadget Core:\n"); ++ p += sprintf(p, "Driver\t: %s\n", ++ ctl->driver ? ctl->driver->name : "none"); ++ p += sprintf(p, "Client\t: %s\n", ++ ctl->clnt ? ctl->clnt->name : "none"); ++ p += sprintf(p, "State\t: %s (%s) %d\n", ++ device_state_names[sm_state_to_device_state[ctl->sm_state]], ++ state_names[ctl->sm_state], ++ ctl->sm_state); ++ p += sprintf(p, "Address\t: %d\n", ctl->address); ++ ++ return p - buf; ++} ++ ++EXPORT_SYMBOL(usbctl_proc_info); ++ ++int ++usbctl_ep_queue_buffer(struct usbctl *ctl, unsigned int ep, ++ char *buf, unsigned int len) ++{ ++ return ctl->driver->ep_queue(ctl->driver->priv, ep, buf, len); ++} ++ ++EXPORT_SYMBOL(usbctl_ep_queue_buffer); ++ ++void usbctl_ep_reset(struct usbctl *ctl, unsigned int ep) ++{ ++ return ctl->driver->ep_reset(ctl->driver->priv, ep); ++} ++ ++EXPORT_SYMBOL(usbctl_ep_reset); ++ ++void ++usbctl_ep_set_callback(struct usbctl *ctl, unsigned int ep, ++ usb_callback_t callback, void *data) ++{ ++ ctl->driver->ep_callback(ctl->driver->priv, ep, callback, data); ++} ++ ++EXPORT_SYMBOL(usbctl_ep_set_callback); ++ ++int usbctl_ep_idle(struct usbctl *ctl, unsigned int ep) ++{ ++ return ctl->driver->ep_idle(ctl->driver->priv, ep); ++} ++ ++EXPORT_SYMBOL(usbctl_ep_idle); ++ ++/* ++ * usbctl_init() ++ * Module load time. Allocate dma and interrupt resources. Setup /proc fs ++ * entry. Leave UDC disabled. ++ */ ++int usbctl_init(struct usbctl *ctl, struct usbc_driver *drv) ++{ ++ usbc_string_init(&ctl->strings); ++printk("usbctl_init: %p %p\n", ctl, drv); ++ /* ++ * start in zombie suspended state ++ */ ++ ctl->sm_state = kStateZombieSuspend; ++ ctl->state = USB_STATE_SUSPENDED; ++ ctl->driver = drv; ++ ++ return 0; ++} ++ ++/* ++ * usbctl_exit() ++ */ ++void usbctl_exit(struct usbctl *ctl) ++{ ++ usbc_string_free_all(&ctl->strings); ++ ++ ctl->driver = NULL; ++} ++ ++EXPORT_SYMBOL(usbctl_init); ++EXPORT_SYMBOL(usbctl_exit); ++ ++MODULE_LICENSE("GPL"); ++MODULE_DESCRIPTION("USB gadget core"); +--- /dev/null 2003-09-23 18:19:32.000000000 -0400 ++++ linux-2.6.5/arch/arm/mach-sa1100/usb/client.h 2004-04-30 20:57:36.000000000 -0400 +@@ -0,0 +1,40 @@ ++#ifndef USBDEV_CLIENT_H ++#define USBDEV_CLIENT_H ++ ++#include "sa1100_usb.h" /* grr */ ++ ++struct usbctl; ++ ++struct usb_client { ++ struct usbctl *ctl; ++ const char *name; /* Client name */ ++ void *priv; /* Client-private data */ ++ void (*state_change)(void *priv, int state, int oldstate); ++ __u16 vendor; /* USB vendor ID */ ++ __u16 product; /* USB product ID */ ++ __u16 version; /* USB version ID */ ++ __u8 class; /* USB class */ ++ __u8 subclass; /* USB subclass */ ++ __u8 protocol; /* USB protocol */ ++ __u8 unused1; ++ __u16 unused2; ++ const char *manufacturer_str; ++ const char *product_str; ++ const char *serial_str; ++}; ++ ++int usbctl_start(struct usb_client *client); ++void usbctl_stop(struct usb_client *client); ++int usbctl_open(struct usb_client *client); ++void usbctl_close(struct usb_client *client); ++ ++int ++usbctl_ep_queue_buffer(struct usbctl *ctl, unsigned int ep, ++ char *buf, unsigned int len); ++void usbctl_ep_reset(struct usbctl *ctl, unsigned int ep); ++void ++usbctl_ep_set_callback(struct usbctl *ctl, unsigned int ep, ++ usb_callback_t callback, void *data); ++int usbctl_ep_idle(struct usbctl *ctl, unsigned int ep); ++ ++#endif +--- /dev/null 2003-09-23 18:19:32.000000000 -0400 ++++ linux-2.6.5/arch/arm/mach-sa1100/usb/sa1100_usb.h 2004-04-30 20:57:36.000000000 -0400 +@@ -0,0 +1,50 @@ ++/* ++ * sa1100_usb.h ++ * ++ * Public interface to the sa1100 USB core. For use by client modules ++ * like usb-eth and usb-char. ++ * ++ */ ++#ifndef _SA1100_USB_H ++#define _SA1100_USB_H ++ ++typedef void (*usb_callback_t)(void *data, int flag, int size); ++ ++/* in usb_send.c */ ++int sa1100_usb_xmitter_avail( void ); ++int sa1100_usb_send(char *buf, int len); ++void sa1100_usb_send_set_callback(usb_callback_t callback, void *data); ++void sa1100_usb_send_reset(void); ++ ++/* in usb_recev.c */ ++int sa1100_usb_recv(char *buf, int len); ++void sa1100_usb_recv_set_callback(usb_callback_t callback, void *data); ++void sa1100_usb_recv_reset(void); ++ ++////////////////////////////////////////////////////////////////////////////// ++// Descriptor Management ++////////////////////////////////////////////////////////////////////////////// ++ ++// MaxPower: ++#define USB_POWER(x) ((x)>>1) /* convert mA to descriptor units of A for MaxPower */ ++ ++/* "config descriptor buffer" - that is, one config, ++ ..one interface and 2 endpoints */ ++struct cdb { ++ struct usb_config_descriptor cfg; ++ struct usb_interface_descriptor intf; ++ struct usb_endpoint_descriptor ep1, ep2; ++} __attribute__ ((packed)); ++ ++ ++/*======================================================= ++ * Descriptor API ++ */ ++ ++/* Get the address of the statically allocated desc_t structure ++ in the usb core driver. Clients can modify this between ++ the time they call sa1100_usb_open() and sa1100_usb_start() ++*/ ++struct cdb *sa1100_usb_get_descriptor_ptr(void); ++ ++#endif /* _SA1100_USB_H */ +--- /dev/null 2003-09-23 18:19:32.000000000 -0400 ++++ linux-2.6.5/arch/arm/mach-sa1100/usb/sa1100usb.h 2004-04-30 20:57:36.000000000 -0400 +@@ -0,0 +1,136 @@ ++/* ++ * Copyright (C) Compaq Computer Corporation, 1998, 1999 ++ * Copyright (C) Extenex Corporation 2001 ++ * ++ * usb_ctl.h ++ * ++ * PRIVATE interface used to share info among components of the SA-1100 USB ++ * core: usb_ctl, usb_ep0, usb_recv and usb_send. Clients of the USB core ++ * should use sa1100_usb.h. ++ * ++ */ ++#ifndef SA1100USB_H ++#define SA1100USB_H ++ ++struct usbctl; ++ ++struct sausb_dev { ++ struct device *dev; ++ struct usbctl *ctl; ++ spinlock_t lock; ++ ++ u32 udccr; ++ ++ /* ++ * EP0 write thread. ++ */ ++ void (*wrint)(struct sausb_dev *); ++ struct usb_buf *wrbuf; ++ unsigned char *wrptr; ++ unsigned int wrlen; ++ ++ /* ++ * EP0 statistics. ++ */ ++ unsigned long ep0_wr_fifo_errs; ++ unsigned long ep0_wr_bytes; ++ unsigned long ep0_wr_packets; ++ unsigned long ep0_rd_fifo_errs; ++ unsigned long ep0_rd_bytes; ++ unsigned long ep0_rd_packets; ++ unsigned long ep0_stall_sent; ++ unsigned long ep0_early_irqs; ++ ++ /* ++ * EP1 .. n ++ */ ++ struct { ++ dma_regs_t *dmach; ++ ++ dma_addr_t bufdma; ++ unsigned int buflen; ++ void *pktcpu; ++ dma_addr_t pktdma; ++ unsigned int pktlen; ++ unsigned int pktrem; ++ ++ void *cb_data; ++ void (*cb_func)(void *data, int flag, int size); ++ ++ u32 udccs; ++ unsigned int maxpktsize; ++ unsigned int configured; ++ unsigned int host_halt; ++ unsigned long fifo_errs; ++ unsigned long bytes; ++ unsigned long packets; ++ } ep[2]; ++}; ++ ++/* receiver */ ++int ep1_recv(void); ++void udc_ep1_init(struct sausb_dev *); ++void udc_ep1_halt(struct sausb_dev *, int); ++void udc_ep1_reset(struct sausb_dev *); ++void udc_ep1_config(struct sausb_dev *, unsigned int); ++void udc_ep1_int_hndlr(struct sausb_dev *); ++ ++/* xmitter */ ++void udc_ep2_init(struct sausb_dev *); ++void udc_ep2_halt(struct sausb_dev *, int); ++void udc_ep2_reset(struct sausb_dev *); ++void udc_ep2_config(struct sausb_dev *, unsigned int); ++void udc_ep2_int_hndlr(struct sausb_dev *); ++ ++#define UDC_write(reg, val) do { \ ++ int i = 10000; \ ++ do { \ ++ (reg) = (val); \ ++ if (i-- <= 0) { \ ++ printk( "%s [%d]: write %#x to %p (%#x) failed\n", \ ++ __FUNCTION__, __LINE__, (val), &(reg), (reg)); \ ++ break; \ ++ } \ ++ } while((reg) != (val)); \ ++} while (0) ++ ++#define UDC_set(reg, val) do { \ ++ int i = 10000; \ ++ do { \ ++ (reg) |= (val); \ ++ if (i-- <= 0) { \ ++ printk( "%s [%d]: set %#x of %p (%#x) failed\n", \ ++ __FUNCTION__, __LINE__, (val), &(reg), (reg)); \ ++ break; \ ++ } \ ++ } while(!((reg) & (val))); \ ++} while (0) ++ ++#define UDC_clear(reg, val) do { \ ++ int i = 10000; \ ++ do { \ ++ (reg) &= ~(val); \ ++ if (i-- <= 0) { \ ++ printk( "%s [%d]: clear %#x of %p (%#x) failed\n", \ ++ __FUNCTION__, __LINE__, (val), &(reg), (reg)); \ ++ break; \ ++ } \ ++ } while((reg) & (val)); \ ++} while (0) ++ ++#define UDC_flip(reg, val) do { \ ++ int i = 10000; \ ++ (reg) = (val); \ ++ do { \ ++ (reg) = (val); \ ++ if (i-- <= 0) { \ ++ printk( "%s [%d]: flip %#x of %p (%#x) failed\n", \ ++ __FUNCTION__, __LINE__, (val), &(reg), (reg)); \ ++ break; \ ++ } \ ++ } while(((reg) & (val))); \ ++} while (0) ++ ++#define CHECK_ADDRESS { if ( Ser0UDCAR == 1 ) { printk("%s:%d I lost my address!!!\n",__FUNCTION__, __LINE__);}} ++ ++#endif +--- /dev/null 2003-09-23 18:19:32.000000000 -0400 ++++ linux-2.6.5/arch/arm/mach-sa1100/usb/strings.c 2004-04-30 20:57:36.000000000 -0400 +@@ -0,0 +1,117 @@ ++/* ++ * usb/strings.c ++ * ++ * Copyright (C) 2002 Russell King. ++ */ ++#include <linux/module.h> ++#include <linux/slab.h> ++#include <linux/errno.h> ++#include <linux/spinlock.h> ++#include <linux/string.h> ++#include <linux/usb_ch9.h> ++ ++#include "buffer.h" ++#include "strings.h" ++ ++struct usb_buf *usbc_string_alloc(int len) ++{ ++ struct usb_buf *buf; ++ int tot_len; ++ ++ tot_len = sizeof(struct usb_descriptor_header) + sizeof(u16) * len; ++ ++ buf = usbb_alloc(tot_len, GFP_KERNEL); ++ ++ if (buf) { ++ struct usb_string_descriptor *desc = usbb_push(buf, tot_len); ++ ++ desc->bLength = tot_len; ++ desc->bDescriptorType = USB_DT_STRING; ++ } ++ return buf; ++} ++ ++void usbc_string_free(struct usb_buf *buf) ++{ ++ if (buf) ++ usbb_put(buf); ++} ++ ++void usbc_string_from_cstr(struct usb_buf *buf, const char *str) ++{ ++ struct usb_string_descriptor *desc = usbc_string_desc(buf); ++ int i, len; ++ ++ len = strlen(str); ++ BUG_ON((sizeof(__u16) * len) > desc->bLength - sizeof(struct usb_descriptor_header)); ++ ++ for (i = 0; i < len; i++) ++ desc->wData[i] = cpu_to_le16(str[i]); ++} ++ ++int usbc_string_add(struct usbc_strs *table, struct usb_buf *buf) ++{ ++ int nr, i; ++ ++ nr = -ENOSPC; ++ spin_lock_irq(&table->lock); ++ for (i = 0; i < NR_STRINGS; i++) ++ if (table->buf[i] == NULL) { ++ table->buf[i] = buf; ++ nr = i; ++ break; ++ } ++ spin_unlock_irq(&table->lock); ++ ++ return nr; ++} ++ ++void usbc_string_del(struct usbc_strs *table, int nr) ++{ ++ if (nr < NR_STRINGS) { ++ spin_lock_irq(&table->lock); ++ table->buf[nr] = NULL; ++ spin_unlock_irq(&table->lock); ++ } ++} ++ ++struct usb_buf * ++usbc_string_find(struct usbc_strs *table, unsigned int lang, unsigned int idx) ++{ ++ struct usb_buf *buf = NULL; ++ ++ if (idx < NR_STRINGS) { ++ spin_lock_irq(&table->lock); ++ buf = usbb_get(table->buf[idx]); ++ spin_unlock_irq(&table->lock); ++ } ++ ++ return buf; ++} ++ ++void usbc_string_free_all(struct usbc_strs *table) ++{ ++ int i; ++ ++ spin_lock_irq(&table->lock); ++ for (i = 0; i < NR_STRINGS; i++) { ++ usbc_string_free(table->buf[i]); ++ table->buf[i] = NULL; ++ } ++ spin_unlock_irq(&table->lock); ++} ++ ++void usbc_string_init(struct usbc_strs *table) ++{ ++ memset(table, 0, sizeof(struct usbc_strs)); ++ spin_lock_init(&table->lock); ++} ++ ++EXPORT_SYMBOL(usbc_string_from_cstr); ++EXPORT_SYMBOL(usbc_string_alloc); ++EXPORT_SYMBOL(usbc_string_free); ++EXPORT_SYMBOL(usbc_string_add); ++EXPORT_SYMBOL(usbc_string_del); ++EXPORT_SYMBOL(usbc_string_find); ++EXPORT_SYMBOL(usbc_string_free_all); ++EXPORT_SYMBOL(usbc_string_init); +--- /dev/null 2003-09-23 18:19:32.000000000 -0400 ++++ linux-2.6.5/arch/arm/mach-sa1100/usb/usb_ctl.c 2004-04-30 20:57:36.000000000 -0400 +@@ -0,0 +1,171 @@ ++ /* ++ * Copyright (C) Compaq Computer Corporation, 1998, 1999 ++ * Copyright (C) Extenex Corporation, 2001 ++ * ++ * usb_ctl.c ++ * ++ * SA1100 USB controller core driver. ++ * ++ * This file provides interrupt routing and overall coordination ++ * of the three endpoints in usb_ep0, usb_receive (1), and usb_send (2). ++ * ++ * Please see linux/Documentation/arm/SA1100/SA1100_USB for details. ++ * ++ */ ++#include <linux/module.h> ++#include <linux/errno.h> ++#include <linux/usb.h> ++ ++#include "buffer.h" ++#include "client.h" ++#include "usbdev.h" ++#include "sa1100_usb.h" ++ ++////////////////////////////////////////////////////////////////////////////// ++// Globals ++////////////////////////////////////////////////////////////////////////////// ++ ++/* device descriptors */ ++static struct cdb cdb; ++ ++////////////////////////////////////////////////////////////////////////////// ++// Private Helpers ++////////////////////////////////////////////////////////////////////////////// ++ ++int sa1100_usb_add_string(struct usbctl *ctl, const char *str) ++{ ++ int nr = 0; ++ ++ if (str) { ++ struct usb_buf *buf; ++ int len; ++ ++ len = strlen(str); ++ ++ nr = -ENOMEM; ++ buf = usbc_string_alloc(len); ++ if (buf) { ++ usbc_string_from_cstr(buf, str); ++ nr = usbc_string_add(&ctl->strings, buf); ++ ++ if (nr < 0) ++ usbc_string_free(buf); ++ } ++ } ++ ++ return nr; ++} ++ ++EXPORT_SYMBOL(sa1100_usb_add_string); ++ ++static int sa1100_usb_add_language(struct usbctl *ctl, unsigned int lang) ++{ ++ struct usb_buf *buf; ++ int nr = -ENOMEM; ++ ++ buf = usbc_string_alloc(1); ++ if (buf) { ++ usbc_string_desc(buf)->wData[0] = cpu_to_le16(lang); /* American English */ ++ nr = usbc_string_add(&ctl->strings, buf); ++ ++ if (nr < 0) ++ usbc_string_free(buf); ++ } ++ ++ return nr; ++} ++ ++/* setup default descriptors */ ++ ++void initialize_descriptors(struct usbctl *ctl) ++{ ++ struct usb_client *clnt = ctl->clnt; ++ int r; ++ ++ ctl->ep_desc[0] = (struct usb_endpoint_descriptor *)&cdb.ep1; ++ ctl->ep_desc[1] = (struct usb_endpoint_descriptor *)&cdb.ep2; ++ ++ cdb.cfg.bLength = USB_DT_CONFIG_SIZE; ++ cdb.cfg.bDescriptorType = USB_DT_CONFIG; ++ cdb.cfg.wTotalLength = cpu_to_le16(sizeof(struct cdb)); ++ cdb.cfg.bNumInterfaces = 1; ++ cdb.cfg.bConfigurationValue = 1; ++ cdb.cfg.iConfiguration = 0; ++ cdb.cfg.bmAttributes = USB_CONFIG_ATT_ONE; ++ cdb.cfg.bMaxPower = USB_POWER( 500 ); ++ ++ cdb.intf.bLength = USB_DT_INTERFACE_SIZE; ++ cdb.intf.bDescriptorType = USB_DT_INTERFACE; ++ cdb.intf.bInterfaceNumber = 0; /* unique intf index*/ ++ cdb.intf.bAlternateSetting = 0; ++ cdb.intf.bNumEndpoints = 2; ++ cdb.intf.bInterfaceClass = 0xff; /* vendor specific */ ++ cdb.intf.bInterfaceSubClass = 0; ++ cdb.intf.bInterfaceProtocol = 0; ++ cdb.intf.iInterface = 0; ++ ++ cdb.ep1.bLength = USB_DT_INTERFACE_SIZE; ++ cdb.ep1.bDescriptorType = USB_DT_ENDPOINT; ++ cdb.ep1.bEndpointAddress = USB_DIR_OUT | 1; ++ cdb.ep1.bmAttributes = USB_ENDPOINT_XFER_BULK; ++ cdb.ep1.wMaxPacketSize = cpu_to_le16(64); ++ cdb.ep1.bInterval = 0; ++ ++ cdb.ep2.bLength = USB_DT_INTERFACE_SIZE; ++ cdb.ep2.bDescriptorType = USB_DT_ENDPOINT; ++ cdb.ep2.bEndpointAddress = USB_DIR_IN | 2; ++ cdb.ep2.bmAttributes = USB_ENDPOINT_XFER_BULK; ++ cdb.ep2.wMaxPacketSize = cpu_to_le16(64); ++ cdb.ep2.bInterval = 0; ++ ++ ctl->dev_desc->bLength = USB_DT_DEVICE_SIZE; ++ ctl->dev_desc->bDescriptorType = USB_DT_DEVICE; ++ ctl->dev_desc->bcdUSB = cpu_to_le16(0x100); /* 1.0 */ ++ ctl->dev_desc->bDeviceClass = clnt->class; ++ ctl->dev_desc->bDeviceSubClass = clnt->subclass; ++ ctl->dev_desc->bDeviceProtocol = clnt->protocol; ++ ctl->dev_desc->bMaxPacketSize0 = 8; /* ep0 max fifo size */ ++ ctl->dev_desc->idVendor = cpu_to_le16(clnt->vendor); ++ ctl->dev_desc->idProduct = cpu_to_le16(clnt->product); ++ ctl->dev_desc->bcdDevice = cpu_to_le16(clnt->version); ++ ctl->dev_desc->bNumConfigurations = 1; ++ ++ /* set language */ ++ /* See: http://www.usb.org/developers/data/USB_LANGIDs.pdf */ ++ r = sa1100_usb_add_language(ctl, 0x409); ++ if (r < 0) ++ printk(KERN_ERR "usbc: couldn't add language\n"); ++ ++ r = sa1100_usb_add_string(ctl, clnt->manufacturer_str); ++ if (r < 0) ++ printk(KERN_ERR "usbc: couldn't add manufacturer string\n"); ++ ++ ctl->dev_desc->iManufacturer = r > 0 ? r : 0; ++ ++ r = sa1100_usb_add_string(ctl, clnt->product_str); ++ if (r < 0) ++ printk(KERN_ERR "usbc: couldn't add product string\n"); ++ ++ ctl->dev_desc->iProduct = r > 0 ? r : 0; ++ ++ r = sa1100_usb_add_string(ctl, clnt->serial_str); ++ if (r < 0) ++ printk(KERN_ERR "usbc: couldn't add serial string\n"); ++ ++ ctl->dev_desc->iSerialNumber = r > 0 ? r : 0; ++} ++ ++ ++/*==================================================== ++ * Descriptor Manipulation. ++ * Use these between open() and start() above to setup ++ * the descriptors for your device. ++ */ ++ ++/* get pointer to static default descriptor */ ++struct cdb *sa1100_usb_get_descriptor_ptr(void) ++{ ++ return &cdb; ++} ++ ++EXPORT_SYMBOL(sa1100_usb_get_descriptor_ptr); +--- /dev/null 2003-09-23 18:19:32.000000000 -0400 ++++ linux-2.6.5/arch/arm/mach-sa1100/usb/Makefile 2004-04-30 20:57:36.000000000 -0400 +@@ -0,0 +1,12 @@ ++# ++# Makefile for the USB client ++# ++ ++usbdevcore-objs := buffer.o control.o strings.o usb_ctl.o ++ ++sa1100-objs := sa1100usb.o usb_recv.o usb_send.o ++ ++obj-$(CONFIG_SA1100_USB) += usbdevcore.o sa1100.o ++obj-$(CONFIG_SA1100_USB_NETLINK) += usb-eth.o ++obj-$(CONFIG_SA1100_USB_CHAR) += usb-char.o ++ +--- /dev/null 2003-09-23 18:19:32.000000000 -0400 ++++ linux-2.6.5/arch/arm/mach-sa1100/usb/usbdev.h 2004-04-30 20:57:36.000000000 -0400 +@@ -0,0 +1,91 @@ ++#ifndef USBDEV_H ++#define USBDEV_H ++ ++#include "strings.h" ++ ++struct usb_buf; ++struct module; ++struct cdb; ++struct usb_client; ++ ++struct usbc_driver { ++ struct module *owner; ++ const char *name; ++ void *priv; ++ int (*start)(void *); ++ int (*stop)(void *); ++ ++ int (*ep0_queue)(void *, struct usb_buf *buf, unsigned int req_len); ++ void (*set_address)(void *, unsigned int addr); ++ void (*set_config)(void *, struct cdb *config); ++ ++ /* ++ * Get specified endpoint status, as defined in 9.4.5. ++ */ ++ unsigned int (*ep_get_status)(void *, unsigned int ep); ++ void (*ep_halt)(void *, unsigned int ep, int halt); ++ ++ /* ++ * Client ++ */ ++ int (*ep_queue)(void *, unsigned int, char *, unsigned int); ++ void (*ep_reset)(void *, unsigned int); ++ void (*ep_callback)(void *, unsigned int, void (*)(void *, int, int), void *); ++ int (*ep_idle)(void *, unsigned int); ++}; ++ ++struct usbc_endpoint { ++ struct usb_endpoint_descriptor *desc; ++}; ++ ++struct usbc_interface { ++ struct usb_interface_descriptor *desc; ++ unsigned int nr_ep; ++ struct usbc_endpoint *ep[0]; ++}; ++ ++struct usbc_config { ++ struct usb_config_descriptor *desc; ++ unsigned int nr_interface; ++ struct usbc_interface *interface[0]; ++}; ++ ++struct usbctl { ++ struct usb_client *clnt; ++ const struct usbc_driver *driver; ++ ++ /* Internal state */ ++ unsigned int address; /* host assigned address */ ++ unsigned int state; /* our device state */ ++ unsigned int sm_state; /* state machine state */ ++ ++ struct usbc_config *config; /* active configuration */ ++ struct usbc_strs strings; ++ ++ /* Descriptors */ ++ struct usb_device_descriptor *dev_desc; /* device descriptor */ ++ struct usb_buf *dev_desc_buf; /* device descriptor buffer */ ++ ++ ++ int nr_ep; ++ struct usb_endpoint_descriptor *ep_desc[2]; ++}; ++ ++/* ++ * Function Prototypes ++ */ ++ ++#define RET_ERROR (-1) ++#define RET_NOACTION (0) ++#define RET_QUEUED (1) ++#define RET_ACK (2) ++#define RET_REQERROR (3) ++ ++int usbctl_parse_request(struct usbctl *ctl, struct usb_ctrlrequest *req); ++ ++int usbctl_reset(struct usbctl *ctl); ++void usbctl_suspend(struct usbctl *ctl); ++void usbctl_resume(struct usbctl *ctl); ++ ++#endif ++ +--- linux-2.6.5/arch/arm/mach-sa1100/pm.c~heh 2004-04-03 22:36:27.000000000 -0500 ++++ linux-2.6.5/arch/arm/mach-sa1100/pm.c 2004-04-30 20:57:36.000000000 -0400 +@@ -150,6 +150,7 @@ + */ + static int sa11x0_pm_prepare(u32 state) + { ++ nmi_watchdog_disable(); + return 0; + } + +@@ -158,6 +159,7 @@ + */ + static int sa11x0_pm_finish(u32 state) + { ++ nmi_watchdog_enable(); + return 0; + } + +--- /dev/null 2003-09-23 18:19:32.000000000 -0400 ++++ linux-2.6.5/arch/arm/mach-sa1100/nmi-oopser.c 2004-04-30 20:57:36.000000000 -0400 +@@ -0,0 +1,104 @@ ++#include <linux/kernel.h> ++#include <linux/init.h> ++#include <linux/sched.h> ++#include <linux/errno.h> ++#include <linux/gfp.h> ++#include <linux/module.h> ++#include <linux/delay.h> ++ ++#include <asm/ptrace.h> ++#include <asm/domain.h> ++#include <asm/hardware.h> ++ ++static void *nmi_stack; ++ ++asm(" \n\ ++nmi_start: \n\ ++ mrs r8, spsr \n\ ++ ldr r9, .Lstack \n\ ++ ldr sp, [r9] \n\ ++ sub sp, sp, #18 * 4 \n\ ++ str r8, [sp, #16 * 4] \n\ ++ str lr, [sp, #15 * 4] \n\ ++ stmia sp, {r0 - r7} \n\ ++ add r0, sp, #8 * 4 \n\ ++ mrs r2, cpsr \n\ ++ bic r1, r2, #0x1f \n\ ++ orr r1, r1, #0x13 \n\ ++ msr cpsr_c, r1 \n\ ++ mov r0, r0 \n\ ++ stmia r0, {r8 - lr} \n\ ++ mov r0, r0 \n\ ++ msr cpsr_c, r2 \n\ ++ mov r0, r0 \n\ ++ mov r0, sp \n\ ++ mov lr, pc \n\ ++ ldr pc, .Lfn \n\ ++ ldmia sp, {r0 - r7} \n\ ++ ldr r8, [sp, #16 * 4] \n\ ++ ldr lr, [sp, #15 * 4] \n\ ++ add sp, sp, #18 * 4 \n\ ++ msr spsr, r8 \n\ ++ movs pc, lr \n\ ++ \n\ ++.Lstack: .long nmi_stack \n\ ++.Lfn: .long nmi_fn \n\ ++nmi_end:"); ++ ++extern unsigned char nmi_start, nmi_end; ++ ++static void __attribute__((unused)) nmi_fn(struct pt_regs *regs) ++{ ++ struct thread_info *thread; ++ unsigned long osmr0, osmr1, oscr, ossr, icmr, icip; ++ ++ oscr = OSCR; ++ osmr0 = OSMR0; ++ osmr1 = OSMR1; ++ ossr = OSSR; ++ icmr = ICMR; ++ icip = ICIP; ++ ++ OSSR = OSSR_M1; ++ ICMR &= ~IC_OST1; ++ ++ thread = (struct thread_info *)(regs->ARM_sp & ~8191); ++ ++ bust_spinlocks(1); ++ printk("OSMR0:%08lx OSMR1:%08lx OSCR:%08lx OSSR:%08lx ICMR:%08lx ICIP:%08lx\n", ++ osmr0, osmr1, oscr, ossr, icmr, icip); ++ nmi_watchdog(thread, regs); ++ bust_spinlocks(0); ++ ++ OSSR = OSSR_M1; ++ OSMR1 = OSSR + 36864000; ++ ICMR |= IC_OST1; ++} ++ ++static int nmi_init(void) ++{ ++ unsigned char *vec_base = (unsigned char *)vectors_base(); ++return 0; ++ nmi_stack = (void *)__get_free_page(GFP_KERNEL); ++ if (!nmi_stack) ++ return -ENOMEM; ++ ++ nmi_stack += PAGE_SIZE; ++ ++ modify_domain(DOMAIN_USER, DOMAIN_MANAGER); ++ memcpy(vec_base + 0x1c, &nmi_start, &nmi_end - &nmi_start); ++ modify_domain(DOMAIN_USER, DOMAIN_CLIENT); ++ ++ /* ++ * Ensure timer 1 is set to FIQ, and enabled. ++ */ ++ OSMR1 = OSCR - 1; ++ OSSR = OSSR_M1; ++ OIER |= OIER_E1; ++ ICLR |= IC_OST1; ++ ICMR |= IC_OST1; ++ ++ return 0; ++} ++ ++__initcall(nmi_init); +--- linux-2.6.5/drivers/media/Kconfig~heh 2004-04-03 22:36:51.000000000 -0500 ++++ linux-2.6.5/drivers/media/Kconfig 2004-04-30 20:57:36.000000000 -0400 +@@ -32,6 +32,8 @@ + + source "drivers/media/common/Kconfig" + ++source "drivers/media/mmc/Kconfig" ++ + config VIDEO_TUNER + tristate + default y if VIDEO_BT848=y || VIDEO_SAA7134=y || VIDEO_MXB=y || VIDEO_CX88=y +--- /dev/null 2003-09-23 18:19:32.000000000 -0400 ++++ linux-2.6.5/drivers/media/mmc/Kconfig 2004-04-30 20:57:36.000000000 -0400 +@@ -0,0 +1,52 @@ ++# ++# MMC subsystem configuration ++# ++ ++menu "MMC/SD Card support" ++ ++config MMC ++ tristate "MMC support" ++ help ++ MMC is the "multi-media card" bus protocol. ++ ++ If you want MMC support, you should say Y here and also ++ to the specific driver for your MMC interface. ++ ++config MMC_DEBUG ++ bool "MMC debugging" ++ depends on MMC != n ++ help ++ This is an option for use by developers; most people should ++ say N here. This enables MMC core and driver debugging. ++ ++config MMC_BLOCK ++ tristate "MMC block device driver" ++ depends on MMC ++ default y ++ help ++ Say Y here to enable the MMC block device driver support. ++ This provides a block device driver, which you can use to ++ mount the filesystem. Almost everyone wishing MMC support ++ should say Y or M here. ++ ++config MMC_ARMMMCI ++ tristate "ARM AMBA Multimedia Card Interface support" ++ depends on ARM_AMBA && MMC ++ help ++ This selects the ARM(R) AMBA(R) PrimeCell Multimedia Card ++ Interface (PL180 and PL181) support. If you have an ARM(R) ++ platform with a Multimedia Card slot, say Y or M here. ++ ++ If unsure, say N. ++ ++config MMC_PXA ++ tristate "Intel PXA255 Multimedia Card Interface support" ++ depends on ARCH_PXA && MMC ++ help ++ This selects the Intel(R) PXA(R) Multimedia card Interface. ++ If you have a PXA(R) platform with a Multimedia Card slot, ++ say Y or M here. ++ ++ If unsure, say N. ++ ++endmenu +--- /dev/null 2003-09-23 18:19:32.000000000 -0400 ++++ linux-2.6.5/drivers/media/mmc/mmc_queue.c 2004-04-30 20:57:36.000000000 -0400 +@@ -0,0 +1,171 @@ ++/* ++ * linux/drivers/media/mmc/mmc_queue.c ++ * ++ * Copyright (C) 2003 Russell King, All Rights Reserved. ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License version 2 as ++ * published by the Free Software Foundation. ++ * ++ */ ++#include <linux/module.h> ++#include <linux/blkdev.h> ++ ++#include <linux/mmc/card.h> ++#include <linux/mmc/host.h> ++#include "mmc_queue.h" ++ ++/* ++ * Prepare a MMC request. Essentially, this means passing the ++ * preparation off to the media driver. The media driver will ++ * create a mmc_io_request in req->special. ++ */ ++static int mmc_prep_request(struct request_queue *q, struct request *req) ++{ ++ struct mmc_queue *mq = q->queuedata; ++ int ret = BLKPREP_KILL; ++ ++ if (req->flags & REQ_SPECIAL) { ++ /* ++ * Special commands already have the command ++ * blocks already setup in req->special. ++ */ ++ BUG_ON(!req->special); ++ ++ ret = BLKPREP_OK; ++ } else if (req->flags & (REQ_CMD | REQ_BLOCK_PC)) { ++ /* ++ * Block I/O requests need translating according ++ * to the protocol. ++ */ ++ ret = mq->prep_fn(mq, req); ++ } else { ++ /* ++ * Everything else is invalid. ++ */ ++ blk_dump_rq_flags(req, "MMC bad request"); ++ } ++ ++ if (ret == BLKPREP_OK) ++ req->flags |= REQ_DONTPREP; ++ ++ return ret; ++} ++ ++static int mmc_queue_thread(void *d) ++{ ++ struct mmc_queue *mq = d; ++ struct request_queue *q = mq->queue; ++ DECLARE_WAITQUEUE(wait, current); ++ int ret; ++ ++ /* ++ * Set iothread to ensure that we aren't put to sleep by ++ * the process freezing. We handle suspension ourselves. ++ */ ++ current->flags |= PF_MEMALLOC|PF_IOTHREAD; ++ ++ daemonize("mmcqd"); ++ ++ spin_lock_irq(¤t->sighand->siglock); ++ sigfillset(¤t->blocked); ++ recalc_sigpending(); ++ spin_unlock_irq(¤t->sighand->siglock); ++ ++ mq->thread = current; ++ complete(&mq->thread_complete); ++ ++ add_wait_queue(&mq->thread_wq, &wait); ++ spin_lock_irq(q->queue_lock); ++ do { ++ struct request *req = NULL; ++ ++ set_current_state(TASK_INTERRUPTIBLE); ++ if (!blk_queue_plugged(q)) ++ mq->req = req = elv_next_request(q); ++ spin_unlock(q->queue_lock); ++ ++ if (!req) { ++ if (!mq->thread) ++ break; ++ schedule(); ++ continue; ++ } ++ set_current_state(TASK_RUNNING); ++ ++ ret = mq->issue_fn(mq, req); ++ ++ spin_lock_irq(q->queue_lock); ++ end_request(req, ret); ++ } while (1); ++ remove_wait_queue(&mq->thread_wq, &wait); ++ ++ complete_and_exit(&mq->thread_complete, 0); ++ return 0; ++} ++ ++/* ++ * Generic MMC request handler. This is called for any queue on a ++ * particular host. When the host is not busy, we look for a request ++ * on any queue on this host, and attempt to issue it. This may ++ * not be the queue we were asked to process. ++ */ ++static void mmc_request(request_queue_t *q) ++{ ++ struct mmc_queue *mq = q->queuedata; ++ ++ if (!mq->req && !blk_queue_plugged(q)) ++ wake_up(&mq->thread_wq); ++} ++ ++/** ++ * mmc_init_queue - initialise a queue structure. ++ * @mq: mmc queue ++ * @card: mmc card to attach this queue ++ * @lock: queue lock ++ * ++ * Initialise a MMC card request queue. ++ */ ++int mmc_init_queue(struct mmc_queue *mq, struct mmc_card *card, spinlock_t *lock) ++{ ++ u64 limit = BLK_BOUNCE_HIGH; ++ int ret; ++ ++ if (card->host->dev->dma_mask) ++ limit = *card->host->dev->dma_mask; ++ ++ mq->card = card; ++ mq->queue = blk_init_queue(mmc_request, lock); ++ blk_queue_prep_rq(mq->queue, mmc_prep_request); ++ blk_queue_bounce_limit(mq->queue, limit); ++ ++ mq->queue->queuedata = mq; ++ mq->req = NULL; ++ ++ init_completion(&mq->thread_complete); ++ init_waitqueue_head(&mq->thread_wq); ++ ++ ret = kernel_thread(mmc_queue_thread, mq, CLONE_KERNEL); ++ if (ret < 0) { ++ blk_cleanup_queue(mq->queue); ++ } else { ++ wait_for_completion(&mq->thread_complete); ++ init_completion(&mq->thread_complete); ++ } ++ ++ return ret; ++} ++ ++EXPORT_SYMBOL(mmc_init_queue); ++ ++void mmc_cleanup_queue(struct mmc_queue *mq) ++{ ++ mq->thread = NULL; ++ wake_up(&mq->thread_wq); ++ wait_for_completion(&mq->thread_complete); ++ blk_cleanup_queue(mq->queue); ++ ++ mq->card = NULL; ++} ++ ++EXPORT_SYMBOL(mmc_cleanup_queue); +--- /dev/null 2003-09-23 18:19:32.000000000 -0400 ++++ linux-2.6.5/drivers/media/mmc/pxamci.c 2004-04-30 20:57:36.000000000 -0400 +@@ -0,0 +1,587 @@ ++/* ++ * linux/drivers/media/mmc/pxa.c - PXA MMCI driver ++ * ++ * Copyright (C) 2003 Russell King, All Rights Reserved. ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License version 2 as ++ * published by the Free Software Foundation. ++ * ++ * This hardware is really sick. No way to clear interrupts. Have ++ * to turn off the clock whenever we touch the device. Yuck! ++ * ++ * 1 and 3 byte data transfers not supported ++ * max block length up to 1023 ++ */ ++#include <linux/config.h> ++#include <linux/module.h> ++#include <linux/init.h> ++#include <linux/ioport.h> ++#include <linux/device.h> ++#include <linux/interrupt.h> ++#include <linux/blkdev.h> ++#include <linux/dma-mapping.h> ++#include <linux/mmc/host.h> ++#include <linux/mmc/protocol.h> ++ ++#include <asm/dma.h> ++#include <asm/io.h> ++#include <asm/irq.h> ++#include <asm/sizes.h> ++ ++#include "pxamci.h" ++ ++#ifdef CONFIG_MMC_DEBUG ++#define DBG(x...) printk(KERN_DEBUG x) ++#else ++#define DBG(x...) do { } while (0) ++#endif ++ ++struct pxamci_host { ++ struct mmc_host mmc; ++ spinlock_t lock; ++ struct resource *res; ++ void *base; ++ int irq; ++ int dma; ++ unsigned int clkrt; ++ unsigned int cmdat; ++ unsigned int imask; ++ unsigned int power_mode; ++ ++ struct mmc_request *req; ++ struct mmc_command *cmd; ++ struct mmc_data *data; ++ ++ dma_addr_t sg_dma; ++ struct pxa_dma_desc *sg_cpu; ++ ++ dma_addr_t dma_buf; ++ unsigned int dma_size; ++ unsigned int dma_dir; ++}; ++ ++#define to_pxamci_host(x) container_of(x, struct pxamci_host, mmc) ++ ++/* ++ * The base MMC clock rate ++ */ ++#define CLOCKRATE 20000000 ++ ++static inline unsigned int ns_to_clocks(unsigned int ns) ++{ ++ return (ns * (CLOCKRATE / 1000000) + 999) / 1000; ++} ++ ++static void pxamci_stop_clock(struct pxamci_host *host) ++{ ++ if (readl(host->base + MMC_STAT) & STAT_CLK_EN) { ++ unsigned long flags; ++ unsigned int v; ++ ++ writel(STOP_CLOCK, host->base + MMC_STRPCL); ++ ++ /* ++ * Wait for the "clock has stopped" interrupt. ++ * We need to unmask the interrupt to receive ++ * the notification. Sigh. ++ */ ++ spin_lock_irqsave(&host->lock, flags); ++ writel(host->imask & ~CLK_IS_OFF, host->base + MMC_I_MASK); ++ do { ++ v = readl(host->base + MMC_I_REG); ++ } while (!(v & CLK_IS_OFF)); ++ writel(host->imask, host->base + MMC_I_MASK); ++ spin_unlock_irqrestore(&host->lock, flags); ++ } ++} ++ ++static void pxamci_enable_irq(struct pxamci_host *host, unsigned int mask) ++{ ++ unsigned long flags; ++ ++ spin_lock_irqsave(&host->lock, flags); ++ host->imask &= ~mask; ++ writel(host->imask, host->base + MMC_I_MASK); ++ spin_unlock_irqrestore(&host->lock, flags); ++} ++ ++static void pxamci_disable_irq(struct pxamci_host *host, unsigned int mask) ++{ ++ unsigned long flags; ++ ++ spin_lock_irqsave(&host->lock, flags); ++ host->imask |= mask; ++ writel(host->imask, host->base + MMC_I_MASK); ++ spin_unlock_irqrestore(&host->lock, flags); ++} ++ ++static void pxamci_setup_data(struct pxamci_host *host, struct mmc_data *data) ++{ ++ unsigned int nob = data->blocks; ++ unsigned int timeout, size; ++ dma_addr_t dma; ++ u32 dcmd; ++ int i; ++ ++ host->data = data; ++ ++ if (data->flags & MMC_DATA_STREAM) ++ nob = 0xffff; ++ ++ writel(nob, host->base + MMC_NOB); ++ writel(1 << data->blksz_bits, host->base + MMC_BLKLEN); ++ ++ timeout = ns_to_clocks(data->timeout_ns) + data->timeout_clks; ++ writel((timeout + 255) / 256, host->base + MMC_RDTO); ++ ++ if (data->flags & MMC_DATA_READ) { ++ host->dma_dir = DMA_FROM_DEVICE; ++ dcmd = DCMD_INCTRGADDR | DCMD_FLOWTRG; ++ DRCMRTXMMC = 0; ++ DRCMRRXMMC = host->dma | DRCMR_MAPVLD; ++ } else { ++ host->dma_dir = DMA_TO_DEVICE; ++ dcmd = DCMD_INCSRCADDR | DCMD_FLOWSRC; ++ DRCMRRXMMC = 0; ++ DRCMRTXMMC = host->dma | DRCMR_MAPVLD; ++ } ++ ++ dcmd |= DCMD_BURST32 | DCMD_WIDTH1; ++ ++ host->dma_size = data->blocks << data->blksz_bits; ++ host->dma_buf = dma_map_single(host->mmc.dev, data->rq->buffer, ++ host->dma_size, host->dma_dir); ++ ++ for (i = 0, size = host->dma_size, dma = host->dma_buf; size; i++) { ++ u32 len = size; ++ ++ if (len > DCMD_LENGTH) ++ len = 0x1000; ++ ++ if (data->flags & MMC_DATA_READ) { ++ host->sg_cpu[i].dsadr = host->res->start + MMC_RXFIFO; ++ host->sg_cpu[i].dtadr = dma; ++ } else { ++ host->sg_cpu[i].dsadr = dma; ++ host->sg_cpu[i].dtadr = host->res->start + MMC_TXFIFO; ++ } ++ host->sg_cpu[i].dcmd = dcmd | len; ++ ++ dma += len; ++ size -= len; ++ ++ if (size) { ++ host->sg_cpu[i].ddadr = host->sg_dma + (i + 1) * ++ sizeof(struct pxa_dma_desc); ++ } else { ++ host->sg_cpu[i].ddadr = DDADR_STOP; ++ } ++ } ++ wmb(); ++ ++ DDADR(host->dma) = host->sg_dma; ++ DCSR(host->dma) = DCSR_RUN; ++} ++ ++static void pxamci_start_cmd(struct pxamci_host *host, struct mmc_command *cmd, unsigned int cmdat) ++{ ++ WARN_ON(host->cmd != NULL); ++ host->cmd = cmd; ++ ++ if (cmd->flags & MMC_RSP_BUSY) ++ cmdat |= CMDAT_BUSY; ++ ++ switch (cmd->flags & (MMC_RSP_MASK | MMC_RSP_CRC)) { ++ case MMC_RSP_SHORT | MMC_RSP_CRC: ++ cmdat |= CMDAT_RESP_SHORT; ++ break; ++ case MMC_RSP_SHORT: ++ cmdat |= CMDAT_RESP_R3; ++ break; ++ case MMC_RSP_LONG | MMC_RSP_CRC: ++ cmdat |= CMDAT_RESP_R2; ++ break; ++ default: ++ break; ++ } ++ ++ writel(cmd->opcode, host->base + MMC_CMD); ++ writel(cmd->arg >> 16, host->base + MMC_ARGH); ++ writel(cmd->arg & 0xffff, host->base + MMC_ARGL); ++ writel(cmdat, host->base + MMC_CMDAT); ++ writel(host->clkrt, host->base + MMC_CLKRT); ++ ++ writel(START_CLOCK, host->base + MMC_STRPCL); ++ ++ pxamci_enable_irq(host, END_CMD_RES); ++} ++ ++static void pxamci_finish_request(struct pxamci_host *host, struct mmc_request *req) ++{ ++ DBG("PXAMCI: request done\n"); ++ host->req = NULL; ++ host->cmd = NULL; ++ host->data = NULL; ++ mmc_request_done(&host->mmc, req); ++} ++ ++static int pxamci_cmd_done(struct pxamci_host *host, unsigned int stat) ++{ ++ struct mmc_command *cmd = host->cmd; ++ int i; ++ u32 v; ++ ++ if (!cmd) ++ return 0; ++ ++ host->cmd = NULL; ++ ++ /* ++ * Did I mention this is Sick. We always need to ++ * discard the upper 8 bits of the first 16-bit word. ++ */ ++ v = readl(host->base + MMC_RES) & 0xffff; ++ for (i = 0; i < 4; i++) { ++ u32 w1 = readl(host->base + MMC_RES) & 0xffff; ++ u32 w2 = readl(host->base + MMC_RES) & 0xffff; ++ cmd->resp[i] = v << 24 | w1 << 8 | w2 >> 8; ++ v = w2; ++ } ++ ++ if (stat & STAT_TIME_OUT_RESPONSE) { ++ cmd->error = MMC_ERR_TIMEOUT; ++ } else if (stat & STAT_RES_CRC_ERR && cmd->flags & MMC_RSP_CRC) { ++ cmd->error = MMC_ERR_BADCRC; ++ } ++ ++ pxamci_disable_irq(host, END_CMD_RES); ++ if (host->data && cmd->error == MMC_ERR_NONE) { ++ pxamci_enable_irq(host, DATA_TRAN_DONE); ++ } else { ++ pxamci_finish_request(host, host->req); ++ } ++ ++ return 1; ++} ++ ++static int pxamci_data_done(struct pxamci_host *host, unsigned int stat) ++{ ++ struct mmc_data *data = host->data; ++ ++ if (!data) ++ return 0; ++ ++ DCSR(host->dma) = 0; ++ dma_unmap_single(host->mmc.dev, host->dma_buf, host->dma_size, ++ host->dma_dir); ++ ++ if (stat & STAT_READ_TIME_OUT) ++ data->error = MMC_ERR_TIMEOUT; ++ else if (stat & (STAT_CRC_READ_ERROR|STAT_CRC_WRITE_ERROR)) ++ data->error = MMC_ERR_BADCRC; ++ ++ data->bytes_xfered = (data->blocks - readl(host->base + MMC_NOB)) ++ << data->blksz_bits; ++ ++ pxamci_disable_irq(host, DATA_TRAN_DONE); ++ ++ host->data = NULL; ++ if (host->req->stop && data->error == MMC_ERR_NONE) { ++ pxamci_stop_clock(host); ++ pxamci_start_cmd(host, host->req->stop, 0); ++ } else { ++ pxamci_finish_request(host, host->req); ++ } ++ ++ return 1; ++} ++ ++static irqreturn_t pxamci_irq(int irq, void *devid, struct pt_regs *regs) ++{ ++ struct pxamci_host *host = devid; ++ unsigned int ireg; ++ int handled = 0; ++ ++ ireg = readl(host->base + MMC_I_REG); ++ ++ DBG("PXAMCI: irq %08x\n", ireg); ++ ++ if (ireg) { ++ unsigned stat = readl(host->base + MMC_STAT); ++ ++ DBG("PXAMCI: stat %08x\n", stat); ++ ++ if (ireg & END_CMD_RES) ++ handled |= pxamci_cmd_done(host, stat); ++ if (ireg & DATA_TRAN_DONE) ++ handled |= pxamci_data_done(host, stat); ++ } ++ ++ return IRQ_RETVAL(handled); ++} ++ ++static void pxamci_request(struct mmc_host *mmc, struct mmc_request *req) ++{ ++ struct pxamci_host *host = to_pxamci_host(mmc); ++ unsigned int cmdat; ++ ++ WARN_ON(host->req != NULL); ++ ++ host->req = req; ++ ++ pxamci_stop_clock(host); ++ ++ cmdat = host->cmdat; ++ host->cmdat &= ~CMDAT_INIT; ++ ++ if (req->data) { ++ pxamci_setup_data(host, req->data); ++ ++ cmdat &= ~CMDAT_BUSY; ++ cmdat |= CMDAT_DATAEN | CMDAT_DMAEN; ++ if (req->data->flags & MMC_DATA_WRITE) ++ cmdat |= CMDAT_WRITE; ++ ++ if (req->data->flags & MMC_DATA_STREAM) ++ cmdat |= CMDAT_STREAM; ++ } ++ ++ pxamci_start_cmd(host, req->cmd, cmdat); ++} ++ ++static void pxamci_set_ios(struct mmc_host *mmc, struct mmc_ios *ios) ++{ ++ struct pxamci_host *host = to_pxamci_host(mmc); ++ ++ DBG("pxamci_set_ios: clock %u power %u vdd %u.%02u\n", ++ ios->clock, ios->power_mode, ios->vdd / 100, ++ ios->vdd % 100); ++ ++ if (ios->clock) { ++ unsigned int clk = CLOCKRATE / ios->clock; ++ if (CLOCKRATE / clk > ios->clock) ++ clk <<= 1; ++ host->clkrt = fls(clk) - 1; ++ ++ /* ++ * we write clkrt on the next command ++ */ ++ } else if (readl(host->base + MMC_STAT) & STAT_CLK_EN) { ++ /* ++ * Ensure that the clock is off. ++ */ ++ writel(STOP_CLOCK, host->base + MMC_STRPCL); ++ } ++ ++ if (host->power_mode != ios->power_mode) { ++ host->power_mode = ios->power_mode; ++ ++ /* ++ * power control? none on the lubbock. ++ */ ++ ++ if (ios->power_mode == MMC_POWER_ON) ++ host->cmdat |= CMDAT_INIT; ++ } ++ ++ DBG("pxamci_set_ios: clkrt = %x cmdat = %x\n", ++ host->clkrt, host->cmdat); ++} ++ ++static struct mmc_host_ops pxamci_ops = { ++ .request = pxamci_request, ++ .set_ios = pxamci_set_ios, ++}; ++ ++static struct resource *platform_device_resource(struct platform_device *dev, unsigned int mask, int nr) ++{ ++ int i; ++ ++ for (i = 0; i < dev->num_resources; i++) ++ if (dev->resource[i].flags == mask && nr-- == 0) ++ return &dev->resource[i]; ++ return NULL; ++} ++ ++static int platform_device_irq(struct platform_device *dev, int nr) ++{ ++ int i; ++ ++ for (i = 0; i < dev->num_resources; i++) ++ if (dev->resource[i].flags == IORESOURCE_IRQ && nr-- == 0) ++ return dev->resource[i].start; ++ return NO_IRQ; ++} ++ ++static void pxamci_dma_irq(int dma, void *devid, struct pt_regs *regs) ++{ ++ printk(KERN_ERR "DMA%d: IRQ???\n", dma); ++ DCSR(dma) = DCSR_STARTINTR|DCSR_ENDINTR|DCSR_BUSERR; ++} ++ ++static int pxamci_probe(struct device *dev) ++{ ++ struct platform_device *pdev = to_platform_device(dev); ++ struct pxamci_host *host; ++ struct resource *r; ++ int ret, irq; ++ ++ r = platform_device_resource(pdev, IORESOURCE_MEM, 0); ++ irq = platform_device_irq(pdev, 0); ++ if (!r || irq == NO_IRQ) ++ return -ENXIO; ++ ++ r = request_mem_region(r->start, SZ_4K, "PXAMCI"); ++ if (!r) ++ return -EBUSY; ++ ++ host = kmalloc(sizeof(struct pxamci_host), GFP_KERNEL); ++ if (!host) { ++ ret = -ENOMEM; ++ goto out; ++ } ++ ++ memset(host, 0, sizeof(struct pxamci_host)); ++ host->dma = -1; ++ ++ host->sg_cpu = dma_alloc_coherent(dev, PAGE_SIZE, &host->sg_dma, GFP_KERNEL); ++ if (!host->sg_cpu) { ++ ret = -ENOMEM; ++ goto out; ++ } ++ ++ ret = mmc_init_host(&host->mmc); ++ if (ret) ++ goto out; ++ ++ spin_lock_init(&host->lock); ++ host->res = r; ++ host->irq = irq; ++ host->imask = TXFIFO_WR_REQ|RXFIFO_RD_REQ|CLK_IS_OFF|STOP_CMD| ++ END_CMD_RES|PRG_DONE|DATA_TRAN_DONE; ++ host->mmc.dev = dev; ++ host->mmc.ops = &pxamci_ops; ++ host->mmc.f_min = 312500; ++ host->mmc.f_max = 20000000; ++ host->mmc.ocr_avail = MMC_VDD_32_33; ++ ++ host->base = ioremap(r->start, SZ_4K); ++ if (!host->base) { ++ ret = -ENOMEM; ++ goto out; ++ } ++ ++ /* ++ * Ensure that the host controller is shut down, and setup ++ * with our defaults. ++ */ ++ pxamci_stop_clock(host); ++ writel(0, host->base + MMC_SPI); ++ writel(64, host->base + MMC_RESTO); ++ ++#ifdef CONFIG_PREEMPT ++#error Not Preempt-safe ++#endif ++ pxa_gpio_mode(GPIO6_MMCCLK_MD); ++ pxa_gpio_mode(GPIO8_MMCCS0_MD); ++ CKEN |= CKEN12_MMC; ++ ++ host->dma = pxa_request_dma("PXAMCI", DMA_PRIO_LOW, pxamci_dma_irq, host); ++ if (host->dma < 0) ++ goto out; ++ ++ ret = request_irq(host->irq, pxamci_irq, 0, "PXAMCI", host); ++ if (ret) ++ goto out; ++ ++ dev_set_drvdata(dev, host); ++ ++ mmc_add_host(&host->mmc); ++ ++ return 0; ++ ++ out: ++ if (host) { ++ if (host->dma >= 0) ++ pxa_free_dma(host->dma); ++ if (host->base) ++ iounmap(host->base); ++ if (host->sg_cpu) ++ dma_free_coherent(dev, PAGE_SIZE, host->sg_cpu, host->sg_dma); ++ kfree(host); ++ } ++ release_resource(r); ++ return ret; ++} ++ ++static int pxamci_remove(struct device *dev) ++{ ++ struct pxamci_host *host = dev_get_drvdata(dev); ++ ++ dev_set_drvdata(dev, NULL); ++ ++ if (host) { ++ mmc_remove_host(&host->mmc); ++ ++ pxamci_stop_clock(host); ++ writel(TXFIFO_WR_REQ|RXFIFO_RD_REQ|CLK_IS_OFF|STOP_CMD| ++ END_CMD_RES|PRG_DONE|DATA_TRAN_DONE, ++ host->base + MMC_I_MASK); ++ ++ free_irq(host->irq, host); ++ pxa_free_dma(host->dma); ++ iounmap(host->base); ++ dma_free_coherent(dev, PAGE_SIZE, host->sg_cpu, host->sg_dma); ++ ++ release_resource(host->res); ++ ++ kfree(host); ++ } ++ return 0; ++} ++ ++static int pxamci_suspend(struct device *dev, u32 state, u32 level) ++{ ++ struct pxamci_host *host = dev_get_drvdata(dev); ++ int ret = 0; ++ ++ if (host && level == SUSPEND_DISABLE) ++ ret = mmc_suspend_host(&host->mmc, state); ++ return ret; ++} ++ ++static int pxamci_resume(struct device *dev, u32 level) ++{ ++ struct pxamci_host *host = dev_get_drvdata(dev); ++ int ret = 0; ++ ++ if (host && level == RESUME_ENABLE) ++ ret = mmc_resume_host(&host->mmc); ++ return ret; ++} ++ ++static struct device_driver pxamci_driver = { ++ .name = "pxamci", ++ .bus = &platform_bus_type, ++ .probe = pxamci_probe, ++ .remove = pxamci_remove, ++ .suspend = pxamci_suspend, ++ .resume = pxamci_resume, ++}; ++ ++static int __init pxamci_init(void) ++{ ++ return driver_register(&pxamci_driver); ++} ++ ++static void __exit pxamci_exit(void) ++{ ++ driver_unregister(&pxamci_driver); ++} ++ ++module_init(pxamci_init); ++module_exit(pxamci_exit); ++ ++MODULE_DESCRIPTION("PXA Multimedia Card Interface Driver"); ++MODULE_LICENSE("GPL"); +--- /dev/null 2003-09-23 18:19:32.000000000 -0400 ++++ linux-2.6.5/drivers/media/mmc/mmc.h 2004-04-30 20:57:36.000000000 -0400 +@@ -0,0 +1,15 @@ ++/* ++ * linux/drivers/media/mmc/mmc.h ++ * ++ * Copyright (C) 2003 Russell King, All Rights Reserved. ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License version 2 as ++ * published by the Free Software Foundation. ++ */ ++#ifndef _MMC_H ++/* core-internal functions */ ++void mmc_init_card(struct mmc_card *card, struct mmc_host *host); ++int mmc_register_card(struct mmc_card *card); ++void mmc_remove_card(struct mmc_card *card); ++#endif +--- /dev/null 2003-09-23 18:19:32.000000000 -0400 ++++ linux-2.6.5/drivers/media/mmc/mmc_sysfs.c 2004-04-30 20:57:36.000000000 -0400 +@@ -0,0 +1,231 @@ ++/* ++ * linux/drivers/media/mmc/mmc_sysfs.c ++ * ++ * Copyright (C) 2003 Russell King, All Rights Reserved. ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License version 2 as ++ * published by the Free Software Foundation. ++ * ++ * MMC sysfs/driver model support. ++ */ ++#include <linux/module.h> ++#include <linux/init.h> ++#include <linux/device.h> ++ ++#include <linux/mmc/card.h> ++#include <linux/mmc/host.h> ++ ++#include "mmc.h" ++ ++#define dev_to_mmc_card(d) container_of(d, struct mmc_card, dev) ++#define to_mmc_driver(d) container_of(d, struct mmc_driver, drv) ++ ++static void mmc_release_card(struct device *dev) ++{ ++ struct mmc_card *card = dev_to_mmc_card(dev); ++ ++ kfree(card); ++} ++ ++/* ++ * This currently matches any MMC driver to any MMC card - drivers ++ * themselves make the decision whether to drive this card in their ++ * probe method. ++ */ ++static int mmc_bus_match(struct device *dev, struct device_driver *drv) ++{ ++ return 1; ++} ++ ++static int ++mmc_bus_hotplug(struct device *dev, char **envp, int num_envp, char *buf, ++ int buf_size) ++{ ++ struct mmc_card *card = dev_to_mmc_card(dev); ++ char ccc[13]; ++ int i = 0; ++ ++#define add_env(fmt,val) \ ++ ({ \ ++ int len, ret = -ENOMEM; \ ++ if (i < num_envp) { \ ++ envp[i++] = buf; \ ++ len = snprintf(buf, buf_size, fmt, val) + 1; \ ++ buf_size -= len; \ ++ buf += len; \ ++ if (buf_size >= 0) \ ++ ret = 0; \ ++ } \ ++ ret; \ ++ }) ++ ++ for (i = 0; i < 12; i++) ++ ccc[i] = card->csd.cmdclass & (1 << i) ? '1' : '0'; ++ ccc[12] = '\0'; ++ ++ i = 0; ++ add_env("MMC_CCC=%s", ccc); ++ add_env("MMC_MANFID=%03x", card->cid.manfid); ++ add_env("MMC_SLOT_NAME=%s", card->dev.bus_id); ++ ++ return 0; ++} ++ ++static int mmc_bus_suspend(struct device *dev, u32 state) ++{ ++ struct mmc_driver *drv = to_mmc_driver(dev->driver); ++ struct mmc_card *card = dev_to_mmc_card(dev); ++ int ret = 0; ++ ++ if (dev->driver && drv->suspend) ++ ret = drv->suspend(card, state); ++ return ret; ++} ++ ++static int mmc_bus_resume(struct device *dev) ++{ ++ struct mmc_driver *drv = to_mmc_driver(dev->driver); ++ struct mmc_card *card = dev_to_mmc_card(dev); ++ int ret = 0; ++ ++ if (dev->driver && drv->resume) ++ ret = drv->resume(card); ++ return ret; ++} ++ ++static struct bus_type mmc_bus_type = { ++ .name = "mmc", ++ .match = mmc_bus_match, ++ .hotplug = mmc_bus_hotplug, ++ .suspend = mmc_bus_suspend, ++ .resume = mmc_bus_resume, ++}; ++ ++ ++static int mmc_drv_probe(struct device *dev) ++{ ++ struct mmc_driver *drv = to_mmc_driver(dev->driver); ++ struct mmc_card *card = dev_to_mmc_card(dev); ++ ++ return drv->probe(card); ++} ++ ++static int mmc_drv_remove(struct device *dev) ++{ ++ struct mmc_driver *drv = to_mmc_driver(dev->driver); ++ struct mmc_card *card = dev_to_mmc_card(dev); ++ ++ drv->remove(card); ++ ++ return 0; ++} ++ ++ ++/** ++ * mmc_register_driver - register a media driver ++ * @drv: MMC media driver ++ */ ++int mmc_register_driver(struct mmc_driver *drv) ++{ ++ drv->drv.bus = &mmc_bus_type; ++ drv->drv.probe = mmc_drv_probe; ++ drv->drv.remove = mmc_drv_remove; ++ return driver_register(&drv->drv); ++} ++ ++EXPORT_SYMBOL(mmc_register_driver); ++ ++/** ++ * mmc_unregister_driver - unregister a media driver ++ * @drv: MMC media driver ++ */ ++void mmc_unregister_driver(struct mmc_driver *drv) ++{ ++ drv->drv.bus = &mmc_bus_type; ++ driver_unregister(&drv->drv); ++} ++ ++EXPORT_SYMBOL(mmc_unregister_driver); ++ ++ ++#define MMC_ATTR(name, fmt, args...) \ ++static ssize_t mmc_dev_show_##name (struct device *dev, char *buf) \ ++{ \ ++ struct mmc_card *card = dev_to_mmc_card(dev); \ ++ return sprintf(buf, fmt, args); \ ++} \ ++static DEVICE_ATTR(name, S_IRUGO, mmc_dev_show_##name, NULL) ++ ++MMC_ATTR(date, "%02d/%04d\n", card->cid.month, 1997 + card->cid.year); ++MMC_ATTR(fwrev, "0x%x\n", card->cid.fwrev); ++MMC_ATTR(hwrev, "0x%x\n", card->cid.hwrev); ++MMC_ATTR(manfid, "0x%03x\n", card->cid.manfid); ++MMC_ATTR(serial, "0x%06x\n", card->cid.serial); ++MMC_ATTR(name, "%s\n", card->cid.prod_name); ++ ++static struct device_attribute *mmc_dev_attributes[] = { ++ &dev_attr_date, ++ &dev_attr_fwrev, ++ &dev_attr_hwrev, ++ &dev_attr_manfid, ++ &dev_attr_serial, ++ &dev_attr_name, ++}; ++ ++/* ++ * Internal function. Initialise a MMC card structure. ++ */ ++void mmc_init_card(struct mmc_card *card, struct mmc_host *host) ++{ ++ memset(card, 0, sizeof(struct mmc_card)); ++ card->host = host; ++ device_initialize(&card->dev); ++ card->dev.parent = card->host->dev; ++ card->dev.bus = &mmc_bus_type; ++ card->dev.release = mmc_release_card; ++} ++ ++/* ++ * Internal function. Register a new MMC card with the driver model. ++ */ ++int mmc_register_card(struct mmc_card *card) ++{ ++ int ret, i; ++ ++ snprintf(card->dev.bus_id, sizeof(card->dev.bus_id), ++ "mmc%02x:%04x", card->host->host_num, card->rca); ++ ++ ret = device_add(&card->dev); ++ if (ret == 0) ++ for (i = 0; i < ARRAY_SIZE(mmc_dev_attributes); i++) ++ device_create_file(&card->dev, mmc_dev_attributes[i]); ++ ++ return ret; ++} ++ ++/* ++ * Internal function. Unregister a new MMC card with the ++ * driver model, and (eventually) free it. ++ */ ++void mmc_remove_card(struct mmc_card *card) ++{ ++ if (mmc_card_present(card)) ++ device_del(&card->dev); ++ ++ put_device(&card->dev); ++} ++ ++ ++static int __init mmc_init(void) ++{ ++ return bus_register(&mmc_bus_type); ++} ++ ++static void __exit mmc_exit(void) ++{ ++ bus_unregister(&mmc_bus_type); ++} ++ ++module_init(mmc_init); ++module_exit(mmc_exit); +--- /dev/null 2003-09-23 18:19:32.000000000 -0400 ++++ linux-2.6.5/drivers/media/mmc/mmci.c 2004-04-30 20:57:36.000000000 -0400 +@@ -0,0 +1,445 @@ ++/* ++ * linux/drivers/media/mmc/mmci.c - ARM PrimeCell MMCI PL180/1 driver ++ * ++ * Copyright (C) 2003 Deep Blue Solutions, Ltd, All Rights Reserved. ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License version 2 as ++ * published by the Free Software Foundation. ++ */ ++#include <linux/config.h> ++#include <linux/module.h> ++#include <linux/moduleparam.h> ++#include <linux/init.h> ++#include <linux/ioport.h> ++#include <linux/device.h> ++#include <linux/interrupt.h> ++#include <linux/blkdev.h> ++#include <linux/delay.h> ++#include <linux/mmc/host.h> ++#include <linux/mmc/protocol.h> ++ ++#include <asm/io.h> ++#include <asm/irq.h> ++#include <asm/hardware/amba.h> ++ ++#include "mmci.h" ++ ++#define DRIVER_NAME "mmci-pl18x" ++ ++#ifdef CONFIG_MMC_DEBUG ++#define DBG(x...) printk(KERN_DEBUG x) ++#else ++#define DBG(x...) do { } while (0) ++#endif ++ ++static int fmax = 515633; ++ ++static void ++mmci_request_end(struct mmci_host *host, struct mmc_request *req) ++{ ++ writel(0, host->base + MMCICOMMAND); ++ host->req = NULL; ++ host->cmd = NULL; ++ host->data = NULL; ++ ++ if (req->data) ++ req->data->bytes_xfered = host->data_xfered; ++ ++ mmc_request_done(&host->mmc, req); ++} ++ ++static void mmci_start_data(struct mmci_host *host, struct mmc_data *data) ++{ ++ unsigned int datactrl; ++ ++ DBG("MMCI: data: blksz %04x blks %04x flags %08x\n", ++ 1 << data->blksz_bits, data->blocks, data->flags); ++ ++ datactrl = MCI_DPSM_ENABLE | data->blksz_bits << 4; ++ ++ if (data->flags & MMC_DATA_READ) ++ datactrl |= MCI_DPSM_DIRECTION; ++ ++ host->data = data; ++ host->buffer = data->rq->buffer; ++ host->size = data->blocks << data->blksz_bits; ++ host->data_xfered = 0; ++ ++ writel(0x800000, host->base + MMCIDATATIMER); ++ writel(host->size, host->base + MMCIDATALENGTH); ++ writel(datactrl, host->base + MMCIDATACTRL); ++} ++ ++static void ++mmci_start_command(struct mmci_host *host, struct mmc_command *cmd, u32 c) ++{ ++ DBG("MMCI: cmd: op %02x arg %08x flags %08x\n", ++ cmd->opcode, cmd->arg, cmd->flags); ++ ++ if (readl(host->base + MMCICOMMAND) & MCI_CPSM_ENABLE) { ++ writel(0, host->base + MMCICOMMAND); ++ udelay(1); ++ } ++ ++ c |= cmd->opcode | MCI_CPSM_ENABLE; ++ switch (cmd->flags & MMC_RSP_MASK) { ++ case MMC_RSP_NONE: ++ default: ++ break; ++ case MMC_RSP_LONG: ++ c |= MCI_CPSM_LONGRSP; ++ case MMC_RSP_SHORT: ++ c |= MCI_CPSM_RESPONSE; ++ break; ++ } ++ if (/*interrupt*/0) ++ c |= MCI_CPSM_INTERRUPT; ++ ++ host->cmd = cmd; ++ ++ writel(cmd->arg, host->base + MMCIARGUMENT); ++ writel(c, host->base + MMCICOMMAND); ++} ++ ++static void ++mmci_data_irq(struct mmci_host *host, struct mmc_data *data, ++ unsigned int status) ++{ ++ if (status & MCI_DATABLOCKEND) { ++ host->data_xfered += 1 << data->blksz_bits; ++ } ++ if (status & (MCI_DATACRCFAIL|MCI_DATATIMEOUT|MCI_TXUNDERRUN|MCI_RXOVERRUN)) { ++ if (status & MCI_DATACRCFAIL) ++ data->error = MMC_ERR_BADCRC; ++ else if (status & MCI_DATATIMEOUT) ++ data->error = MMC_ERR_TIMEOUT; ++ else if (status & (MCI_TXUNDERRUN|MCI_RXOVERRUN)) ++ data->error = MMC_ERR_FIFO; ++ status |= MCI_DATAEND; ++ } ++ if (status & MCI_DATAEND) { ++ host->data = NULL; ++ if (!data->stop) { ++ mmci_request_end(host, data->req); ++ } else /*if (readl(host->base + MMCIDATACNT) > 6)*/ { ++ mmci_start_command(host, data->stop, 0); ++ } ++ } ++} ++ ++static void ++mmci_cmd_irq(struct mmci_host *host, struct mmc_command *cmd, ++ unsigned int status) ++{ ++ host->cmd = NULL; ++ ++ cmd->resp[0] = readl(host->base + MMCIRESPONSE0); ++ cmd->resp[1] = readl(host->base + MMCIRESPONSE1); ++ cmd->resp[2] = readl(host->base + MMCIRESPONSE2); ++ cmd->resp[3] = readl(host->base + MMCIRESPONSE3); ++ ++ if (status & MCI_CMDTIMEOUT) { ++ cmd->error = MMC_ERR_TIMEOUT; ++ } else if (status & MCI_CMDCRCFAIL && cmd->flags & MMC_RSP_CRC) { ++ cmd->error = MMC_ERR_BADCRC; ++ } ++ ++ if (!cmd->data || cmd->error != MMC_ERR_NONE) { ++ mmci_request_end(host, cmd->req); ++ } else if (!(cmd->data->flags & MMC_DATA_READ)) { ++ mmci_start_data(host, cmd->data); ++ } ++} ++ ++static irqreturn_t mmci_irq(int irq, void *dev_id, struct pt_regs *regs) ++{ ++ struct mmci_host *host = dev_id; ++ u32 status; ++ int ret = 0; ++ ++ do { ++ struct mmc_command *cmd; ++ struct mmc_data *data; ++ ++ status = readl(host->base + MMCISTATUS); ++ writel(status, host->base + MMCICLEAR); ++ ++ if (!(status & MCI_IRQMASK)) ++ break; ++ ++ DBG("MMCI: irq %08x\n", status); ++ ++ if (status & (MCI_RXDATAAVLBL|MCI_RXFIFOHALFFULL)) { ++ int count = host->size - (readl(host->base + MMCIFIFOCNT) << 2); ++ if (count < 0) ++ count = 0; ++ if (count && host->buffer) { ++ readsl(host->base + MMCIFIFO, host->buffer, count >> 2); ++ host->buffer += count; ++ host->size -= count; ++ if (host->size == 0) ++ host->buffer = NULL; ++ } else { ++ static int first = 1; ++ if (first) { ++ first = 0; ++ printk(KERN_ERR "MMCI: sinking excessive data\n"); ++ } ++ readl(host->base + MMCIFIFO); ++ } ++ } ++ if (status & (MCI_TXFIFOEMPTY|MCI_TXFIFOHALFEMPTY)) { ++ int count = host->size; ++ if (count > MCI_FIFOHALFSIZE) ++ count = MCI_FIFOHALFSIZE; ++ if (count && host->buffer) { ++ writesl(host->base + MMCIFIFO, host->buffer, count >> 2); ++ host->buffer += count; ++ host->size -= count; ++ if (host->size == 0) ++ host->buffer = NULL; ++ } else { ++ static int first = 1; ++ if (first) { ++ first = 0; ++ printk(KERN_ERR "MMCI: ran out of source data\n"); ++ } ++ } ++ } ++ ++ data = host->data; ++ if (status & (MCI_DATACRCFAIL|MCI_DATATIMEOUT|MCI_TXUNDERRUN| ++ MCI_RXOVERRUN|MCI_DATAEND|MCI_DATABLOCKEND)) ++ mmci_data_irq(host, data, status); ++ ++ cmd = host->cmd; ++ if (status & (MCI_CMDCRCFAIL|MCI_CMDTIMEOUT|MCI_CMDSENT|MCI_CMDRESPEND) && cmd) ++ mmci_cmd_irq(host, cmd, status); ++ ++ ret = 1; ++ } while (status); ++ ++ return IRQ_RETVAL(ret); ++} ++ ++static void mmci_request(struct mmc_host *mmc, struct mmc_request *req) ++{ ++ struct mmci_host *host = to_mmci_host(mmc); ++ ++ WARN_ON(host->req != NULL); ++ ++ host->req = req; ++ ++ if (req->data && req->data->flags & MMC_DATA_READ) ++ mmci_start_data(host, req->data); ++ ++ mmci_start_command(host, req->cmd, 0); ++} ++ ++static void mmci_set_ios(struct mmc_host *mmc, struct mmc_ios *ios) ++{ ++ struct mmci_host *host = to_mmci_host(mmc); ++ u32 clk = 0, pwr = 0; ++ ++ DBG("MMCI: set_ios: clock %dHz busmode %d powermode %d Vdd %d.%02d\n", ++ ios->clock, ios->bus_mode, ios->power_mode, ++ ios->vdd / 100, ios->vdd % 100); ++ ++ if (ios->clock) { ++ clk = host->mclk / (2 * ios->clock) - 1; ++ if (clk > 256) ++ clk = 255; ++ clk |= MCI_CLK_ENABLE; ++ } ++ ++ switch (ios->power_mode) { ++ case MMC_POWER_OFF: ++ break; ++ case MMC_POWER_UP: ++ pwr |= MCI_PWR_UP; ++ break; ++ case MMC_POWER_ON: ++ pwr |= MCI_PWR_ON; ++ break; ++ } ++ ++ if (ios->bus_mode == MMC_BUSMODE_OPENDRAIN) ++ pwr |= MCI_ROD; ++ ++ writel(clk, host->base + MMCICLOCK); ++ ++ if (host->pwr != pwr) { ++ host->pwr = pwr; ++ writel(pwr, host->base + MMCIPOWER); ++ } ++} ++ ++static struct mmc_host_ops mmci_ops = { ++ .request = mmci_request, ++ .set_ios = mmci_set_ios, ++}; ++ ++static int mmci_probe(struct amba_device *dev, void *id) ++{ ++ struct mmci_host *host; ++ int ret; ++// void *tmp; ++ ++ /* enable the interrupt via the VIC */ ++// tmp = ioremap(0xc3000000, SZ_4K); ++// if (tmp) { ++// u32 val = readl(tmp + 0x10); ++// writel(val | 0x180, tmp + 0x10); ++// iounmap(tmp); ++// } ++ ++ if (!request_mem_region(dev->res.start, SZ_4K, DRIVER_NAME)) ++ return -EBUSY; ++ ++ host = kmalloc(sizeof(struct mmci_host), GFP_KERNEL); ++ if (!host) { ++ ret = -ENOMEM; ++ goto out; ++ } ++ ++ memset(host, 0, sizeof(struct mmci_host)); ++ ++ ret = mmc_init_host(&host->mmc); ++ if (ret) ++ goto out; ++ ++ host->base = ioremap(dev->res.start, SZ_4K); ++ if (!host->base) { ++ ret = -ENOMEM; ++ goto out; ++ } ++ ++ host->irq = dev->irq; ++ host->mclk = 33000000; /* impd1 */ ++ host->mmc.dev = &dev->dev; ++ host->mmc.ops = &mmci_ops; ++ host->mmc.f_min = (host->mclk + 511) / 512; ++ host->mmc.f_max = host->mclk / 2; ++ if (host->mmc.f_max > fmax) ++ host->mmc.f_max = fmax; ++ ++ host->mmc.ocr_avail = MMC_VDD_35_36; ++ ++ writel(0, host->base + MMCIMASK0); ++ writel(0, host->base + MMCIMASK1); ++ writel(0xfff, host->base + MMCICLEAR); ++ ++ ret = request_irq(host->irq, mmci_irq, SA_SHIRQ, DRIVER_NAME, host); ++ if (ret) ++ goto out; ++ ++ writel(MCI_IRQENABLE, host->base + MMCIMASK0); ++ ++ amba_set_drvdata(dev, host); ++ ++ mmc_add_host(&host->mmc); ++ ++ return 0; ++ ++ out: ++ if (host) { ++ if (host->base) ++ iounmap(host->base); ++ kfree(host); ++ } ++ release_mem_region(dev->res.start, SZ_4K); ++ return ret; ++} ++ ++static int mmci_remove(struct amba_device *dev) ++{ ++ struct mmci_host *host = amba_get_drvdata(dev); ++ ++ amba_set_drvdata(dev, NULL); ++ ++ if (host) { ++ mmc_remove_host(&host->mmc); ++ ++ writel(0, host->base + MMCIMASK0); ++ writel(0, host->base + MMCIMASK1); ++ ++ writel(0, host->base + MMCICOMMAND); ++ writel(0, host->base + MMCIDATACTRL); ++ ++ free_irq(host->irq, host); ++ ++ iounmap(host->base); ++ ++ kfree(host); ++ ++ release_mem_region(dev->res.start, SZ_4K); ++ } ++ ++ return 0; ++} ++ ++#ifdef CONFIG_PM ++static int mmci_suspend(struct amba_device *dev, u32 state) ++{ ++ struct mmci_host *host = amba_get_drvdata(dev); ++ ++ return host ? mmc_suspend_host(&host->mmc, state) : 0; ++} ++ ++static int mmci_resume(struct amba_device *dev) ++{ ++ struct mmci_host *host = amba_get_drvdata(dev); ++ int ret = 0; ++ ++ if (host) { ++ writel(MCI_IRQENABLE, host->base + MMCIMASK0); ++ ret = mmc_resume_host(&host->mmc); ++ } ++ ++ return ret; ++} ++#else ++#define mmci_suspend NULL ++#define mmci_resume NULL ++#endif ++ ++static struct amba_id mmci_ids[] = { ++ { ++ .id = 0x00041180, ++ .mask = 0x000fffff, ++ }, ++ { ++ .id = 0x00041181, ++ .mask = 0x000fffff, ++ }, ++ { 0, 0 }, ++}; ++ ++static struct amba_driver mmci_driver = { ++ .drv = { ++ .name = DRIVER_NAME, ++ }, ++ .probe = mmci_probe, ++ .remove = mmci_remove, ++ .suspend = mmci_suspend, ++ .resume = mmci_resume, ++ .id_table = mmci_ids, ++}; ++ ++static int __init mmci_init(void) ++{ ++ return amba_driver_register(&mmci_driver); ++} ++ ++static void __exit mmci_exit(void) ++{ ++ amba_driver_unregister(&mmci_driver); ++} ++ ++module_init(mmci_init); ++module_exit(mmci_exit); ++module_param(fmax, int, 0444); ++ ++MODULE_DESCRIPTION("ARM PrimeCell PL180/181 Multimedia Card Interface driver"); ++MODULE_LICENSE("GPL"); +--- /dev/null 2003-09-23 18:19:32.000000000 -0400 ++++ linux-2.6.5/drivers/media/mmc/mmc_queue.h 2004-04-30 20:57:36.000000000 -0400 +@@ -0,0 +1,29 @@ ++#ifndef MMC_QUEUE_H ++#define MMC_QUEUE_H ++ ++struct request; ++struct task_struct; ++ ++struct mmc_queue { ++ struct mmc_card *card; ++ struct completion thread_complete; ++ wait_queue_head_t thread_wq; ++ struct task_struct *thread; ++ struct request *req; ++ int (*prep_fn)(struct mmc_queue *, struct request *); ++ int (*issue_fn)(struct mmc_queue *, struct request *); ++ void *data; ++ struct request_queue *queue; ++}; ++ ++struct mmc_io_request { ++ struct request *rq; ++ int num; ++ struct mmc_command selcmd; /* mmc_queue private */ ++ struct mmc_command cmd[4]; /* max 4 commands */ ++}; ++ ++extern int mmc_init_queue(struct mmc_queue *, struct mmc_card *, spinlock_t *); ++extern void mmc_cleanup_queue(struct mmc_queue *); ++ ++#endif +--- /dev/null 2003-09-23 18:19:32.000000000 -0400 ++++ linux-2.6.5/drivers/media/mmc/mmc_block.c 2004-04-30 20:57:36.000000000 -0400 +@@ -0,0 +1,482 @@ ++/* ++ * Block driver for media (i.e., flash cards) ++ * ++ * Copyright 2002 Hewlett-Packard Company ++ * ++ * Use consistent with the GNU GPL is permitted, ++ * provided that this copyright notice is ++ * preserved in its entirety in all copies and derived works. ++ * ++ * HEWLETT-PACKARD COMPANY MAKES NO WARRANTIES, EXPRESSED OR IMPLIED, ++ * AS TO THE USEFULNESS OR CORRECTNESS OF THIS CODE OR ITS ++ * FITNESS FOR ANY PARTICULAR PURPOSE. ++ * ++ * Many thanks to Alessandro Rubini and Jonathan Corbet! ++ * ++ * Author: Andrew Christian ++ * 28 May 2002 ++ */ ++#include <linux/moduleparam.h> ++#include <linux/module.h> ++#include <linux/init.h> ++ ++#include <linux/sched.h> ++#include <linux/kernel.h> /* printk() */ ++#include <linux/fs.h> /* everything... */ ++#include <linux/errno.h> /* error codes */ ++#include <linux/hdreg.h> /* HDIO_GETGEO */ ++#include <linux/kdev_t.h> ++#include <linux/blkdev.h> ++#include <linux/devfs_fs_kernel.h> ++ ++#include <linux/mmc/card.h> ++#include <linux/mmc/protocol.h> ++ ++#include <asm/system.h> ++#include <asm/uaccess.h> ++ ++#include "mmc_queue.h" ++ ++#define MMC_SHIFT 3 /* max 8 partitions per card */ ++ ++static int mmc_major; ++static int maxsectors = 8; ++ ++/* ++ * There is one mmc_blk_data per slot. ++ */ ++struct mmc_blk_data { ++ spinlock_t lock; ++ struct gendisk *disk; ++ struct mmc_queue queue; ++ ++ unsigned int usage; ++ unsigned int block_bits; ++ unsigned int suspended; ++}; ++ ++static DECLARE_MUTEX(open_lock); ++ ++static struct mmc_blk_data *mmc_blk_get(struct gendisk *disk) ++{ ++ struct mmc_blk_data *md; ++ ++ down(&open_lock); ++ md = disk->private_data; ++ if (md && md->usage == 0) ++ md = NULL; ++ if (md) ++ md->usage++; ++ up(&open_lock); ++ ++ return md; ++} ++ ++static void mmc_blk_put(struct mmc_blk_data *md) ++{ ++ down(&open_lock); ++ md->usage--; ++ if (md->usage == 0) { ++ put_disk(md->disk); ++ mmc_cleanup_queue(&md->queue); ++ kfree(md); ++ } ++ up(&open_lock); ++} ++ ++static int mmc_blk_open(struct inode *inode, struct file *filp) ++{ ++ struct mmc_blk_data *md; ++ int ret = -ENXIO; ++ ++ md = mmc_blk_get(inode->i_bdev->bd_disk); ++ if (md) { ++ if (md->usage == 2) ++ check_disk_change(inode->i_bdev); ++ ret = 0; ++ } ++ ++ return ret; ++} ++ ++static int mmc_blk_release(struct inode *inode, struct file *filp) ++{ ++ struct mmc_blk_data *md = inode->i_bdev->bd_disk->private_data; ++ ++ mmc_blk_put(md); ++ return 0; ++} ++ ++static int ++mmc_blk_ioctl(struct inode *inode, struct file *filp, unsigned int cmd, unsigned long arg) ++{ ++ struct block_device *bdev = inode->i_bdev; ++ ++ if (cmd == HDIO_GETGEO) { ++ struct hd_geometry geo; ++ ++ memset(&geo, 0, sizeof(struct hd_geometry)); ++ ++ geo.cylinders = get_capacity(bdev->bd_disk) / (4 * 16); ++ geo.heads = 4; ++ geo.sectors = 16; ++ geo.start = get_start_sect(bdev); ++ ++ return copy_to_user((void *)arg, &geo, sizeof(geo)) ++ ? -EFAULT : 0; ++ } ++ ++ return -ENOTTY; ++} ++ ++static struct block_device_operations mmc_bdops = { ++ .open = mmc_blk_open, ++ .release = mmc_blk_release, ++ .ioctl = mmc_blk_ioctl, ++ .owner = THIS_MODULE, ++}; ++ ++struct mmc_blk_request { ++ struct mmc_request req; ++ struct mmc_command cmd; ++ struct mmc_command stop; ++ struct mmc_data data; ++}; ++ ++static int mmc_blk_prep_rq(struct mmc_queue *mq, struct request *req) ++{ ++ struct mmc_blk_data *md = mq->data; ++ ++ /* ++ * If we have no device, we haven't finished initialising. ++ */ ++ if (!md || !mq->card) { ++ printk("killing request - no device/host\n"); ++ goto kill; ++ } ++ ++ if (md->suspended) { ++ blk_plug_device(md->queue.queue); ++ goto defer; ++ } ++ ++ /* ++ * Check for excessive requests. ++ */ ++ if (req->sector + req->nr_sectors > get_capacity(req->rq_disk)) { ++ printk("bad request size\n"); ++ goto kill; ++ } ++ ++ return BLKPREP_OK; ++ ++ defer: ++ return BLKPREP_DEFER; ++ kill: ++ return BLKPREP_KILL; ++} ++ ++static int mmc_blk_issue_rq(struct mmc_queue *mq, struct request *req) ++{ ++ struct mmc_blk_data *md = mq->data; ++ struct mmc_card *card = md->queue.card; ++ int err, sz = 0; ++ ++ err = mmc_card_claim_host(card); ++ if (err) ++ goto cmd_err; ++ ++ do { ++ struct mmc_blk_request rq; ++ struct mmc_command cmd; ++ ++ memset(&rq, 0, sizeof(struct mmc_blk_request)); ++ rq.req.cmd = &rq.cmd; ++ rq.req.data = &rq.data; ++ ++ rq.cmd.arg = req->sector << 9; ++ rq.cmd.flags = MMC_RSP_SHORT | MMC_RSP_CRC; ++ rq.data.rq = req; ++ rq.data.timeout_ns = card->csd.tacc_ns * 10; ++ rq.data.timeout_clks = card->csd.tacc_clks * 10; ++ rq.data.blksz_bits = md->block_bits; ++ rq.data.blocks = req->current_nr_sectors >> (md->block_bits - 9); ++ rq.stop.opcode = MMC_STOP_TRANSMISSION; ++ rq.stop.arg = 0; ++ rq.stop.flags = MMC_RSP_SHORT | MMC_RSP_CRC | MMC_RSP_BUSY; ++ ++ if (rq_data_dir(req) == READ) { ++ rq.cmd.opcode = rq.data.blocks > 1 ? MMC_READ_MULTIPLE_BLOCK : MMC_READ_SINGLE_BLOCK; ++ rq.data.flags |= MMC_DATA_READ; ++ } else { ++ rq.cmd.opcode = MMC_WRITE_BLOCK; ++ rq.cmd.flags |= MMC_RSP_BUSY; ++ rq.data.flags |= MMC_DATA_WRITE; ++ rq.data.blocks = 1; ++ } ++ rq.req.stop = rq.data.blocks > 1 ? &rq.stop : NULL; ++ ++ mmc_wait_for_req(card->host, &rq.req); ++ if (rq.cmd.error) { ++ err = rq.cmd.error; ++ printk("error %d sending read/write command\n", err); ++ goto cmd_err; ++ } ++ ++ if (rq_data_dir(req) == READ) { ++ sz = rq.data.bytes_xfered; ++ } else { ++ sz = 0; ++ } ++ ++ if (rq.data.error) { ++ err = rq.data.error; ++ printk("error %d transferring data\n", err); ++ goto cmd_err; ++ } ++ ++ if (rq.stop.error) { ++ err = rq.stop.error; ++ printk("error %d sending stop command\n", err); ++ goto cmd_err; ++ } ++ ++ do { ++ cmd.opcode = MMC_SEND_STATUS; ++ cmd.arg = card->rca << 16; ++ cmd.flags = MMC_RSP_SHORT | MMC_RSP_CRC; ++ err = mmc_wait_for_cmd(card->host, &cmd, 5); ++ if (err) { ++ printk("error %d requesting status\n", err); ++ goto cmd_err; ++ } ++ } while (!(cmd.resp[0] & R1_READY_FOR_DATA)); ++ ++#if 0 ++ if (cmd.resp[0] & ~0x00000900) ++ printk("status = %08x\n", cmd.resp[0]); ++ err = mmc_decode_status(cmd.resp); ++ if (err) ++ goto cmd_err; ++#endif ++ ++ sz = rq.data.bytes_xfered; ++ } while (end_that_request_chunk(req, 1, sz)); ++ ++ mmc_card_release_host(card); ++ ++ return 1; ++ ++ cmd_err: ++ mmc_card_release_host(card); ++ ++ end_that_request_chunk(req, 1, sz); ++ req->errors = err; ++ ++ return 0; ++} ++ ++#define MMC_NUM_MINORS (256 >> MMC_SHIFT) ++ ++static unsigned long dev_use[MMC_NUM_MINORS/(8*sizeof(unsigned long))]; ++ ++static struct mmc_blk_data *mmc_blk_alloc(struct mmc_card *card) ++{ ++ struct mmc_blk_data *md; ++ int devidx; ++ ++ devidx = find_first_zero_bit(dev_use, MMC_NUM_MINORS); ++ if (devidx >= MMC_NUM_MINORS) ++ return NULL; ++ __set_bit(devidx, dev_use); ++ ++ md = kmalloc(sizeof(struct mmc_blk_data), GFP_KERNEL); ++ if (md) { ++ memset(md, 0, sizeof(struct mmc_blk_data)); ++ ++ md->disk = alloc_disk(1 << MMC_SHIFT); ++ if (md->disk == NULL) { ++ kfree(md); ++ md = NULL; ++ goto out; ++ } ++ ++ spin_lock_init(&md->lock); ++ md->usage = 1; ++ ++ mmc_init_queue(&md->queue, card, &md->lock); ++ md->queue.prep_fn = mmc_blk_prep_rq; ++ md->queue.issue_fn = mmc_blk_issue_rq; ++ md->queue.data = md; ++ ++ md->disk->major = mmc_major; ++ md->disk->first_minor = devidx << MMC_SHIFT; ++ md->disk->fops = &mmc_bdops; ++ md->disk->private_data = md; ++ md->disk->queue = md->queue.queue; ++ md->disk->driverfs_dev = &card->dev; ++ ++ sprintf(md->disk->disk_name, "mmcblk%d", devidx); ++ sprintf(md->disk->devfs_name, "mmc/blk%d", devidx); ++ ++ md->block_bits = md->queue.card->csd.read_blkbits; ++ ++ blk_queue_max_sectors(md->queue.queue, maxsectors); ++ blk_queue_hardsect_size(md->queue.queue, 1 << md->block_bits); ++ set_capacity(md->disk, md->queue.card->csd.capacity); ++ } ++ out: ++ return md; ++} ++ ++static int ++mmc_blk_set_blksize(struct mmc_blk_data *md, struct mmc_card *card) ++{ ++ struct mmc_command cmd; ++ int err; ++ ++ mmc_card_claim_host(card); ++ cmd.opcode = MMC_SET_BLOCKLEN; ++ cmd.arg = 1 << card->csd.read_blkbits; ++ cmd.flags = MMC_RSP_SHORT | MMC_RSP_CRC; ++ err = mmc_wait_for_cmd(card->host, &cmd, 5); ++ mmc_card_release_host(card); ++ ++ if (err) { ++ printk(KERN_ERR "%s: unable to set block size to %d: %d\n", ++ md->disk->disk_name, cmd.arg, err); ++ return -EINVAL; ++ } ++ ++ return 0; ++} ++ ++static int mmc_blk_probe(struct mmc_card *card) ++{ ++ struct mmc_blk_data *md; ++ int err; ++ ++ if (card->csd.cmdclass & ~0x1ff) ++ return -ENODEV; ++ ++ if (card->csd.read_blkbits < 9) { ++ printk(KERN_WARNING "%s: read blocksize too small (%u)\n", ++ mmc_card_id(card), 1 << card->csd.read_blkbits); ++ return -ENODEV; ++ } ++ ++ md = mmc_blk_alloc(card); ++ if (md == NULL) ++ return -ENOMEM; ++ ++ err = mmc_blk_set_blksize(md, card); ++ if (err) ++ goto out; ++ ++ printk(KERN_INFO "%s: %s %s %dKiB\n", ++ md->disk->disk_name, mmc_card_id(card), mmc_card_name(card), ++ (card->csd.capacity << card->csd.read_blkbits) / 1024); ++ ++ mmc_set_drvdata(card, md); ++ add_disk(md->disk); ++ return 0; ++ ++ out: ++ mmc_blk_put(md); ++ ++ return err; ++} ++ ++static void mmc_blk_remove(struct mmc_card *card) ++{ ++ struct mmc_blk_data *md = mmc_get_drvdata(card); ++ ++ if (md) { ++ int devidx; ++ ++ del_gendisk(md->disk); ++ ++ /* ++ * I think this is needed. ++ */ ++ md->disk->queue = NULL; ++ ++ devidx = md->disk->first_minor >> MMC_SHIFT; ++ __clear_bit(devidx, dev_use); ++ ++ mmc_blk_put(md); ++ } ++ mmc_set_drvdata(card, NULL); ++} ++ ++#ifdef CONFIG_PM ++static int mmc_blk_suspend(struct mmc_card *card, u32 state) ++{ ++ struct mmc_blk_data *md = mmc_get_drvdata(card); ++ ++ if (md) { ++ blk_stop_queue(md->queue.queue); ++ } ++ return 0; ++} ++ ++static int mmc_blk_resume(struct mmc_card *card) ++{ ++ struct mmc_blk_data *md = mmc_get_drvdata(card); ++ ++ if (md) { ++ mmc_blk_set_blksize(md, md->queue.card); ++ blk_start_queue(md->queue.queue); ++ } ++ return 0; ++} ++#else ++#define mmc_blk_suspend NULL ++#define mmc_blk_resume NULL ++#endif ++ ++static struct mmc_driver mmc_driver = { ++ .drv = { ++ .name = "mmcblk", ++ }, ++ .probe = mmc_blk_probe, ++ .remove = mmc_blk_remove, ++ .suspend = mmc_blk_suspend, ++ .resume = mmc_blk_resume, ++}; ++ ++static int __init mmc_blk_init(void) ++{ ++ int res = -ENOMEM; ++ ++ res = register_blkdev(mmc_major, "mmc"); ++ if (res < 0) { ++ printk(KERN_WARNING "Unable to get major %d for MMC media: %d\n", ++ mmc_major, res); ++ goto out; ++ } ++ if (mmc_major == 0) ++ mmc_major = res; ++ ++ devfs_mk_dir("mmc"); ++ return mmc_register_driver(&mmc_driver); ++ ++ out: ++ return res; ++} ++ ++static void __exit mmc_blk_exit(void) ++{ ++ mmc_unregister_driver(&mmc_driver); ++ devfs_remove("mmc"); ++ unregister_blkdev(mmc_major, "mmc"); ++} ++ ++module_init(mmc_blk_init); ++module_exit(mmc_blk_exit); ++module_param(maxsectors, int, 0444); ++ ++MODULE_PARM_DESC(maxsectors, "Maximum number of sectors for a single request"); ++ ++MODULE_LICENSE("GPL"); ++MODULE_DESCRIPTION("Multimedia Card (MMC) block device driver"); +--- /dev/null 2003-09-23 18:19:32.000000000 -0400 ++++ linux-2.6.5/drivers/media/mmc/pxamci.h 2004-04-30 20:57:36.000000000 -0400 +@@ -0,0 +1,94 @@ ++#undef MMC_STRPCL ++#undef MMC_STAT ++#undef MMC_CLKRT ++#undef MMC_SPI ++#undef MMC_CMDAT ++#undef MMC_RESTO ++#undef MMC_RDTO ++#undef MMC_BLKLEN ++#undef MMC_NOB ++#undef MMC_PRTBUF ++#undef MMC_I_MASK ++#undef END_CMD_RES ++#undef PRG_DONE ++#undef DATA_TRAN_DONE ++#undef MMC_I_REG ++#undef MMC_CMD ++#undef MMC_ARGH ++#undef MMC_ARGL ++#undef MMC_RES ++#undef MMC_RXFIFO ++#undef MMC_TXFIFO ++ ++#define MMC_STRPCL 0x0000 ++#define STOP_CLOCK (1 << 0) ++#define START_CLOCK (2 << 0) ++ ++#define MMC_STAT 0x0004 ++#define STAT_END_CMD_RES (1 << 13) ++#define STAT_PRG_DONE (1 << 12) ++#define STAT_DATA_TRAN_DONE (1 << 11) ++#define STAT_CLK_EN (1 << 8) ++#define STAT_RECV_FIFO_FULL (1 << 7) ++#define STAT_XMIT_FIFO_EMPTY (1 << 6) ++#define STAT_RES_CRC_ERR (1 << 5) ++#define STAT_SPI_READ_ERROR_TOKEN (1 << 4) ++#define STAT_CRC_READ_ERROR (1 << 3) ++#define STAT_CRC_WRITE_ERROR (1 << 2) ++#define STAT_TIME_OUT_RESPONSE (1 << 1) ++#define STAT_READ_TIME_OUT (1 << 0) ++ ++#define MMC_CLKRT 0x0008 /* 3 bit */ ++ ++#define MMC_SPI 0x000c ++#define SPI_CS_ADDRESS (1 << 3) ++#define SPI_CS_EN (1 << 2) ++#define CRC_ON (1 << 1) ++#define SPI_EN (1 << 0) ++ ++#define MMC_CMDAT 0x0010 ++#define CMDAT_DMAEN (1 << 7) ++#define CMDAT_INIT (1 << 6) ++#define CMDAT_BUSY (1 << 5) ++#define CMDAT_STREAM (1 << 4) /* 1 = stream */ ++#define CMDAT_WRITE (1 << 3) /* 1 = write */ ++#define CMDAT_DATAEN (1 << 2) ++#define CMDAT_RESP_NONE (0 << 0) ++#define CMDAT_RESP_SHORT (1 << 0) ++#define CMDAT_RESP_R2 (2 << 0) ++#define CMDAT_RESP_R3 (3 << 0) ++ ++#define MMC_RESTO 0x0014 /* 7 bit */ ++ ++#define MMC_RDTO 0x0018 /* 16 bit */ ++ ++#define MMC_BLKLEN 0x001c /* 10 bit */ ++ ++#define MMC_NOB 0x0020 /* 16 bit */ ++ ++#define MMC_PRTBUF 0x0024 ++#define BUF_PART_FULL (1 << 0) ++ ++#define MMC_I_MASK 0x0028 ++#define TXFIFO_WR_REQ (1 << 6) ++#define RXFIFO_RD_REQ (1 << 5) ++#define CLK_IS_OFF (1 << 4) ++#define STOP_CMD (1 << 3) ++#define END_CMD_RES (1 << 2) ++#define PRG_DONE (1 << 1) ++#define DATA_TRAN_DONE (1 << 0) ++ ++#define MMC_I_REG 0x002c ++/* same as MMC_I_MASK */ ++ ++#define MMC_CMD 0x0030 ++ ++#define MMC_ARGH 0x0034 /* 16 bit */ ++ ++#define MMC_ARGL 0x0038 /* 16 bit */ ++ ++#define MMC_RES 0x003c /* 16 bit */ ++ ++#define MMC_RXFIFO 0x0040 /* 8 bit */ ++ ++#define MMC_TXFIFO 0x0044 /* 8 bit */ +--- /dev/null 2003-09-23 18:19:32.000000000 -0400 ++++ linux-2.6.5/drivers/media/mmc/mmci.h 2004-04-30 20:57:36.000000000 -0400 +@@ -0,0 +1,147 @@ ++/* ++ * linux/drivers/media/mmc/mmci.h - ARM PrimeCell MMCI PL180/1 driver ++ * ++ * Copyright (C) 2003 Deep Blue Solutions, Ltd, All Rights Reserved. ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License version 2 as ++ * published by the Free Software Foundation. ++ */ ++#define MMCIPOWER 0x000 ++#define MCI_PWR_OFF 0x00 ++#define MCI_PWR_UP 0x02 ++#define MCI_PWR_ON 0x03 ++#define MCI_OD (1 << 6) ++#define MCI_ROD (1 << 7) ++ ++#define MMCICLOCK 0x004 ++#define MCI_CLK_ENABLE (1 << 8) ++#define MCI_PWRSAVE (1 << 9) ++#define MCI_BYPASS (1 << 10) ++ ++#define MMCIARGUMENT 0x008 ++#define MMCICOMMAND 0x00c ++#define MCI_CPSM_RESPONSE (1 << 6) ++#define MCI_CPSM_LONGRSP (1 << 7) ++#define MCI_CPSM_INTERRUPT (1 << 8) ++#define MCI_CPSM_PENDING (1 << 9) ++#define MCI_CPSM_ENABLE (1 << 10) ++ ++#define MMCIRESPCMD 0x010 ++#define MMCIRESPONSE0 0x014 ++#define MMCIRESPONSE1 0x018 ++#define MMCIRESPONSE2 0x01c ++#define MMCIRESPONSE3 0x020 ++#define MMCIDATATIMER 0x024 ++#define MMCIDATALENGTH 0x028 ++#define MMCIDATACTRL 0x02c ++#define MCI_DPSM_ENABLE (1 << 0) ++#define MCI_DPSM_DIRECTION (1 << 1) ++#define MCI_DPSM_MODE (1 << 2) ++#define MCI_DPSM_DMAENABLE (1 << 3) ++ ++#define MMCIDATACNT 0x030 ++#define MMCISTATUS 0x034 ++#define MCI_CMDCRCFAIL (1 << 0) ++#define MCI_DATACRCFAIL (1 << 1) ++#define MCI_CMDTIMEOUT (1 << 2) ++#define MCI_DATATIMEOUT (1 << 3) ++#define MCI_TXUNDERRUN (1 << 4) ++#define MCI_RXOVERRUN (1 << 5) ++#define MCI_CMDRESPEND (1 << 6) ++#define MCI_CMDSENT (1 << 7) ++#define MCI_DATAEND (1 << 8) ++#define MCI_DATABLOCKEND (1 << 10) ++#define MCI_CMDACTIVE (1 << 11) ++#define MCI_TXACTIVE (1 << 12) ++#define MCI_RXACTIVE (1 << 13) ++#define MCI_TXFIFOHALFEMPTY (1 << 14) ++#define MCI_RXFIFOHALFFULL (1 << 15) ++#define MCI_TXFIFOFULL (1 << 16) ++#define MCI_RXFIFOFULL (1 << 17) ++#define MCI_TXFIFOEMPTY (1 << 18) ++#define MCI_RXFIFOEMPTY (1 << 19) ++#define MCI_TXDATAAVLBL (1 << 20) ++#define MCI_RXDATAAVLBL (1 << 21) ++ ++#define MMCICLEAR 0x038 ++#define MCI_CMDCRCFAILCLR (1 << 0) ++#define MCI_DATACRCFAILCLR (1 << 1) ++#define MCI_CMDTIMEOUTCLR (1 << 2) ++#define MCI_DATATIMEOUTCLR (1 << 3) ++#define MCI_TXUNDERRUNCLR (1 << 4) ++#define MCI_RXOVERRUNCLR (1 << 5) ++#define MCI_CMDRESPENDCLR (1 << 6) ++#define MCI_CMDSENTCLR (1 << 7) ++#define MCI_DATAENDCLR (1 << 8) ++#define MCI_DATABLOCKENDCLR (1 << 10) ++ ++#define MMCIMASK0 0x03c ++#define MCI_CMDCRCFAILMASK (1 << 0) ++#define MCI_DATACRCFAILMASK (1 << 1) ++#define MCI_CMDTIMEOUTMASK (1 << 2) ++#define MCI_DATATIMEOUTMASK (1 << 3) ++#define MCI_TXUNDERRUNMASK (1 << 4) ++#define MCI_RXOVERRUNMASK (1 << 5) ++#define MCI_CMDRESPENDMASK (1 << 6) ++#define MCI_CMDSENTMASK (1 << 7) ++#define MCI_DATAENDMASK (1 << 8) ++#define MCI_DATABLOCKENDMASK (1 << 10) ++#define MCI_CMDACTIVEMASK (1 << 11) ++#define MCI_TXACTIVEMASK (1 << 12) ++#define MCI_RXACTIVEMASK (1 << 13) ++#define MCI_TXFIFOHALFEMPTYMASK (1 << 14) ++#define MCI_RXFIFOHALFFULLMASK (1 << 15) ++#define MCI_TXFIFOFULLMASK (1 << 16) ++#define MCI_RXFIFOFULLMASK (1 << 17) ++#define MCI_TXFIFOEMPTYMASK (1 << 18) ++#define MCI_RXFIFOEMPTYMASK (1 << 19) ++#define MCI_TXDATAAVLBLMASK (1 << 20) ++#define MCI_RXDATAAVLBLMASK (1 << 21) ++ ++#define MMCIMASK1 0x040 ++#define MMCIFIFOCNT 0x048 ++#define MMCIFIFO 0x080 /* to 0x0bc */ ++ ++#define MCI_IRQMASK \ ++ (MCI_CMDCRCFAIL|MCI_DATACRCFAIL|MCI_CMDTIMEOUT|MCI_DATATIMEOUT| \ ++ MCI_TXUNDERRUN|MCI_RXOVERRUN|MCI_CMDRESPEND|MCI_CMDSENT| \ ++ MCI_DATAEND|MCI_DATABLOCKEND| \ ++ MCI_TXFIFOHALFEMPTY|MCI_RXFIFOHALFFULL| \ ++ MCI_TXFIFOEMPTY|MCI_RXDATAAVLBL) ++ ++#define MCI_IRQENABLE \ ++ (MCI_CMDCRCFAILMASK|MCI_DATACRCFAILMASK|MCI_CMDTIMEOUTMASK| \ ++ MCI_DATATIMEOUTMASK|MCI_TXUNDERRUNMASK|MCI_RXOVERRUNMASK| \ ++ MCI_CMDRESPENDMASK|MCI_CMDSENTMASK|MCI_DATAENDMASK| \ ++ MCI_DATABLOCKENDMASK|MCI_TXFIFOHALFEMPTYMASK| \ ++ MCI_RXFIFOHALFFULLMASK) ++ ++#define MCI_FIFOSIZE 16 ++ ++#define MCI_FIFOHALFSIZE (MCI_FIFOSIZE / 2) ++ ++struct mmci_host { ++ struct mmc_host mmc; ++ void *base; ++ int irq; ++ unsigned int mclk; ++ u32 pwr; ++ ++ struct mmc_request *req; ++ struct mmc_command *cmd; ++ struct mmc_data *data; ++ ++ unsigned int data_xfered; ++ ++ /* pio stuff */ ++ void *buffer; ++ unsigned int size; ++ ++ /* dma stuff */ ++// struct scatterlist *sg_list; ++// int sg_len; ++// int sg_dir; ++}; ++ ++#define to_mmci_host(mmc) container_of(mmc, struct mmci_host, mmc) +--- /dev/null 2003-09-23 18:19:32.000000000 -0400 ++++ linux-2.6.5/drivers/media/mmc/mmc.c 2004-04-30 20:57:36.000000000 -0400 +@@ -0,0 +1,801 @@ ++/* ++ * linux/drivers/media/mmc/mmc.c ++ * ++ * Copyright (C) 2003 Russell King, All Rights Reserved. ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License version 2 as ++ * published by the Free Software Foundation. ++ */ ++#include <linux/config.h> ++#include <linux/module.h> ++#include <linux/init.h> ++#include <linux/interrupt.h> ++#include <linux/completion.h> ++#include <linux/device.h> ++#include <linux/delay.h> ++#include <linux/err.h> ++ ++#include <linux/mmc/card.h> ++#include <linux/mmc/host.h> ++#include <linux/mmc/protocol.h> ++ ++#include "mmc.h" ++ ++#ifdef CONFIG_MMC_DEBUG ++#define DBG(x...) printk(KERN_DEBUG x) ++#else ++#define DBG(x...) do { } while (0) ++#endif ++ ++#define CMD_RETRIES 3 ++ ++/* ++ * OCR Bit positions to 10s of Vdd mV. ++ */ ++static const unsigned short mmc_ocr_bit_to_vdd[] = { ++ 150, 155, 160, 165, 170, 180, 190, 200, ++ 210, 220, 230, 240, 250, 260, 270, 280, ++ 290, 300, 310, 320, 330, 340, 350, 360 ++}; ++ ++static const unsigned int tran_exp[] = { ++ 10000, 100000, 1000000, 10000000, ++ 0, 0, 0, 0 ++}; ++ ++static const unsigned char tran_mant[] = { ++ 0, 10, 12, 13, 15, 20, 25, 30, ++ 35, 40, 45, 50, 55, 60, 70, 80, ++}; ++ ++static const unsigned int tacc_exp[] = { ++ 1, 10, 100, 1000, 10000, 100000, 1000000, 10000000, ++}; ++ ++static const unsigned int tacc_mant[] = { ++ 0, 10, 12, 13, 15, 20, 25, 30, ++ 35, 40, 45, 50, 55, 60, 70, 80, ++}; ++ ++ ++/** ++ * mmc_request_done - finish processing an MMC command ++ * @host: MMC host which completed command ++ * @cmd: MMC command which completed ++ * @err: MMC error code ++ * ++ * MMC drivers should call this function when they have completed ++ * their processing of a command. This should be called before the ++ * data part of the command has completed. ++ */ ++void mmc_request_done(struct mmc_host *host, struct mmc_request *req) ++{ ++ struct mmc_command *cmd = req->cmd; ++ int err = req->cmd->error; ++ DBG("MMC: req done (%02x): %d: %08x %08x %08x %08x\n", cmd->opcode, ++ err, cmd->resp[0], cmd->resp[1], cmd->resp[2], cmd->resp[3]); ++ ++ if (err && cmd->retries) { ++ cmd->retries--; ++ cmd->error = 0; ++ host->ops->request(host, req); ++ } else if (req->done) { ++ req->done(req); ++ } ++} ++ ++EXPORT_SYMBOL(mmc_request_done); ++ ++/** ++ * mmc_start_request - start a command on a host ++ * @host: MMC host to start command on ++ * @cmd: MMC command to start ++ * ++ * Queue a command on the specified host. We expect the ++ * caller to be holding the host lock with interrupts disabled. ++ */ ++void ++mmc_start_request(struct mmc_host *host, struct mmc_request *req) ++{ ++ DBG("MMC: starting cmd %02x arg %08x flags %08x\n", ++ req->cmd->opcode, req->cmd->arg, req->cmd->flags); ++ ++ req->cmd->error = 0; ++ req->cmd->req = req; ++ if (req->data) { ++ req->cmd->data = req->data; ++ req->data->error = 0; ++ req->data->req = req; ++ if (req->stop) { ++ req->data->stop = req->stop; ++ req->stop->error = 0; ++ req->stop->req = req; ++ } ++ } ++ host->ops->request(host, req); ++} ++ ++EXPORT_SYMBOL(mmc_start_request); ++ ++static void mmc_wait_done(struct mmc_request *req) ++{ ++ complete(req->done_data); ++} ++ ++int mmc_wait_for_req(struct mmc_host *host, struct mmc_request *req) ++{ ++ DECLARE_COMPLETION(complete); ++ ++ req->done_data = &complete; ++ req->done = mmc_wait_done; ++ ++ mmc_start_request(host, req); ++ ++ wait_for_completion(&complete); ++ ++ return 0; ++} ++ ++EXPORT_SYMBOL(mmc_wait_for_req); ++ ++/** ++ * mmc_wait_for_cmd - start a command and wait for completion ++ * @host: MMC host to start command ++ * @cmd: MMC command to start ++ * @retries: maximum number of retries ++ * ++ * Start a new MMC command for a host, and wait for the command ++ * to complete. Return any error that occurred while the command ++ * was executing. Do not attempt to parse the response. ++ */ ++int mmc_wait_for_cmd(struct mmc_host *host, struct mmc_command *cmd, int retries) ++{ ++ struct mmc_request req; ++ ++ BUG_ON(host->card_busy == NULL); ++ ++ memset(&req, 0, sizeof(struct mmc_request)); ++ ++ memset(cmd->resp, 0, sizeof(cmd->resp)); ++ cmd->retries = retries; ++ ++ req.cmd = cmd; ++ cmd->data = NULL; ++ ++ mmc_wait_for_req(host, &req); ++ ++ return cmd->error; ++} ++ ++EXPORT_SYMBOL(mmc_wait_for_cmd); ++ ++ ++ ++/** ++ * __mmc_claim_host - exclusively claim a host ++ * @host: mmc host to claim ++ * @card: mmc card to claim host for ++ * ++ * Claim a host for a set of operations. If a valid card ++ * is passed and this wasn't the last card selected, select ++ * the card before returning. ++ * ++ * Note: you should use mmc_card_claim_host or mmc_claim_host. ++ */ ++int __mmc_claim_host(struct mmc_host *host, struct mmc_card *card) ++{ ++ DECLARE_WAITQUEUE(wait, current); ++ unsigned long flags; ++ int err = 0; ++ ++ add_wait_queue(&host->wq, &wait); ++ spin_lock_irqsave(&host->lock, flags); ++ while (1) { ++ set_current_state(TASK_UNINTERRUPTIBLE); ++ if (host->card_busy == NULL) ++ break; ++ spin_unlock_irqrestore(&host->lock, flags); ++ schedule(); ++ spin_lock_irqsave(&host->lock, flags); ++ } ++ set_current_state(TASK_RUNNING); ++ host->card_busy = card; ++ spin_unlock_irqrestore(&host->lock, flags); ++ remove_wait_queue(&host->wq, &wait); ++ ++ if (card != (void *)-1 && host->card_selected != card) { ++ struct mmc_command cmd; ++ ++ host->card_selected = card; ++ ++ cmd.opcode = MMC_SELECT_CARD; ++ cmd.arg = card->rca << 16; ++ cmd.flags = MMC_RSP_SHORT | MMC_RSP_CRC; ++ ++ err = mmc_wait_for_cmd(host, &cmd, CMD_RETRIES); ++ } ++ ++ return err; ++} ++ ++EXPORT_SYMBOL(__mmc_claim_host); ++ ++/** ++ * mmc_release_host - release a host ++ * @host: mmc host to release ++ * ++ * Release a MMC host, allowing others to claim the host ++ * for their operations. ++ */ ++void mmc_release_host(struct mmc_host *host) ++{ ++ unsigned long flags; ++ ++ BUG_ON(host->card_busy == NULL); ++ ++ spin_lock_irqsave(&host->lock, flags); ++ host->card_busy = NULL; ++ spin_unlock_irqrestore(&host->lock, flags); ++ ++ wake_up(&host->wq); ++} ++ ++EXPORT_SYMBOL(mmc_release_host); ++ ++static void mmc_deselect_cards(struct mmc_host *host) ++{ ++ struct mmc_command cmd; ++ ++ /* ++ * Ensure that no card is selected. ++ */ ++ if (host->card_selected) { ++ host->card_selected = NULL; ++ ++ cmd.opcode = MMC_SELECT_CARD; ++ cmd.arg = 0; ++ cmd.flags = MMC_RSP_NONE; ++ ++ mmc_wait_for_cmd(host, &cmd, 0); ++ } ++} ++ ++ ++static inline void mmc_delay(unsigned int ms) ++{ ++ if (ms < HZ / 1000) { ++ yield(); ++ mdelay(ms); ++ } else { ++ set_current_state(TASK_INTERRUPTIBLE); ++ schedule_timeout(ms * HZ / 1000); ++ } ++} ++ ++static u32 mmc_select_voltage(struct mmc_host *host, u32 ocr) ++{ ++ int bit; ++ ++ /* ++ * Mask off any voltages we don't support ++ */ ++ ocr &= host->ocr_avail; ++ ++ /* ++ * Select the lowest voltage ++ */ ++ bit = ffs(ocr); ++ if (bit) { ++ bit -= 1; ++ ++ ocr = 1 << bit; ++ ++ host->ios.vdd = mmc_ocr_bit_to_vdd[bit]; ++ host->ops->set_ios(host, &host->ios); ++ } else { ++ ocr = 0; ++ } ++ ++ return ocr; ++} ++ ++static void mmc_decode_cid(struct mmc_cid *cid, u32 *resp) ++{ ++ memset(cid, 0, sizeof(struct mmc_cid)); ++ ++ cid->manfid = resp[0] >> 8; ++ cid->prod_name[0] = resp[0]; ++ cid->prod_name[1] = resp[1] >> 24; ++ cid->prod_name[2] = resp[1] >> 16; ++ cid->prod_name[3] = resp[1] >> 8; ++ cid->prod_name[4] = resp[1]; ++ cid->prod_name[5] = resp[2] >> 24; ++ cid->prod_name[6] = resp[2] >> 16; ++ cid->prod_name[7] = '\0'; ++ cid->hwrev = (resp[2] >> 12) & 15; ++ cid->fwrev = (resp[2] >> 8) & 15; ++ cid->serial = (resp[2] & 255) << 16 | (resp[3] >> 16); ++ cid->month = (resp[3] >> 12) & 15; ++ cid->year = (resp[3] >> 8) & 15; ++} ++ ++static void mmc_decode_csd(struct mmc_csd *csd, u32 *resp) ++{ ++ unsigned int e, m; ++ ++ csd->mmc_prot = (resp[0] >> 26) & 15; ++ m = (resp[0] >> 19) & 15; ++ e = (resp[0] >> 16) & 7; ++ csd->tacc_ns = (tacc_exp[e] * tacc_mant[m] + 9) / 10; ++ csd->tacc_clks = ((resp[0] >> 8) & 255) * 100; ++ ++ m = (resp[0] >> 3) & 15; ++ e = resp[0] & 7; ++ csd->max_dtr = tran_exp[e] * tran_mant[m]; ++ csd->cmdclass = (resp[1] >> 20) & 0xfff; ++ ++ e = (resp[2] >> 15) & 7; ++ m = (resp[1] << 2 | resp[2] >> 30) & 0x3fff; ++ csd->capacity = (1 + m) << (e + 2); ++ ++ csd->read_blkbits = (resp[1] >> 16) & 15; ++} ++ ++/* ++ * Locate a MMC card on this MMC host given a CID. ++ */ ++static struct mmc_card * ++mmc_find_card(struct mmc_host *host, struct mmc_cid *cid) ++{ ++ struct mmc_card *card; ++ ++ list_for_each_entry(card, &host->cards, node) { ++ if (memcmp(&card->cid, cid, sizeof(struct mmc_cid)) == 0) ++ return card; ++ } ++ return NULL; ++} ++ ++/* ++ * Allocate a new MMC card, and assign a unique RCA. ++ */ ++static struct mmc_card * ++mmc_alloc_card(struct mmc_host *host, struct mmc_cid *cid, unsigned int *frca) ++{ ++ struct mmc_card *card, *c; ++ unsigned int rca = *frca; ++ ++ card = kmalloc(sizeof(struct mmc_card), GFP_KERNEL); ++ if (!card) ++ return ERR_PTR(-ENOMEM); ++ ++ mmc_init_card(card, host); ++ memcpy(&card->cid, cid, sizeof(struct mmc_cid)); ++ ++ again: ++ list_for_each_entry(c, &host->cards, node) ++ if (c->rca == rca) { ++ rca++; ++ goto again; ++ } ++ ++ card->rca = rca; ++ ++ *frca = rca; ++ ++ return card; ++} ++ ++/* ++ * Apply power to the MMC stack. ++ */ ++static void mmc_power_up(struct mmc_host *host) ++{ ++ struct mmc_command cmd; ++ int bit = fls(host->ocr_avail) - 1; ++ ++ host->ios.vdd = mmc_ocr_bit_to_vdd[bit]; ++ host->ios.bus_mode = MMC_BUSMODE_OPENDRAIN; ++ host->ios.power_mode = MMC_POWER_UP; ++ host->ops->set_ios(host, &host->ios); ++ ++ mmc_delay(1); ++ ++ host->ios.clock = host->f_min; ++ host->ios.power_mode = MMC_POWER_ON; ++ host->ops->set_ios(host, &host->ios); ++ ++ mmc_delay(2); ++ ++ cmd.opcode = MMC_GO_IDLE_STATE; ++ cmd.arg = 0; ++ cmd.flags = MMC_RSP_NONE; ++ ++ mmc_wait_for_cmd(host, &cmd, 0); ++} ++ ++static void mmc_power_off(struct mmc_host *host) ++{ ++ host->ios.clock = 0; ++ host->ios.vdd = 0; ++ host->ios.bus_mode = MMC_BUSMODE_OPENDRAIN; ++ host->ios.power_mode = MMC_POWER_OFF; ++ host->ops->set_ios(host, &host->ios); ++} ++ ++static int mmc_send_op_cond(struct mmc_host *host, u32 ocr, u32 *rocr) ++{ ++ struct mmc_command cmd; ++ int i, err = 0; ++ ++ cmd.opcode = MMC_SEND_OP_COND; ++ cmd.arg = ocr; ++ cmd.flags = MMC_RSP_SHORT; ++ ++ for (i = 100; i; i--) { ++ err = mmc_wait_for_cmd(host, &cmd, 0); ++ if (err != MMC_ERR_NONE) ++ break; ++ ++ if (cmd.resp[0] & MMC_CARD_BUSY || ocr == 0) ++ break; ++ ++ err = MMC_ERR_TIMEOUT; ++ } ++ ++ if (rocr) ++ *rocr = cmd.resp[0]; ++ ++ return err; ++} ++ ++/* ++ * Discover cards by requesting their CID. If this command ++ * times out, it is not an error; there are no further cards ++ * to be discovered. Add new cards to the list. ++ * ++ * Create a mmc_card entry for each discovered card, assigning ++ * it an RCA, and save the CID. ++ */ ++static void mmc_discover_cards(struct mmc_host *host) ++{ ++ struct mmc_card *card; ++ unsigned int first_rca = 1, err; ++ ++ while (1) { ++ struct mmc_command cmd; ++ struct mmc_cid cid; ++ ++ /* ++ * Read CID ++ */ ++ cmd.opcode = MMC_ALL_SEND_CID; ++ cmd.arg = 0; ++ cmd.flags = MMC_RSP_LONG | MMC_RSP_CRC; ++ ++ err = mmc_wait_for_cmd(host, &cmd, CMD_RETRIES); ++ if (err == MMC_ERR_TIMEOUT) { ++ err = MMC_ERR_NONE; ++ break; ++ } ++ if (err != MMC_ERR_NONE) { ++ printk(KERN_ERR "MMC: mmc%d error requesting CID: %d\n", ++ host->host_num, err); ++ break; ++ } ++ ++ mmc_decode_cid(&cid, cmd.resp); ++ ++ card = mmc_find_card(host, &cid); ++ if (!card) { ++ card = mmc_alloc_card(host, &cid, &first_rca); ++ if (IS_ERR(card)) { ++ err = PTR_ERR(card); ++ break; ++ } ++ list_add(&card->node, &host->cards); ++ } ++ ++ card->state &= ~MMC_STATE_DEAD; ++ ++ cmd.opcode = MMC_SET_RELATIVE_ADDR; ++ cmd.arg = card->rca << 16; ++ cmd.flags = MMC_RSP_SHORT | MMC_RSP_CRC; ++ ++ err = mmc_wait_for_cmd(host, &cmd, CMD_RETRIES); ++ if (err != MMC_ERR_NONE) ++ card->state |= MMC_STATE_DEAD; ++ } ++} ++ ++static void mmc_read_csds(struct mmc_host *host) ++{ ++ struct mmc_card *card; ++ ++ list_for_each_entry(card, &host->cards, node) { ++ struct mmc_command cmd; ++ int err; ++ ++ if (card->state & (MMC_STATE_DEAD|MMC_STATE_PRESENT)) ++ continue; ++ ++ cmd.opcode = MMC_SEND_CSD; ++ cmd.arg = card->rca << 16; ++ cmd.flags = MMC_RSP_LONG | MMC_RSP_CRC; ++ ++ err = mmc_wait_for_cmd(host, &cmd, CMD_RETRIES); ++ if (err != MMC_ERR_NONE) { ++ card->state |= MMC_STATE_DEAD; ++ continue; ++ } ++ ++ mmc_decode_csd(&card->csd, cmd.resp); ++ } ++} ++ ++static unsigned int mmc_calculate_clock(struct mmc_host *host) ++{ ++ struct mmc_card *card; ++ unsigned int max_dtr = host->f_max; ++ ++ list_for_each_entry(card, &host->cards, node) ++ if (!mmc_card_dead(card) && max_dtr > card->csd.max_dtr) ++ max_dtr = card->csd.max_dtr; ++ ++ DBG("MMC: selected %d.%03dMHz transfer rate\n", ++ max_dtr / 1000000, (max_dtr / 1000) % 1000); ++ ++ return max_dtr; ++} ++ ++/* ++ * Check whether cards we already know about are still present. ++ * We do this by requesting status, and checking whether a card ++ * responds. ++ * ++ * A request for status does not cause a state change in data ++ * transfer mode. ++ */ ++static void mmc_check_cards(struct mmc_host *host) ++{ ++ struct list_head *l, *n; ++ ++ mmc_deselect_cards(host); ++ ++ list_for_each_safe(l, n, &host->cards) { ++ struct mmc_card *card = mmc_list_to_card(l); ++ struct mmc_command cmd; ++ int err; ++ ++ cmd.opcode = MMC_SEND_STATUS; ++ cmd.arg = card->rca << 16; ++ cmd.flags = MMC_RSP_LONG | MMC_RSP_CRC; ++ ++ err = mmc_wait_for_cmd(host, &cmd, CMD_RETRIES); ++ if (err == MMC_ERR_NONE) ++ continue; ++ ++ /* ++ * Ok, we believe this card has been removed. ++ */ ++ card->state |= MMC_STATE_DEAD; ++ } ++} ++ ++static void mmc_setup(struct mmc_host *host) ++{ ++ if (host->ios.power_mode != MMC_POWER_ON) { ++ int err; ++ u32 ocr; ++ ++ mmc_power_up(host); ++ ++ err = mmc_send_op_cond(host, 0, &ocr); ++ if (err != MMC_ERR_NONE) ++ return; ++ ++ host->ocr = mmc_select_voltage(host, ocr); ++ } else { ++ host->ios.bus_mode = MMC_BUSMODE_OPENDRAIN; ++ host->ios.clock = host->f_min; ++ host->ops->set_ios(host, &host->ios); ++ ++ /* ++ * We should remember the OCR mask from the existing ++ * cards, and detect the new cards OCR mask, combine ++ * the two and re-select the VDD. However, if we do ++ * change VDD, we should do an idle, and then do a ++ * full re-initialisation. We would need to notify ++ * drivers so that they can re-setup the cards as ++ * well, while keeping their queues at bay. ++ * ++ * For the moment, we take the easy way out - if the ++ * new cards don't like our currently selected VDD, ++ * they drop off the bus. ++ */ ++ } ++ ++ if (host->ocr == 0) ++ return; ++ ++ /* ++ * Send the selected OCR multiple times... until the cards ++ * all get the idea that they should be ready for CMD2. ++ * (My SanDisk card seems to need this.) ++ */ ++ mmc_send_op_cond(host, host->ocr, NULL); ++ ++ mmc_discover_cards(host); ++ ++ /* ++ * Ok, now switch to push-pull mode. ++ */ ++ host->ios.bus_mode = MMC_BUSMODE_PUSHPULL; ++ host->ops->set_ios(host, &host->ios); ++ ++ mmc_read_csds(host); ++} ++ ++ ++/** ++ * mmc_detect_change - process change of state on a MMC socket ++ * @host: host which changed state. ++ * ++ * All we know is that card(s) have been inserted or removed ++ * from the socket(s). We don't know which socket or cards. ++ */ ++void mmc_detect_change(struct mmc_host *host) ++{ ++ struct list_head *l, *n; ++ ++ mmc_claim_host(host); ++ ++ if (host->ios.power_mode == MMC_POWER_ON) ++ mmc_check_cards(host); ++ ++ mmc_setup(host); ++ ++ if (!list_empty(&host->cards)) { ++ /* ++ * (Re-)calculate the fastest clock rate which the ++ * attached cards and the host support. ++ */ ++ host->ios.clock = mmc_calculate_clock(host); ++ host->ops->set_ios(host, &host->ios); ++ } ++ ++ mmc_release_host(host); ++ ++ list_for_each_safe(l, n, &host->cards) { ++ struct mmc_card *card = mmc_list_to_card(l); ++ ++ /* ++ * If this is a new and good card, register it. ++ */ ++ if (!mmc_card_present(card) && !mmc_card_dead(card)) { ++ if (mmc_register_card(card)) ++ card->state |= MMC_STATE_DEAD; ++ else ++ card->state |= MMC_STATE_PRESENT; ++ } ++ ++ /* ++ * If this card is dead, destroy it. ++ */ ++ if (mmc_card_dead(card)) { ++ list_del(&card->node); ++ mmc_remove_card(card); ++ } ++ } ++ ++ /* ++ * If we discover that there are no cards on the ++ * bus, turn off the clock and power down. ++ */ ++ if (list_empty(&host->cards)) ++ mmc_power_off(host); ++} ++ ++EXPORT_SYMBOL(mmc_detect_change); ++ ++ ++/** ++ * mmc_init_host - initialise the per-host structure. ++ * @host: mmc host ++ * ++ * Initialise the per-host structure. ++ */ ++int mmc_init_host(struct mmc_host *host) ++{ ++ static unsigned int host_num; ++ ++ memset(host, 0, sizeof(struct mmc_host)); ++ ++ host->host_num = host_num++; ++ ++ spin_lock_init(&host->lock); ++ init_waitqueue_head(&host->wq); ++ INIT_LIST_HEAD(&host->cards); ++ ++ return 0; ++} ++ ++EXPORT_SYMBOL(mmc_init_host); ++ ++/** ++ * mmc_add_host - initialise host hardware ++ * @host: mmc host ++ */ ++int mmc_add_host(struct mmc_host *host) ++{ ++ mmc_power_off(host); ++ mmc_detect_change(host); ++ ++ return 0; ++} ++ ++EXPORT_SYMBOL(mmc_add_host); ++ ++/** ++ * mmc_remove_host - remove host hardware ++ * @host: mmc host ++ * ++ * Unregister and remove all cards associated with this host, ++ * and power down the MMC bus. ++ */ ++void mmc_remove_host(struct mmc_host *host) ++{ ++ struct list_head *l, *n; ++ ++ list_for_each_safe(l, n, &host->cards) { ++ struct mmc_card *card = mmc_list_to_card(l); ++ ++ mmc_remove_card(card); ++ } ++ ++ mmc_power_off(host); ++} ++ ++EXPORT_SYMBOL(mmc_remove_host); ++ ++#ifdef CONFIG_PM ++ ++/** ++ * mmc_suspend_host - suspend a host ++ * @host: mmc host ++ * @state: suspend mode (PM_SUSPEND_xxx) ++ */ ++int mmc_suspend_host(struct mmc_host *host, u32 state) ++{ ++ mmc_claim_host(host); ++ mmc_deselect_cards(host); ++ mmc_power_off(host); ++ mmc_release_host(host); ++ ++ return 0; ++} ++ ++/** ++ * mmc_resume_host - resume a previously suspended host ++ * @host: mmc host ++ */ ++int mmc_resume_host(struct mmc_host *host) ++{ ++ mmc_detect_change(host); ++ ++ return 0; ++} ++ ++ ++#else /* CONFIG_PM is not set */ ++ ++int mmc_suspend_host(struct mmc_host *host, u32 state) { return 0; } ++int mmc_resume_host(struct mmc_host *host) { return 0; } ++ ++#endif ++ ++EXPORT_SYMBOL(mmc_suspend_host); ++EXPORT_SYMBOL(mmc_resume_host); ++ ++MODULE_LICENSE("GPL"); +--- /dev/null 2003-09-23 18:19:32.000000000 -0400 ++++ linux-2.6.5/drivers/media/mmc/Makefile 2004-04-30 20:57:36.000000000 -0400 +@@ -0,0 +1,21 @@ ++# ++# Makefile for the kernel mmc device drivers. ++# ++ ++# ++# Core ++# ++obj-$(CONFIG_MMC) += mmc_core.o ++ ++# ++# Media drivers ++# ++obj-$(CONFIG_MMC_BLOCK) += mmc_block.o ++ ++# ++# Host drivers ++# ++obj-$(CONFIG_MMC_ARMMMCI) += mmci.o ++obj-$(CONFIG_MMC_PXA) += pxamci.o ++ ++mmc_core-y := mmc.o mmc_queue.o mmc_sysfs.o +--- linux-2.6.5/drivers/media/Makefile~heh 2004-04-03 22:38:15.000000000 -0500 ++++ linux-2.6.5/drivers/media/Makefile 2004-04-30 20:57:36.000000000 -0400 +@@ -3,3 +3,6 @@ + # + + obj-y := video/ radio/ dvb/ common/ ++ ++obj-$(CONFIG_MMC) += mmc/ ++ +--- linux-2.6.5/drivers/serial/Kconfig~heh 2004-04-03 22:38:15.000000000 -0500 ++++ linux-2.6.5/drivers/serial/Kconfig 2004-04-30 20:57:36.000000000 -0400 +@@ -315,6 +315,29 @@ + your boot loader (lilo or loadlin) about how to pass options to the + kernel at boot time.) + ++config SERIAL_PXA ++ bool "PXA serial port support" ++ depends on ARM && ARCH_PXA ++ select SERIAL_CORE ++ help ++ If you have a machine based on an Intel XScale PXA2xx CPU you ++ can enable its onboard serial ports by enabling this option. ++ ++config SERIAL_PXA_CONSOLE ++ bool "Console on PXA serial port" ++ depends on SERIAL_PXA ++ select SERIAL_CORE_CONSOLE ++ help ++ If you have enabled the serial port on the Intel XScale PXA ++ CPU you can make it the console by answering Y to this option. ++ ++ Even if you say Y here, the currently visible virtual console ++ (/dev/tty0) will still be used as the system console by default, but ++ you can alter that using a kernel command line option such as ++ "console=ttySA0". (Try "man bootparam" or see the documentation of ++ your boot loader (lilo or loadlin) about how to pass options to the ++ kernel at boot time.) ++ + config SERIAL_SA1100 + bool "SA1100 serial port support" + depends on ARM && ARCH_SA1100 +--- linux-2.6.5/drivers/serial/pxa.c~heh 2004-04-03 22:38:16.000000000 -0500 ++++ linux-2.6.5/drivers/serial/pxa.c 2004-04-30 20:57:36.000000000 -0400 +@@ -294,7 +294,6 @@ + unsigned char status; + unsigned int ret; + +-return TIOCM_CTS | TIOCM_DSR | TIOCM_CAR; + spin_lock_irqsave(&up->port.lock, flags); + status = serial_in(up, UART_MSR); + spin_unlock_irqrestore(&up->port.lock, flags); +@@ -800,6 +799,21 @@ + .ops = &serial_pxa_pops, + .line = 2, + }, ++ }, { /* HWUART */ ++ .name = "HWUART", ++ .cken = CKEN4_HWUART, ++ .port = { ++ .type = PORT_PXA, ++ .iotype = SERIAL_IO_MEM, ++ .membase = (void *)&HWUART, ++ .mapbase = __PREG(HWUART), ++ .irq = IRQ_HWUART, ++ .uartclk = 921600 * 16, ++ .fifosize = 64, ++ .flags = ASYNC_SKIP_TEST, ++ .ops = &serial_pxa_pops, ++ .line = 3, ++ }, + } + }; + +--- linux-2.6.5/drivers/serial/sa1100.c~heh 2004-04-03 22:36:24.000000000 -0500 ++++ linux-2.6.5/drivers/serial/sa1100.c 2004-04-30 20:57:36.000000000 -0400 +@@ -448,6 +448,15 @@ + unsigned int old_csize = old ? old->c_cflag & CSIZE : CS8; + + /* ++ * If we don't support modem control lines, don't allow ++ * these to be set. ++ */ ++ if (0) { ++ termios->c_cflag &= ~(HUPCL | CRTSCTS | CMSPAR); ++ termios->c_cflag |= CLOCAL; ++ } ++ ++ /* + * We only support CS7 and CS8. + */ + while ((termios->c_cflag & CSIZE) != CS7 && +@@ -894,6 +903,7 @@ + if (sa1100_ports[i].port.mapbase != res->start) + continue; + ++ sa1100_ports[i].port.dev = _dev; + uart_add_one_port(&sa1100_reg, &sa1100_ports[i].port); + dev_set_drvdata(_dev, &sa1100_ports[i]); + break; +--- linux-2.6.5/drivers/mtd/mtd_blkdevs.c~heh 2004-04-03 22:36:14.000000000 -0500 ++++ linux-2.6.5/drivers/mtd/mtd_blkdevs.c 2004-04-30 20:57:36.000000000 -0400 +@@ -81,7 +81,7 @@ + struct request_queue *rq = tr->blkcore_priv->rq; + + /* we might get involved when memory gets low, so use PF_MEMALLOC */ +- current->flags |= PF_MEMALLOC; ++ current->flags |= PF_MEMALLOC|PF_IOTHREAD; + + daemonize("%sd", tr->name); + +--- linux-2.6.5/drivers/mtd/devices/doc1000.c~heh 2004-04-03 22:37:36.000000000 -0500 ++++ linux-2.6.5/drivers/mtd/devices/doc1000.c 2004-04-30 20:57:36.000000000 -0400 +@@ -1,6 +1,6 @@ + /*====================================================================== + +- $Id: doc1000.c,v 1.15 2001/10/02 15:05:13 dwmw2 Exp $ ++ $Id: doc1000.c,v 1.16 2001/12/28 22:45:17 dwmw2 Exp $ + + ======================================================================*/ + +@@ -20,6 +20,7 @@ + #include <linux/ioctl.h> + #include <asm/io.h> + #include <asm/system.h> ++#include <asm/segment.h> + #include <stdarg.h> + #include <linux/delay.h> + #include <linux/init.h> +@@ -482,7 +483,7 @@ + else + priv->devstat[erase->dev] = erase->state = MTD_ERASE_PENDING; + } +- else if (erase->time + erase_timeout < jiffies) ++ else if (time_after(jiffies, erase->time + erase_timeout)) + { + printk("Flash erase timed out. The world is broken.\n"); + +--- linux-2.6.5/drivers/mtd/mtdconcat.c~heh 2004-04-03 22:37:37.000000000 -0500 ++++ linux-2.6.5/drivers/mtd/mtdconcat.c 2004-04-30 20:57:36.000000000 -0400 +@@ -7,7 +7,7 @@ + * + * This code is GPL + * +- * $Id: mtdconcat.c,v 1.4 2003/03/07 17:44:59 rkaiser Exp $ ++ * $Id: mtdconcat.c,v 1.7 2003/06/29 21:26:34 dwmw2 Exp $ + */ + + #include <linux/module.h> +@@ -26,7 +26,7 @@ + */ + struct mtd_concat { + struct mtd_info mtd; +- int num_subdev; ++ int num_subdev; + struct mtd_info **subdev; + }; + +@@ -37,21 +37,20 @@ + #define SIZEOF_STRUCT_MTD_CONCAT(num_subdev) \ + ((sizeof(struct mtd_concat) + (num_subdev) * sizeof(struct mtd_info *))) + +- + /* + * Given a pointer to the MTD object in the mtd_concat structure, + * we can retrieve the pointer to that structure with this macro. + */ + #define CONCAT(x) ((struct mtd_concat *)(x)) + +- + /* + * MTD methods which look up the relevant subdevice, translate the + * effective address and pass through to the subdevice. + */ + +-static int concat_read (struct mtd_info *mtd, loff_t from, size_t len, +- size_t *retlen, u_char *buf) ++static int ++concat_read(struct mtd_info *mtd, loff_t from, size_t len, ++ size_t * retlen, u_char * buf) + { + struct mtd_concat *concat = CONCAT(mtd); + int err = -EINVAL; +@@ -59,43 +58,43 @@ + + *retlen = 0; + +- for(i = 0; i < concat->num_subdev; i++) +- { ++ for (i = 0; i < concat->num_subdev; i++) { + struct mtd_info *subdev = concat->subdev[i]; + size_t size, retsize; + +- if (from >= subdev->size) +- { /* Not destined for this subdev */ +- size = 0; ++ if (from >= subdev->size) { ++ /* Not destined for this subdev */ ++ size = 0; + from -= subdev->size; ++ continue; + } ++ if (from + len > subdev->size) ++ /* First part goes into this subdev */ ++ size = subdev->size - from; + else +- { +- if (from + len > subdev->size) +- size = subdev->size - from; /* First part goes into this subdev */ +- else +- size = len; /* Entire transaction goes into this subdev */ ++ /* Entire transaction goes into this subdev */ ++ size = len; + +- err = subdev->read(subdev, from, size, &retsize, buf); ++ err = subdev->read(subdev, from, size, &retsize, buf); + +- if(err) +- break; ++ if (err) ++ break; + +- *retlen += retsize; +- len -= size; +- if(len == 0) +- break; ++ *retlen += retsize; ++ len -= size; ++ if (len == 0) ++ break; + +- err = -EINVAL; +- buf += size; +- from = 0; +- } ++ err = -EINVAL; ++ buf += size; ++ from = 0; + } + return err; + } + +-static int concat_write (struct mtd_info *mtd, loff_t to, size_t len, +- size_t *retlen, const u_char *buf) ++static int ++concat_write(struct mtd_info *mtd, loff_t to, size_t len, ++ size_t * retlen, const u_char * buf) + { + struct mtd_concat *concat = CONCAT(mtd); + int err = -EINVAL; +@@ -106,46 +105,44 @@ + + *retlen = 0; + +- for(i = 0; i < concat->num_subdev; i++) +- { ++ for (i = 0; i < concat->num_subdev; i++) { + struct mtd_info *subdev = concat->subdev[i]; + size_t size, retsize; + +- if (to >= subdev->size) +- { +- size = 0; ++ if (to >= subdev->size) { ++ size = 0; + to -= subdev->size; ++ continue; + } ++ if (to + len > subdev->size) ++ size = subdev->size - to; + else +- { +- if (to + len > subdev->size) +- size = subdev->size - to; +- else +- size = len; ++ size = len; + +- if (!(subdev->flags & MTD_WRITEABLE)) +- err = -EROFS; +- else +- err = subdev->write(subdev, to, size, &retsize, buf); ++ if (!(subdev->flags & MTD_WRITEABLE)) ++ err = -EROFS; ++ else ++ err = subdev->write(subdev, to, size, &retsize, buf); + +- if(err) +- break; ++ if (err) ++ break; + +- *retlen += retsize; +- len -= size; +- if(len == 0) +- break; ++ *retlen += retsize; ++ len -= size; ++ if (len == 0) ++ break; + +- err = -EINVAL; +- buf += size; +- to = 0; +- } ++ err = -EINVAL; ++ buf += size; ++ to = 0; + } + return err; + } + +-static int concat_read_ecc (struct mtd_info *mtd, loff_t from, size_t len, +- size_t *retlen, u_char *buf, u_char *eccbuf, struct nand_oobinfo *oobsel) ++static int ++concat_read_ecc(struct mtd_info *mtd, loff_t from, size_t len, ++ size_t * retlen, u_char * buf, u_char * eccbuf, ++ struct nand_oobinfo *oobsel) + { + struct mtd_concat *concat = CONCAT(mtd); + int err = -EINVAL; +@@ -153,53 +150,56 @@ + + *retlen = 0; + +- for(i = 0; i < concat->num_subdev; i++) +- { ++ for (i = 0; i < concat->num_subdev; i++) { + struct mtd_info *subdev = concat->subdev[i]; + size_t size, retsize; +- +- if (from >= subdev->size) +- { /* Not destined for this subdev */ +- size = 0; ++ ++ if (from >= subdev->size) { ++ /* Not destined for this subdev */ ++ size = 0; + from -= subdev->size; ++ continue; + } ++ ++ if (from + len > subdev->size) ++ /* First part goes into this subdev */ ++ size = subdev->size - from; + else +- { +- if (from + len > subdev->size) +- size = subdev->size - from; /* First part goes into this subdev */ +- else +- size = len; /* Entire transaction goes into this subdev */ +- +- if (subdev->read_ecc) +- err = subdev->read_ecc(subdev, from, size, &retsize, buf, eccbuf, oobsel); +- else +- err = -EINVAL; ++ /* Entire transaction goes into this subdev */ ++ size = len; + +- if(err) +- break; ++ if (subdev->read_ecc) ++ err = subdev->read_ecc(subdev, from, size, ++ &retsize, buf, eccbuf, oobsel); ++ else ++ err = -EINVAL; + +- *retlen += retsize; +- len -= size; +- if(len == 0) +- break; ++ if (err) ++ break; + +- err = -EINVAL; +- buf += size; +- if (eccbuf) +- { +- eccbuf += subdev->oobsize; +- /* in nand.c at least, eccbufs are tagged with 2 (int)eccstatus', +- we must account for these */ +- eccbuf += 2 * (sizeof(int)); +- } +- from = 0; ++ *retlen += retsize; ++ len -= size; ++ if (len == 0) ++ break; ++ ++ err = -EINVAL; ++ buf += size; ++ if (eccbuf) { ++ eccbuf += subdev->oobsize; ++ /* in nand.c at least, eccbufs are ++ tagged with 2 (int)eccstatus'; we ++ must account for these */ ++ eccbuf += 2 * (sizeof (int)); + } ++ from = 0; + } + return err; + } + +-static int concat_write_ecc (struct mtd_info *mtd, loff_t to, size_t len, +- size_t *retlen, const u_char *buf, u_char *eccbuf, struct nand_oobinfo *oobsel) ++static int ++concat_write_ecc(struct mtd_info *mtd, loff_t to, size_t len, ++ size_t * retlen, const u_char * buf, u_char * eccbuf, ++ struct nand_oobinfo *oobsel) + { + struct mtd_concat *concat = CONCAT(mtd); + int err = -EINVAL; +@@ -210,50 +210,48 @@ + + *retlen = 0; + +- for(i = 0; i < concat->num_subdev; i++) +- { ++ for (i = 0; i < concat->num_subdev; i++) { + struct mtd_info *subdev = concat->subdev[i]; + size_t size, retsize; +- +- if (to >= subdev->size) +- { +- size = 0; ++ ++ if (to >= subdev->size) { ++ size = 0; + to -= subdev->size; ++ continue; + } ++ if (to + len > subdev->size) ++ size = subdev->size - to; + else +- { +- if (to + len > subdev->size) +- size = subdev->size - to; +- else +- size = len; ++ size = len; + +- if (!(subdev->flags & MTD_WRITEABLE)) +- err = -EROFS; +- else if (subdev->write_ecc) +- err = subdev->write_ecc(subdev, to, size, &retsize, buf, eccbuf, oobsel); +- else +- err = -EINVAL; ++ if (!(subdev->flags & MTD_WRITEABLE)) ++ err = -EROFS; ++ else if (subdev->write_ecc) ++ err = subdev->write_ecc(subdev, to, size, ++ &retsize, buf, eccbuf, oobsel); ++ else ++ err = -EINVAL; + +- if(err) +- break; ++ if (err) ++ break; + +- *retlen += retsize; +- len -= size; +- if(len == 0) +- break; ++ *retlen += retsize; ++ len -= size; ++ if (len == 0) ++ break; + +- err = -EINVAL; +- buf += size; +- if (eccbuf) +- eccbuf += subdev->oobsize; +- to = 0; +- } ++ err = -EINVAL; ++ buf += size; ++ if (eccbuf) ++ eccbuf += subdev->oobsize; ++ to = 0; + } + return err; + } + +-static int concat_read_oob (struct mtd_info *mtd, loff_t from, size_t len, +- size_t *retlen, u_char *buf) ++static int ++concat_read_oob(struct mtd_info *mtd, loff_t from, size_t len, ++ size_t * retlen, u_char * buf) + { + struct mtd_concat *concat = CONCAT(mtd); + int err = -EINVAL; +@@ -261,46 +259,47 @@ + + *retlen = 0; + +- for(i = 0; i < concat->num_subdev; i++) +- { ++ for (i = 0; i < concat->num_subdev; i++) { + struct mtd_info *subdev = concat->subdev[i]; + size_t size, retsize; +- +- if (from >= subdev->size) +- { /* Not destined for this subdev */ +- size = 0; ++ ++ if (from >= subdev->size) { ++ /* Not destined for this subdev */ ++ size = 0; + from -= subdev->size; ++ continue; + } ++ if (from + len > subdev->size) ++ /* First part goes into this subdev */ ++ size = subdev->size - from; + else +- { +- if (from + len > subdev->size) +- size = subdev->size - from; /* First part goes into this subdev */ +- else +- size = len; /* Entire transaction goes into this subdev */ +- +- if (subdev->read_oob) +- err = subdev->read_oob(subdev, from, size, &retsize, buf); +- else +- err = -EINVAL; ++ /* Entire transaction goes into this subdev */ ++ size = len; + +- if(err) +- break; ++ if (subdev->read_oob) ++ err = subdev->read_oob(subdev, from, size, ++ &retsize, buf); ++ else ++ err = -EINVAL; + +- *retlen += retsize; +- len -= size; +- if(len == 0) +- break; ++ if (err) ++ break; + +- err = -EINVAL; +- buf += size; +- from = 0; +- } ++ *retlen += retsize; ++ len -= size; ++ if (len == 0) ++ break; ++ ++ err = -EINVAL; ++ buf += size; ++ from = 0; + } + return err; + } + +-static int concat_write_oob (struct mtd_info *mtd, loff_t to, size_t len, +- size_t *retlen, const u_char *buf) ++static int ++concat_write_oob(struct mtd_info *mtd, loff_t to, size_t len, ++ size_t * retlen, const u_char * buf) + { + struct mtd_concat *concat = CONCAT(mtd); + int err = -EINVAL; +@@ -311,50 +310,46 @@ + + *retlen = 0; + +- for(i = 0; i < concat->num_subdev; i++) +- { ++ for (i = 0; i < concat->num_subdev; i++) { + struct mtd_info *subdev = concat->subdev[i]; + size_t size, retsize; +- +- if (to >= subdev->size) +- { +- size = 0; ++ ++ if (to >= subdev->size) { ++ size = 0; + to -= subdev->size; ++ continue; + } ++ if (to + len > subdev->size) ++ size = subdev->size - to; + else +- { +- if (to + len > subdev->size) +- size = subdev->size - to; +- else +- size = len; ++ size = len; + +- if (!(subdev->flags & MTD_WRITEABLE)) +- err = -EROFS; +- else if (subdev->write_oob) +- err = subdev->write_oob(subdev, to, size, &retsize, buf); +- else +- err = -EINVAL; ++ if (!(subdev->flags & MTD_WRITEABLE)) ++ err = -EROFS; ++ else if (subdev->write_oob) ++ err = subdev->write_oob(subdev, to, size, &retsize, ++ buf); ++ else ++ err = -EINVAL; + +- if(err) +- break; ++ if (err) ++ break; + +- *retlen += retsize; +- len -= size; +- if(len == 0) +- break; ++ *retlen += retsize; ++ len -= size; ++ if (len == 0) ++ break; + +- err = -EINVAL; +- buf += size; +- to = 0; +- } ++ err = -EINVAL; ++ buf += size; ++ to = 0; + } + return err; + } + +- +-static void concat_erase_callback (struct erase_info *instr) ++static void concat_erase_callback(struct erase_info *instr) + { +- wake_up((wait_queue_head_t *)instr->priv); ++ wake_up((wait_queue_head_t *) instr->priv); + } + + static int concat_dev_erase(struct mtd_info *mtd, struct erase_info *erase) +@@ -370,18 +365,18 @@ + + erase->mtd = mtd; + erase->callback = concat_erase_callback; +- erase->priv = (unsigned long)&waitq; +- ++ erase->priv = (unsigned long) &waitq; ++ + /* + * FIXME: Allow INTERRUPTIBLE. Which means + * not having the wait_queue head on the stack. + */ + err = mtd->erase(mtd, erase); +- if (!err) +- { ++ if (!err) { + set_current_state(TASK_UNINTERRUPTIBLE); + add_wait_queue(&waitq, &wait); +- if (erase->state != MTD_ERASE_DONE && erase->state != MTD_ERASE_FAILED) ++ if (erase->state != MTD_ERASE_DONE ++ && erase->state != MTD_ERASE_FAILED) + schedule(); + remove_wait_queue(&waitq, &wait); + set_current_state(TASK_RUNNING); +@@ -391,7 +386,7 @@ + return err; + } + +-static int concat_erase (struct mtd_info *mtd, struct erase_info *instr) ++static int concat_erase(struct mtd_info *mtd, struct erase_info *instr) + { + struct mtd_concat *concat = CONCAT(mtd); + struct mtd_info *subdev; +@@ -402,10 +397,10 @@ + if (!(mtd->flags & MTD_WRITEABLE)) + return -EROFS; + +- if(instr->addr > concat->mtd.size) ++ if (instr->addr > concat->mtd.size) + return -EINVAL; + +- if(instr->len + instr->addr > concat->mtd.size) ++ if (instr->len + instr->addr > concat->mtd.size) + return -EINVAL; + + /* +@@ -414,23 +409,22 @@ + * region info rather than looking at each particular sub-device + * in turn. + */ +- if (!concat->mtd.numeraseregions) +- { /* the easy case: device has uniform erase block size */ +- if(instr->addr & (concat->mtd.erasesize - 1)) ++ if (!concat->mtd.numeraseregions) { ++ /* the easy case: device has uniform erase block size */ ++ if (instr->addr & (concat->mtd.erasesize - 1)) + return -EINVAL; +- if(instr->len & (concat->mtd.erasesize - 1)) ++ if (instr->len & (concat->mtd.erasesize - 1)) + return -EINVAL; +- } +- else +- { /* device has variable erase size */ +- struct mtd_erase_region_info *erase_regions = concat->mtd.eraseregions; ++ } else { ++ /* device has variable erase size */ ++ struct mtd_erase_region_info *erase_regions = ++ concat->mtd.eraseregions; + + /* + * Find the erase region where the to-be-erased area begins: + */ +- for(i = 0; i < concat->mtd.numeraseregions && +- instr->addr >= erase_regions[i].offset; i++) +- ; ++ for (i = 0; i < concat->mtd.numeraseregions && ++ instr->addr >= erase_regions[i].offset; i++) ; + --i; + + /* +@@ -438,25 +432,26 @@ + * to-be-erased area begins. Verify that the starting + * offset is aligned to this region's erase size: + */ +- if (instr->addr & (erase_regions[i].erasesize-1)) ++ if (instr->addr & (erase_regions[i].erasesize - 1)) + return -EINVAL; + + /* + * now find the erase region where the to-be-erased area ends: + */ +- for(; i < concat->mtd.numeraseregions && +- (instr->addr + instr->len) >= erase_regions[i].offset ; ++i) +- ; ++ for (; i < concat->mtd.numeraseregions && ++ (instr->addr + instr->len) >= erase_regions[i].offset; ++ ++i) ; + --i; + /* + * check if the ending offset is aligned to this region's erase size + */ +- if ((instr->addr + instr->len) & (erase_regions[i].erasesize-1)) ++ if ((instr->addr + instr->len) & (erase_regions[i].erasesize - ++ 1)) + return -EINVAL; + } + + /* make a local copy of instr to avoid modifying the caller's struct */ +- erase = kmalloc(sizeof(struct erase_info),GFP_KERNEL); ++ erase = kmalloc(sizeof (struct erase_info), GFP_KERNEL); + + if (!erase) + return -ENOMEM; +@@ -468,39 +463,40 @@ + * find the subdevice where the to-be-erased area begins, adjust + * starting offset to be relative to the subdevice start + */ +- for(i = 0; i < concat->num_subdev; i++) +- { ++ for (i = 0; i < concat->num_subdev; i++) { + subdev = concat->subdev[i]; +- if(subdev->size <= erase->addr) ++ if (subdev->size <= erase->addr) + erase->addr -= subdev->size; + else + break; +- } +- if(i >= concat->num_subdev) /* must never happen since size */ +- BUG(); /* limit has been verified above */ ++ } ++ ++ /* must never happen since size limit has been verified above */ ++ if (i >= concat->num_subdev) ++ BUG(); + + /* now do the erase: */ + err = 0; +- for(;length > 0; i++) /* loop for all subevices affected by this request */ +- { +- subdev = concat->subdev[i]; /* get current subdevice */ ++ for (; length > 0; i++) { ++ /* loop for all subdevices affected by this request */ ++ subdev = concat->subdev[i]; /* get current subdevice */ + + /* limit length to subdevice's size: */ +- if(erase->addr + length > subdev->size) ++ if (erase->addr + length > subdev->size) + erase->len = subdev->size - erase->addr; + else + erase->len = length; + +- if (!(subdev->flags & MTD_WRITEABLE)) +- { ++ if (!(subdev->flags & MTD_WRITEABLE)) { + err = -EROFS; + break; + } + length -= erase->len; +- if ((err = concat_dev_erase(subdev, erase))) +- { +- if(err == -EINVAL) /* sanity check: must never happen since */ +- BUG(); /* block alignment has been checked above */ ++ if ((err = concat_dev_erase(subdev, erase))) { ++ /* sanity check: should never happen since ++ * block alignment has been checked above */ ++ if (err == -EINVAL) ++ BUG(); + break; + } + /* +@@ -523,85 +519,79 @@ + return 0; + } + +-static int concat_lock (struct mtd_info *mtd, loff_t ofs, size_t len) ++static int concat_lock(struct mtd_info *mtd, loff_t ofs, size_t len) + { + struct mtd_concat *concat = CONCAT(mtd); + int i, err = -EINVAL; + +- if ((len + ofs) > mtd->size) ++ if ((len + ofs) > mtd->size) + return -EINVAL; + +- for(i = 0; i < concat->num_subdev; i++) +- { ++ for (i = 0; i < concat->num_subdev; i++) { + struct mtd_info *subdev = concat->subdev[i]; + size_t size; + +- if (ofs >= subdev->size) +- { +- size = 0; ++ if (ofs >= subdev->size) { ++ size = 0; + ofs -= subdev->size; ++ continue; + } ++ if (ofs + len > subdev->size) ++ size = subdev->size - ofs; + else +- { +- if (ofs + len > subdev->size) +- size = subdev->size - ofs; +- else +- size = len; ++ size = len; + +- err = subdev->lock(subdev, ofs, size); ++ err = subdev->lock(subdev, ofs, size); + +- if(err) +- break; ++ if (err) ++ break; + +- len -= size; +- if(len == 0) +- break; ++ len -= size; ++ if (len == 0) ++ break; + +- err = -EINVAL; +- ofs = 0; +- } ++ err = -EINVAL; ++ ofs = 0; + } ++ + return err; + } + +-static int concat_unlock (struct mtd_info *mtd, loff_t ofs, size_t len) ++static int concat_unlock(struct mtd_info *mtd, loff_t ofs, size_t len) + { + struct mtd_concat *concat = CONCAT(mtd); + int i, err = 0; + +- if ((len + ofs) > mtd->size) ++ if ((len + ofs) > mtd->size) + return -EINVAL; + +- for(i = 0; i < concat->num_subdev; i++) +- { ++ for (i = 0; i < concat->num_subdev; i++) { + struct mtd_info *subdev = concat->subdev[i]; + size_t size; + +- if (ofs >= subdev->size) +- { +- size = 0; ++ if (ofs >= subdev->size) { ++ size = 0; + ofs -= subdev->size; ++ continue; + } ++ if (ofs + len > subdev->size) ++ size = subdev->size - ofs; + else +- { +- if (ofs + len > subdev->size) +- size = subdev->size - ofs; +- else +- size = len; ++ size = len; + +- err = subdev->unlock(subdev, ofs, size); ++ err = subdev->unlock(subdev, ofs, size); + +- if(err) +- break; ++ if (err) ++ break; + +- len -= size; +- if(len == 0) +- break; ++ len -= size; ++ if (len == 0) ++ break; + +- err = -EINVAL; +- ofs = 0; +- } ++ err = -EINVAL; ++ ofs = 0; + } ++ + return err; + } + +@@ -610,8 +600,7 @@ + struct mtd_concat *concat = CONCAT(mtd); + int i; + +- for(i = 0; i < concat->num_subdev; i++) +- { ++ for (i = 0; i < concat->num_subdev; i++) { + struct mtd_info *subdev = concat->subdev[i]; + subdev->sync(subdev); + } +@@ -622,10 +611,9 @@ + struct mtd_concat *concat = CONCAT(mtd); + int i, rc = 0; + +- for(i = 0; i < concat->num_subdev; i++) +- { ++ for (i = 0; i < concat->num_subdev; i++) { + struct mtd_info *subdev = concat->subdev[i]; +- if((rc = subdev->suspend(subdev)) < 0) ++ if ((rc = subdev->suspend(subdev)) < 0) + return rc; + } + return rc; +@@ -636,8 +624,7 @@ + struct mtd_concat *concat = CONCAT(mtd); + int i; + +- for(i = 0; i < concat->num_subdev; i++) +- { ++ for (i = 0; i < concat->num_subdev; i++) { + struct mtd_info *subdev = concat->subdev[i]; + subdev->resume(subdev); + } +@@ -649,11 +636,10 @@ + * stored to *new_dev upon success. This function does _not_ + * register any devices: this is the caller's responsibility. + */ +-struct mtd_info *mtd_concat_create( +- struct mtd_info *subdev[], /* subdevices to concatenate */ +- int num_devs, /* number of subdevices */ +- char *name) /* name for the new device */ +-{ ++struct mtd_info *mtd_concat_create(struct mtd_info *subdev[], /* subdevices to concatenate */ ++ int num_devs, /* number of subdevices */ ++ char *name) ++{ /* name for the new device */ + int i; + size_t size; + struct mtd_concat *concat; +@@ -661,94 +647,103 @@ + int num_erase_region; + + printk(KERN_NOTICE "Concatenating MTD devices:\n"); +- for(i = 0; i < num_devs; i++) ++ for (i = 0; i < num_devs; i++) + printk(KERN_NOTICE "(%d): \"%s\"\n", i, subdev[i]->name); + printk(KERN_NOTICE "into device \"%s\"\n", name); + + /* allocate the device structure */ + size = SIZEOF_STRUCT_MTD_CONCAT(num_devs); +- concat = kmalloc (size, GFP_KERNEL); +- if(!concat) +- { +- printk ("memory allocation error while creating concatenated device \"%s\"\n", +- name); +- return NULL; ++ concat = kmalloc(size, GFP_KERNEL); ++ if (!concat) { ++ printk ++ ("memory allocation error while creating concatenated device \"%s\"\n", ++ name); ++ return NULL; + } + memset(concat, 0, size); +- concat->subdev = (struct mtd_info **)(concat + 1); ++ concat->subdev = (struct mtd_info **) (concat + 1); + + /* + * Set up the new "super" device's MTD object structure, check for + * incompatibilites between the subdevices. + */ +- concat->mtd.type = subdev[0]->type; +- concat->mtd.flags = subdev[0]->flags; +- concat->mtd.size = subdev[0]->size; ++ concat->mtd.type = subdev[0]->type; ++ concat->mtd.flags = subdev[0]->flags; ++ concat->mtd.size = subdev[0]->size; + concat->mtd.erasesize = subdev[0]->erasesize; +- concat->mtd.oobblock = subdev[0]->oobblock; +- concat->mtd.oobsize = subdev[0]->oobsize; +- concat->mtd.ecctype = subdev[0]->ecctype; +- concat->mtd.eccsize = subdev[0]->eccsize; ++ concat->mtd.oobblock = subdev[0]->oobblock; ++ concat->mtd.oobsize = subdev[0]->oobsize; ++ concat->mtd.ecctype = subdev[0]->ecctype; ++ concat->mtd.eccsize = subdev[0]->eccsize; ++ if (subdev[0]->read_ecc) ++ concat->mtd.read_ecc = concat_read_ecc; ++ if (subdev[0]->write_ecc) ++ concat->mtd.write_ecc = concat_write_ecc; ++ if (subdev[0]->read_oob) ++ concat->mtd.read_oob = concat_read_oob; ++ if (subdev[0]->write_oob) ++ concat->mtd.write_oob = concat_write_oob; + +- concat->subdev[0] = subdev[0]; ++ concat->subdev[0] = subdev[0]; + +- for(i = 1; i < num_devs; i++) +- { +- if(concat->mtd.type != subdev[i]->type) +- { ++ for (i = 1; i < num_devs; i++) { ++ if (concat->mtd.type != subdev[i]->type) { + kfree(concat); +- printk ("Incompatible device type on \"%s\"\n", subdev[i]->name); ++ printk("Incompatible device type on \"%s\"\n", ++ subdev[i]->name); + return NULL; + } +- if(concat->mtd.flags != subdev[i]->flags) +- { /* +- * Expect all flags except MTD_WRITEABLE to be equal on +- * all subdevices. ++ if (concat->mtd.flags != subdev[i]->flags) { ++ /* ++ * Expect all flags except MTD_WRITEABLE to be ++ * equal on all subdevices. + */ +- if((concat->mtd.flags ^ subdev[i]->flags) & ~MTD_WRITEABLE) +- { ++ if ((concat->mtd.flags ^ subdev[i]-> ++ flags) & ~MTD_WRITEABLE) { + kfree(concat); +- printk ("Incompatible device flags on \"%s\"\n", subdev[i]->name); ++ printk("Incompatible device flags on \"%s\"\n", ++ subdev[i]->name); + return NULL; +- } +- else /* if writeable attribute differs, make super device writeable */ +- concat->mtd.flags |= subdev[i]->flags & MTD_WRITEABLE; ++ } else ++ /* if writeable attribute differs, ++ make super device writeable */ ++ concat->mtd.flags |= ++ subdev[i]->flags & MTD_WRITEABLE; + } + concat->mtd.size += subdev[i]->size; +- if(concat->mtd.oobblock != subdev[i]->oobblock || +- concat->mtd.oobsize != subdev[i]->oobsize || +- concat->mtd.ecctype != subdev[i]->ecctype || +- concat->mtd.eccsize != subdev[i]->eccsize) +- { ++ if (concat->mtd.oobblock != subdev[i]->oobblock || ++ concat->mtd.oobsize != subdev[i]->oobsize || ++ concat->mtd.ecctype != subdev[i]->ecctype || ++ concat->mtd.eccsize != subdev[i]->eccsize || ++ !concat->mtd.read_ecc != !subdev[i]->read_ecc || ++ !concat->mtd.write_ecc != !subdev[i]->write_ecc || ++ !concat->mtd.read_oob != !subdev[i]->read_oob || ++ !concat->mtd.write_oob != !subdev[i]->write_oob) { + kfree(concat); +- printk ("Incompatible OOB or ECC data on \"%s\"\n", subdev[i]->name); ++ printk("Incompatible OOB or ECC data on \"%s\"\n", ++ subdev[i]->name); + return NULL; + } + concat->subdev[i] = subdev[i]; +- ++ + } + +- concat->num_subdev = num_devs; +- concat->mtd.name = name; ++ concat->num_subdev = num_devs; ++ concat->mtd.name = name; + + /* + * NOTE: for now, we do not provide any readv()/writev() methods + * because they are messy to implement and they are not + * used to a great extent anyway. + */ +- concat->mtd.erase = concat_erase; +- concat->mtd.read = concat_read; +- concat->mtd.write = concat_write; +- concat->mtd.read_ecc = concat_read_ecc; +- concat->mtd.write_ecc = concat_write_ecc; +- concat->mtd.read_oob = concat_read_oob; +- concat->mtd.write_oob = concat_write_oob; +- concat->mtd.sync = concat_sync; +- concat->mtd.lock = concat_lock; +- concat->mtd.unlock = concat_unlock; +- concat->mtd.suspend = concat_suspend; +- concat->mtd.resume = concat_resume; +- ++ concat->mtd.erase = concat_erase; ++ concat->mtd.read = concat_read; ++ concat->mtd.write = concat_write; ++ concat->mtd.sync = concat_sync; ++ concat->mtd.lock = concat_lock; ++ concat->mtd.unlock = concat_unlock; ++ concat->mtd.suspend = concat_suspend; ++ concat->mtd.resume = concat_resume; + + /* + * Combine the erase block size info of the subdevices: +@@ -758,44 +753,44 @@ + */ + max_erasesize = curr_erasesize = subdev[0]->erasesize; + num_erase_region = 1; +- for(i = 0; i < num_devs; i++) +- { +- if(subdev[i]->numeraseregions == 0) +- { /* current subdevice has uniform erase size */ +- if(subdev[i]->erasesize != curr_erasesize) +- { /* if it differs from the last subdevice's erase size, count it */ ++ for (i = 0; i < num_devs; i++) { ++ if (subdev[i]->numeraseregions == 0) { ++ /* current subdevice has uniform erase size */ ++ if (subdev[i]->erasesize != curr_erasesize) { ++ /* if it differs from the last subdevice's erase size, count it */ + ++num_erase_region; + curr_erasesize = subdev[i]->erasesize; +- if(curr_erasesize > max_erasesize) ++ if (curr_erasesize > max_erasesize) + max_erasesize = curr_erasesize; + } +- } +- else +- { /* current subdevice has variable erase size */ ++ } else { ++ /* current subdevice has variable erase size */ + int j; +- for(j = 0; j < subdev[i]->numeraseregions; j++) +- { /* walk the list of erase regions, count any changes */ +- if(subdev[i]->eraseregions[j].erasesize != curr_erasesize) +- { ++ for (j = 0; j < subdev[i]->numeraseregions; j++) { ++ ++ /* walk the list of erase regions, count any changes */ ++ if (subdev[i]->eraseregions[j].erasesize != ++ curr_erasesize) { + ++num_erase_region; +- curr_erasesize = subdev[i]->eraseregions[j].erasesize; +- if(curr_erasesize > max_erasesize) ++ curr_erasesize = ++ subdev[i]->eraseregions[j]. ++ erasesize; ++ if (curr_erasesize > max_erasesize) + max_erasesize = curr_erasesize; + } + } + } + } + +- if(num_erase_region == 1) +- { /* ++ if (num_erase_region == 1) { ++ /* + * All subdevices have the same uniform erase size. + * This is easy: + */ + concat->mtd.erasesize = curr_erasesize; + concat->mtd.numeraseregions = 0; +- } +- else +- { /* ++ } else { ++ /* + * erase block size varies across the subdevices: allocate + * space to store the data describing the variable erase regions + */ +@@ -804,13 +799,14 @@ + + concat->mtd.erasesize = max_erasesize; + concat->mtd.numeraseregions = num_erase_region; +- concat->mtd.eraseregions = erase_region_p = kmalloc ( +- num_erase_region * sizeof(struct mtd_erase_region_info), GFP_KERNEL); +- if(!erase_region_p) +- { ++ concat->mtd.eraseregions = erase_region_p = ++ kmalloc(num_erase_region * ++ sizeof (struct mtd_erase_region_info), GFP_KERNEL); ++ if (!erase_region_p) { + kfree(concat); +- printk ("memory allocation error while creating erase region list" +- " for device \"%s\"\n", name); ++ printk ++ ("memory allocation error while creating erase region list" ++ " for device \"%s\"\n", name); + return NULL; + } + +@@ -820,46 +816,53 @@ + */ + curr_erasesize = subdev[0]->erasesize; + begin = position = 0; +- for(i = 0; i < num_devs; i++) +- { +- if(subdev[i]->numeraseregions == 0) +- { /* current subdevice has uniform erase size */ +- if(subdev[i]->erasesize != curr_erasesize) +- { /* ++ for (i = 0; i < num_devs; i++) { ++ if (subdev[i]->numeraseregions == 0) { ++ /* current subdevice has uniform erase size */ ++ if (subdev[i]->erasesize != curr_erasesize) { ++ /* + * fill in an mtd_erase_region_info structure for the area + * we have walked so far: + */ +- erase_region_p->offset = begin; +- erase_region_p->erasesize = curr_erasesize; +- erase_region_p->numblocks = (position - begin) / curr_erasesize; ++ erase_region_p->offset = begin; ++ erase_region_p->erasesize = ++ curr_erasesize; ++ erase_region_p->numblocks = ++ (position - begin) / curr_erasesize; + begin = position; + + curr_erasesize = subdev[i]->erasesize; + ++erase_region_p; + } + position += subdev[i]->size; +- } +- else +- { /* current subdevice has variable erase size */ ++ } else { ++ /* current subdevice has variable erase size */ + int j; +- for(j = 0; j < subdev[i]->numeraseregions; j++) +- { /* walk the list of erase regions, count any changes */ +- if(subdev[i]->eraseregions[j].erasesize != curr_erasesize) +- { +- erase_region_p->offset = begin; +- erase_region_p->erasesize = curr_erasesize; +- erase_region_p->numblocks = (position - begin) / curr_erasesize; ++ for (j = 0; j < subdev[i]->numeraseregions; j++) { ++ /* walk the list of erase regions, count any changes */ ++ if (subdev[i]->eraseregions[j]. ++ erasesize != curr_erasesize) { ++ erase_region_p->offset = begin; ++ erase_region_p->erasesize = ++ curr_erasesize; ++ erase_region_p->numblocks = ++ (position - ++ begin) / curr_erasesize; + begin = position; + +- curr_erasesize = subdev[i]->eraseregions[j].erasesize; ++ curr_erasesize = ++ subdev[i]->eraseregions[j]. ++ erasesize; + ++erase_region_p; + } +- position += subdev[i]->eraseregions[j].numblocks * curr_erasesize; ++ position += ++ subdev[i]->eraseregions[j]. ++ numblocks * curr_erasesize; + } + } + } + /* Now write the final entry */ +- erase_region_p->offset = begin; ++ erase_region_p->offset = begin; + erase_region_p->erasesize = curr_erasesize; + erase_region_p->numblocks = (position - begin) / curr_erasesize; + } +@@ -874,16 +877,14 @@ + void mtd_concat_destroy(struct mtd_info *mtd) + { + struct mtd_concat *concat = CONCAT(mtd); +- if(concat->mtd.numeraseregions) ++ if (concat->mtd.numeraseregions) + kfree(concat->mtd.eraseregions); + kfree(concat); + } + +- + EXPORT_SYMBOL(mtd_concat_create); + EXPORT_SYMBOL(mtd_concat_destroy); + +- + MODULE_LICENSE("GPL"); + MODULE_AUTHOR("Robert Kaiser <rkaiser@sysgo.de>"); + MODULE_DESCRIPTION("Generic support for concatenating of MTD devices"); +--- linux-2.6.5/drivers/mtd/maps/Makefile~heh 2004-04-03 22:36:12.000000000 -0500 ++++ linux-2.6.5/drivers/mtd/maps/Makefile 2004-04-30 20:57:36.000000000 -0400 +@@ -17,12 +17,14 @@ + obj-$(CONFIG_MTD_ELAN_104NC) += elan-104nc.o + obj-$(CONFIG_MTD_EPXA10DB) += epxa10db-flash.o + obj-$(CONFIG_MTD_IQ80310) += iq80310.o ++obj-$(CONFIG_MTD_IQ80321) += iq80321.o + obj-$(CONFIG_MTD_L440GX) += l440gx.o + obj-$(CONFIG_MTD_AMD76XROM) += amd76xrom.o + obj-$(CONFIG_MTD_ICH2ROM) += ich2rom.o + obj-$(CONFIG_MTD_TSUNAMI) += tsunami_flash.o + obj-$(CONFIG_MTD_LUBBOCK) += lubbock-flash.o + obj-$(CONFIG_MTD_MBX860) += mbx860.o ++obj-$(CONFIG_MTD_NORA) += nora.o + obj-$(CONFIG_MTD_CEIVA) += ceiva.o + obj-$(CONFIG_MTD_OCTAGON) += octagon-5066.o + obj-$(CONFIG_MTD_PHYSMAP) += physmap.o +--- linux-2.6.5/drivers/mtd/maps/sa1100-flash.c~heh 2004-04-03 22:36:51.000000000 -0500 ++++ linux-2.6.5/drivers/mtd/maps/sa1100-flash.c 2004-04-30 20:57:36.000000000 -0400 +@@ -14,6 +14,7 @@ + #include <linux/init.h> + #include <linux/errno.h> + #include <linux/slab.h> ++#include <linux/device.h> + + #include <linux/mtd/mtd.h> + #include <linux/mtd/map.h> +@@ -887,6 +888,7 @@ + int width; + void *vbase; + void (*set_vpp)(struct map_info *, int); ++ char name[16]; + struct map_info *map; + struct mtd_info *mtd; + struct resource *res; +@@ -925,6 +927,8 @@ + } + + sa[i].map = maps + i; ++ sa[i].map->name = sa[i].name; ++ sprintf(sa[i].name, "sa1100-%d", i); + + sa[i].vbase = ioremap(sa[i].base, sa[i].size); + if (!sa[i].vbase) { +@@ -986,7 +990,7 @@ + */ + #ifdef CONFIG_MTD_CONCAT + *rmtd = mtd_concat_create(subdev, found, +- "sa1100 flash"); ++ "sa1100"); + if (*rmtd == NULL) + ret = -ENXIO; + #else +@@ -1044,13 +1048,9 @@ + * - Is the MSC setup for flash (no -> failure) + * - Probe for flash + */ +- +-static struct map_info sa1100_probe_map __initdata = { +- .name = "SA1100-flash", +-}; +- +-static void __init sa1100_probe_one_cs(unsigned int msc, unsigned long phys) ++static void sa1100_probe_one_cs(unsigned int msc, unsigned long phys) + { ++ struct map_info map; + struct mtd_info *mtd; + + printk(KERN_INFO "* Probing 0x%08lx: MSC = 0x%04x %d bit ", +@@ -1066,19 +1066,23 @@ + return; + } + +- sa1100_probe_map.buswidth = msc & MSC_RBW ? 2 : 4; +- sa1100_probe_map.size = SZ_1M; +- sa1100_probe_map.phys = phys; +- sa1100_probe_map.virt = (unsigned long)ioremap(phys, SZ_1M); +- if (sa1100_probe_map.virt == 0) ++ memset(&map, 0, sizeof(map)); ++ ++ map.name = "Probe"; ++ map.buswidth = msc & MSC_RBW ? 2 : 4; ++ map.size = SZ_1M; ++ map.phys = NO_XIP; ++ map.virt = (unsigned long)ioremap(phys, SZ_1M); ++ if (map.virt == 0) + goto fail; +- simple_map_init(&sa1100_probe_map); ++ ++ simple_map_init(&map); + + /* Shame cfi_probe blurts out kernel messages... */ +- mtd = do_map_probe("cfi_probe", &sa1100_probe_map); ++ mtd = do_map_probe("cfi_probe", &map); + if (mtd) + map_destroy(mtd); +- iounmap((void *)sa1100_probe_map.virt); ++ iounmap((void *)map.virt); + + if (!mtd) + goto fail; +@@ -1090,7 +1094,7 @@ + printk("failed\n"); + } + +-static void __init sa1100_probe_flash(void) ++static void sa1100_probe_flash(void) + { + printk(KERN_INFO "-- SA11xx Flash probe. Please report results.\n"); + sa1100_probe_one_cs(MSC0, SA1100_CS0_PHYS); +@@ -1321,10 +1325,9 @@ + kfree(parsed_parts); + } + +-static struct mtd_info *mymtd; +- +-static int __init sa1100_mtd_init(void) ++static int __init sa1100_mtd_probe(struct device *dev) + { ++ struct mtd_info *mtd; + int ret; + int nr; + +@@ -1332,21 +1335,74 @@ + if (nr < 0) + return nr; + +- ret = sa1100_setup_mtd(info, nr, &mymtd); +- if (ret == 0) +- sa1100_locate_partitions(mymtd); ++ ret = sa1100_setup_mtd(info, nr, &mtd); ++ if (ret == 0) { ++ sa1100_locate_partitions(mtd); ++ dev_set_drvdata(dev, mtd); ++ } + + return ret; + } + +-static void __exit sa1100_mtd_cleanup(void) ++static int __exit sa1100_mtd_remove(struct device *dev) + { +- sa1100_destroy_mtd(info, mymtd); ++ struct mtd_info *mtd = dev_get_drvdata(dev); ++ sa1100_destroy_mtd(info, mtd); + sa1100_destroy_partitions(); ++ return 0; ++} ++ ++static int sa1100_mtd_suspend(struct device *dev, u32 level, u32 state) ++{ ++ struct mtd_info *mtd = dev_get_drvdata(dev); ++ if (level == SUSPEND_SAVE_STATE) ++ mtd->suspend(mtd); ++ return 0; ++} ++ ++static int sa1100_mtd_resume(struct device *dev, u32 level) ++{ ++ struct mtd_info *mtd = dev_get_drvdata(dev); ++ if (level == RESUME_RESTORE_STATE) ++ mtd->resume(mtd); ++ return 0; ++} ++ ++static struct platform_device sa1100_mtd_device = { ++ .name = "flash", ++ .id = 0, ++}; ++ ++static struct device_driver sa1100_mtd_driver = { ++ .name = "flash", ++ .bus = &platform_bus_type, ++ .probe = sa1100_mtd_probe, ++#ifdef MODULE ++ .remove = sa1100_mtd_remove, ++#endif ++ .suspend = sa1100_mtd_suspend, ++ .resume = sa1100_mtd_resume, ++}; ++ ++static int __init sa1100_mtd_init(void) ++{ ++ int ret = driver_register(&sa1100_mtd_driver); ++ if (ret == 0) { ++ ret = platform_device_register(&sa1100_mtd_device); ++ if (ret) ++ driver_unregister(&sa1100_mtd_driver); ++ } ++ return ret; ++} ++ ++static void __exit sa1100_mtd_exit(void) ++{ ++ platform_device_unregister(&sa1100_mtd_device); ++ driver_unregister(&sa1100_mtd_driver); + } + + module_init(sa1100_mtd_init); +-module_exit(sa1100_mtd_cleanup); ++module_exit(sa1100_mtd_exit); + + MODULE_AUTHOR("Nicolas Pitre"); + MODULE_DESCRIPTION("SA1100 CFI map driver"); +--- linux-2.6.5/drivers/mtd/maps/pcmciamtd.c~heh 2004-04-03 22:36:19.000000000 -0500 ++++ linux-2.6.5/drivers/mtd/maps/pcmciamtd.c 2004-04-30 20:57:36.000000000 -0400 +@@ -25,10 +25,9 @@ + #include <pcmcia/ds.h> + + #include <linux/mtd/map.h> +-#include <linux/mtd/mtd.h> + +-#ifdef CONFIG_MTD_DEBUG +-static int debug = CONFIG_MTD_DEBUG_VERBOSE; ++#if 1 //def CONFIG_MTD_DEBUG ++static int debug = 5; //CONFIG_MTD_DEBUG_VERBOSE; + MODULE_PARM(debug, "i"); + MODULE_PARM_DESC(debug, "Set Debug Level 0=quiet, 5=noisy"); + #undef DEBUG +@@ -88,7 +87,7 @@ + static int setvpp; + + /* Force card to be treated as FLASH, ROM or RAM */ +-static int mem_type; ++static int mem_type = 1; + + MODULE_LICENSE("GPL"); + MODULE_AUTHOR("Simon Evans <spse@secret.org.uk>"); +--- linux-2.6.5/drivers/mtd/maps/pci.c~heh 2004-04-03 22:36:56.000000000 -0500 ++++ linux-2.6.5/drivers/mtd/maps/pci.c 2004-04-30 20:57:36.000000000 -0400 +@@ -22,6 +22,8 @@ + #include <linux/mtd/map.h> + #include <linux/mtd/partitions.h> + ++#include <asm/io.h> ++ + struct map_pci_info; + + struct mtd_pci_info { +--- linux-2.6.5/drivers/input/Kconfig~heh 2004-04-03 22:36:18.000000000 -0500 ++++ linux-2.6.5/drivers/input/Kconfig 2004-04-30 20:57:36.000000000 -0400 +@@ -80,7 +80,7 @@ + module will be called joydev. + + config INPUT_TSDEV +- tristate "Touchscreen interface" ++ tristate "Compaq Touchscreen interface" + depends on INPUT + ---help--- + Say Y here if you have an application that only can understand the +@@ -102,6 +102,10 @@ + depends on INPUT_TSDEV + default "320" + ++config INPUT_TSLIBDEV ++ tristate "TSLIB Touchscreen interface" ++ depends on INPUT ++ + config INPUT_EVDEV + tristate "Event interface" + depends on INPUT +--- linux-2.6.5/drivers/input/serio/Kconfig~heh 2004-04-03 22:37:07.000000000 -0500 ++++ linux-2.6.5/drivers/input/serio/Kconfig 2004-04-30 20:57:36.000000000 -0400 +@@ -80,7 +80,7 @@ + + config SERIO_RPCKBD + tristate "Acorn RiscPC keyboard controller" +- depends on ARCH_ACORN && SERIO ++ depends on (ARCH_ACORN || ARCH_CLPS7500) && SERIO + default y + help + Say Y here if you have the Acorn RiscPC and want to use an AT +@@ -89,6 +89,18 @@ + To compile this driver as a module, choose M here: the + module will be called rpckbd. + ++config SERIO_CLPS7500 ++ tristate "CLPS7500 PS/2 mouse port controller" ++ depends on ARCH_CLPS7500 && SERIO ++ help ++ Say Y here if you have CLPS7500 based hardware and want to use ++ the mouse port. ++ ++ This driver is also available as a module ( = code which can be ++ inserted in and removed from the running kernel whenever you want). ++ The module will be called clps7500ps2. If you want to compile it ++ as a module, say M here and read <file:Documentation/modules.txt>. ++ + config SERIO_AMBAKMI + tristate "AMBA KMI keyboard controller" + depends on ARCH_INTEGRATOR && SERIO +--- /dev/null 2003-09-23 18:19:32.000000000 -0400 ++++ linux-2.6.5/drivers/input/serio/sa1100ir.c 2004-04-30 20:57:36.000000000 -0400 +@@ -0,0 +1,90 @@ ++/* ++ * linux/drivers/input/serio/sa1100ir.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; either version 2. ++ */ ++#include <linux/module.h> ++#include <linux/init.h> ++#include <linux/serio.h> ++ ++#include <asm/io.h> ++#include <asm/irq.h> ++#include <asm/hardware.h> ++ ++ ++ ++struct sa1100_kbd { ++ struct serio io; ++ void *base; ++ int irq; ++}; ++ ++static void sa1100ir_int(int irq, void *dev_id, struct pt_regs *regs) ++{ ++ struct sa1100_kbd *kbd = dev_id; ++ unsigned int status; ++ ++ do { ++ unsigned int flag, data; ++ ++ status = readl(kbd->base + UTSR1); ++ if (!(status & UTSR1_RNE)) ++ break; ++ ++ flag = (status & UTSR1_FRE ? SERIO_FRAME : 0) | ++ (status & UTSR1_PRE ? SERIO_PARITY : 0); ++ ++ data = readl(kbd->base + UTDR); ++ ++ serio_interrupt(&kbd->io, data, flag); ++ } while (1); ++ ++ status = readl(kbd->base + UTSR0) & UTSR0_RID | UTSR0_RBB | UTSR0_REB; ++ if (status) ++ writel(status, kbd->base + UTSR0); ++} ++ ++static int sa1100ir_kbd_open(struct serio *io) ++{ ++ struct sa1100_kbd *kbd = io->driver; ++ int ret; ++ ++ ret = request_irq(kbd->irq, sa1100ir_int, 0, kbd->io.phys, kbd); ++ if (ret) ++ return ret; ++ ++ return 0; ++} ++ ++static void sa1100ir_kbd_close(struct serio *io) ++{ ++ struct sa1100_kbd *kbd = io->driver; ++ ++ free_irq(kbd->irq, kbd); ++} ++ ++static struct sa1100_kbd sa1100_kbd = { ++ .io = { ++ .type = 0, ++ .open = sa1100ir_kbd_open, ++ .close = sa1100ir_kbd_close, ++ .name = "SA11x0 IR port", ++ .phys = "sa11x0/ir", ++ .driver = &sa1100_kbd, ++ }, ++}; ++ ++static int __init sa1100_kbd_init(void) ++{ ++ serio_register_port(&sa1100_kbd.io); ++} ++ ++static void __exit sa1100_kbd_exit(void) ++{ ++ serio_unregister_port(&sa1100_kbd.io); ++} ++ ++module_init(sa1100_kbd_init); ++module_exit(sa1100_kbd_exit); +--- linux-2.6.5/drivers/input/serio/Makefile~heh 2004-04-03 22:36:16.000000000 -0500 ++++ linux-2.6.5/drivers/input/serio/Makefile 2004-04-30 20:57:36.000000000 -0400 +@@ -10,6 +10,7 @@ + obj-$(CONFIG_SERIO_SERPORT) += serport.o + obj-$(CONFIG_SERIO_CT82C710) += ct82c710.o + obj-$(CONFIG_SERIO_RPCKBD) += rpckbd.o ++obj-$(CONFIG_SERIO_CLPS7500) += clps7500ps2.o + obj-$(CONFIG_SERIO_SA1111) += sa1111ps2.o + obj-$(CONFIG_SERIO_AMBAKMI) += ambakmi.o + obj-$(CONFIG_SERIO_Q40KBD) += q40kbd.o +--- /dev/null 2003-09-23 18:19:32.000000000 -0400 ++++ linux-2.6.5/drivers/input/tslibdev.c 2004-04-30 20:57:36.000000000 -0400 +@@ -0,0 +1,358 @@ ++/* ++ * linux/drivers/input/tslibdev.c ++ * ++ * Copyright (C) 2002 Russell King ++ * ++ * From tsdev.c: ++ * ++ * Copyright (c) 2001 "Crazy" james Simmons ++ * ++ * Input driver to Touchscreen device driver module. ++ * ++ * Sponsored by Transvirtual Technology ++ */ ++ ++/* ++ * 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 ++ * ++ * Should you need to contact me, the author, you can do so either by ++ * e-mail - mail your message to <jsimmons@transvirtual.com>. ++ */ ++ ++#include <linux/slab.h> ++#include <linux/poll.h> ++#include <linux/module.h> ++#include <linux/init.h> ++#include <linux/input.h> ++#include <linux/config.h> ++#include <linux/smp_lock.h> ++#include <linux/random.h> ++#include <linux/time.h> ++#include <linux/list.h> ++#include <linux/miscdevice.h> ++ ++struct ucb1x00_dev { ++ int exist; ++ char name[16]; ++ wait_queue_head_t wait; ++ struct list_head list; ++ struct input_handle handle; ++ int x; ++ int y; ++ int pressure; ++}; ++ ++struct ts_event { ++ u16 pressure; ++ u16 x; ++ u16 y; ++ u16 pad; ++ struct timeval stamp; ++}; ++ ++#define TSDEV_BUFFER_SIZE 64 ++ ++struct ucb1x00_list { ++ struct list_head list; ++ struct fasync_struct *fasync; ++ struct ucb1x00_dev *tsdev; ++ unsigned int head; ++ unsigned int tail; ++ struct ts_event event[TSDEV_BUFFER_SIZE]; ++}; ++ ++static struct input_handler ucb1x00_handler; ++static struct ucb1x00_dev *ucb1x00_dev; ++ ++static void ucb1x00_remove(struct ucb1x00_dev *tsdev); ++ ++ ++static int ucb1x00_fasync(int fd, struct file *file, int on) ++{ ++ struct ucb1x00_list *list = file->private_data; ++ int retval; ++ ++ retval = fasync_helper(fd, file, on, &list->fasync); ++ return retval < 0 ? retval : 0; ++} ++ ++static int ucb1x00_open(struct inode *inode, struct file *file) ++{ ++ struct ucb1x00_list *list; ++ int empty; ++ ++ if (!ucb1x00_dev || !ucb1x00_dev->exist) ++ return -ENODEV; ++ ++ printk(KERN_WARNING ++ "tslibdev: process %s (%d) uses obsolete tslib device\n", ++ current->comm, current->pid); ++ ++ list = kmalloc(sizeof(struct ucb1x00_list), GFP_KERNEL); ++ if (!list) ++ return -ENOMEM; ++ ++ memset(list, 0, sizeof(struct ucb1x00_list)); ++ ++ empty = list_empty(&ucb1x00_dev->list); ++ ++ list->tsdev = ucb1x00_dev; ++ list_add(&list->list, &list->tsdev->list); ++ ++ file->private_data = list; ++ ++ if (empty && list->tsdev->exist) ++ input_open_device(&list->tsdev->handle); ++ ++ return 0; ++} ++ ++static int ucb1x00_release(struct inode *inode, struct file *file) ++{ ++ struct ucb1x00_list *list = file->private_data; ++ ++ ucb1x00_fasync(-1, file, 0); ++ ++ list_del(&list->list); ++ ++ ucb1x00_remove(list->tsdev); ++ ++ kfree(list); ++ ++ return 0; ++} ++ ++static ssize_t ++ucb1x00_read(struct file *file, char *buffer, size_t count, loff_t * ppos) ++{ ++ DECLARE_WAITQUEUE(wait, current); ++ struct ucb1x00_list *list = file->private_data; ++ int retval = 0; ++ ++ if (list->head == list->tail) { ++ add_wait_queue(&list->tsdev->wait, &wait); ++ ++ while (list->head == list->tail) { ++ set_current_state(TASK_INTERRUPTIBLE); ++ ++ if (!list->tsdev->exist) { ++ retval = -ENODEV; ++ break; ++ } ++ if (file->f_flags & O_NONBLOCK) { ++ retval = -EAGAIN; ++ break; ++ } ++ if (signal_pending(current)) { ++ retval = -ERESTARTSYS; ++ break; ++ } ++ schedule(); ++ } ++ set_current_state(TASK_RUNNING); ++ remove_wait_queue(&list->tsdev->wait, &wait); ++ } ++ ++ if (retval) ++ return retval; ++ ++ while (list->head != list->tail && count >= sizeof(struct ts_event)) { ++ if (copy_to_user(buffer, list->event + list->tail, ++ sizeof(struct ts_event))) ++ return retval ? retval : -EFAULT; ++ list->tail = (list->tail + 1) & (TSDEV_BUFFER_SIZE - 1); ++ retval += sizeof(struct ts_event); ++ buffer += sizeof(struct ts_event); ++ count -= sizeof(struct ts_event); ++ } ++ return retval; ++} ++ ++/* No kernel lock - fine */ ++static unsigned int ucb1x00_poll(struct file *file, poll_table * wait) ++{ ++ struct ucb1x00_list *list = file->private_data; ++ ++ poll_wait(file, &list->tsdev->wait, wait); ++ if (list->head != list->tail || !list->tsdev->exist) ++ return POLLIN | POLLRDNORM; ++ return 0; ++} ++ ++static int ++ucb1x00_ioctl(struct inode *inode, struct file *file, unsigned int cmd, ++ unsigned long arg) ++{ ++ return -EINVAL; ++} ++ ++struct file_operations ucb1x00_fops = { ++ .owner = THIS_MODULE, ++ .open = ucb1x00_open, ++ .release = ucb1x00_release, ++ .read = ucb1x00_read, ++ .poll = ucb1x00_poll, ++ .fasync = ucb1x00_fasync, ++ .ioctl = ucb1x00_ioctl, ++}; ++ ++/* ++ * The official UCB1x00 touchscreen is a miscdevice: ++ * 10 char Non-serial mice, misc features ++ * 14 = /dev/touchscreen/ucb1x00 UCB 1x00 touchscreen ++ */ ++static struct miscdevice ucb1x00_ts_dev = { ++ .minor = 14, ++ .name = "touchscreen/ucb1x00", ++ .fops = &ucb1x00_fops, ++ .devfs_name = "touchscreen/ucb1x00", ++}; ++ ++static void ucb1x00_remove(struct ucb1x00_dev *tsdev) ++{ ++ if (list_empty(&tsdev->list)) { ++ if (tsdev->exist) { ++ input_close_device(&tsdev->handle); ++ wake_up_interruptible(&tsdev->wait); ++ } else { ++ misc_deregister(&ucb1x00_ts_dev); ++ ucb1x00_dev = NULL; ++ kfree(tsdev); ++ } ++ } ++} ++ ++ ++static void ++ucb1x00_event(struct input_handle *handle, unsigned int type, unsigned int code, ++ int value) ++{ ++ struct ucb1x00_dev *tsdev = handle->private; ++ struct list_head *l; ++ ++ /* sorry, we only handle absolute stuff */ ++ if (type == EV_ABS) { ++ switch (code) { ++ case ABS_X: ++ tsdev->x = value; ++ break; ++ case ABS_Y: ++ tsdev->y = value; ++ break; ++ case ABS_PRESSURE: ++ tsdev->pressure = value; ++ break; ++ } ++ return; ++ } ++ ++ if (type != EV_SYN || code != SYN_REPORT) ++ return; ++ ++ list_for_each(l, &tsdev->list) { ++ struct ucb1x00_list *list = list_entry(l, struct ucb1x00_list, list); ++ list->event[list->head].pressure = tsdev->pressure; ++ if (tsdev->pressure) { ++ list->event[list->head].x = tsdev->x; ++ list->event[list->head].y = tsdev->y; ++ } else { ++ list->event[list->head].x = 0; ++ list->event[list->head].y = 0; ++ } ++ do_gettimeofday(&list->event[list->head].stamp); ++ list->head = (list->head + 1) & (TSDEV_BUFFER_SIZE - 1); ++ kill_fasync(&list->fasync, SIGIO, POLL_IN); ++ } ++ wake_up_interruptible(&tsdev->wait); ++} ++ ++static struct input_handle * ++ucb1x00_connect(struct input_handler *handler, struct input_dev *dev, ++ struct input_device_id *id) ++{ ++ struct ucb1x00_dev *tsdev; ++ ++ if (ucb1x00_dev) ++ return NULL; ++ ++ tsdev = kmalloc(sizeof(struct ucb1x00_dev), GFP_KERNEL); ++ if (!tsdev) ++ return NULL; ++ ++ memset(tsdev, 0, sizeof(struct ucb1x00_dev)); ++ init_waitqueue_head(&tsdev->wait); ++ INIT_LIST_HEAD(&tsdev->list); ++ ++ ucb1x00_dev = tsdev; ++ ++ strcpy(tsdev->name, ucb1x00_ts_dev.name); ++ ++ tsdev->handle.dev = dev; ++ tsdev->handle.name = tsdev->name; ++ tsdev->handle.handler = handler; ++ tsdev->handle.private = tsdev; ++ ++ misc_register(&ucb1x00_ts_dev); ++ ++ tsdev->exist = 1; ++ ++ return &tsdev->handle; ++} ++ ++static void ucb1x00_disconnect(struct input_handle *handle) ++{ ++ struct ucb1x00_dev *tsdev = handle->private; ++ ++ tsdev->exist = 0; ++ ucb1x00_remove(tsdev); ++} ++ ++static struct input_device_id ucb1x00_ids[] = { ++ { ++ .flags = INPUT_DEVICE_ID_MATCH_ABSBIT, ++ .evbit = { BIT(EV_ABS) }, ++ .absbit = { BIT(ABS_X) | BIT(ABS_Y) | BIT(ABS_PRESSURE) }, ++ }, ++ ++ {},/* Terminating entry */ ++}; ++ ++MODULE_DEVICE_TABLE(input, ucb1x00_ids); ++ ++static struct input_handler ucb1x00_handler = { ++ .event = ucb1x00_event, ++ .connect = ucb1x00_connect, ++ .disconnect = ucb1x00_disconnect, ++ .name = "touchscreen/ucb1x00", ++ .id_table = ucb1x00_ids, ++}; ++ ++static int __init ucb1x00_init(void) ++{ ++ input_register_handler(&ucb1x00_handler); ++ printk(KERN_INFO "ts: UCB1x00 touchscreen protocol output\n"); ++ return 0; ++} ++ ++static void __exit ucb1x00_exit(void) ++{ ++ input_unregister_handler(&ucb1x00_handler); ++} ++ ++module_init(ucb1x00_init); ++module_exit(ucb1x00_exit); ++ ++MODULE_AUTHOR("Russell King <rmk@arm.linux.org.uk>"); ++MODULE_DESCRIPTION("Input driver to UCB1x00 touchscreen converter"); +--- linux-2.6.5/drivers/input/Makefile~heh 2004-04-03 22:38:17.000000000 -0500 ++++ linux-2.6.5/drivers/input/Makefile 2004-04-30 20:57:36.000000000 -0400 +@@ -8,6 +8,7 @@ + obj-$(CONFIG_INPUT_MOUSEDEV) += mousedev.o + obj-$(CONFIG_INPUT_JOYDEV) += joydev.o + obj-$(CONFIG_INPUT_EVDEV) += evdev.o ++obj-$(CONFIG_INPUT_TSLIBDEV) += tslibdev.o + obj-$(CONFIG_INPUT_TSDEV) += tsdev.o + obj-$(CONFIG_INPUT_POWER) += power.o + obj-$(CONFIG_INPUT_EVBUG) += evbug.o +--- /dev/null 2003-09-23 18:19:32.000000000 -0400 ++++ linux-2.6.5/drivers/char/sa1100-rtc.c 2004-04-30 20:57:36.000000000 -0400 +@@ -0,0 +1,416 @@ ++/* ++ * Real Time Clock interface for Linux on Intel SA11x0/PXA2xx ++ * ++ * Copyright (c) 2000 Nils Faerber ++ * ++ * Based on rtc.c by Paul Gortmaker ++ * Date/time conversion routines taken from arch/arm/kernel/time.c ++ * by Linus Torvalds and Russel King ++ * and the GNU C Library ++ * ( ... I love the GPL ... just take what you need! ;) ++ * ++ * 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. ++ * ++ * 1.00 2001-06-08 Nicolas Pitre <nico@cam.org> ++ * - added periodic timer capability using OSMR1 ++ * - flag compatibility with other RTC chips ++ * - permission checks for ioctls ++ * - major cleanup, partial rewrite ++ * ++ * 0.03 2001-03-07 CIH <cih@coventive.com> ++ * - Modify the bug setups RTC clock. ++ * ++ * 0.02 2001-02-27 Nils Faerber <nils@@kernelconcepts.de> ++ * - removed mktime(), added alarm irq clear ++ * ++ * 0.01 2000-10-01 Nils Faerber <nils@@kernelconcepts.de> ++ * - initial release ++ */ ++ ++#include <linux/module.h> ++#include <linux/fs.h> ++#include <linux/miscdevice.h> ++#include <linux/string.h> ++#include <linux/init.h> ++#include <linux/poll.h> ++#include <linux/proc_fs.h> ++#include <linux/interrupt.h> ++#include <linux/rtc.h> ++ ++#include <asm/bitops.h> ++#include <asm/hardware.h> ++#include <asm/irq.h> ++#include <asm/rtc.h> ++ ++#define TIMER_FREQ 3686400 ++ ++#define RTC_DEF_DIVIDER 32768 - 1 ++#define RTC_DEF_TRIM 0 ++ ++/* Those are the bits from a classic RTC we want to mimic */ ++#define RTC_IRQF 0x80 /* any of the following 3 is active */ ++#define RTC_PF 0x40 ++#define RTC_AF 0x20 ++#define RTC_UF 0x10 ++ ++static unsigned long rtc_freq = 1024; ++static struct rtc_time rtc_alarm = { ++ .tm_year = 0, ++ .tm_mon = 0, ++ .tm_mday = 0, ++ .tm_hour = 0, ++ .tm_mon = 0, ++ .tm_sec = 0, ++}; ++ ++extern spinlock_t rtc_lock; ++ ++static int rtc_update_alarm(struct rtc_time *alrm) ++{ ++ struct rtc_time alarm_tm, now_tm; ++ unsigned long now, time; ++ int ret; ++ ++ do { ++ now = RCNR; ++ rtc_time_to_tm(now, &now_tm); ++ rtc_next_alarm_time(&alarm_tm, &now_tm, alrm); ++ ret = rtc_tm_to_time(&alarm_tm, &time); ++ if (ret != 0) ++ break; ++ ++ RTSR = RTSR & (RTSR_HZE|RTSR_ALE|RTSR_AL); ++ RTAR = time; ++ } while (now != RCNR); ++ ++ return ret; ++} ++ ++static irqreturn_t rtc_interrupt(int irq, void *dev_id, struct pt_regs *regs) ++{ ++ unsigned int rtsr; ++ unsigned long events = 0; ++ ++ spin_lock(&rtc_lock); ++ ++ rtsr = RTSR; ++ /* clear interrupt sources */ ++ RTSR = 0; ++ RTSR = (RTSR_AL|RTSR_HZ) & (rtsr >> 2); ++ ++ /* clear alarm interrupt if it has occurred */ ++ if (rtsr & RTSR_AL) ++ rtsr &= ~RTSR_ALE; ++ RTSR = rtsr & (RTSR_ALE|RTSR_HZE); ++ ++ /* update irq data & counter */ ++ if (rtsr & RTSR_AL) ++ events |= (RTC_AF|RTC_IRQF); ++ if (rtsr & RTSR_HZ) ++ events |= (RTC_UF|RTC_IRQF); ++ ++ rtc_update(1, events); ++ ++ if (rtsr & RTSR_AL && rtc_periodic_alarm(&rtc_alarm)) ++ rtc_update_alarm(&rtc_alarm); ++ ++ spin_unlock(&rtc_lock); ++ ++ return IRQ_HANDLED; ++} ++ ++#if 0 ++static unsigned long rtc_irq_data; ++ ++static irqreturn_t timer1_interrupt(int irq, void *dev_id, struct pt_regs *regs) ++{ ++ /* ++ * If we match for the first time, the periodic interrupt flag won't ++ * be set. If it is, then we did wrap around (very unlikely but ++ * still possible) and compute the amount of missed periods. ++ * The match reg is updated only when the data is actually retrieved ++ * to avoid unnecessary interrupts. ++ */ ++ OSSR = OSSR_M1; /* clear match on timer1 */ ++ if (rtc_irq_data & RTC_PF) { ++ rtc_irq_data += (rtc_freq * ((1<<30)/(TIMER_FREQ>>2))) << 8; ++ } else { ++ rtc_update(1, RTC_PF | RTC_IRQF); ++ } ++ ++ wake_up_interruptible(&rtc_wait); ++ kill_fasync (&rtc_async_queue, SIGIO, POLL_IN); ++ ++ return IRQ_HANDLED; ++} ++#endif ++ ++static int sa1100_rtc_open(void) ++{ ++ int ret; ++ ++ ret = request_irq(IRQ_RTC1Hz, rtc_interrupt, SA_INTERRUPT, "rtc 1Hz", NULL); ++ if (ret) { ++ printk(KERN_ERR "rtc: IRQ%d already in use.\n", IRQ_RTC1Hz); ++ goto fail_ui; ++ } ++ ret = request_irq(IRQ_RTCAlrm, rtc_interrupt, SA_INTERRUPT, "rtc Alrm", NULL); ++ if (ret) { ++ printk(KERN_ERR "rtc: IRQ%d already in use.\n", IRQ_RTCAlrm); ++ goto fail_ai; ++ } ++#if 0 ++ ret = request_irq(IRQ_OST1, timer1_interrupt, SA_INTERRUPT, "rtc timer", NULL); ++ if (ret) { ++ printk(KERN_ERR "rtc: IRQ%d already in use.\n", IRQ_OST1); ++ goto fail_pi; ++ } ++ rtc_irq_data = 0; ++#endif ++ return 0; ++ ++ fail_pi: ++ free_irq(IRQ_RTCAlrm, NULL); ++ fail_ai: ++ free_irq(IRQ_RTC1Hz, NULL); ++ fail_ui: ++ return ret; ++} ++ ++static void sa1100_rtc_release(void) ++{ ++ spin_lock_irq (&rtc_lock); ++ RTSR = 0; ++ OIER &= ~OIER_E1; ++ OSSR = OSSR_M1; ++ spin_unlock_irq (&rtc_lock); ++ ++// free_irq(IRQ_OST1, NULL); ++ free_irq(IRQ_RTCAlrm, NULL); ++ free_irq(IRQ_RTC1Hz, NULL); ++} ++ ++#if 0 ++ssize_t rtc_read(struct file *file, char *buf, size_t count, loff_t *ppos) ++{ ++ DECLARE_WAITQUEUE(wait, current); ++ unsigned long data; ++ ssize_t retval; ++ ++ if (count < sizeof(unsigned long)) ++ return -EINVAL; ++ ++ add_wait_queue(&rtc_wait, &wait); ++ set_current_state(TASK_INTERRUPTIBLE); ++ for (;;) { ++ spin_lock_irq (&rtc_lock); ++ data = rtc_irq_data; ++ if (data != 0) { ++ rtc_irq_data = 0; ++ break; ++ } ++ spin_unlock_irq (&rtc_lock); ++ ++ if (file->f_flags & O_NONBLOCK) { ++ retval = -EAGAIN; ++ goto out; ++ } ++ ++ if (signal_pending(current)) { ++ retval = -ERESTARTSYS; ++ goto out; ++ } ++ ++ schedule(); ++ } ++ ++ if (data & RTC_PF) { ++ /* interpolate missed periods and set match for the next one */ ++ unsigned long period = TIMER_FREQ/rtc_freq; ++ unsigned long oscr = OSCR; ++ unsigned long osmr1 = OSMR1; ++ unsigned long missed = (oscr - osmr1)/period; ++ data += missed << 8; ++ OSSR = OSSR_M1; /* clear match on timer 1 */ ++ OSMR1 = osmr1 + (missed + 1)*period; ++ /* ensure we didn't miss another match in the mean time */ ++ while( (signed long)((osmr1 = OSMR1) - OSCR) <= 0 ) { ++ data += 0x100; ++ OSSR = OSSR_M1; /* clear match on timer 1 */ ++ OSMR1 = osmr1 + period; ++ } ++ } ++ spin_unlock_irq (&rtc_lock); ++ ++ data -= 0x100; /* the first IRQ wasn't actually missed */ ++ ++ retval = put_user(data, (unsigned long *)buf); ++ if (!retval) ++ retval = sizeof(unsigned long); ++ ++out: ++ set_current_state(TASK_RUNNING); ++ remove_wait_queue(&rtc_wait, &wait); ++ return retval; ++} ++#endif ++ ++static int sa1100_rtc_ioctl(unsigned int cmd, unsigned long arg) ++{ ++ switch (cmd) { ++ case RTC_AIE_OFF: ++ spin_lock_irq(&rtc_lock); ++ RTSR &= ~RTSR_ALE; ++// rtc_irq_data = 0; ++ spin_unlock_irq(&rtc_lock); ++ return 0; ++ case RTC_AIE_ON: ++ spin_lock_irq(&rtc_lock); ++ RTSR |= RTSR_ALE; ++// rtc_irq_data = 0; ++ spin_unlock_irq(&rtc_lock); ++ return 0; ++ case RTC_UIE_OFF: ++ spin_lock_irq(&rtc_lock); ++ RTSR &= ~RTSR_HZE; ++// rtc_irq_data = 0; ++ spin_unlock_irq(&rtc_lock); ++ return 0; ++ case RTC_UIE_ON: ++ spin_lock_irq(&rtc_lock); ++ RTSR |= RTSR_HZE; ++// rtc_irq_data = 0; ++ spin_unlock_irq(&rtc_lock); ++ return 0; ++#if 0 ++ case RTC_PIE_OFF: ++ spin_lock_irq(&rtc_lock); ++ OIER &= ~OIER_E1; ++// rtc_irq_data = 0; ++ spin_unlock_irq(&rtc_lock); ++ return 0; ++ case RTC_PIE_ON: ++ if ((rtc_freq > 64) && !capable(CAP_SYS_RESOURCE)) ++ return -EACCES; ++ spin_lock_irq(&rtc_lock); ++ OSMR1 = TIMER_FREQ/rtc_freq + OSCR; ++ OIER |= OIER_E1; ++// rtc_irq_data = 0; ++ spin_unlock_irq(&rtc_lock); ++ return 0; ++ case RTC_IRQP_READ: ++ return put_user(rtc_freq, (unsigned long *)arg); ++ case RTC_IRQP_SET: ++ if (arg < 1 || arg > TIMER_FREQ) ++ return -EINVAL; ++ if ((arg > 64) && (!capable(CAP_SYS_RESOURCE))) ++ return -EACCES; ++ rtc_freq = arg; ++ return 0; ++#endif ++ } ++ return -EINVAL; ++} ++ ++static void sa1100_rtc_read_time(struct rtc_time *tm) ++{ ++ rtc_time_to_tm(RCNR, tm); ++} ++ ++static int sa1100_rtc_set_time(struct rtc_time *tm) ++{ ++ unsigned long time; ++ int ret; ++ ++ ret = rtc_tm_to_time(tm, &time); ++ if (ret == 0) ++ RCNR = time; ++ return ret; ++} ++ ++static void sa1100_rtc_read_alarm(struct rtc_wkalrm *alrm) ++{ ++ memcpy(&alrm->time, &rtc_alarm, sizeof(struct rtc_time)); ++ alrm->pending = RTSR & RTSR_AL ? 1 : 0; ++} ++ ++static int sa1100_rtc_set_alarm(struct rtc_wkalrm *alrm) ++{ ++ int ret; ++ ++ spin_lock_irq(&rtc_lock); ++ ret = rtc_update_alarm(&alrm->time); ++ if (ret == 0) { ++ memcpy(&rtc_alarm, &alrm->time, sizeof(struct rtc_time)); ++ ++ if (alrm->enabled) ++ enable_irq_wake(IRQ_RTCAlrm); ++ else ++ disable_irq_wake(IRQ_RTCAlrm); ++ } ++ spin_unlock_irq(&rtc_lock); ++ ++ return ret; ++} ++ ++static int sa1100_rtc_proc(char *buf) ++{ ++ char *p = buf; ++ ++ p += sprintf(p, "trim/divider\t: 0x%08x\n", RTTR); ++ p += sprintf(p, "alarm_IRQ\t: %s\n", (RTSR & RTSR_ALE) ? "yes" : "no" ); ++ p += sprintf(p, "update_IRQ\t: %s\n", (RTSR & RTSR_HZE) ? "yes" : "no"); ++ p += sprintf(p, "periodic_IRQ\t: %s\n", (OIER & OIER_E1) ? "yes" : "no"); ++ p += sprintf(p, "periodic_freq\t: %ld\n", rtc_freq); ++ ++ return p - buf; ++} ++ ++static struct rtc_ops sa1100_rtc_ops = { ++ .owner = THIS_MODULE, ++ .open = sa1100_rtc_open, ++ .release = sa1100_rtc_release, ++ .ioctl = sa1100_rtc_ioctl, ++ ++ .read_time = sa1100_rtc_read_time, ++ .set_time = sa1100_rtc_set_time, ++ .read_alarm = sa1100_rtc_read_alarm, ++ .set_alarm = sa1100_rtc_set_alarm, ++ .proc = sa1100_rtc_proc, ++}; ++ ++static int __init rtc_init(void) ++{ ++ /* ++ * According to the manual we should be able to let RTTR be zero ++ * and then a default diviser for a 32.768KHz clock is used. ++ * Apparently this doesn't work, at least for my SA1110 rev 5. ++ * If the clock divider is uninitialized then reset it to the ++ * default value to get the 1Hz clock. ++ */ ++ if (RTTR == 0) { ++ RTTR = RTC_DEF_DIVIDER + (RTC_DEF_TRIM << 16); ++ printk(KERN_WARNING "rtc: warning: initializing default clock divider/trim value\n"); ++ /* The current RTC value probably doesn't make sense either */ ++ RCNR = 0; ++ } ++ ++ register_rtc(&sa1100_rtc_ops); ++ ++ return 0; ++} ++ ++static void __exit rtc_exit(void) ++{ ++ unregister_rtc(&sa1100_rtc_ops); ++} ++ ++module_init(rtc_init); ++module_exit(rtc_exit); ++ ++MODULE_AUTHOR("Nils Faerber <nils@@kernelconcepts.de>"); ++MODULE_DESCRIPTION("SA11x0/PXA2xx Realtime Clock Driver (RTC)"); ++MODULE_LICENSE("GPL"); /* so says the header */ +--- linux-2.6.5/drivers/char/Kconfig~heh 2004-04-03 22:36:15.000000000 -0500 ++++ linux-2.6.5/drivers/char/Kconfig 2004-04-30 20:57:36.000000000 -0400 +@@ -814,6 +814,10 @@ + + If unsure, say N. + ++config SA1100_RTC ++ tristate "SA1100 or PXA Real Time Clock" ++ depends on ARCH_SA1100 || ARCH_PXA ++ + config DTLK + tristate "Double Talk PC internal speech card support" + help +--- linux-2.6.5/drivers/char/tty_io.c~heh 2004-04-03 22:37:23.000000000 -0500 ++++ linux-2.6.5/drivers/char/tty_io.c 2004-04-30 20:57:36.000000000 -0400 +@@ -1535,10 +1535,17 @@ + return 0; + } + ++/* ++ * In the case of pty's, "tty" is the master side ++ * and "real_tty" is the slave side. ++ */ + static int tiocswinsz(struct tty_struct *tty, struct tty_struct *real_tty, + struct winsize * arg) + { + struct winsize tmp_ws; ++ struct task_struct *p; ++ struct list_head *l; ++ struct pid *pid; + + if (copy_from_user(&tmp_ws, arg, sizeof(*arg))) + return -EFAULT; +@@ -1558,8 +1565,21 @@ + #endif + if (tty->pgrp > 0) + kill_pg(tty->pgrp, SIGWINCH, 1); +- if ((real_tty->pgrp != tty->pgrp) && (real_tty->pgrp > 0)) +- kill_pg(real_tty->pgrp, SIGWINCH, 1); ++ ++ /* ++ * Send SIGWINCH to the whole session on the slave tty. ++ * However, in the case of non-master pty's, be careful ++ * not to send two SIGWINCH to the same procress group. ++ */ ++ if (real_tty->session > 0) { ++ read_lock(&tasklist_lock); ++ for_each_task_pid(real_tty->session, PIDTYPE_SID, p, l, pid) { ++ if (process_group(p) != tty->pgrp) ++ group_send_sig_info(SIGWINCH, (void *)1L, p); ++ } ++ read_unlock(&tasklist_lock); ++ } ++ + tty->winsize = tmp_ws; + real_tty->winsize = tmp_ws; + return 0; +--- linux-2.6.5/drivers/Makefile~heh 2004-04-03 22:37:43.000000000 -0500 ++++ linux-2.6.5/drivers/Makefile 2004-04-30 20:57:36.000000000 -0400 +@@ -11,6 +11,8 @@ + # PnP must come after ACPI since it will eventually need to check if acpi + # was used and do nothing if so + obj-$(CONFIG_PNP) += pnp/ ++obj-$(CONFIG_I2C) += i2c/ ++obj-$(CONFIG_L3) += l3/ + + # char/ comes before serial/ etc so that the VT console is the boot-time + # default. +@@ -41,7 +43,6 @@ + obj-$(CONFIG_GAMEPORT) += input/gameport/ + obj-$(CONFIG_SERIO) += input/serio/ + obj-$(CONFIG_I2O) += message/ +-obj-$(CONFIG_I2C) += i2c/ + obj-$(CONFIG_PHONE) += telephony/ + obj-$(CONFIG_MD) += md/ + obj-$(CONFIG_BT) += bluetooth/ +--- /dev/null 2003-09-23 18:19:32.000000000 -0400 ++++ linux-2.6.5/drivers/l3/Kconfig 2004-04-30 20:57:36.000000000 -0400 +@@ -0,0 +1,24 @@ ++# ++# L3 bus configuration ++# ++ ++menu "L3 serial bus support" ++ ++config L3 ++ tristate "L3 support" ++ ++config L3_ALGOBIT ++ bool "L3 bit-banging interfaces" ++ depends on L3=y ++ ++config L3_BIT_SA1100_GPIO ++ bool "SA11x0 GPIO adapter" ++ depends on L3_ALGOBIT && ARCH_SA1100 ++ ++# i2c must come before this ++config BIT_SA1100_GPIO ++ bool ++ depends on L3_BIT_SA1100_GPIO || I2C_BIT_SA1100_GPIO=y ++ default y ++ ++endmenu +--- /dev/null 2003-09-23 18:19:32.000000000 -0400 ++++ linux-2.6.5/drivers/l3/l3-core.c 2004-04-30 20:57:36.000000000 -0400 +@@ -0,0 +1,203 @@ ++/* ++ * linux/drivers/l3/l3-core.c ++ * ++ * Copyright (C) 2001 Russell King ++ * ++ * General structure taken from i2c-core.c by Simon G. Vogl ++ * ++ * 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. ++ * ++ * See linux/Documentation/l3 for further documentation. ++ */ ++#include <linux/module.h> ++#include <linux/kernel.h> ++#include <linux/errno.h> ++#include <linux/slab.h> ++#include <linux/proc_fs.h> ++#include <linux/kmod.h> ++#include <linux/init.h> ++#include <linux/l3/l3.h> ++ ++static DECLARE_MUTEX(adapter_lock); ++static LIST_HEAD(adapter_list); ++ ++static DECLARE_MUTEX(driver_lock); ++static LIST_HEAD(driver_list); ++ ++/** ++ * l3_add_adapter - register a new L3 bus adapter ++ * @adap: l3_adapter structure for the registering adapter ++ * ++ * Make the adapter available for use by clients using name adap->name. ++ * The adap->adapters list is initialised by this function. ++ * ++ * Returns 0; ++ */ ++int l3_add_adapter(struct l3_adapter *adap) ++{ ++ down(&adapter_lock); ++ list_add(&adap->adapters, &adapter_list); ++ up(&adapter_lock); ++ return 0; ++} ++ ++/** ++ * l3_del_adapter - unregister a L3 bus adapter ++ * @adap: l3_adapter structure to unregister ++ * ++ * Remove an adapter from the list of available L3 Bus adapters. ++ * ++ * Returns 0; ++ */ ++int l3_del_adapter(struct l3_adapter *adap) ++{ ++ down(&adapter_lock); ++ list_del(&adap->adapters); ++ up(&adapter_lock); ++ return 0; ++} ++ ++static struct l3_adapter *__l3_get_adapter(const char *name) ++{ ++ struct list_head *l; ++ ++ list_for_each(l, &adapter_list) { ++ struct l3_adapter *adap = list_entry(l, struct l3_adapter, adapters); ++ ++ if (strcmp(adap->name, name) == 0) ++ return adap; ++ } ++ ++ return NULL; ++} ++ ++/** ++ * l3_get_adapter - get a reference to an adapter ++ * @name: driver name ++ * ++ * Obtain a l3_adapter structure for the specified adapter. If the adapter ++ * is not currently load, then load it. The adapter will be locked in core ++ * until all references are released via l3_put_adapter. ++ */ ++struct l3_adapter *l3_get_adapter(const char *name) ++{ ++ struct l3_adapter *adap; ++ int try; ++ ++ for (try = 0; try < 2; try ++) { ++ down(&adapter_lock); ++ adap = __l3_get_adapter(name); ++ if (adap && !try_module_get(adap->owner)) ++ adap = NULL; ++ up(&adapter_lock); ++ ++ if (adap) ++ break; ++ ++ if (try == 0) ++ request_module(name); ++ } ++ ++ return adap; ++} ++ ++/** ++ * l3_put_adapter - release a reference to an adapter ++ * @adap: driver to release reference ++ * ++ * Indicate to the L3 core that you no longer require the adapter reference. ++ * The adapter module may be unloaded when there are no references to its ++ * data structure. ++ * ++ * You must not use the reference after calling this function. ++ */ ++void l3_put_adapter(struct l3_adapter *adap) ++{ ++ if (adap && adap->owner) ++ module_put(adap->owner); ++} ++ ++/** ++ * l3_transfer - transfer information on an L3 bus ++ * @adap: adapter structure to perform transfer on ++ * @msgs: array of l3_msg structures describing transfer ++ * @num: number of l3_msg structures ++ * ++ * Transfer the specified messages to/from a device on the L3 bus. ++ * ++ * Returns number of messages successfully transferred, otherwise negative ++ * error code. ++ */ ++int l3_transfer(struct l3_adapter *adap, struct l3_msg msgs[], int num) ++{ ++ int ret = -ENOSYS; ++ ++ if (adap->algo->xfer) { ++ down(adap->lock); ++ ret = adap->algo->xfer(adap, msgs, num); ++ up(adap->lock); ++ } ++ return ret; ++} ++ ++/** ++ * l3_write - send data to a device on an L3 bus ++ * @adap: L3 bus adapter ++ * @addr: L3 bus address ++ * @buf: buffer for bytes to send ++ * @len: number of bytes to send ++ * ++ * Send len bytes pointed to by buf to device address addr on the L3 bus ++ * described by client. ++ * ++ * Returns the number of bytes transferred, or negative error code. ++ */ ++int l3_write(struct l3_adapter *adap, int addr, const char *buf, int len) ++{ ++ struct l3_msg msg; ++ int ret; ++ ++ msg.addr = addr; ++ msg.flags = 0; ++ msg.buf = (char *)buf; ++ msg.len = len; ++ ++ ret = l3_transfer(adap, &msg, 1); ++ return ret == 1 ? len : ret; ++} ++ ++/** ++ * l3_read - receive data from a device on an L3 bus ++ * @adap: L3 bus adapter ++ * @addr: L3 bus address ++ * @buf: buffer for bytes to receive ++ * @len: number of bytes to receive ++ * ++ * Receive len bytes from device address addr on the L3 bus described by ++ * client to a buffer pointed to by buf. ++ * ++ * Returns the number of bytes transferred, or negative error code. ++ */ ++int l3_read(struct l3_adapter *adap, int addr, char *buf, int len) ++{ ++ struct l3_msg msg; ++ int ret; ++ ++ msg.addr = addr; ++ msg.flags = L3_M_RD; ++ msg.buf = buf; ++ msg.len = len; ++ ++ ret = l3_transfer(adap, &msg, 1); ++ return ret == 1 ? len : ret; ++} ++ ++EXPORT_SYMBOL(l3_add_adapter); ++EXPORT_SYMBOL(l3_del_adapter); ++EXPORT_SYMBOL(l3_get_adapter); ++EXPORT_SYMBOL(l3_put_adapter); ++EXPORT_SYMBOL(l3_transfer); ++EXPORT_SYMBOL(l3_write); ++EXPORT_SYMBOL(l3_read); +--- /dev/null 2003-09-23 18:19:32.000000000 -0400 ++++ linux-2.6.5/drivers/l3/l3-algo-bit.c 2004-04-30 20:57:36.000000000 -0400 +@@ -0,0 +1,175 @@ ++/* ++ * L3 bus algorithm module. ++ * ++ * Copyright (C) 2001 Russell King, All Rights Reserved. ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License version 2 as ++ * published by the Free Software Foundation. ++ * ++ * Note that L3 buses can share the same pins as I2C buses, so we must ++ * _not_ generate an I2C start condition. An I2C start condition is ++ * defined as a high-to-low transition of the data line while the clock ++ * is high. Therefore, we must only change the data line while the ++ * clock is low. ++ */ ++#include <linux/module.h> ++#include <linux/kernel.h> ++#include <linux/delay.h> ++#include <linux/slab.h> ++#include <linux/init.h> ++#include <linux/errno.h> ++#include <linux/sched.h> ++#include <linux/l3/l3.h> ++#include <linux/l3/algo-bit.h> ++ ++#define setdat(adap,val) adap->setdat(adap->data, val) ++#define setclk(adap,val) adap->setclk(adap->data, val) ++#define setmode(adap,val) adap->setmode(adap->data, val) ++#define setdatin(adap) adap->setdir(adap->data, 1) ++#define setdatout(adap) adap->setdir(adap->data, 0) ++#define getdat(adap) adap->getdat(adap->data) ++ ++/* ++ * Send one byte of data to the chip. Data is latched into the chip on ++ * the rising edge of the clock. ++ */ ++static void sendbyte(struct l3_algo_bit_data *adap, unsigned int byte) ++{ ++ int i; ++ ++ for (i = 0; i < 8; i++) { ++ setclk(adap, 0); ++ udelay(adap->data_hold); ++ setdat(adap, byte & 1); ++ udelay(adap->data_setup); ++ setclk(adap, 1); ++ udelay(adap->clock_high); ++ byte >>= 1; ++ } ++} ++ ++/* ++ * Send a set of bytes to the chip. We need to pulse the MODE line ++ * between each byte, but never at the start nor at the end of the ++ * transfer. ++ */ ++static void sendbytes(struct l3_algo_bit_data *adap, const char *buf, int len) ++{ ++ int i; ++ ++ for (i = 0; i < len; i++) { ++ if (i) { ++ udelay(adap->mode_hold); ++ setmode(adap, 0); ++ udelay(adap->mode); ++ } ++ setmode(adap, 1); ++ udelay(adap->mode_setup); ++ sendbyte(adap, buf[i]); ++ } ++} ++ ++/* ++ * Read one byte of data from the chip. Data is latched into the chip on ++ * the rising edge of the clock. ++ */ ++static unsigned int readbyte(struct l3_algo_bit_data *adap) ++{ ++ unsigned int byte = 0; ++ int i; ++ ++ for (i = 0; i < 8; i++) { ++ setclk(adap, 0); ++ udelay(adap->data_hold + adap->data_setup); ++ setclk(adap, 1); ++ if (getdat(adap)) ++ byte |= 1 << i; ++ udelay(adap->clock_high); ++ } ++ ++ return byte; ++} ++ ++/* ++ * Read a set of bytes from the chip. We need to pulse the MODE line ++ * between each byte, but never at the start nor at the end of the ++ * transfer. ++ */ ++static void readbytes(struct l3_algo_bit_data *adap, char *buf, int len) ++{ ++ int i; ++ ++ for (i = 0; i < len; i++) { ++ if (i) { ++ udelay(adap->mode_hold); ++ setmode(adap, 0); ++ } ++ setmode(adap, 1); ++ udelay(adap->mode_setup); ++ buf[i] = readbyte(adap); ++ } ++} ++ ++static int l3_xfer(struct l3_adapter *l3_adap, struct l3_msg msgs[], int num) ++{ ++ struct l3_algo_bit_data *adap = l3_adap->algo_data; ++ int i; ++ ++ /* ++ * If we share an I2C bus, ensure that it is in STOP mode ++ */ ++ setclk(adap, 1); ++ setdat(adap, 1); ++ setmode(adap, 1); ++ setdatout(adap); ++ udelay(adap->mode); ++ ++ for (i = 0; i < num; i++) { ++ struct l3_msg *pmsg = &msgs[i]; ++ ++ if (!(pmsg->flags & L3_M_NOADDR)) { ++ setmode(adap, 0); ++ udelay(adap->mode_setup); ++ sendbyte(adap, pmsg->addr); ++ udelay(adap->mode_hold); ++ } ++ ++ if (pmsg->flags & L3_M_RD) { ++ setdatin(adap); ++ readbytes(adap, pmsg->buf, pmsg->len); ++ } else { ++ setdatout(adap); ++ sendbytes(adap, pmsg->buf, pmsg->len); ++ } ++ } ++ ++ /* ++ * Ensure that we leave the bus in I2C stop mode. ++ */ ++ setclk(adap, 1); ++ setdat(adap, 1); ++ setmode(adap, 0); ++ setdatin(adap); ++ ++ return num; ++} ++ ++static struct l3_algorithm l3_bit_algo = { ++ name: "L3 bit-shift algorithm", ++ xfer: l3_xfer, ++}; ++ ++int l3_bit_add_bus(struct l3_adapter *adap) ++{ ++ adap->algo = &l3_bit_algo; ++ return l3_add_adapter(adap); ++} ++ ++int l3_bit_del_bus(struct l3_adapter *adap) ++{ ++ return l3_del_adapter(adap); ++} ++ ++EXPORT_SYMBOL(l3_bit_add_bus); ++EXPORT_SYMBOL(l3_bit_del_bus); +--- /dev/null 2003-09-23 18:19:32.000000000 -0400 ++++ linux-2.6.5/drivers/l3/Makefile 2004-04-30 20:57:36.000000000 -0400 +@@ -0,0 +1,11 @@ ++# ++# Makefile for the L3 bus driver. ++# ++ ++# Link order: ++# (core, adapters, algorithms, drivers) then clients ++ ++l3-$(CONFIG_L3_ALGOBIT) += l3-algo-bit.o ++l3-$(CONFIG_BIT_SA1100_GPIO) += l3-bit-sa1100.o ++ ++obj-$(CONFIG_L3) += l3-core.o $(l3-y) $(l3-drv-y) +--- /dev/null 2003-09-23 18:19:32.000000000 -0400 ++++ linux-2.6.5/drivers/l3/l3-bit-sa1100.c 2004-04-30 20:57:36.000000000 -0400 +@@ -0,0 +1,271 @@ ++/* ++ * linux/drivers/l3/l3-bit-sa1100.c ++ * ++ * Copyright (C) 2001 Russell King ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License version 2 as ++ * published by the Free Software Foundation. ++ * ++ * This is a combined I2C and L3 bus driver. ++ */ ++#include <linux/config.h> ++#include <linux/module.h> ++#include <linux/kernel.h> ++#include <linux/ioport.h> ++#include <linux/delay.h> ++#include <linux/slab.h> ++#include <linux/init.h> ++#include <linux/i2c.h> ++#include <linux/i2c-algo-bit.h> ++#include <linux/l3/algo-bit.h> ++ ++#include <asm/system.h> ++#include <asm/hardware.h> ++#include <asm/mach-types.h> ++#include <asm/arch/assabet.h> ++ ++#define NAME "l3-bit-sa1100-gpio" ++ ++struct bit_data { ++ unsigned int sda; ++ unsigned int scl; ++ unsigned int l3_mode; ++}; ++ ++static int getsda(void *data) ++{ ++ struct bit_data *bits = data; ++ ++ return GPLR & bits->sda; ++} ++ ++#ifdef CONFIG_I2C_BIT_SA1100_GPIO ++static void i2c_setsda(void *data, int state) ++{ ++ struct bit_data *bits = data; ++ unsigned long flags; ++ ++ local_irq_save(flags); ++ if (state) ++ GPDR &= ~bits->sda; ++ else { ++ GPCR = bits->sda; ++ GPDR |= bits->sda; ++ } ++ local_irq_restore(flags); ++} ++ ++static void i2c_setscl(void *data, int state) ++{ ++ struct bit_data *bits = data; ++ unsigned long flags; ++ ++ local_irq_save(flags); ++ if (state) ++ GPDR &= ~bits->scl; ++ else { ++ GPCR = bits->scl; ++ GPDR |= bits->scl; ++ } ++ local_irq_restore(flags); ++} ++ ++static int i2c_getscl(void *data) ++{ ++ struct bit_data *bits = data; ++ ++ return GPLR & bits->scl; ++} ++ ++static struct i2c_algo_bit_data i2c_bit_data = { ++ .setsda = i2c_setsda, ++ .setscl = i2c_setscl, ++ .getsda = getsda, ++ .getscl = i2c_getscl, ++ .udelay = 10, ++ .mdelay = 10, ++ .timeout = 100, ++}; ++ ++static struct i2c_adapter i2c_adapter = { ++ .algo_data = &i2c_bit_data, ++}; ++ ++#define LOCK &i2c_adapter.bus_lock ++ ++static int __init i2c_init(struct bit_data *bits) ++{ ++ i2c_bit_data.data = bits; ++ return i2c_bit_add_bus(&i2c_adapter); ++} ++ ++static void i2c_exit(void) ++{ ++ i2c_bit_del_bus(&i2c_adapter); ++} ++ ++#else ++static DECLARE_MUTEX(l3_lock); ++#define LOCK &l3_lock ++#define i2c_init(bits) (0) ++#define i2c_exit() do { } while (0) ++#endif ++ ++#ifdef CONFIG_L3_BIT_SA1100_GPIO ++/* ++ * iPAQs need the clock line driven hard high and low. ++ */ ++static void l3_setscl(void *data, int state) ++{ ++ struct bit_data *bits = data; ++ unsigned long flags; ++ ++ local_irq_save(flags); ++ if (state) ++ GPSR = bits->scl; ++ else ++ GPCR = bits->scl; ++ GPDR |= bits->scl; ++ local_irq_restore(flags); ++} ++ ++static void l3_setsda(void *data, int state) ++{ ++ struct bit_data *bits = data; ++ ++ if (state) ++ GPSR = bits->sda; ++ else ++ GPCR = bits->sda; ++} ++ ++static void l3_setdir(void *data, int in) ++{ ++ struct bit_data *bits = data; ++ unsigned long flags; ++ ++ local_irq_save(flags); ++ if (in) ++ GPDR &= ~bits->sda; ++ else ++ GPDR |= bits->sda; ++ local_irq_restore(flags); ++} ++ ++static void l3_setmode(void *data, int state) ++{ ++ struct bit_data *bits = data; ++ ++ if (state) ++ GPSR = bits->l3_mode; ++ else ++ GPCR = bits->l3_mode; ++} ++ ++static struct l3_algo_bit_data l3_bit_data = { ++ .data = NULL, ++ .setdat = l3_setsda, ++ .setclk = l3_setscl, ++ .setmode = l3_setmode, ++ .setdir = l3_setdir, ++ .getdat = getsda, ++ .data_hold = 1, ++ .data_setup = 1, ++ .clock_high = 1, ++ .mode_hold = 1, ++ .mode_setup = 1, ++}; ++ ++static struct l3_adapter l3_adapter = { ++ .owner = THIS_MODULE, ++ .name = NAME, ++ .algo_data = &l3_bit_data, ++ .lock = LOCK, ++}; ++ ++static int __init l3_init(struct bit_data *bits) ++{ ++ l3_bit_data.data = bits; ++ return l3_bit_add_bus(&l3_adapter); ++} ++ ++static void __exit l3_exit(void) ++{ ++ l3_bit_del_bus(&l3_adapter); ++} ++#else ++#define l3_init(bits) (0) ++#define l3_exit() do { } while (0) ++#endif ++ ++static struct bit_data bit_data; ++ ++static int __init bus_init(void) ++{ ++ struct bit_data *bit = &bit_data; ++ unsigned long flags; ++ int ret; ++ ++ if (machine_is_assabet() || machine_is_pangolin()) { ++ bit->sda = GPIO_GPIO15; ++ bit->scl = GPIO_GPIO18; ++ bit->l3_mode = GPIO_GPIO17; ++ } ++ ++ if (machine_is_h3600() || machine_is_h3100()) { ++ bit->sda = GPIO_GPIO14; ++ bit->scl = GPIO_GPIO16; ++ bit->l3_mode = GPIO_GPIO15; ++ } ++ ++ if (machine_is_stork()) { ++ bit->sda = GPIO_GPIO15; ++ bit->scl = GPIO_GPIO18; ++ bit->l3_mode = GPIO_GPIO17; ++ } ++ ++ if (!bit->sda) ++ return -ENODEV; ++ ++ /* ++ * Default level for L3 mode is low. ++ * We set SCL and SDA high (i2c idle state). ++ */ ++ local_irq_save(flags); ++ GPDR &= ~(bit->scl | bit->sda); ++ GPCR = bit->l3_mode | bit->scl | bit->sda; ++ GPDR |= bit->l3_mode; ++ local_irq_restore(flags); ++ ++ if (machine_is_assabet()) { ++ /* ++ * Release reset on UCB1300, ADI7171 and UDA1341. We ++ * need to do this here so that we can communicate on ++ * the I2C/L3 buses. ++ */ ++ ASSABET_BCR_set(ASSABET_BCR_CODEC_RST); ++ mdelay(1); ++ ASSABET_BCR_clear(ASSABET_BCR_CODEC_RST); ++ mdelay(1); ++ ASSABET_BCR_set(ASSABET_BCR_CODEC_RST); ++ } ++ ++ ret = i2c_init(bit); ++ if (ret == 0 && bit->l3_mode) { ++ ret = l3_init(bit); ++ if (ret) ++ i2c_exit(); ++ } ++ ++ return ret; ++} ++ ++static void __exit bus_exit(void) ++{ ++ l3_exit(); ++ i2c_exit(); ++} ++ ++module_init(bus_init); ++module_exit(bus_exit); +--- /dev/null 2003-09-23 18:19:32.000000000 -0400 ++++ linux-2.6.5/drivers/misc/switches.h 2004-04-30 20:57:36.000000000 -0400 +@@ -0,0 +1,22 @@ ++/* ++ * linux/drivers/misc/switches.h ++ * ++ * Copyright (C) 2001 John Dorsey ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License version 2 as ++ * published by the Free Software Foundation. ++ * ++ * 19 December 2001 - created. ++ */ ++ ++#if !defined(_SWITCHES_H) ++# define _SWITCHES_H ++ ++#include <linux/switches.h> ++ ++#define SWITCHES_NAME "switches" ++ ++extern int switches_event(switches_mask_t *mask); ++ ++#endif /* !defined(_SWITCHES_H) */ +--- linux-2.6.5/drivers/misc/Kconfig~heh 2004-04-03 22:36:26.000000000 -0500 ++++ linux-2.6.5/drivers/misc/Kconfig 2004-04-30 20:57:36.000000000 -0400 +@@ -21,5 +21,62 @@ + + If unsure, say N. + ++menu "Multimedia Capabilities Port drivers" ++ ++config MCP ++ tristate "Multimedia drivers" ++ ++# Interface drivers ++config MCP_SA1100 ++ tristate "Support SA1100 MCP interface" ++ depends on MCP && ARCH_SA1100 ++ ++# Chip drivers ++config MCP_UCB1200 ++ tristate "Support for UCB1200 / UCB1300" ++ depends on MCP ++ ++config MCP_UCB1200_AUDIO ++ tristate "Audio / Telephony interface support" ++ depends on MCP_UCB1200 && SOUND ++ ++config MCP_UCB1200_TS ++ tristate "Touchscreen interface support" ++ depends on MCP_UCB1200 && INPUT ++ ++endmenu ++ ++ ++menu "Console Switches" ++ ++config SWITCHES ++ tristate "Console Switch Support" ++ help ++ Say Y here to include support for simple console momentary switches. ++ This driver implements a miscellaneous character device (named ++ `switches' in /proc/misc) which can be read by userland programs ++ to respond to switch press events. This mechanism is efficient for ++ systems which may not implement a traditional heavyweight console ++ server. ++ ++ It is also possible to say M to build this driver as a module (named ++ `switches.o'). ++ ++config SWITCHES_SA1100 ++ tristate "SA-1100 switches" ++ depends on SWITCHES && ARCH_SA1100 ++ help ++ Say Y here to include support for switches routed directly to ++ interruptable signals on StrongARM SA-1100 systems. ++ ++config SWITCHES_UCB1X00 ++ tristate "UCB1x00 switches" ++ depends on SWITCHES && MCP_UCB1200 ++ help ++ Say Y here to include support for switches routed through a ++ UCB1x00 modem/audio analog front-end device. ++ ++endmenu ++ + endmenu + +--- /dev/null 2003-09-23 18:19:32.000000000 -0400 ++++ linux-2.6.5/drivers/misc/ucb1x00-assabet.c 2004-04-30 20:57:36.000000000 -0400 +@@ -0,0 +1,73 @@ ++/* ++ * linux/drivers/misc/ucb1x00-assabet.c ++ * ++ * Copyright (C) 2001-2003 Russell King, All Rights Reserved. ++ * ++ * 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. ++ * ++ * We handle the machine-specific bits of the UCB1x00 driver here. ++ */ ++#include <linux/module.h> ++#include <linux/init.h> ++#include <linux/fs.h> ++#include <linux/proc_fs.h> ++#include <linux/device.h> ++ ++#include <asm/dma.h> ++ ++#include "ucb1x00.h" ++ ++#define UCB1X00_ATTR(name,input)\ ++static ssize_t name##_show(struct class_device *dev, char *buf) \ ++{ \ ++ struct ucb1x00 *ucb = classdev_to_ucb1x00(dev); \ ++ int val; \ ++ ucb1x00_adc_enable(ucb); \ ++ val = ucb1x00_adc_read(ucb, input, UCB_NOSYNC); \ ++ ucb1x00_adc_disable(ucb); \ ++ return sprintf(buf, "%d\n", val); \ ++} \ ++static CLASS_DEVICE_ATTR(name,0444,name##_show,NULL) ++ ++UCB1X00_ATTR(vbatt, UCB_ADC_INP_AD1); ++UCB1X00_ATTR(vcharger, UCB_ADC_INP_AD0); ++UCB1X00_ATTR(batt_temp, UCB_ADC_INP_AD2); ++ ++static int ucb1x00_assabet_add(struct class_device *dev) ++{ ++ class_device_create_file(dev, &class_device_attr_vbatt); ++ class_device_create_file(dev, &class_device_attr_vcharger); ++ class_device_create_file(dev, &class_device_attr_batt_temp); ++ return 0; ++} ++ ++static void ucb1x00_assabet_remove(struct class_device *dev) ++{ ++ class_device_remove_file(dev, &class_device_attr_batt_temp); ++ class_device_remove_file(dev, &class_device_attr_vcharger); ++ class_device_remove_file(dev, &class_device_attr_vbatt); ++} ++ ++static struct class_interface ucb1x00_assabet_interface = { ++ .add = ucb1x00_assabet_add, ++ .remove = ucb1x00_assabet_remove, ++}; ++ ++static int __init ucb1x00_assabet_init(void) ++{ ++ return ucb1x00_register_interface(&ucb1x00_assabet_interface); ++} ++ ++static void __exit ucb1x00_assabet_exit(void) ++{ ++ ucb1x00_unregister_interface(&ucb1x00_assabet_interface); ++} ++ ++module_init(ucb1x00_assabet_init); ++module_exit(ucb1x00_assabet_exit); ++ ++MODULE_AUTHOR("Russell King <rmk@arm.linux.org.uk>"); ++MODULE_DESCRIPTION("Assabet noddy testing only example ADC driver"); ++MODULE_LICENSE("GPL"); +--- /dev/null 2003-09-23 18:19:32.000000000 -0400 ++++ linux-2.6.5/drivers/misc/mcp-pxa.c 2004-04-30 20:57:36.000000000 -0400 +@@ -0,0 +1,57 @@ ++/* ++ * linux/drivers/misc/mcp-pxa.c ++ * ++ * 2002-01-10 Jeff Sutherland <jeffs@accelent.com> ++ * ++ * 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. ++ * ++ * NOTE: This is a quick hack to gain access to the aclink codec's ++ * touch screen facility. Its audio is handled by a separate ++ * (non-mcp) driver at the present time. ++ */ ++ ++#include <linux/module.h> ++#include <linux/types.h> ++#include <linux/ac97_codec.h> ++ ++#include "mcp.h" ++ ++ ++extern int pxa_ac97_get(struct ac97_codec **codec); ++extern void pxa_ac97_put(void); ++ ++ ++struct mcp *mcp_get(void) ++{ ++ struct ac97_codec *codec; ++ if (pxa_ac97_get(&codec) < 0) ++ return NULL; ++ return (struct mcp *)codec; ++} ++ ++void mcp_reg_write(struct mcp *mcp, unsigned int reg, unsigned int val) ++{ ++ struct ac97_codec *codec = (struct ac97_codec *)mcp; ++ codec->codec_write(codec, reg, val); ++} ++ ++unsigned int mcp_reg_read(struct mcp *mcp, unsigned int reg) ++{ ++ struct ac97_codec *codec = (struct ac97_codec *)mcp; ++ return codec->codec_read(codec, reg); ++} ++ ++void mcp_enable(struct mcp *mcp) ++{ ++ /* ++ * Should we do something here to make sure the aclink ++ * codec is alive??? ++ * A: not for now --NP ++ */ ++} ++ ++void mcp_disable(struct mcp *mcp) ++{ ++} +--- /dev/null 2003-09-23 18:19:32.000000000 -0400 ++++ linux-2.6.5/drivers/misc/mcp-core.c 2004-04-30 20:57:36.000000000 -0400 +@@ -0,0 +1,235 @@ ++/* ++ * linux/drivers/misc/mcp-core.c ++ * ++ * Copyright (C) 2001 Russell King ++ * ++ * 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. ++ * ++ * Generic MCP (Multimedia Communications Port) layer. All MCP locking ++ * is solely held within this file. ++ */ ++#include <linux/module.h> ++#include <linux/init.h> ++#include <linux/errno.h> ++#include <linux/smp.h> ++#include <linux/device.h> ++ ++#include <asm/dma.h> ++#include <asm/system.h> ++ ++#include "mcp.h" ++ ++#define to_mcp(d) container_of(d, struct mcp, attached_device) ++#define to_mcp_driver(d) container_of(d, struct mcp_driver, drv) ++ ++static int mcp_bus_match(struct device *dev, struct device_driver *drv) ++{ ++ return 1; ++} ++ ++static int mcp_bus_probe(struct device *dev) ++{ ++ struct mcp *mcp = to_mcp(dev); ++ struct mcp_driver *drv = to_mcp_driver(dev->driver); ++ ++ return drv->probe(mcp); ++} ++ ++static int mcp_bus_remove(struct device *dev) ++{ ++ struct mcp *mcp = to_mcp(dev); ++ struct mcp_driver *drv = to_mcp_driver(dev->driver); ++ ++ drv->remove(mcp); ++ return 0; ++} ++ ++static int mcp_bus_suspend(struct device *dev, u32 state) ++{ ++ struct mcp *mcp = to_mcp(dev); ++ int ret = 0; ++ ++ if (dev->driver) { ++ struct mcp_driver *drv = to_mcp_driver(dev->driver); ++ ++ ret = drv->suspend(mcp, state); ++ } ++ return ret; ++} ++ ++static int mcp_bus_resume(struct device *dev) ++{ ++ struct mcp *mcp = to_mcp(dev); ++ int ret = 0; ++ ++ if (dev->driver) { ++ struct mcp_driver *drv = to_mcp_driver(dev->driver); ++ ++ ret = drv->resume(mcp); ++ } ++ return ret; ++} ++ ++static struct bus_type mcp_bus_type = { ++ .name = "mcp", ++ .match = mcp_bus_match, ++ .suspend = mcp_bus_suspend, ++ .resume = mcp_bus_resume, ++}; ++ ++/** ++ * mcp_set_telecom_divisor - set the telecom divisor ++ * @mcp: MCP interface structure ++ * @div: SIB clock divisor ++ * ++ * Set the telecom divisor on the MCP interface. The resulting ++ * sample rate is SIBCLOCK/div. ++ */ ++void mcp_set_telecom_divisor(struct mcp *mcp, unsigned int div) ++{ ++ spin_lock_irq(&mcp->lock); ++ mcp->set_telecom_divisor(mcp, div); ++ spin_unlock_irq(&mcp->lock); ++} ++ ++/** ++ * mcp_set_audio_divisor - set the audio divisor ++ * @mcp: MCP interface structure ++ * @div: SIB clock divisor ++ * ++ * Set the audio divisor on the MCP interface. ++ */ ++void mcp_set_audio_divisor(struct mcp *mcp, unsigned int div) ++{ ++ spin_lock_irq(&mcp->lock); ++ mcp->set_audio_divisor(mcp, div); ++ spin_unlock_irq(&mcp->lock); ++} ++ ++/** ++ * mcp_reg_write - write a device register ++ * @mcp: MCP interface structure ++ * @reg: 4-bit register index ++ * @val: 16-bit data value ++ * ++ * Write a device register. The MCP interface must be enabled ++ * to prevent this function hanging. ++ */ ++void mcp_reg_write(struct mcp *mcp, unsigned int reg, unsigned int val) ++{ ++ unsigned long flags; ++ ++ spin_lock_irqsave(&mcp->lock, flags); ++ mcp->reg_write(mcp, reg, val); ++ spin_unlock_irqrestore(&mcp->lock, flags); ++} ++ ++/** ++ * mcp_reg_read - read a device register ++ * @mcp: MCP interface structure ++ * @reg: 4-bit register index ++ * ++ * Read a device register and return its value. The MCP interface ++ * must be enabled to prevent this function hanging. ++ */ ++unsigned int mcp_reg_read(struct mcp *mcp, unsigned int reg) ++{ ++ unsigned long flags; ++ unsigned int val; ++ ++ spin_lock_irqsave(&mcp->lock, flags); ++ val = mcp->reg_read(mcp, reg); ++ spin_unlock_irqrestore(&mcp->lock, flags); ++ ++ return val; ++} ++ ++/** ++ * mcp_enable - enable the MCP interface ++ * @mcp: MCP interface to enable ++ * ++ * Enable the MCP interface. Each call to mcp_enable will need ++ * a corresponding call to mcp_disable to disable the interface. ++ */ ++void mcp_enable(struct mcp *mcp) ++{ ++ spin_lock_irq(&mcp->lock); ++ if (mcp->use_count++ == 0) ++ mcp->enable(mcp); ++ spin_unlock_irq(&mcp->lock); ++} ++ ++/** ++ * mcp_disable - disable the MCP interface ++ * @mcp: MCP interface to disable ++ * ++ * Disable the MCP interface. The MCP interface will only be ++ * disabled once the number of calls to mcp_enable matches the ++ * number of calls to mcp_disable. ++ */ ++void mcp_disable(struct mcp *mcp) ++{ ++ unsigned long flags; ++ ++ spin_lock_irqsave(&mcp->lock, flags); ++ if (--mcp->use_count == 0) ++ mcp->disable(mcp); ++ spin_unlock_irqrestore(&mcp->lock, flags); ++} ++ ++int mcp_host_register(struct mcp *mcp, struct device *parent) ++{ ++ mcp->attached_device.parent = parent; ++ mcp->attached_device.bus = &mcp_bus_type; ++ mcp->attached_device.dma_mask = parent->dma_mask; ++ strcpy(mcp->attached_device.bus_id, "mcp0"); ++ return device_register(&mcp->attached_device); ++} ++ ++void mcp_host_unregister(struct mcp *mcp) ++{ ++ device_unregister_wait(&mcp->attached_device); ++} ++ ++int mcp_driver_register(struct mcp_driver *mcpdrv) ++{ ++ mcpdrv->drv.bus = &mcp_bus_type; ++ mcpdrv->drv.probe = mcp_bus_probe; ++ mcpdrv->drv.remove = mcp_bus_remove; ++ return driver_register(&mcpdrv->drv); ++} ++ ++void mcp_driver_unregister(struct mcp_driver *mcpdrv) ++{ ++ driver_unregister(&mcpdrv->drv); ++} ++ ++static int __init mcp_init(void) ++{ ++ return bus_register(&mcp_bus_type); ++} ++ ++static void __exit mcp_exit(void) ++{ ++ bus_unregister(&mcp_bus_type); ++} ++ ++module_init(mcp_init); ++module_exit(mcp_exit); ++ ++EXPORT_SYMBOL(mcp_set_telecom_divisor); ++EXPORT_SYMBOL(mcp_set_audio_divisor); ++EXPORT_SYMBOL(mcp_reg_write); ++EXPORT_SYMBOL(mcp_reg_read); ++EXPORT_SYMBOL(mcp_enable); ++EXPORT_SYMBOL(mcp_disable); ++EXPORT_SYMBOL(mcp_host_register); ++EXPORT_SYMBOL(mcp_host_unregister); ++EXPORT_SYMBOL(mcp_driver_register); ++EXPORT_SYMBOL(mcp_driver_unregister); ++ ++MODULE_AUTHOR("Russell King <rmk@arm.linux.org.uk>"); ++MODULE_DESCRIPTION("Core multimedia communications port driver"); ++MODULE_LICENSE("GPL"); +--- /dev/null 2003-09-23 18:19:32.000000000 -0400 ++++ linux-2.6.5/drivers/misc/ucb1x00-ts.c 2004-04-30 20:57:36.000000000 -0400 +@@ -0,0 +1,465 @@ ++/* ++ * linux/drivers/misc/ucb1x00-ts.c ++ * ++ * Copyright (C) 2001 Russell King, All Rights Reserved. ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License version 2 as ++ * published by the Free Software Foundation. ++ * ++ * 21-Jan-2002 <jco@ict.es> : ++ * ++ * Added support for synchronous A/D mode. This mode is useful to ++ * avoid noise induced in the touchpanel by the LCD, provided that ++ * the UCB1x00 has a valid LCD sync signal routed to its ADCSYNC pin. ++ * It is important to note that the signal connected to the ADCSYNC ++ * pin should provide pulses even when the LCD is blanked, otherwise ++ * a pen touch needed to unblank the LCD will never be read. ++ */ ++#include <linux/config.h> ++#include <linux/module.h> ++#include <linux/init.h> ++#include <linux/smp.h> ++#include <linux/smp_lock.h> ++#include <linux/sched.h> ++#include <linux/completion.h> ++#include <linux/delay.h> ++#include <linux/string.h> ++#include <linux/input.h> ++#include <linux/device.h> ++#include <linux/slab.h> ++ ++#include <asm/dma.h> ++#include <asm/semaphore.h> ++ ++#include "ucb1x00.h" ++ ++ ++struct ucb1x00_ts { ++ struct input_dev idev; ++ struct ucb1x00 *ucb; ++ ++ struct semaphore irq_wait; ++ struct semaphore sem; ++ struct completion init_exit; ++ struct task_struct *rtask; ++ int use_count; ++ u16 x_res; ++ u16 y_res; ++ ++ int restart:1; ++ int adcsync:1; ++}; ++ ++static int adcsync = UCB_NOSYNC; ++ ++static inline void ucb1x00_ts_evt_add(struct ucb1x00_ts *ts, u16 pressure, u16 x, u16 y) ++{ ++ input_report_abs(&ts->idev, ABS_X, x); ++ input_report_abs(&ts->idev, ABS_Y, y); ++ input_report_abs(&ts->idev, ABS_PRESSURE, pressure); ++ input_sync(&ts->idev); ++} ++ ++static inline void ucb1x00_ts_event_release(struct ucb1x00_ts *ts) ++{ ++ input_report_abs(&ts->idev, ABS_PRESSURE, 0); ++ input_sync(&ts->idev); ++} ++ ++/* ++ * Switch to interrupt mode. ++ */ ++static inline void ucb1x00_ts_mode_int(struct ucb1x00_ts *ts) ++{ ++ if (ts->ucb->id == UCB_ID_1400_BUGGY) ++ ucb1x00_reg_write(ts->ucb, UCB_TS_CR, ++ UCB_TS_CR_TSMY_GND | UCB_TS_CR_TSPY_GND | ++ UCB_TS_CR_MODE_INT); ++ else ++ ucb1x00_reg_write(ts->ucb, UCB_TS_CR, ++ UCB_TS_CR_TSMX_POW | UCB_TS_CR_TSPX_POW | ++ UCB_TS_CR_TSMY_GND | UCB_TS_CR_TSPY_GND | ++ UCB_TS_CR_MODE_INT); ++} ++ ++/* ++ * Switch to pressure mode, and read pressure. We don't need to wait ++ * here, since both plates are being driven. ++ */ ++static inline unsigned int ucb1x00_ts_read_pressure(struct ucb1x00_ts *ts) ++{ ++ ucb1x00_reg_write(ts->ucb, UCB_TS_CR, ++ UCB_TS_CR_TSMX_POW | UCB_TS_CR_TSPX_POW | ++ UCB_TS_CR_TSMY_GND | UCB_TS_CR_TSPY_GND | ++ UCB_TS_CR_MODE_PRES | UCB_TS_CR_BIAS_ENA); ++ ++ return ucb1x00_adc_read(ts->ucb, UCB_ADC_INP_TSPY, ts->adcsync); ++} ++ ++/* ++ * Switch to X position mode and measure Y plate. We switch the plate ++ * configuration in pressure mode, then switch to position mode. This ++ * gives a faster response time. Even so, we need to wait about 55us ++ * for things to stabilise. ++ */ ++static inline unsigned int ucb1x00_ts_read_xpos(struct ucb1x00_ts *ts) ++{ ++ ucb1x00_reg_write(ts->ucb, UCB_TS_CR, ++ UCB_TS_CR_TSMX_GND | UCB_TS_CR_TSPX_POW | ++ UCB_TS_CR_MODE_PRES | UCB_TS_CR_BIAS_ENA); ++ ucb1x00_reg_write(ts->ucb, UCB_TS_CR, ++ UCB_TS_CR_TSMX_GND | UCB_TS_CR_TSPX_POW | ++ UCB_TS_CR_MODE_PRES | UCB_TS_CR_BIAS_ENA); ++ ucb1x00_reg_write(ts->ucb, UCB_TS_CR, ++ UCB_TS_CR_TSMX_GND | UCB_TS_CR_TSPX_POW | ++ UCB_TS_CR_MODE_POS | UCB_TS_CR_BIAS_ENA); ++ ++ udelay(55); ++ ++ return ucb1x00_adc_read(ts->ucb, UCB_ADC_INP_TSPY, ts->adcsync); ++} ++ ++/* ++ * Switch to Y position mode and measure X plate. We switch the plate ++ * configuration in pressure mode, then switch to position mode. This ++ * gives a faster response time. Even so, we need to wait about 55us ++ * for things to stabilise. ++ */ ++static inline unsigned int ucb1x00_ts_read_ypos(struct ucb1x00_ts *ts) ++{ ++ ucb1x00_reg_write(ts->ucb, UCB_TS_CR, ++ UCB_TS_CR_TSMY_GND | UCB_TS_CR_TSPY_POW | ++ UCB_TS_CR_MODE_PRES | UCB_TS_CR_BIAS_ENA); ++ ucb1x00_reg_write(ts->ucb, UCB_TS_CR, ++ UCB_TS_CR_TSMY_GND | UCB_TS_CR_TSPY_POW | ++ UCB_TS_CR_MODE_PRES | UCB_TS_CR_BIAS_ENA); ++ ucb1x00_reg_write(ts->ucb, UCB_TS_CR, ++ UCB_TS_CR_TSMY_GND | UCB_TS_CR_TSPY_POW | ++ UCB_TS_CR_MODE_POS | UCB_TS_CR_BIAS_ENA); ++ ++ udelay(55); ++ ++ return ucb1x00_adc_read(ts->ucb, UCB_ADC_INP_TSPX, ts->adcsync); ++} ++ ++/* ++ * Switch to X plate resistance mode. Set MX to ground, PX to ++ * supply. Measure current. ++ */ ++static inline unsigned int ucb1x00_ts_read_xres(struct ucb1x00_ts *ts) ++{ ++ ucb1x00_reg_write(ts->ucb, UCB_TS_CR, ++ UCB_TS_CR_TSMX_GND | UCB_TS_CR_TSPX_POW | ++ UCB_TS_CR_MODE_PRES | UCB_TS_CR_BIAS_ENA); ++ return ucb1x00_adc_read(ts->ucb, 0, ts->adcsync); ++} ++ ++/* ++ * Switch to Y plate resistance mode. Set MY to ground, PY to ++ * supply. Measure current. ++ */ ++static inline unsigned int ucb1x00_ts_read_yres(struct ucb1x00_ts *ts) ++{ ++ ucb1x00_reg_write(ts->ucb, UCB_TS_CR, ++ UCB_TS_CR_TSMY_GND | UCB_TS_CR_TSPY_POW | ++ UCB_TS_CR_MODE_PRES | UCB_TS_CR_BIAS_ENA); ++ return ucb1x00_adc_read(ts->ucb, 0, ts->adcsync); ++} ++ ++/* ++ * This is a RT kernel thread that handles the ADC accesses ++ * (mainly so we can use semaphores in the UCB1200 core code ++ * to serialise accesses to the ADC, and in the UCB1400 case where ++ * any register access may sleep). ++ */ ++static int ucb1x00_thread(void *_ts) ++{ ++ struct ucb1x00_ts *ts = _ts; ++ struct task_struct *tsk = current; ++ int valid; ++ ++ ts->rtask = tsk; ++ ++ daemonize("ktsd"); ++ /* only want to receive SIGKILL */ ++ allow_signal(SIGKILL); ++ ++ /* ++ * We could run as a real-time thread. However, thus far ++ * this doesn't seem to be necessary. ++ */ ++// tsk->policy = SCHED_FIFO; ++// tsk->rt_priority = 1; ++ ++ complete(&ts->init_exit); ++ ++ valid = 0; ++ ++ for (;;) { ++ unsigned int x, y, p, val; ++ ++ ts->restart = 0; ++ ++ ucb1x00_adc_enable(ts->ucb); ++ ++ x = ucb1x00_ts_read_xpos(ts); ++ y = ucb1x00_ts_read_ypos(ts); ++ p = ucb1x00_ts_read_pressure(ts); ++ ++ /* ++ * Switch back to interrupt mode. ++ */ ++ ucb1x00_ts_mode_int(ts); ++ ucb1x00_adc_disable(ts->ucb); ++ ++ set_task_state(tsk, TASK_UNINTERRUPTIBLE); ++ schedule_timeout(HZ / 100); ++ if (signal_pending(tsk)) ++ break; ++ ++ ucb1x00_enable(ts->ucb); ++ val = ucb1x00_reg_read(ts->ucb, UCB_TS_CR); ++ ++ if (val & (UCB_TS_CR_TSPX_LOW | UCB_TS_CR_TSMX_LOW)) { ++ ucb1x00_enable_irq(ts->ucb, UCB_IRQ_TSPX, UCB_FALLING); ++ ucb1x00_disable(ts->ucb); ++ ++ /* ++ * If we spat out a valid sample set last time, ++ * spit out a "pen off" sample here. ++ */ ++ if (valid) { ++ ucb1x00_ts_event_release(ts); ++ valid = 0; ++ } ++ ++ /* ++ * Since ucb1x00_enable_irq() might sleep due ++ * to the way the UCB1400 regs are accessed, we ++ * can't use set_task_state() before that call, ++ * and not changing state before enabling the ++ * interrupt is racy. A semaphore solves all ++ * those issues quite nicely. ++ */ ++ down_interruptible(&ts->irq_wait); ++ } else { ++ ucb1x00_disable(ts->ucb); ++ ++ /* ++ * Filtering is policy. Policy belongs in user ++ * space. We therefore leave it to user space ++ * to do any filtering they please. ++ */ ++ if (!ts->restart) { ++ ucb1x00_ts_evt_add(ts, p, x, y); ++ valid = 1; ++ } ++ ++ set_task_state(tsk, TASK_INTERRUPTIBLE); ++ } ++ ++ schedule_timeout(HZ / 100); ++ if (signal_pending(tsk)) ++ break; ++ } ++ ++ ts->rtask = NULL; ++ complete_and_exit(&ts->init_exit, 0); ++} ++ ++/* ++ * We only detect touch screen _touches_ with this interrupt ++ * handler, and even then we just schedule our task. ++ */ ++static void ucb1x00_ts_irq(int idx, void *id) ++{ ++ struct ucb1x00_ts *ts = id; ++ ucb1x00_disable_irq(ts->ucb, UCB_IRQ_TSPX, UCB_FALLING); ++ up(&ts->irq_wait); ++} ++ ++static inline void ucb1x00_ts_event_release(struct ucb1x00_ts *ts) ++{ ++ input_report_abs(&ts->idev, ABS_PRESSURE, 0); ++} ++ ++static int ucb1x00_ts_open(struct input_dev *idev) ++{ ++ struct ucb1x00_ts *ts = (struct ucb1x00_ts *)idev; ++ int ret = 0; ++ ++ if (down_interruptible(&ts->sem)) ++ return -EINTR; ++ ++ if (ts->use_count++ != 0) ++ goto out; ++ ++ if (ts->rtask) ++ panic("ucb1x00: rtask running?"); ++ ++ sema_init(&ts->irq_wait, 0); ++ ret = ucb1x00_hook_irq(ts->ucb, UCB_IRQ_TSPX, ucb1x00_ts_irq, ts); ++ if (ret < 0) ++ goto out; ++ ++ /* ++ * If we do this at all, we should allow the user to ++ * measure and read the X and Y resistance at any time. ++ */ ++ ucb1x00_adc_enable(ts->ucb); ++ ts->x_res = ucb1x00_ts_read_xres(ts); ++ ts->y_res = ucb1x00_ts_read_yres(ts); ++ ucb1x00_adc_disable(ts->ucb); ++ ++ init_completion(&ts->init_exit); ++ ret = kernel_thread(ucb1x00_thread, ts, CLONE_KERNEL); ++ if (ret >= 0) { ++ wait_for_completion(&ts->init_exit); ++ ret = 0; ++ } else { ++ ucb1x00_free_irq(ts->ucb, UCB_IRQ_TSPX, ts); ++ } ++ ++ out: ++ if (ret) ++ ts->use_count--; ++ up(&ts->sem); ++ return ret; ++} ++ ++/* ++ * Release touchscreen resources. Disable IRQs. ++ */ ++static void ucb1x00_ts_close(struct input_dev *idev) ++{ ++ struct ucb1x00_ts *ts = (struct ucb1x00_ts *)idev; ++ ++ down(&ts->sem); ++ if (--ts->use_count == 0) { ++ if (ts->rtask) { ++ send_sig(SIGKILL, ts->rtask, 1); ++ wait_for_completion(&ts->init_exit); ++ } ++ ++ ucb1x00_enable(ts->ucb); ++ ucb1x00_free_irq(ts->ucb, UCB_IRQ_TSPX, ts); ++ ucb1x00_reg_write(ts->ucb, UCB_TS_CR, 0); ++ ucb1x00_disable(ts->ucb); ++ } ++ up(&ts->sem); ++} ++ ++#if 0 ++static int ucb1x00_ts_resume(struct device *_dev, u32 level) ++{ ++ struct ucb1x00_device *dev = ucb1x00_dev(_dev); ++ struct ucb1x00_ts *ts = ucb1x00_get_drvdata(dev); ++ ++ if (level == RESUME_ENABLE && ts->rtask != NULL) { ++ /* ++ * Restart the TS thread to ensure the ++ * TS interrupt mode is set up again ++ * after sleep. ++ */ ++ ts->restart = 1; ++ up(&ts->irq_wait); ++ } ++ return 0; ++} ++#endif ++ ++ ++/* ++ * Initialisation. ++ */ ++static int ucb1x00_ts_add(struct class_device *dev) ++{ ++ struct ucb1x00 *ucb = classdev_to_ucb1x00(dev); ++ struct ucb1x00_ts *ts; ++ ++ ts = kmalloc(sizeof(struct ucb1x00_ts), GFP_KERNEL); ++ if (!ts) ++ return -ENOMEM; ++ ++ memset(ts, 0, sizeof(struct ucb1x00_ts)); ++ ++ ts->ucb = ucb; ++ ts->adcsync = adcsync; ++ init_MUTEX(&ts->sem); ++ ++ ts->idev.name = "Touchscreen panel"; ++ ts->idev.id.product = ts->ucb->id; ++ ts->idev.open = ucb1x00_ts_open; ++ ts->idev.close = ucb1x00_ts_close; ++ ++ __set_bit(EV_ABS, ts->idev.evbit); ++ __set_bit(ABS_X, ts->idev.absbit); ++ __set_bit(ABS_Y, ts->idev.absbit); ++ __set_bit(ABS_PRESSURE, ts->idev.absbit); ++ ++ input_register_device(&ts->idev); ++ ++ ucb->ts_data = ts; ++ ++ return 0; ++} ++ ++static void ucb1x00_ts_remove(struct class_device *dev) ++{ ++ struct ucb1x00 *ucb = classdev_to_ucb1x00(dev); ++ struct ucb1x00_ts *ts = ucb->ts_data; ++ ++ input_unregister_device(&ts->idev); ++ kfree(ts); ++} ++ ++static struct class_interface ucb1x00_ts_interface = { ++ .add = ucb1x00_ts_add, ++ .remove = ucb1x00_ts_remove, ++}; ++ ++static int __init ucb1x00_ts_init(void) ++{ ++ return ucb1x00_register_interface(&ucb1x00_ts_interface); ++} ++ ++static void __exit ucb1x00_ts_exit(void) ++{ ++ ucb1x00_unregister_interface(&ucb1x00_ts_interface); ++} ++ ++#ifndef MODULE ++ ++/* ++ * Parse kernel command-line options. ++ * ++ * syntax : ucbts=[sync|nosync],... ++ */ ++static int __init ucb1x00_ts_setup(char *str) ++{ ++ char *p; ++ ++ while ((p = strsep(&str, ",")) != NULL) { ++ if (strcmp(p, "sync") == 0) ++ adcsync = UCB_SYNC; ++ } ++ ++ return 1; ++} ++ ++__setup("ucbts=", ucb1x00_ts_setup); ++ ++#else ++ ++MODULE_PARM(adcsync, "i"); ++MODULE_PARM_DESC(adcsync, "Enable use of ADCSYNC signal"); ++ ++#endif ++ ++module_init(ucb1x00_ts_init); ++module_exit(ucb1x00_ts_exit); ++ ++MODULE_AUTHOR("Russell King <rmk@arm.linux.org.uk>"); ++MODULE_DESCRIPTION("UCB1x00 touchscreen driver"); ++MODULE_LICENSE("GPL"); +--- /dev/null 2003-09-23 18:19:32.000000000 -0400 ++++ linux-2.6.5/drivers/misc/ucb1x00-core.c 2004-04-30 20:57:36.000000000 -0400 +@@ -0,0 +1,624 @@ ++/* ++ * linux/drivers/misc/ucb1x00-core.c ++ * ++ * Copyright (C) 2001 Russell King, All Rights Reserved. ++ * ++ * 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. ++ * ++ * The UCB1x00 core driver provides basic services for handling IO, ++ * the ADC, interrupts, and accessing registers. It is designed ++ * such that everything goes through this layer, thereby providing ++ * a consistent locking methodology, as well as allowing the drivers ++ * to be used on other non-MCP-enabled hardware platforms. ++ * ++ * Note that all locks are private to this file. Nothing else may ++ * touch them. ++ */ ++#include <linux/config.h> ++#include <linux/module.h> ++#include <linux/kernel.h> ++#include <linux/slab.h> ++#include <linux/init.h> ++#include <linux/errno.h> ++#include <linux/interrupt.h> ++#include <linux/device.h> ++ ++#include <asm/dma.h> ++#include <asm/hardware.h> ++#include <asm/irq.h> ++ ++#include "ucb1x00.h" ++ ++/** ++ * ucb1x00_io_set_dir - set IO direction ++ * @ucb: UCB1x00 structure describing chip ++ * @in: bitfield of IO pins to be set as inputs ++ * @out: bitfield of IO pins to be set as outputs ++ * ++ * Set the IO direction of the ten general purpose IO pins on ++ * the UCB1x00 chip. The @in bitfield has priority over the ++ * @out bitfield, in that if you specify a pin as both input ++ * and output, it will end up as an input. ++ * ++ * ucb1x00_enable must have been called to enable the comms ++ * before using this function. ++ * ++ * This function takes a spinlock, disabling interrupts. ++ */ ++void ucb1x00_io_set_dir(struct ucb1x00 *ucb, unsigned int in, unsigned int out) ++{ ++ unsigned long flags; ++ ++ spin_lock_irqsave(&ucb->io_lock, flags); ++ ucb->io_dir |= out; ++ ucb->io_dir &= ~in; ++ ++ ucb1x00_reg_write(ucb, UCB_IO_DIR, ucb->io_dir); ++ spin_unlock_irqrestore(&ucb->io_lock, flags); ++} ++ ++/** ++ * ucb1x00_io_write - set or clear IO outputs ++ * @ucb: UCB1x00 structure describing chip ++ * @set: bitfield of IO pins to set to logic '1' ++ * @clear: bitfield of IO pins to set to logic '0' ++ * ++ * Set the IO output state of the specified IO pins. The value ++ * is retained if the pins are subsequently configured as inputs. ++ * The @clear bitfield has priority over the @set bitfield - ++ * outputs will be cleared. ++ * ++ * ucb1x00_enable must have been called to enable the comms ++ * before using this function. ++ * ++ * This function takes a spinlock, disabling interrupts. ++ */ ++void ucb1x00_io_write(struct ucb1x00 *ucb, unsigned int set, unsigned int clear) ++{ ++ unsigned long flags; ++ ++ spin_lock_irqsave(&ucb->io_lock, flags); ++ ucb->io_out |= set; ++ ucb->io_out &= ~clear; ++ ++ ucb1x00_reg_write(ucb, UCB_IO_DATA, ucb->io_out); ++ spin_unlock_irqrestore(&ucb->io_lock, flags); ++} ++ ++/** ++ * ucb1x00_io_read - read the current state of the IO pins ++ * @ucb: UCB1x00 structure describing chip ++ * ++ * Return a bitfield describing the logic state of the ten ++ * general purpose IO pins. ++ * ++ * ucb1x00_enable must have been called to enable the comms ++ * before using this function. ++ * ++ * This function does not take any semaphores or spinlocks. ++ */ ++unsigned int ucb1x00_io_read(struct ucb1x00 *ucb) ++{ ++ return ucb1x00_reg_read(ucb, UCB_IO_DATA); ++} ++ ++/* ++ * UCB1300 data sheet says we must: ++ * 1. enable ADC => 5us (including reference startup time) ++ * 2. select input => 51*tsibclk => 4.3us ++ * 3. start conversion => 102*tsibclk => 8.5us ++ * (tsibclk = 1/11981000) ++ * Period between SIB 128-bit frames = 10.7us ++ */ ++ ++/** ++ * ucb1x00_adc_enable - enable the ADC converter ++ * @ucb: UCB1x00 structure describing chip ++ * ++ * Enable the ucb1x00 and ADC converter on the UCB1x00 for use. ++ * Any code wishing to use the ADC converter must call this ++ * function prior to using it. ++ * ++ * This function takes the ADC semaphore to prevent two or more ++ * concurrent uses, and therefore may sleep. As a result, it ++ * can only be called from process context, not interrupt ++ * context. ++ * ++ * You should release the ADC as soon as possible using ++ * ucb1x00_adc_disable. ++ */ ++void ucb1x00_adc_enable(struct ucb1x00 *ucb) ++{ ++ down(&ucb->adc_sem); ++ ++ ucb->adc_cr |= UCB_ADC_ENA; ++ ++ ucb1x00_enable(ucb); ++ ucb1x00_reg_write(ucb, UCB_ADC_CR, ucb->adc_cr); ++} ++ ++/** ++ * ucb1x00_adc_read - read the specified ADC channel ++ * @ucb: UCB1x00 structure describing chip ++ * @adc_channel: ADC channel mask ++ * @sync: wait for syncronisation pulse. ++ * ++ * Start an ADC conversion and wait for the result. Note that ++ * synchronised ADC conversions (via the ADCSYNC pin) must wait ++ * until the trigger is asserted and the conversion is finished. ++ * ++ * This function currently spins waiting for the conversion to ++ * complete (2 frames max without sync). ++ * ++ * If called for a synchronised ADC conversion, it may sleep ++ * with the ADC semaphore held. ++ * ++ * See ucb1x00.h for definition of the UCB_ADC_DAT macro. It ++ * addresses a bug in the ucb1200/1300 which, of course, Philips ++ * decided to finally fix in the ucb1400 ;-) -jws ++ */ ++unsigned int ucb1x00_adc_read(struct ucb1x00 *ucb, int adc_channel, int sync) ++{ ++ unsigned int val; ++ ++ if (sync) ++ adc_channel |= UCB_ADC_SYNC_ENA; ++ ++ ucb1x00_reg_write(ucb, UCB_ADC_CR, ucb->adc_cr | adc_channel); ++ ucb1x00_reg_write(ucb, UCB_ADC_CR, ucb->adc_cr | adc_channel | UCB_ADC_START); ++ ++ for (;;) { ++ val = ucb1x00_reg_read(ucb, UCB_ADC_DATA); ++ if (val & UCB_ADC_DAT_VAL) ++ break; ++ /* yield to other processes */ ++ set_current_state(TASK_INTERRUPTIBLE); ++ schedule_timeout(1); ++ } ++ ++ return UCB_ADC_DAT(val); ++} ++ ++/** ++ * ucb1x00_adc_disable - disable the ADC converter ++ * @ucb: UCB1x00 structure describing chip ++ * ++ * Disable the ADC converter and release the ADC semaphore. ++ */ ++void ucb1x00_adc_disable(struct ucb1x00 *ucb) ++{ ++ ucb->adc_cr &= ~UCB_ADC_ENA; ++ ucb1x00_reg_write(ucb, UCB_ADC_CR, ucb->adc_cr); ++ ucb1x00_disable(ucb); ++ ++ up(&ucb->adc_sem); ++} ++ ++/* ++ * UCB1x00 Interrupt handling. ++ * ++ * The UCB1x00 can generate interrupts when the SIBCLK is stopped. ++ * Since we need to read an internal register, we must re-enable ++ * SIBCLK to talk to the chip. We leave the clock running until ++ * we have finished processing all interrupts from the chip. ++ * ++ * A restriction with interrupts exists when using the ucb1400, as ++ * the codec read/write routines may sleep while waiting for codec ++ * access completion and uses semaphores for access control to the ++ * AC97 bus. A complete codec read cycle could take anywhere from ++ * 60 to 100uSec so we *definitely* don't want to spin inside the ++ * interrupt handler waiting for codec access. So, we handle the ++ * interrupt by scheduling a RT kernel thread to run in process ++ * context instead of interrupt context. ++ */ ++ ++static int ucb1x00_thread(void *_ucb) ++{ ++ struct task_struct *tsk = current; ++ DECLARE_WAITQUEUE(wait, tsk); ++ struct ucb1x00 *ucb = _ucb; ++ struct ucb1x00_irq *irq; ++ unsigned int isr, i; ++ ++ ucb->rtask = tsk; ++ ++ daemonize(); ++ reparent_to_init(); ++ tsk->tty = NULL; ++ tsk->policy = SCHED_FIFO; ++ tsk->rt_priority = 1; ++ strcpy(tsk->comm, "kUCB1x00d"); ++ ++ /* only want to receive SIGKILL */ ++ spin_lock_irq(&tsk->sigmask_lock); ++ siginitsetinv(&tsk->blocked, sigmask(SIGKILL)); ++ recalc_sigpending(); ++ spin_unlock_irq(&tsk->sigmask_lock); ++ ++ add_wait_queue(&ucb->irq_wait, &wait); ++ set_task_state(tsk, TASK_INTERRUPTIBLE); ++ complete(&ucb->complete); ++ ++ for (;;) { ++ if (signal_pending(tsk)) ++ break; ++ enable_irq(ucb->irq); ++ schedule(); ++ ++ ucb1x00_enable(ucb); ++ isr = ucb1x00_reg_read(ucb, UCB_IE_STATUS); ++ ucb1x00_reg_write(ucb, UCB_IE_CLEAR, isr); ++ ucb1x00_reg_write(ucb, UCB_IE_CLEAR, 0); ++ ++ for (i = 0, irq = ucb->irq_handler; ++ i < 16 && isr; ++ i++, isr >>= 1, irq++) ++ if (isr & 1 && irq->fn) ++ irq->fn(i, irq->devid); ++ ucb1x00_disable(ucb); ++ ++ set_task_state(tsk, TASK_INTERRUPTIBLE); ++ } ++ ++ remove_wait_queue(&ucb->irq_wait, &wait); ++ ucb->rtask = NULL; ++ complete_and_exit(&ucb->complete, 0); ++} ++ ++static irqreturn_t ucb1x00_irq(int irqnr, void *devid, struct pt_regs *regs) ++{ ++ struct ucb1x00 *ucb = devid; ++ disable_irq(irqnr); ++ wake_up(&ucb->irq_wait); ++ return IRQ_HANDLED; ++} ++ ++/** ++ * ucb1x00_hook_irq - hook a UCB1x00 interrupt ++ * @ucb: UCB1x00 structure describing chip ++ * @idx: interrupt index ++ * @fn: function to call when interrupt is triggered ++ * @devid: device id to pass to interrupt handler ++ * ++ * Hook the specified interrupt. You can only register one handler ++ * for each interrupt source. The interrupt source is not enabled ++ * by this function; use ucb1x00_enable_irq instead. ++ * ++ * Interrupt handlers will be called with other interrupts enabled. ++ * ++ * Returns zero on success, or one of the following errors: ++ * -EINVAL if the interrupt index is invalid ++ * -EBUSY if the interrupt has already been hooked ++ */ ++int ucb1x00_hook_irq(struct ucb1x00 *ucb, unsigned int idx, void (*fn)(int, void *), void *devid) ++{ ++ struct ucb1x00_irq *irq; ++ int ret = -EINVAL; ++ ++ if (idx < 16) { ++ irq = ucb->irq_handler + idx; ++ ret = -EBUSY; ++ ++ spin_lock_irq(&ucb->lock); ++ if (irq->fn == NULL) { ++ irq->devid = devid; ++ irq->fn = fn; ++ ret = 0; ++ } ++ spin_unlock_irq(&ucb->lock); ++ } ++ return ret; ++} ++ ++/** ++ * ucb1x00_enable_irq - enable an UCB1x00 interrupt source ++ * @ucb: UCB1x00 structure describing chip ++ * @idx: interrupt index ++ * @edges: interrupt edges to enable ++ * ++ * Enable the specified interrupt to trigger on %UCB_RISING, ++ * %UCB_FALLING or both edges. The interrupt should have been ++ * hooked by ucb1x00_hook_irq. ++ */ ++void ucb1x00_enable_irq(struct ucb1x00 *ucb, unsigned int idx, int edges) ++{ ++ unsigned long flags; ++ ++ if (idx < 16) { ++ spin_lock_irqsave(&ucb->lock, flags); ++ ++ ucb1x00_enable(ucb); ++ ++ /* This prevents spurious interrupts on the UCB1400 */ ++ ucb1x00_reg_write(ucb, UCB_IE_CLEAR, 1 << idx); ++ ucb1x00_reg_write(ucb, UCB_IE_CLEAR, 0); ++ ++ if (edges & UCB_RISING) { ++ ucb->irq_ris_enbl |= 1 << idx; ++ ucb1x00_reg_write(ucb, UCB_IE_RIS, ucb->irq_ris_enbl); ++ } ++ if (edges & UCB_FALLING) { ++ ucb->irq_fal_enbl |= 1 << idx; ++ ucb1x00_reg_write(ucb, UCB_IE_FAL, ucb->irq_fal_enbl); ++ } ++ ucb1x00_disable(ucb); ++ spin_unlock_irqrestore(&ucb->lock, flags); ++ } ++} ++ ++/** ++ * ucb1x00_disable_irq - disable an UCB1x00 interrupt source ++ * @ucb: UCB1x00 structure describing chip ++ * @edges: interrupt edges to disable ++ * ++ * Disable the specified interrupt triggering on the specified ++ * (%UCB_RISING, %UCB_FALLING or both) edges. ++ */ ++void ucb1x00_disable_irq(struct ucb1x00 *ucb, unsigned int idx, int edges) ++{ ++ unsigned long flags; ++ ++ if (idx < 16) { ++ spin_lock_irqsave(&ucb->lock, flags); ++ ++ ucb1x00_enable(ucb); ++ if (edges & UCB_RISING) { ++ ucb->irq_ris_enbl &= ~(1 << idx); ++ ucb1x00_reg_write(ucb, UCB_IE_RIS, ucb->irq_ris_enbl); ++ } ++ if (edges & UCB_FALLING) { ++ ucb->irq_fal_enbl &= ~(1 << idx); ++ ucb1x00_reg_write(ucb, UCB_IE_FAL, ucb->irq_fal_enbl); ++ } ++ ucb1x00_disable(ucb); ++ spin_unlock_irqrestore(&ucb->lock, flags); ++ } ++} ++ ++/** ++ * ucb1x00_free_irq - disable and free the specified UCB1x00 interrupt ++ * @ucb: UCB1x00 structure describing chip ++ * @idx: interrupt index ++ * @devid: device id. ++ * ++ * Disable the interrupt source and remove the handler. devid must ++ * match the devid passed when hooking the interrupt. ++ * ++ * Returns zero on success, or one of the following errors: ++ * -EINVAL if the interrupt index is invalid ++ * -ENOENT if devid does not match ++ */ ++int ucb1x00_free_irq(struct ucb1x00 *ucb, unsigned int idx, void *devid) ++{ ++ struct ucb1x00_irq *irq; ++ int ret; ++ ++ if (idx >= 16) ++ goto bad; ++ ++ irq = ucb->irq_handler + idx; ++ ret = -ENOENT; ++ ++ spin_lock_irq(&ucb->lock); ++ if (irq->devid == devid) { ++ ucb->irq_ris_enbl &= ~(1 << idx); ++ ucb->irq_fal_enbl &= ~(1 << idx); ++ ++ ucb1x00_enable(ucb); ++ ucb1x00_reg_write(ucb, UCB_IE_RIS, ucb->irq_ris_enbl); ++ ucb1x00_reg_write(ucb, UCB_IE_FAL, ucb->irq_fal_enbl); ++ ucb1x00_disable(ucb); ++ ++ irq->fn = NULL; ++ irq->devid = NULL; ++ ret = 0; ++ } ++ spin_unlock_irq(&ucb->lock); ++ return ret; ++ ++bad: ++ printk(KERN_ERR "Freeing bad UCB1x00 irq %d\n", idx); ++ return -EINVAL; ++} ++ ++/* ++ * Try to probe our interrupt, rather than relying on lots of ++ * hard-coded machine dependencies. For reference, the expected ++ * IRQ mappings are: ++ * ++ * Machine Default IRQ ++ * adsbitsy IRQ_GPCIN4 ++ * cerf IRQ_GPIO_UCB1200_IRQ ++ * flexanet IRQ_GPIO_GUI ++ * freebird IRQ_GPIO_FREEBIRD_UCB1300_IRQ ++ * graphicsclient ADS_EXT_IRQ(8) ++ * graphicsmaster ADS_EXT_IRQ(8) ++ * lart LART_IRQ_UCB1200 ++ * omnimeter IRQ_GPIO23 ++ * pfs168 IRQ_GPIO_UCB1300_IRQ ++ * simpad IRQ_GPIO_UCB1300_IRQ ++ * shannon SHANNON_IRQ_GPIO_IRQ_CODEC ++ * yopy IRQ_GPIO_UCB1200_IRQ ++ */ ++static int ucb1x00_detect_irq(struct ucb1x00 *ucb) ++{ ++ unsigned long mask; ++ ++ mask = probe_irq_on(); ++ if (!mask) ++ return NO_IRQ; ++ ++ /* ++ * Enable the ADC interrupt. ++ */ ++ ucb1x00_reg_write(ucb, UCB_IE_RIS, UCB_IE_ADC); ++ ucb1x00_reg_write(ucb, UCB_IE_FAL, UCB_IE_ADC); ++ ucb1x00_reg_write(ucb, UCB_IE_CLEAR, 0xffff); ++ ucb1x00_reg_write(ucb, UCB_IE_CLEAR, 0); ++ ++ /* ++ * Cause an ADC interrupt. ++ */ ++ ucb1x00_reg_write(ucb, UCB_ADC_CR, UCB_ADC_ENA); ++ ucb1x00_reg_write(ucb, UCB_ADC_CR, UCB_ADC_ENA | UCB_ADC_START); ++ ++ /* ++ * Wait for the conversion to complete. ++ */ ++ while ((ucb1x00_reg_read(ucb, UCB_ADC_DATA) & UCB_ADC_DAT_VAL) == 0); ++ ucb1x00_reg_write(ucb, UCB_ADC_CR, 0); ++ ++ /* ++ * Disable and clear interrupt. ++ */ ++ ucb1x00_reg_write(ucb, UCB_IE_RIS, 0); ++ ucb1x00_reg_write(ucb, UCB_IE_FAL, 0); ++ ucb1x00_reg_write(ucb, UCB_IE_CLEAR, 0xffff); ++ ucb1x00_reg_write(ucb, UCB_IE_CLEAR, 0); ++ ++ /* ++ * Read triggered interrupt. ++ */ ++ return probe_irq_off(mask); ++} ++ ++static int ucb1x00_probe(struct mcp *mcp) ++{ ++ struct ucb1x00 *ucb; ++ unsigned int id; ++ int ret = -ENODEV; ++ ++ mcp_enable(mcp); ++ id = mcp_reg_read(mcp, UCB_ID); ++ ++ if (id != UCB_ID_1200 && id != UCB_ID_1300) { ++ printk(KERN_WARNING "UCB1x00 ID not found: %04x\n", id); ++ goto err_disable; ++ } ++ ++ ucb = kmalloc(sizeof(struct ucb1x00), GFP_KERNEL); ++ ret = -ENOMEM; ++ if (!ucb) ++ goto err_disable; ++ ++ memset(ucb, 0, sizeof(struct ucb1x00)); ++ ++ ucb->cdev.class = &ucb1x00_class; ++ ucb->cdev.dev = &mcp->attached_device; ++ strlcpy(ucb->cdev.class_id, "ucb1x00", sizeof(ucb->cdev.class_id)); ++ ++ spin_lock_init(&ucb->lock); ++ spin_lock_init(&ucb->io_lock); ++ sema_init(&ucb->adc_sem, 1); ++ ++ ucb->id = id; ++ ucb->mcp = mcp; ++ ucb->irq = ucb1x00_detect_irq(ucb); ++ if (ucb->irq == NO_IRQ) { ++ printk(KERN_ERR "UCB1x00: IRQ probe failed\n"); ++ ret = -ENODEV; ++ goto err_free; ++ } ++ ++ ret = request_irq(ucb->irq, ucb1x00_irq, 0, "UCB1x00", ucb); ++ if (ret) { ++ printk(KERN_ERR "ucb1x00: unable to grab irq%d: %d\n", ++ ucb->irq, ret); ++ goto err_free; ++ } ++ ++ set_irq_type(ucb->irq, IRQT_RISING); ++ mcp_set_drvdata(mcp, ucb); ++ ++ ret = class_device_register(&ucb->cdev); ++ if (ret) { ++ free_irq(ucb->irq, ucb); ++ err_free: ++ kfree(ucb); ++ } ++ err_disable: ++ mcp_disable(mcp); ++ return ret; ++} ++ ++static void ucb1x00_remove(struct mcp *mcp) ++{ ++ struct ucb1x00 *ucb = mcp_get_drvdata(mcp); ++ ++ class_device_unregister(&ucb->cdev); ++ free_irq(ucb->irq, ucb); ++} ++ ++static void ucb1x00_release(struct class_device *dev) ++{ ++ struct ucb1x00 *ucb = classdev_to_ucb1x00(dev); ++ kfree(ucb); ++} ++ ++static struct class ucb1x00_class = { ++ .name = "ucb1x00", ++ .release = ucb1x00_release, ++}; ++ ++int ucb1x00_register_interface(struct class_interface *intf) ++{ ++ intf->class = &ucb1x00_class; ++ return class_interface_register(intf); ++} ++ ++void ucb1x00_unregister_interface(struct class_interface *intf) ++{ ++ class_interface_unregister(intf); ++} ++ ++static struct mcp_driver ucb1x00_driver = { ++ .drv = { ++ .name = "ucb1x00", ++ }, ++ .probe = ucb1x00_probe, ++ .remove = ucb1x00_remove, ++}; ++ ++static int __init ucb1x00_init(void) ++{ ++ int ret = class_register(&ucb1x00_class); ++ if (ret == 0) { ++ ret = mcp_driver_register(&ucb1x00_driver); ++ if (ret) ++ class_unregister(&ucb1x00_class); ++ } ++ return ret; ++} ++ ++static void __exit ucb1x00_exit(void) ++{ ++ mcp_driver_unregister(&ucb1x00_driver); ++ class_unregister(&ucb1x00_class); ++} ++ ++module_init(ucb1x00_init); ++module_exit(ucb1x00_exit); ++ ++EXPORT_SYMBOL(ucb1x00_class); ++ ++EXPORT_SYMBOL(ucb1x00_io_set_dir); ++EXPORT_SYMBOL(ucb1x00_io_write); ++EXPORT_SYMBOL(ucb1x00_io_read); ++ ++EXPORT_SYMBOL(ucb1x00_adc_enable); ++EXPORT_SYMBOL(ucb1x00_adc_read); ++EXPORT_SYMBOL(ucb1x00_adc_disable); ++ ++EXPORT_SYMBOL(ucb1x00_hook_irq); ++EXPORT_SYMBOL(ucb1x00_free_irq); ++EXPORT_SYMBOL(ucb1x00_enable_irq); ++EXPORT_SYMBOL(ucb1x00_disable_irq); ++ ++EXPORT_SYMBOL(ucb1x00_register_interface); ++EXPORT_SYMBOL(ucb1x00_unregister_interface); ++ ++MODULE_AUTHOR("Russell King <rmk@arm.linux.org.uk>"); ++MODULE_DESCRIPTION("UCB1x00 core driver"); ++MODULE_LICENSE("GPL"); +--- /dev/null 2003-09-23 18:19:32.000000000 -0400 ++++ linux-2.6.5/drivers/misc/switches-ucb1x00.c 2004-04-30 20:57:36.000000000 -0400 +@@ -0,0 +1,214 @@ ++/* ++ * linux/drivers/misc/switches-ucb1x00.c ++ * ++ * Copyright (C) 2001 John Dorsey ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License version 2 as ++ * published by the Free Software Foundation. ++ * ++ * 19 December 2001 - created from sa1100_switches.c. ++ */ ++ ++#include <linux/config.h> ++#include <linux/module.h> ++#include <linux/init.h> ++#include <linux/kernel.h> ++#include <linux/sched.h> ++#include <linux/errno.h> ++#include <linux/device.h> ++ ++#include <asm/dma.h> ++#include <asm/hardware.h> ++#include <asm/irq.h> ++#include <asm/mach-types.h> ++ ++#ifdef CONFIG_SA1100_ASSABET ++#include <asm/arch/assabet.h> ++#endif ++ ++#include "switches.h" ++#include "ucb1x00.h" ++ ++ ++static void switches_ucb1x00_handler(int irq, void *devid); ++ ++ ++#ifdef CONFIG_SA1100_ASSABET ++ ++/* Assabet ++ * ^^^^^^^ ++ * Six switches are routed to GPIO pins on the UCB1300: S3 -- S8. ++ * This code sets bits in the range [3, 8] in the mask that we ++ * return to userland. Note that we transpose signals SW7 and SW8; ++ * see assabet_switches_ucb1x00_handler(). ++ */ ++ ++static int assabet_switches_ucb1x00_init(struct ucb1x00 *ucb) ++{ ++ int i; ++ ++ ucb1x00_enable(ucb); ++ ++ ucb1x00_io_set_dir(ucb, ++ UCB_IO_0 | UCB_IO_1 | UCB_IO_2 | ++ UCB_IO_3 | UCB_IO_4 | UCB_IO_5, 0); ++ ++ for (i = 0; i < 6; ++i) { ++ ucb1x00_enable_irq(ucb, i, UCB_RISING | UCB_FALLING); ++ ++ if (ucb1x00_hook_irq(ucb, i, ++ switches_ucb1x00_handler, ucb) < 0) { ++ printk(KERN_ERR "%s: unable to hook IRQ for " ++ "UCB1300 IO_%d\n", SWITCHES_NAME, i); ++ ++ /* FIXME: BUGGY ERROR HANDLING */ ++ return -EBUSY; ++ } ++ ++ } ++ ++ ucb1x00_disable(ucb); ++ ++ return 0; ++ ++} ++ ++static void assabet_switches_ucb1x00_shutdown(struct ucb1x00 *ucb) ++{ ++ int i; ++ ++ ucb1x00_enable(ucb); ++ ++ for (i = 5; i >= 0; --i) { ++ ucb1x00_disable_irq(ucb, i, UCB_RISING | UCB_FALLING); ++ ++ /* Only error conditions are ENOENT and EINVAL; silently ++ * ignore: ++ */ ++ ucb1x00_free_irq(ucb, i, ucb); ++ } ++ ++ ucb1x00_disable(ucb); ++} ++ ++static void assabet_switches_ucb1x00_handler(struct ucb1x00 *ucb, int irq, switches_mask_t *mask) ++{ ++ unsigned int last, this; ++ static unsigned int states = 0; ++ ++ last = ((states & (1 << irq)) != 0); ++ this = ((ucb1x00_io_read(ucb) & (1 << irq)) != 0); ++ ++ if (last == this) /* debounce */ ++ return; ++ ++ /* Intel StrongARM SA-1110 Development Board ++ * Schematics Figure 5, Sheet 5 of 12 ++ * ++ * See switches S8 and S7. Notice their ++ * relationship to signals SW7 and SW8. Hmmm. ++ */ ++ ++ switch (irq) { ++ ++ case 4: ++ ++ SWITCHES_SET(mask, 8, this); ++ break; ++ ++ case 5: ++ ++ SWITCHES_SET(mask, 7, this); ++ break; ++ ++ default: ++ ++ SWITCHES_SET(mask, irq + 3, this); ++ ++ } ++ ++ states = this ? (states | (1 << irq)) : (states & ~(1 << irq)); ++ ++} ++#endif /* CONFIG_SA1100_ASSABET */ ++ ++ ++/* switches_ucb1x00_handler() ++ * ^^^^^^^^^^^^^^^^^^^^^^^^^^ ++ * This routine is a generalized handler for UCB1x00 GPIO switches ++ * which calls a board-specific service routine and passes an event ++ * mask to the core event handler. This routine is appropriate for ++ * systems which use the ucb1x00 framework, and can be registered ++ * using ucb1x00_hook_irq(). ++ */ ++static void switches_ucb1x00_handler(int irq, void *devid) ++{ ++ struct ucb1x00 *ucb = devid; ++ switches_mask_t mask; ++ ++ SWITCHES_ZERO(&mask); ++ ++ /* Porting note: call a board-specific UCB1x00 switch handler here. ++ * The handler can assume that sufficient storage for `mask' has ++ * been allocated, and that the corresponding switches_mask_t ++ * structure has been zeroed. ++ */ ++ ++#ifdef CONFIG_SA1100_ASSABET ++ if (machine_is_assabet()) { ++ assabet_switches_ucb1x00_handler(ucb, irq, &mask); ++ } ++#endif ++ ++ switches_event(&mask); ++} ++ ++static int switches_add(struct class_device *dev) ++{ ++ struct ucb1x00 *ucb = classdev_to_ucb1x00(dev); ++ int ret = -ENODEV; ++ ++#ifdef CONFIG_SA1100_ASSABET ++ if (machine_is_assabet()) { ++ ret = assabet_switches_ucb1x00_init(ucb); ++ } ++#endif ++ /* Porting note: call a board-specific init routine here. */ ++ ++ return ret; ++} ++ ++static void switches_remove(struct class_device *dev) ++{ ++ struct ucb1x00 *ucb = classdev_to_ucb1x00(dev); ++ ++ /* Porting note: call a board-specific shutdown routine here. */ ++ ++#ifdef CONFIG_SA1100_ASSABET ++ if (machine_is_assabet()) { ++ assabet_switches_ucb1x00_shutdown(ucb); ++ } ++#endif ++} ++ ++static struct class_interface ucb1x00_switches_interface = { ++ .add = switches_add, ++ .remove = switches_remove, ++}; ++ ++static int __init switches_ucb1x00_init(void) ++{ ++ return ucb1x00_register_interface(&ucb1x00_switches_interface); ++} ++ ++static void __exit switches_ucb1x00_exit(void) ++{ ++ ucb1x00_unregister_interface(&ucb1x00_switches_interface); ++} ++ ++module_init(switches_ucb1x00_init); ++module_exit(switches_ucb1x00_exit); ++ ++MODULE_DESCRIPTION("ucb1x00 switches driver"); ++MODULE_LICENSE("GPL"); +--- /dev/null 2003-09-23 18:19:32.000000000 -0400 ++++ linux-2.6.5/drivers/misc/switches-core.c 2004-04-30 20:57:36.000000000 -0400 +@@ -0,0 +1,200 @@ ++/* ++ * linux/drivers/misc/switches-core.c ++ * ++ * Copyright (C) 2000-2001 John Dorsey ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License version 2 as ++ * published by the Free Software Foundation. ++ * ++ * 5 October 2000 - created. ++ * ++ * 25 October 2000 - userland file interface added. ++ * ++ * 13 January 2001 - added support for Spot. ++ * ++ * 11 September 2001 - UCB1200 driver framework support added. ++ * ++ * 19 December 2001 - separated out SA-1100 and UCB1x00 code. ++ */ ++ ++#include <linux/config.h> ++#include <linux/init.h> ++#include <linux/fs.h> ++#include <linux/kernel.h> ++#include <linux/miscdevice.h> ++#include <linux/module.h> ++#include <linux/mm.h> ++#include <linux/poll.h> ++#include <linux/sched.h> ++#include <linux/slab.h> ++#include <linux/wait.h> ++ ++#include <asm/uaccess.h> ++ ++#include "switches.h" ++ ++ ++MODULE_AUTHOR("John Dorsey"); ++MODULE_DESCRIPTION("Console switch support"); ++MODULE_LICENSE("GPL"); ++ ++ ++struct switches_action { ++ struct list_head list; ++ switches_mask_t mask; ++}; ++ ++ ++static int switches_users = 0; ++ ++static spinlock_t switches_lock = SPIN_LOCK_UNLOCKED; ++ ++DECLARE_WAIT_QUEUE_HEAD(switches_wait); ++LIST_HEAD(switches_event_queue); ++ ++ ++static ssize_t switches_read(struct file *file, char *buffer, ++ size_t count, loff_t *pos) ++{ ++ unsigned long flags; ++ struct list_head *event; ++ struct switches_action *action; ++ ++ if (count < sizeof(struct switches_mask_t)) ++ return -EINVAL; ++ ++ while (list_empty(&switches_event_queue)) { ++ ++ if (file->f_flags & O_NDELAY) ++ return -EAGAIN; ++ ++ interruptible_sleep_on(&switches_wait); ++ ++ if (signal_pending(current)) ++ return -ERESTARTSYS; ++ ++ } ++ ++ if (verify_area(VERIFY_WRITE, buffer, sizeof(struct switches_mask_t))) ++ return -EFAULT; ++ ++ spin_lock_irqsave(&switches_lock, flags); ++ ++ event = switches_event_queue.next; ++ action = list_entry(event, struct switches_action, list); ++ copy_to_user(buffer, &(action->mask), sizeof(struct switches_mask_t)); ++ list_del(event); ++ kfree(action); ++ ++ spin_unlock_irqrestore(&switches_lock, flags); ++ ++ return 0; ++ ++} ++ ++static ssize_t switches_write(struct file *file, const char *buffer, ++ size_t count, loff_t *ppos) ++{ ++ return -EINVAL; ++} ++ ++static unsigned int switches_poll(struct file *file, poll_table *wait) ++{ ++ ++ poll_wait(file, &switches_wait, wait); ++ ++ if (!list_empty(&switches_event_queue)) ++ return POLLIN | POLLRDNORM; ++ ++ return 0; ++ ++} ++ ++static int switches_open(struct inode *inode, struct file *file) ++{ ++ ++ if (switches_users > 0) ++ return -EBUSY; ++ ++ ++switches_users; ++ return 0; ++ ++} ++ ++static int switches_release(struct inode *inode, struct file *file) ++{ ++ ++ --switches_users; ++ return 0; ++ ++} ++ ++static struct file_operations switches_ops = { ++ .owner = THIS_MODULE, ++ .read = switches_read, ++ .write = switches_write, ++ .poll = switches_poll, ++ .open = switches_open, ++ .release = switches_release, ++}; ++ ++static struct miscdevice switches_misc = { ++ .minor = MISC_DYNAMIC_MINOR, ++ .name = SWITCHES_NAME, ++ .fops = &switches_ops, ++}; ++ ++int switches_event(switches_mask_t *mask) ++{ ++ struct switches_action *action; ++ ++ if ((switches_users > 0) && (SWITCHES_COUNT(mask) > 0)) { ++ ++ if ((action = (struct switches_action *) ++ kmalloc(sizeof(struct switches_action), ++ GFP_KERNEL)) == NULL) { ++ printk(KERN_ERR "%s: unable to allocate action " ++ "descriptor\n", SWITCHES_NAME); ++ return -1; ++ } ++ ++ action->mask = *mask; ++ ++ spin_lock(&switches_lock); ++ list_add_tail(&action->list, &switches_event_queue); ++ spin_unlock(&switches_lock); ++ ++ wake_up_interruptible(&switches_wait); ++ ++ } ++ ++ return 0; ++ ++} ++ ++EXPORT_SYMBOL(switches_event); ++ ++ ++static int __init switches_init(void) ++{ ++ if (misc_register(&switches_misc) < 0) { ++ printk(KERN_ERR "%s: unable to register misc device\n", ++ SWITCHES_NAME); ++ return -EIO; ++ } ++ ++ printk(KERN_INFO "Console switches initialized\n"); ++ ++ return 0; ++} ++ ++static void __exit switches_exit(void) ++{ ++ if (misc_deregister(&switches_misc) < 0) ++ printk(KERN_ERR "%s: unable to deregister misc device\n", ++ SWITCHES_NAME); ++} ++ ++module_init(switches_init); ++module_exit(switches_exit); +--- /dev/null 2003-09-23 18:19:32.000000000 -0400 ++++ linux-2.6.5/drivers/misc/ucb1x00-audio.c 2004-04-30 20:57:36.000000000 -0400 +@@ -0,0 +1,439 @@ ++/* ++ * linux/drivers/misc/ucb1x00-audio.c ++ * ++ * Copyright (C) 2001 Russell King, All Rights Reserved. ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License version 2 as ++ * published by the Free Software Foundation. ++ */ ++#include <linux/module.h> ++#include <linux/init.h> ++#include <linux/fs.h> ++#include <linux/errno.h> ++#include <linux/slab.h> ++#include <linux/sound.h> ++#include <linux/soundcard.h> ++#include <linux/list.h> ++#include <linux/device.h> ++ ++#include <asm/dma.h> ++#include <asm/hardware.h> ++#include <asm/semaphore.h> ++#include <asm/uaccess.h> ++ ++#include "ucb1x00.h" ++ ++#include "../sound/oss/sa1100-audio.h" ++ ++#define MAGIC 0x41544154 ++ ++struct ucb1x00_audio { ++ struct file_operations fops; ++ struct file_operations mops; ++ struct ucb1x00 *ucb; ++ audio_stream_t output_stream; ++ audio_stream_t input_stream; ++ audio_state_t state; ++ unsigned int rate; ++ int dev_id; ++ int mix_id; ++ unsigned int daa_oh_bit; ++ unsigned int telecom; ++ unsigned int magic; ++ unsigned int ctrl_a; ++ unsigned int ctrl_b; ++ ++ /* mixer info */ ++ unsigned int mod_cnt; ++ unsigned short output_level; ++ unsigned short input_level; ++}; ++ ++#define REC_MASK (SOUND_MASK_VOLUME | SOUND_MASK_MIC) ++#define DEV_MASK REC_MASK ++ ++static int ++ucb1x00_mixer_ioctl(struct inode *ino, struct file *filp, uint cmd, ulong arg) ++{ ++ struct ucb1x00_audio *ucba; ++ unsigned int val, gain; ++ int ret = 0; ++ ++ ucba = list_entry(filp->f_op, struct ucb1x00_audio, mops); ++ ++ if (_IOC_TYPE(cmd) != 'M') ++ return -EINVAL; ++ ++ if (cmd == SOUND_MIXER_INFO) { ++ struct mixer_info mi; ++ ++ strncpy(mi.id, "UCB1x00", sizeof(mi.id)); ++ strncpy(mi.name, "Philips UCB1x00", sizeof(mi.name)); ++ mi.modify_counter = ucba->mod_cnt; ++ return copy_to_user((void *)arg, &mi, sizeof(mi)) ? -EFAULT : 0; ++ } ++ ++ if (_IOC_DIR(cmd) & _IOC_WRITE) { ++ unsigned int left, right; ++ ++ ret = get_user(val, (unsigned int *)arg); ++ if (ret) ++ goto out; ++ ++ left = val & 255; ++ right = val >> 8; ++ ++ if (left > 100) ++ left = 100; ++ if (right > 100) ++ right = 100; ++ ++ gain = (left + right) / 2; ++ ++ ret = -EINVAL; ++ if (!ucba->telecom) { ++ switch(_IOC_NR(cmd)) { ++ case SOUND_MIXER_VOLUME: ++ ucba->output_level = gain | gain << 8; ++ ucba->mod_cnt++; ++ ucba->ctrl_b = (ucba->ctrl_b & 0xff00) | ++ ((gain * 31) / 100); ++ ucb1x00_reg_write(ucba->ucb, UCB_AC_B, ++ ucba->ctrl_b); ++ ret = 0; ++ break; ++ ++ case SOUND_MIXER_MIC: ++ ucba->input_level = gain | gain << 8; ++ ucba->mod_cnt++; ++ ucba->ctrl_a = (ucba->ctrl_a & 0x7f) | ++ (((gain * 31) / 100) << 7); ++ ucb1x00_reg_write(ucba->ucb, UCB_AC_A, ++ ucba->ctrl_a); ++ ret = 0; ++ break; ++ } ++ } ++ } ++ ++ if (ret == 0 && _IOC_DIR(cmd) & _IOC_READ) { ++ switch (_IOC_NR(cmd)) { ++ case SOUND_MIXER_VOLUME: ++ val = ucba->output_level; ++ break; ++ ++ case SOUND_MIXER_MIC: ++ val = ucba->input_level; ++ break; ++ ++ case SOUND_MIXER_RECSRC: ++ case SOUND_MIXER_RECMASK: ++ val = ucba->telecom ? 0 : REC_MASK; ++ break; ++ ++ case SOUND_MIXER_DEVMASK: ++ val = ucba->telecom ? 0 : DEV_MASK; ++ break; ++ ++ case SOUND_MIXER_CAPS: ++ case SOUND_MIXER_STEREODEVS: ++ val = 0; ++ break; ++ ++ default: ++ val = 0; ++ ret = -EINVAL; ++ break; ++ } ++ ++ if (ret == 0) ++ ret = put_user(val, (int *)arg); ++ } ++ out: ++ return ret; ++} ++ ++static int ucb1x00_audio_setrate(struct ucb1x00_audio *ucba, int rate) ++{ ++ unsigned int div_rate = ucb1x00_clkrate(ucba->ucb) / 32; ++ unsigned int div; ++ ++ div = (div_rate + (rate / 2)) / rate; ++ if (div < 6) ++ div = 6; ++ if (div > 127) ++ div = 127; ++ ++ ucba->ctrl_a = (ucba->ctrl_a & ~0x7f) | div; ++ ++ if (ucba->telecom) { ++ ucb1x00_reg_write(ucba->ucb, UCB_TC_B, 0); ++ ucb1x00_set_telecom_divisor(ucba->ucb, div * 32); ++ ucb1x00_reg_write(ucba->ucb, UCB_TC_A, ucba->ctrl_a); ++ ucb1x00_reg_write(ucba->ucb, UCB_TC_B, ucba->ctrl_b); ++ } else { ++ ucb1x00_reg_write(ucba->ucb, UCB_AC_B, 0); ++ ucb1x00_set_audio_divisor(ucba->ucb, div * 32); ++ ucb1x00_reg_write(ucba->ucb, UCB_AC_A, ucba->ctrl_a); ++ ucb1x00_reg_write(ucba->ucb, UCB_AC_B, ucba->ctrl_b); ++ } ++ ++ ucba->rate = div_rate / div; ++ ++ return ucba->rate; ++} ++ ++static int ucb1x00_audio_getrate(struct ucb1x00_audio *ucba) ++{ ++ return ucba->rate; ++} ++ ++static void ucb1x00_audio_startup(void *data) ++{ ++ struct ucb1x00_audio *ucba = data; ++ ++ ucb1x00_enable(ucba->ucb); ++ ucb1x00_audio_setrate(ucba, ucba->rate); ++ ++ ucb1x00_reg_write(ucba->ucb, UCB_MODE, UCB_MODE_DYN_VFLAG_ENA); ++ ++ /* ++ * Take off-hook ++ */ ++ if (ucba->daa_oh_bit) ++ ucb1x00_io_write(ucba->ucb, 0, ucba->daa_oh_bit); ++} ++ ++static void ucb1x00_audio_shutdown(void *data) ++{ ++ struct ucb1x00_audio *ucba = data; ++ ++ /* ++ * Place on-hook ++ */ ++ if (ucba->daa_oh_bit) ++ ucb1x00_io_write(ucba->ucb, ucba->daa_oh_bit, 0); ++ ++ ucb1x00_reg_write(ucba->ucb, ucba->telecom ? UCB_TC_B : UCB_AC_B, 0); ++ ucb1x00_disable(ucba->ucb); ++} ++ ++static int ++ucb1x00_audio_ioctl(struct inode *inode, struct file *file, uint cmd, ulong arg) ++{ ++ struct ucb1x00_audio *ucba; ++ int val, ret = 0; ++ ++ ucba = list_entry(file->f_op, struct ucb1x00_audio, fops); ++ ++ /* ++ * Make sure we have our magic number ++ */ ++ if (ucba->magic != MAGIC) ++ return -ENODEV; ++ ++ switch (cmd) { ++ case SNDCTL_DSP_STEREO: ++ ret = get_user(val, (int *)arg); ++ if (ret) ++ return ret; ++ if (val != 0) ++ return -EINVAL; ++ val = 0; ++ break; ++ ++ case SNDCTL_DSP_CHANNELS: ++ case SOUND_PCM_READ_CHANNELS: ++ val = 1; ++ break; ++ ++ case SNDCTL_DSP_SPEED: ++ ret = get_user(val, (int *)arg); ++ if (ret) ++ return ret; ++ val = ucb1x00_audio_setrate(ucba, val); ++ break; ++ ++ case SOUND_PCM_READ_RATE: ++ val = ucb1x00_audio_getrate(ucba); ++ break; ++ ++ case SNDCTL_DSP_SETFMT: ++ case SNDCTL_DSP_GETFMTS: ++ val = AFMT_S16_LE; ++ break; ++ ++ default: ++ return ucb1x00_mixer_ioctl(inode, file, cmd, arg); ++ } ++ ++ return put_user(val, (int *)arg); ++} ++ ++static int ucb1x00_audio_open(struct inode *inode, struct file *file) ++{ ++ struct ucb1x00_audio *ucba; ++ ++ ucba = list_entry(file->f_op, struct ucb1x00_audio, fops); ++ ++ return sa1100_audio_attach(inode, file, &ucba->state); ++} ++ ++static struct ucb1x00_audio *ucb1x00_audio_alloc(struct ucb1x00 *ucb) ++{ ++ struct ucb1x00_audio *ucba; ++ ++ ucba = kmalloc(sizeof(*ucba), GFP_KERNEL); ++ if (ucba) { ++ memset(ucba, 0, sizeof(*ucba)); ++ ++ ucba->magic = MAGIC; ++ ucba->ucb = ucb; ++ ucba->fops.owner = THIS_MODULE; ++ ucba->fops.open = ucb1x00_audio_open; ++ ucba->mops.owner = THIS_MODULE; ++ ucba->mops.ioctl = ucb1x00_mixer_ioctl; ++ ucba->state.output_stream = &ucba->output_stream; ++ ucba->state.input_stream = &ucba->input_stream; ++ ucba->state.data = ucba; ++ ucba->state.hw_init = ucb1x00_audio_startup; ++ ucba->state.hw_shutdown = ucb1x00_audio_shutdown; ++ ucba->state.client_ioctl = ucb1x00_audio_ioctl; ++ ++ /* There is a bug in the StrongARM causes corrupt MCP data to be sent to ++ * the codec when the FIFOs are empty and writes are made to the OS timer ++ * match register 0. To avoid this we must make sure that data is always ++ * sent to the codec. ++ */ ++ ucba->state.need_tx_for_rx = 1; ++ ++ init_MUTEX(&ucba->state.sem); ++ ucba->rate = 8000; ++ } ++ return ucba; ++} ++ ++static struct ucb1x00_audio *ucb1x00_audio_add_one(struct ucb1x00 *ucb, int telecom) ++{ ++ struct ucb1x00_audio *a; ++ ++ a = ucb1x00_audio_alloc(ucb); ++ if (a) { ++ a->telecom = telecom; ++ ++ a->input_stream.dev = ucb->cdev.dev; ++ a->output_stream.dev = ucb->cdev.dev; ++ a->ctrl_a = 0; ++ ++ if (a->telecom) { ++ a->input_stream.dma_dev = ucb->mcp->dma_telco_rd; ++ a->input_stream.id = "UCB1x00 telco in"; ++ a->output_stream.dma_dev = ucb->mcp->dma_telco_wr; ++ a->output_stream.id = "UCB1x00 telco out"; ++ a->ctrl_b = UCB_TC_B_IN_ENA|UCB_TC_B_OUT_ENA; ++#if 0 ++ a->daa_oh_bit = UCB_IO_8; ++ ++ ucb1x00_enable(ucb); ++ ucb1x00_io_write(ucb, a->daa_oh_bit, 0); ++ ucb1x00_io_set_dir(ucb, UCB_IO_7 | UCB_IO_6, a->daa_oh_bit); ++ ucb1x00_disable(ucb); ++#endif ++ } else { ++ a->input_stream.dma_dev = ucb->mcp->dma_audio_rd; ++ a->input_stream.id = "UCB1x00 audio in"; ++ a->output_stream.dma_dev = ucb->mcp->dma_audio_wr; ++ a->output_stream.id = "UCB1x00 audio out"; ++ a->ctrl_b = UCB_AC_B_IN_ENA|UCB_AC_B_OUT_ENA; ++ } ++ ++ a->dev_id = register_sound_dsp(&a->fops, -1); ++ a->mix_id = register_sound_mixer(&a->mops, -1); ++ ++ printk("Sound: UCB1x00 %s: dsp id %d mixer id %d\n", ++ a->telecom ? "telecom" : "audio", ++ a->dev_id, a->mix_id); ++ } ++ ++ return a; ++} ++ ++static void ucb1x00_audio_remove_one(struct ucb1x00_audio *a) ++{ ++ unregister_sound_dsp(a->dev_id); ++ unregister_sound_mixer(a->mix_id); ++ kfree(a); ++} ++ ++static int ucb1x00_audio_add(struct class_device *cdev) ++{ ++ struct ucb1x00 *ucb = classdev_to_ucb1x00(cdev); ++ ++ if (ucb->cdev.dev == NULL || ucb->cdev.dev->dma_mask == NULL) ++ return -ENXIO; ++ ++ ucb->audio_data = ucb1x00_audio_add_one(ucb, 0); ++ ucb->telecom_data = ucb1x00_audio_add_one(ucb, 1); ++ ++ return 0; ++} ++ ++static void ucb1x00_audio_remove(struct class_device *cdev) ++{ ++ struct ucb1x00 *ucb = classdev_to_ucb1x00(cdev); ++ ++ ucb1x00_audio_remove_one(ucb->audio_data); ++ ucb1x00_audio_remove_one(ucb->telecom_data); ++} ++ ++#if 0 //def CONFIG_PM ++static int ucb1x00_audio_suspend(struct ucb1x00 *ucb, u32 state) ++{ ++ struct ucb1x00_audio *a; ++ ++ a = ucb->audio_data; ++ sa1100_audio_suspend(&a->state, state); ++ a = ucb->telecom_data; ++ sa1100_audio_suspend(&a->state, state); ++ ++ return 0; ++} ++ ++static int ucb1x00_audio_resume(struct ucb1x00 *ucb) ++{ ++ struct ucb1x00_audio *a; ++ ++ a = ucb->audio_data; ++ sa1100_audio_resume(&a->state); ++ a = ucb->telecom_data; ++ sa1100_audio_resume(&a->state); ++ ++ return 0; ++} ++#else ++#define ucb1x00_audio_suspend NULL ++#define ucb1x00_audio_resume NULL ++#endif ++ ++static struct class_interface ucb1x00_audio_interface = { ++ .add = ucb1x00_audio_add, ++ .remove = ucb1x00_audio_remove, ++}; ++ ++static int __init ucb1x00_audio_init(void) ++{ ++ return ucb1x00_register_interface(&ucb1x00_audio_interface); ++} ++ ++static void __exit ucb1x00_audio_exit(void) ++{ ++ ucb1x00_unregister_interface(&ucb1x00_audio_interface); ++} ++ ++module_init(ucb1x00_audio_init); ++module_exit(ucb1x00_audio_exit); ++ ++MODULE_AUTHOR("Russell King <rmk@arm.linux.org.uk>"); ++MODULE_DESCRIPTION("UCB1x00 telecom/audio driver"); ++MODULE_LICENSE("GPL"); +--- /dev/null 2003-09-23 18:19:32.000000000 -0400 ++++ linux-2.6.5/drivers/misc/mcp-sa1100.c 2004-04-30 20:57:36.000000000 -0400 +@@ -0,0 +1,275 @@ ++/* ++ * linux/drivers/misc/mcp-sa1100.c ++ * ++ * Copyright (C) 2001 Russell King ++ * ++ * 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. ++ * ++ * SA1100 MCP (Multimedia Communications Port) driver. ++ * ++ * MCP read/write timeouts from Jordi Colomer, rehacked by rmk. ++ */ ++#include <linux/module.h> ++#include <linux/init.h> ++#include <linux/errno.h> ++#include <linux/kernel.h> ++#include <linux/delay.h> ++#include <linux/spinlock.h> ++#include <linux/slab.h> ++#include <linux/device.h> ++ ++#include <asm/dma.h> ++#include <asm/hardware.h> ++#include <asm/mach-types.h> ++#include <asm/system.h> ++ ++#include <asm/arch/assabet.h> ++ ++#include "mcp.h" ++ ++static void ++mcp_sa1100_set_telecom_divisor(struct mcp *mcp, unsigned int divisor) ++{ ++ unsigned int mccr0; ++ ++ divisor /= 32; ++ ++ mccr0 = Ser4MCCR0 & ~0x00007f00; ++ mccr0 |= divisor << 8; ++ Ser4MCCR0 = mccr0; ++} ++ ++static void ++mcp_sa1100_set_audio_divisor(struct mcp *mcp, unsigned int divisor) ++{ ++ unsigned int mccr0; ++ ++ divisor /= 32; ++ ++ mccr0 = Ser4MCCR0 & ~0x0000007f; ++ mccr0 |= divisor; ++ Ser4MCCR0 = mccr0; ++} ++ ++/* ++ * Write data to the device. The bit should be set after 3 subframe ++ * times (each frame is 64 clocks). We wait a maximum of 6 subframes. ++ * We really should try doing something more productive while we ++ * wait. ++ */ ++static void ++mcp_sa1100_write(struct mcp *mcp, unsigned int reg, unsigned int val) ++{ ++ int ret = -ETIME; ++ int i; ++ ++ Ser4MCDR2 = reg << 17 | MCDR2_Wr | (val & 0xffff); ++ ++ for (i = 0; i < 2; i++) { ++ udelay(mcp->rw_timeout); ++ if (Ser4MCSR & MCSR_CWC) { ++ ret = 0; ++ break; ++ } ++ } ++ ++ if (ret < 0) ++ printk(KERN_WARNING "mcp: write timed out\n"); ++} ++ ++/* ++ * Read data from the device. The bit should be set after 3 subframe ++ * times (each frame is 64 clocks). We wait a maximum of 6 subframes. ++ * We really should try doing something more productive while we ++ * wait. ++ */ ++static unsigned int ++mcp_sa1100_read(struct mcp *mcp, unsigned int reg) ++{ ++ int ret = -ETIME; ++ int i; ++ ++ Ser4MCDR2 = reg << 17 | MCDR2_Rd; ++ ++ for (i = 0; i < 2; i++) { ++ udelay(mcp->rw_timeout); ++ if (Ser4MCSR & MCSR_CRC) { ++ ret = Ser4MCDR2 & 0xffff; ++ break; ++ } ++ } ++ ++ if (ret < 0) ++ printk(KERN_WARNING "mcp: read timed out\n"); ++ ++ return ret; ++} ++ ++static void mcp_sa1100_enable(struct mcp *mcp) ++{ ++ Ser4MCSR = -1; ++ Ser4MCCR0 |= MCCR0_MCE; ++} ++ ++static void mcp_sa1100_disable(struct mcp *mcp) ++{ ++ Ser4MCCR0 &= ~MCCR0_MCE; ++} ++ ++/* ++ * Our methods. ++ */ ++static struct mcp mcp_sa1100 = { ++ .owner = THIS_MODULE, ++ .lock = SPIN_LOCK_UNLOCKED, ++ .sclk_rate = 11981000, ++ .dma_audio_rd = DMA_Ser4MCP0Rd, ++ .dma_audio_wr = DMA_Ser4MCP0Wr, ++ .dma_telco_rd = DMA_Ser4MCP1Rd, ++ .dma_telco_wr = DMA_Ser4MCP1Wr, ++ .set_telecom_divisor = mcp_sa1100_set_telecom_divisor, ++ .set_audio_divisor = mcp_sa1100_set_audio_divisor, ++ .reg_write = mcp_sa1100_write, ++ .reg_read = mcp_sa1100_read, ++ .enable = mcp_sa1100_enable, ++ .disable = mcp_sa1100_disable, ++}; ++ ++static int mcp_sa1100_probe(struct device *dev) ++{ ++ struct platform_device *pdev = to_platform_device(dev); ++ struct mcp *mcp = &mcp_sa1100; ++ int ret; ++ ++ if (!machine_is_adsbitsy() && !machine_is_assabet() && ++ !machine_is_cerf() && !machine_is_flexanet() && ++ !machine_is_freebird() && !machine_is_graphicsclient() && ++ !machine_is_graphicsmaster() && !machine_is_lart() && ++ !machine_is_omnimeter() && !machine_is_pfs168() && ++ !machine_is_shannon() && !machine_is_simpad() && ++ !machine_is_yopy()) ++ return -ENODEV; ++ ++ if (!request_mem_region(0x80060000, 0x60, "sa11x0-mcp")) ++ return -EBUSY; ++ ++ mcp->me = dev; ++ dev_set_drvdata(dev, mcp); ++ ++ if (machine_is_assabet()) { ++ ASSABET_BCR_set(ASSABET_BCR_CODEC_RST); ++ } ++ ++ /* ++ * Setup the PPC unit correctly. ++ */ ++ PPDR &= ~PPC_RXD4; ++ PPDR |= PPC_TXD4 | PPC_SCLK | PPC_SFRM; ++ PSDR |= PPC_RXD4; ++ PSDR &= ~(PPC_TXD4 | PPC_SCLK | PPC_SFRM); ++ PPSR &= ~(PPC_TXD4 | PPC_SCLK | PPC_SFRM); ++ ++ Ser4MCSR = -1; ++ Ser4MCCR1 = 0; ++ Ser4MCCR0 = 0x00007f7f | MCCR0_ADM; ++ ++ /* ++ * Calculate the read/write timeout (us) from the bit clock ++ * rate. This is the period for 3 64-bit frames. Always ++ * round this time up. ++ */ ++ mcp->rw_timeout = (64 * 3 * 1000000 + mcp->sclk_rate - 1) / ++ mcp->sclk_rate; ++ ++ ret = mcp_host_register(mcp, &pdev->dev); ++ if (ret != 0) { ++ release_mem_region(0x80060000, 0x60); ++ dev_set_drvdata(dev, NULL); ++ } ++ ++ return ret; ++} ++ ++static int mcp_sa1100_remove(struct device *dev) ++{ ++ struct mcp *mcp = dev_get_drvdata(dev); ++ ++ dev_set_drvdata(dev, NULL); ++ ++ mcp_host_unregister(mcp); ++ release_mem_region(0x80060000, 0x60); ++ ++ return 0; ++} ++ ++struct mcp_sa1100_state { ++ u32 mccr0; ++ u32 mccr1; ++}; ++ ++static int mcp_sa1100_suspend(struct device *dev, u32 state, u32 level) ++{ ++ struct mcp_sa1100_state *s = (struct mcp_sa1100_state *)dev->saved_state; ++ ++ if (!s) { ++ s = kmalloc(sizeof(struct mcp_sa1100_state), GFP_KERNEL); ++ dev->saved_state = (unsigned char *)s; ++ } ++ ++ if (s) { ++ s->mccr0 = Ser4MCCR0; ++ s->mccr1 = Ser4MCCR1; ++ } ++ ++ if (level == SUSPEND_DISABLE) ++ Ser4MCCR0 &= ~MCCR0_MCE; ++ return 0; ++} ++ ++static int mcp_sa1100_resume(struct device *dev, u32 level) ++{ ++ struct mcp_sa1100_state *s = (struct mcp_sa1100_state *)dev->saved_state; ++ ++ if (s && level == RESUME_RESTORE_STATE) { ++ Ser4MCCR1 = s->mccr1; ++ Ser4MCCR0 = s->mccr0; ++ ++ dev->saved_state = NULL; ++ kfree(s); ++ } ++ return 0; ++} ++ ++/* ++ * The driver for the SA11x0 MCP port. ++ */ ++static struct device_driver mcp_sa1100_driver = { ++ .name = "sa11x0-mcp", ++ .bus = &platform_bus_type, ++ .probe = mcp_sa1100_probe, ++ .remove = mcp_sa1100_remove, ++ .suspend = mcp_sa1100_suspend, ++ .resume = mcp_sa1100_resume, ++}; ++ ++/* ++ * This needs re-working ++ */ ++static int __init mcp_sa1100_init(void) ++{ ++ return driver_register(&mcp_sa1100_driver); ++} ++ ++static void __exit mcp_sa1100_exit(void) ++{ ++ driver_unregister(&mcp_sa1100_driver); ++} ++ ++module_init(mcp_sa1100_init); ++module_exit(mcp_sa1100_exit); ++ ++MODULE_AUTHOR("Russell King <rmk@arm.linux.org.uk>"); ++MODULE_DESCRIPTION("SA11x0 multimedia communications port driver"); ++MODULE_LICENSE("GPL"); +--- /dev/null 2003-09-23 18:19:32.000000000 -0400 ++++ linux-2.6.5/drivers/misc/mcp.h 2004-04-30 20:57:36.000000000 -0400 +@@ -0,0 +1,58 @@ ++/* ++ * linux/drivers/misc/mcp.h ++ * ++ * Copyright (C) 2001 Russell King, All Rights Reserved. ++ * ++ * 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. ++ */ ++#ifndef MCP_H ++#define MCP_H ++ ++struct mcp { ++ struct module *owner; ++ struct device *me; ++ spinlock_t lock; ++ int use_count; ++ unsigned int sclk_rate; ++ unsigned int rw_timeout; ++ dma_device_t dma_audio_rd; ++ dma_device_t dma_audio_wr; ++ dma_device_t dma_telco_rd; ++ dma_device_t dma_telco_wr; ++ void (*set_telecom_divisor)(struct mcp *, unsigned int); ++ void (*set_audio_divisor)(struct mcp *, unsigned int); ++ void (*reg_write)(struct mcp *, unsigned int, unsigned int); ++ unsigned int (*reg_read)(struct mcp *, unsigned int); ++ void (*enable)(struct mcp *); ++ void (*disable)(struct mcp *); ++ struct device attached_device; ++}; ++ ++void mcp_set_telecom_divisor(struct mcp *, unsigned int); ++void mcp_set_audio_divisor(struct mcp *, unsigned int); ++void mcp_reg_write(struct mcp *, unsigned int, unsigned int); ++unsigned int mcp_reg_read(struct mcp *, unsigned int); ++void mcp_enable(struct mcp *); ++void mcp_disable(struct mcp *); ++#define mcp_get_sclk_rate(mcp) ((mcp)->sclk_rate) ++ ++int mcp_host_register(struct mcp *, struct device *); ++void mcp_host_unregister(struct mcp *); ++ ++struct mcp_driver { ++ struct device_driver drv; ++ int (*probe)(struct mcp *); ++ void (*remove)(struct mcp *); ++ int (*suspend)(struct mcp *, u32); ++ int (*resume)(struct mcp *); ++}; ++ ++int mcp_driver_register(struct mcp_driver *); ++void mcp_driver_unregister(struct mcp_driver *); ++ ++#define mcp_get_drvdata(mcp) dev_get_drvdata(&(mcp)->attached_device) ++#define mcp_set_drvdata(mcp,d) dev_set_drvdata(&(mcp)->attached_device, d) ++ ++#endif +--- /dev/null 2003-09-23 18:19:32.000000000 -0400 ++++ linux-2.6.5/drivers/misc/ucb1x00-input.h 2004-04-30 20:57:36.000000000 -0400 +@@ -0,0 +1,233 @@ ++/* ++ * linux/drivers/misc/ucb1x00.h ++ * ++ * Copyright (C) 2001 Russell King, All Rights Reserved. ++ * ++ * 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. ++ */ ++#ifndef UCB1200_H ++#define UCB1200_H ++ ++#define UCB_IO_DATA 0x00 ++#define UCB_IO_DIR 0x01 ++ ++#define UCB_IO_0 (1 << 0) ++#define UCB_IO_1 (1 << 1) ++#define UCB_IO_2 (1 << 2) ++#define UCB_IO_3 (1 << 3) ++#define UCB_IO_4 (1 << 4) ++#define UCB_IO_5 (1 << 5) ++#define UCB_IO_6 (1 << 6) ++#define UCB_IO_7 (1 << 7) ++#define UCB_IO_8 (1 << 8) ++#define UCB_IO_9 (1 << 9) ++ ++#define UCB_IE_RIS 0x02 ++#define UCB_IE_FAL 0x03 ++#define UCB_IE_STATUS 0x04 ++#define UCB_IE_CLEAR 0x04 ++#define UCB_IE_ADC (1 << 11) ++#define UCB_IE_TSPX (1 << 12) ++#define UCB_IE_TSMX (1 << 13) ++#define UCB_IE_TCLIP (1 << 14) ++#define UCB_IE_ACLIP (1 << 15) ++ ++#define UCB_IRQ_TSPX 12 ++ ++#define UCB_TC_A 0x05 ++#define UCB_TC_A_LOOP (1 << 7) /* UCB1200 */ ++#define UCB_TC_A_AMPL (1 << 7) /* UCB1300 */ ++ ++#define UCB_TC_B 0x06 ++#define UCB_TC_B_VOICE_ENA (1 << 3) ++#define UCB_TC_B_CLIP (1 << 4) ++#define UCB_TC_B_ATT (1 << 6) ++#define UCB_TC_B_SIDE_ENA (1 << 11) ++#define UCB_TC_B_MUTE (1 << 13) ++#define UCB_TC_B_IN_ENA (1 << 14) ++#define UCB_TC_B_OUT_ENA (1 << 15) ++ ++#define UCB_AC_A 0x07 ++#define UCB_AC_B 0x08 ++#define UCB_AC_B_LOOP (1 << 8) ++#define UCB_AC_B_MUTE (1 << 13) ++#define UCB_AC_B_IN_ENA (1 << 14) ++#define UCB_AC_B_OUT_ENA (1 << 15) ++ ++#define UCB_TS_CR 0x09 ++#define UCB_TS_CR_TSMX_POW (1 << 0) ++#define UCB_TS_CR_TSPX_POW (1 << 1) ++#define UCB_TS_CR_TSMY_POW (1 << 2) ++#define UCB_TS_CR_TSPY_POW (1 << 3) ++#define UCB_TS_CR_TSMX_GND (1 << 4) ++#define UCB_TS_CR_TSPX_GND (1 << 5) ++#define UCB_TS_CR_TSMY_GND (1 << 6) ++#define UCB_TS_CR_TSPY_GND (1 << 7) ++#define UCB_TS_CR_MODE_INT (0 << 8) ++#define UCB_TS_CR_MODE_PRES (1 << 8) ++#define UCB_TS_CR_MODE_POS (2 << 8) ++#define UCB_TS_CR_BIAS_ENA (1 << 11) ++#define UCB_TS_CR_TSPX_LOW (1 << 12) ++#define UCB_TS_CR_TSMX_LOW (1 << 13) ++ ++#define UCB_ADC_CR 0x0a ++#define UCB_ADC_SYNC_ENA (1 << 0) ++#define UCB_ADC_VREFBYP_CON (1 << 1) ++#define UCB_ADC_INP_TSPX (0 << 2) ++#define UCB_ADC_INP_TSMX (1 << 2) ++#define UCB_ADC_INP_TSPY (2 << 2) ++#define UCB_ADC_INP_TSMY (3 << 2) ++#define UCB_ADC_INP_AD0 (4 << 2) ++#define UCB_ADC_INP_AD1 (5 << 2) ++#define UCB_ADC_INP_AD2 (6 << 2) ++#define UCB_ADC_INP_AD3 (7 << 2) ++#define UCB_ADC_EXT_REF (1 << 5) ++#define UCB_ADC_START (1 << 7) ++#define UCB_ADC_ENA (1 << 15) ++ ++#define UCB_ADC_DATA 0x0b ++#define UCB_ADC_DAT_VAL (1 << 15) ++#define UCB_ADC_DAT(x) (((x) & 0x7fe0) >> 5) ++ ++#define UCB_ID 0x0c ++#define UCB_ID_1200 0x1004 ++#define UCB_ID_1300 0x1005 ++#define UCB_ID_1400 0x4304 ++#define UCB_ID_1400_BUGGY 0x4303 /* fake ID */ ++ ++#define UCB_MODE 0x0d ++#define UCB_MODE_DYN_VFLAG_ENA (1 << 12) ++#define UCB_MODE_AUD_OFF_CAN (1 << 13) ++ ++#include "mcp.h" ++ ++struct ucb1x00; ++ ++struct ucb1x00_irq { ++ void *devid; ++ void (*fn)(int, void *); ++}; ++ ++struct ucb1x00 { ++ spinlock_t lock; ++ struct mcp *mcp; ++ unsigned int irq; ++ struct semaphore adc_sem; ++ spinlock_t io_lock; ++ u16 id; ++ u16 io_dir; ++ u16 io_out; ++ u16 adc_cr; ++ u16 irq_fal_enbl; ++ u16 irq_ris_enbl; ++ struct ucb1x00_irq irq_handler[16]; ++}; ++ ++/** ++ * ucb1x00_clkrate - return the UCB1x00 SIB clock rate ++ * @ucb: UCB1x00 structure describing chip ++ * ++ * Return the SIB clock rate in Hz. ++ */ ++static inline unsigned int ucb1x00_clkrate(struct ucb1x00 *ucb) ++{ ++ return mcp_get_sclk_rate(ucb->mcp); ++} ++ ++/** ++ * ucb1x00_enable - enable the UCB1x00 SIB clock ++ * @ucb: UCB1x00 structure describing chip ++ * ++ * Enable the SIB clock. This can be called multiple times. ++ */ ++static inline void ucb1x00_enable(struct ucb1x00 *ucb) ++{ ++ mcp_enable(ucb->mcp); ++} ++ ++/** ++ * ucb1x00_disable - disable the UCB1x00 SIB clock ++ * @ucb: UCB1x00 structure describing chip ++ * ++ * Disable the SIB clock. The SIB clock will only be disabled ++ * when the number of ucb1x00_enable calls match the number of ++ * ucb1x00_disable calls. ++ */ ++static inline void ucb1x00_disable(struct ucb1x00 *ucb) ++{ ++ mcp_disable(ucb->mcp); ++} ++ ++/** ++ * ucb1x00_reg_write - write a UCB1x00 register ++ * @ucb: UCB1x00 structure describing chip ++ * @reg: UCB1x00 4-bit register index to write ++ * @val: UCB1x00 16-bit value to write ++ * ++ * Write the UCB1x00 register @reg with value @val. The SIB ++ * clock must be running for this function to return. ++ */ ++static inline void ucb1x00_reg_write(struct ucb1x00 *ucb, unsigned int reg, unsigned int val) ++{ ++ mcp_reg_write(ucb->mcp, reg, val); ++} ++ ++/** ++ * ucb1x00_reg_read - read a UCB1x00 register ++ * @ucb: UCB1x00 structure describing chip ++ * @reg: UCB1x00 4-bit register index to write ++ * ++ * Read the UCB1x00 register @reg and return its value. The SIB ++ * clock must be running for this function to return. ++ */ ++static inline unsigned int ucb1x00_reg_read(struct ucb1x00 *ucb, unsigned int reg) ++{ ++ return mcp_reg_read(ucb->mcp, reg); ++} ++/** ++ * ucb1x00_set_audio_divisor - ++ * @ucb: UCB1x00 structure describing chip ++ * @div: SIB clock divisor ++ */ ++static inline void ucb1x00_set_audio_divisor(struct ucb1x00 *ucb, unsigned int div) ++{ ++ mcp_set_audio_divisor(ucb->mcp, div); ++} ++ ++/** ++ * ucb1x00_set_telecom_divisor - ++ * @ucb: UCB1x00 structure describing chip ++ * @div: SIB clock divisor ++ */ ++static inline void ucb1x00_set_telecom_divisor(struct ucb1x00 *ucb, unsigned int div) ++{ ++ mcp_set_telecom_divisor(ucb->mcp, div); ++} ++ ++struct ucb1x00 *ucb1x00_get(void); ++ ++void ucb1x00_io_set_dir(struct ucb1x00 *ucb, unsigned int, unsigned int); ++void ucb1x00_io_write(struct ucb1x00 *ucb, unsigned int, unsigned int); ++unsigned int ucb1x00_io_read(struct ucb1x00 *ucb); ++ ++#define UCB_NOSYNC (0) ++#define UCB_SYNC (1) ++ ++unsigned int ucb1x00_adc_read(struct ucb1x00 *ucb, int adc_channel, int sync); ++void ucb1x00_adc_enable(struct ucb1x00 *ucb); ++void ucb1x00_adc_disable(struct ucb1x00 *ucb); ++ ++/* ++ * Which edges of the IRQ do you want to control today? ++ */ ++#define UCB_RISING (1 << 0) ++#define UCB_FALLING (1 << 1) ++ ++int ucb1x00_hook_irq(struct ucb1x00 *ucb, unsigned int idx, void (*fn)(int, void *), void *devid); ++void ucb1x00_enable_irq(struct ucb1x00 *ucb, unsigned int idx, int edges); ++void ucb1x00_disable_irq(struct ucb1x00 *ucb, unsigned int idx, int edges); ++int ucb1x00_free_irq(struct ucb1x00 *ucb, unsigned int idx, void *devid); ++ ++#endif +--- /dev/null 2003-09-23 18:19:32.000000000 -0400 ++++ linux-2.6.5/drivers/misc/ucb1x00.h 2004-04-30 20:57:36.000000000 -0400 +@@ -0,0 +1,271 @@ ++/* ++ * linux/drivers/misc/ucb1x00.h ++ * ++ * Copyright (C) 2001 Russell King, All Rights Reserved. ++ * ++ * 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. ++ */ ++#ifndef UCB1200_H ++#define UCB1200_H ++ ++#ifdef CONFIG_ARCH_PXA ++ ++/* ucb1400 aclink register mappings: */ ++ ++#define UCB_IO_DATA 0x5a ++#define UCB_IO_DIR 0x5c ++#define UCB_IE_RIS 0x5e ++#define UCB_IE_FAL 0x60 ++#define UCB_IE_STATUS 0x62 ++#define UCB_IE_CLEAR 0x62 ++#define UCB_TS_CR 0x64 ++#define UCB_ADC_CR 0x66 ++#define UCB_ADC_DATA 0x68 ++#define UCB_ID 0x7e /* 7c is mfr id, 7e part id (from aclink spec) */ ++ ++#define UCB_ADC_DAT(x) ((x) & 0x3ff) ++ ++#else ++ ++/* ucb1x00 SIB register mappings: */ ++ ++#define UCB_IO_DATA 0x00 ++#define UCB_IO_DIR 0x01 ++#define UCB_IE_RIS 0x02 ++#define UCB_IE_FAL 0x03 ++#define UCB_IE_STATUS 0x04 ++#define UCB_IE_CLEAR 0x04 ++#define UCB_TC_A 0x05 ++#define UCB_TC_B 0x06 ++#define UCB_AC_A 0x07 ++#define UCB_AC_B 0x08 ++#define UCB_TS_CR 0x09 ++#define UCB_ADC_CR 0x0a ++#define UCB_ADC_DATA 0x0b ++#define UCB_ID 0x0c ++#define UCB_MODE 0x0d ++ ++#define UCB_ADC_DAT(x) (((x) & 0x7fe0) >> 5) ++ ++#endif ++ ++ ++#define UCB_IO_0 (1 << 0) ++#define UCB_IO_1 (1 << 1) ++#define UCB_IO_2 (1 << 2) ++#define UCB_IO_3 (1 << 3) ++#define UCB_IO_4 (1 << 4) ++#define UCB_IO_5 (1 << 5) ++#define UCB_IO_6 (1 << 6) ++#define UCB_IO_7 (1 << 7) ++#define UCB_IO_8 (1 << 8) ++#define UCB_IO_9 (1 << 9) ++ ++#define UCB_IE_ADC (1 << 11) ++#define UCB_IE_TSPX (1 << 12) ++#define UCB_IE_TSMX (1 << 13) ++#define UCB_IE_TCLIP (1 << 14) ++#define UCB_IE_ACLIP (1 << 15) ++ ++#define UCB_IRQ_TSPX 12 ++ ++#define UCB_TC_A_LOOP (1 << 7) /* UCB1200 */ ++#define UCB_TC_A_AMPL (1 << 7) /* UCB1300 */ ++ ++#define UCB_TC_B_VOICE_ENA (1 << 3) ++#define UCB_TC_B_CLIP (1 << 4) ++#define UCB_TC_B_ATT (1 << 6) ++#define UCB_TC_B_SIDE_ENA (1 << 11) ++#define UCB_TC_B_MUTE (1 << 13) ++#define UCB_TC_B_IN_ENA (1 << 14) ++#define UCB_TC_B_OUT_ENA (1 << 15) ++ ++#define UCB_AC_B_LOOP (1 << 8) ++#define UCB_AC_B_MUTE (1 << 13) ++#define UCB_AC_B_IN_ENA (1 << 14) ++#define UCB_AC_B_OUT_ENA (1 << 15) ++ ++#define UCB_TS_CR_TSMX_POW (1 << 0) ++#define UCB_TS_CR_TSPX_POW (1 << 1) ++#define UCB_TS_CR_TSMY_POW (1 << 2) ++#define UCB_TS_CR_TSPY_POW (1 << 3) ++#define UCB_TS_CR_TSMX_GND (1 << 4) ++#define UCB_TS_CR_TSPX_GND (1 << 5) ++#define UCB_TS_CR_TSMY_GND (1 << 6) ++#define UCB_TS_CR_TSPY_GND (1 << 7) ++#define UCB_TS_CR_MODE_INT (0 << 8) ++#define UCB_TS_CR_MODE_PRES (1 << 8) ++#define UCB_TS_CR_MODE_POS (2 << 8) ++#define UCB_TS_CR_BIAS_ENA (1 << 11) ++#define UCB_TS_CR_TSPX_LOW (1 << 12) ++#define UCB_TS_CR_TSMX_LOW (1 << 13) ++ ++#define UCB_ADC_SYNC_ENA (1 << 0) ++#define UCB_ADC_VREFBYP_CON (1 << 1) ++#define UCB_ADC_INP_TSPX (0 << 2) ++#define UCB_ADC_INP_TSMX (1 << 2) ++#define UCB_ADC_INP_TSPY (2 << 2) ++#define UCB_ADC_INP_TSMY (3 << 2) ++#define UCB_ADC_INP_AD0 (4 << 2) ++#define UCB_ADC_INP_AD1 (5 << 2) ++#define UCB_ADC_INP_AD2 (6 << 2) ++#define UCB_ADC_INP_AD3 (7 << 2) ++#define UCB_ADC_EXT_REF (1 << 5) ++#define UCB_ADC_START (1 << 7) ++#define UCB_ADC_ENA (1 << 15) ++ ++#define UCB_ADC_DAT_VAL (1 << 15) ++ ++#define UCB_ID_1200 0x1004 ++#define UCB_ID_1300 0x1005 ++#define UCB_ID_1400 0x4304 ++#define UCB_ID_1400_BUGGY 0x4303 /* fake ID */ ++ ++#define UCB_MODE_DYN_VFLAG_ENA (1 << 12) ++#define UCB_MODE_AUD_OFF_CAN (1 << 13) ++ ++#include <linux/completion.h> ++#include "mcp.h" ++ ++struct ucb1x00_irq { ++ void *devid; ++ void (*fn)(int, void *); ++}; ++ ++extern struct class ucb1x00_class; ++ ++struct ucb1x00 { ++ spinlock_t lock; ++ struct mcp *mcp; ++ unsigned int irq; ++ struct semaphore adc_sem; ++ spinlock_t io_lock; ++ wait_queue_head_t irq_wait; ++ struct completion complete; ++ struct task_struct *rtask; ++ u16 id; ++ u16 io_dir; ++ u16 io_out; ++ u16 adc_cr; ++ u16 irq_fal_enbl; ++ u16 irq_ris_enbl; ++ struct ucb1x00_irq irq_handler[16]; ++ struct class_device cdev; ++ void *audio_data; ++ void *telecom_data; ++ void *ts_data; ++}; ++ ++#define classdev_to_ucb1x00(cd) container_of(cd, struct ucb1x00, cdev) ++ ++int ucb1x00_register_interface(struct class_interface *intf); ++void ucb1x00_unregister_interface(struct class_interface *intf); ++ ++/** ++ * ucb1x00_clkrate - return the UCB1x00 SIB clock rate ++ * @ucb: UCB1x00 structure describing chip ++ * ++ * Return the SIB clock rate in Hz. ++ */ ++static inline unsigned int ucb1x00_clkrate(struct ucb1x00 *ucb) ++{ ++ return mcp_get_sclk_rate(ucb->mcp); ++} ++ ++/** ++ * ucb1x00_enable - enable the UCB1x00 SIB clock ++ * @ucb: UCB1x00 structure describing chip ++ * ++ * Enable the SIB clock. This can be called multiple times. ++ */ ++static inline void ucb1x00_enable(struct ucb1x00 *ucb) ++{ ++ mcp_enable(ucb->mcp); ++} ++ ++/** ++ * ucb1x00_disable - disable the UCB1x00 SIB clock ++ * @ucb: UCB1x00 structure describing chip ++ * ++ * Disable the SIB clock. The SIB clock will only be disabled ++ * when the number of ucb1x00_enable calls match the number of ++ * ucb1x00_disable calls. ++ */ ++static inline void ucb1x00_disable(struct ucb1x00 *ucb) ++{ ++ mcp_disable(ucb->mcp); ++} ++ ++/** ++ * ucb1x00_reg_write - write a UCB1x00 register ++ * @ucb: UCB1x00 structure describing chip ++ * @reg: UCB1x00 4-bit register index to write ++ * @val: UCB1x00 16-bit value to write ++ * ++ * Write the UCB1x00 register @reg with value @val. The SIB ++ * clock must be running for this function to return. ++ */ ++static inline void ucb1x00_reg_write(struct ucb1x00 *ucb, unsigned int reg, unsigned int val) ++{ ++ mcp_reg_write(ucb->mcp, reg, val); ++} ++ ++/** ++ * ucb1x00_reg_read - read a UCB1x00 register ++ * @ucb: UCB1x00 structure describing chip ++ * @reg: UCB1x00 4-bit register index to write ++ * ++ * Read the UCB1x00 register @reg and return its value. The SIB ++ * clock must be running for this function to return. ++ */ ++static inline unsigned int ucb1x00_reg_read(struct ucb1x00 *ucb, unsigned int reg) ++{ ++ return mcp_reg_read(ucb->mcp, reg); ++} ++/** ++ * ucb1x00_set_audio_divisor - ++ * @ucb: UCB1x00 structure describing chip ++ * @div: SIB clock divisor ++ */ ++static inline void ucb1x00_set_audio_divisor(struct ucb1x00 *ucb, unsigned int div) ++{ ++ mcp_set_audio_divisor(ucb->mcp, div); ++} ++ ++/** ++ * ucb1x00_set_telecom_divisor - ++ * @ucb: UCB1x00 structure describing chip ++ * @div: SIB clock divisor ++ */ ++static inline void ucb1x00_set_telecom_divisor(struct ucb1x00 *ucb, unsigned int div) ++{ ++ mcp_set_telecom_divisor(ucb->mcp, div); ++} ++ ++#define ucb1x00_get() NULL ++ ++void ucb1x00_io_set_dir(struct ucb1x00 *ucb, unsigned int, unsigned int); ++void ucb1x00_io_write(struct ucb1x00 *ucb, unsigned int, unsigned int); ++unsigned int ucb1x00_io_read(struct ucb1x00 *ucb); ++ ++#define UCB_NOSYNC (0) ++#define UCB_SYNC (1) ++ ++unsigned int ucb1x00_adc_read(struct ucb1x00 *ucb, int adc_channel, int sync); ++void ucb1x00_adc_enable(struct ucb1x00 *ucb); ++void ucb1x00_adc_disable(struct ucb1x00 *ucb); ++ ++/* ++ * Which edges of the IRQ do you want to control today? ++ */ ++#define UCB_RISING (1 << 0) ++#define UCB_FALLING (1 << 1) ++ ++int ucb1x00_hook_irq(struct ucb1x00 *ucb, unsigned int idx, void (*fn)(int, void *), void *devid); ++void ucb1x00_enable_irq(struct ucb1x00 *ucb, unsigned int idx, int edges); ++void ucb1x00_disable_irq(struct ucb1x00 *ucb, unsigned int idx, int edges); ++int ucb1x00_free_irq(struct ucb1x00 *ucb, unsigned int idx, void *devid); ++ ++#endif +--- /dev/null 2003-09-23 18:19:32.000000000 -0400 ++++ linux-2.6.5/drivers/misc/switches-sa1100.c 2004-04-30 20:57:36.000000000 -0400 +@@ -0,0 +1,323 @@ ++/* ++ * linux/drivers/misc/switches-sa1100.c ++ * ++ * Copyright (C) 2001 John Dorsey ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License version 2 as ++ * published by the Free Software Foundation. ++ * ++ * 19 December 2001 - created from sa1100_switches.c. ++ */ ++ ++#include <linux/config.h> ++#include <linux/init.h> ++#include <linux/module.h> ++#include <linux/kernel.h> ++#include <linux/sched.h> ++#include <linux/errno.h> ++#include <linux/interrupt.h> ++ ++#include <asm/hardware.h> ++#include <asm/mach-types.h> ++#include <asm/irq.h> ++ ++#include <asm/arch/assabet.h> ++#include <asm/arch/neponset.h> ++#include <asm/arch/badge4.h> ++ ++#include "switches.h" ++ ++ ++static irqreturn_t switches_sa1100_handler(int irq, void *dev_id, ++ struct pt_regs *regs); ++ ++ ++#ifdef CONFIG_SA1100_ASSABET ++ ++/* Assabet ++ * ^^^^^^^ ++ * We have two general-purpose switches, S1 and S2, available via GPIO ++ * on Assabet. This code sets bits in the range [1, 2] in the mask that ++ * we return to userland. ++ */ ++ ++static int assabet_switches_sa1100_init(void) ++{ ++ ++ if (machine_has_neponset()) ++ NCR_0 |= NCR_GP01_OFF; ++ ++ if (request_irq(IRQ_GPIO0, switches_sa1100_handler, SA_INTERRUPT, ++ SWITCHES_NAME, NULL) < 0) { ++ printk(KERN_ERR "%s: unable to register IRQ for GPIO 0\n", ++ SWITCHES_NAME); ++ return -EIO; ++ } ++ ++ if (request_irq(IRQ_GPIO1, switches_sa1100_handler, SA_INTERRUPT, ++ SWITCHES_NAME, NULL) < 0) { ++ printk(KERN_ERR "%s: unable to register IRQ for GPIO 1\n", ++ SWITCHES_NAME); ++ free_irq(IRQ_GPIO0, NULL); ++ return -EIO; ++ } ++ ++ set_irq_type(IRQ_GPIO0, IRQT_BOTHEDGE); ++ set_irq_type(IRQ_GPIO1, IRQT_BOTHEDGE); ++ ++ return 0; ++ ++} ++ ++static void assabet_switches_sa1100_shutdown(void) ++{ ++ ++ free_irq(IRQ_GPIO1, NULL); ++ free_irq(IRQ_GPIO0, NULL); ++ ++} ++ ++static irqreturn_t assabet_switches_sa1100_handler(int irq, switches_mask_t *mask) ++{ ++ unsigned int s, last, this; ++ static unsigned int states = 0; ++ ++ switch (irq) { ++ ++ case IRQ_GPIO0: s = 0; break; ++ ++ case IRQ_GPIO1: s = 1; break; ++ ++ default: return IRQ_NONE; ++ ++ } ++ ++ last = ((states & (1 << s)) != 0); ++ this = ((GPLR & GPIO_GPIO(s)) != 0); ++ ++ if (last == this) /* debounce */ ++ return IRQ_HANDLED; ++ ++ SWITCHES_SET(mask, s + 1, this); ++ ++ states = this ? (states | (1 << s)) : (states & ~(1 << s)); ++ ++ return IRQ_HANDLED; ++} ++#endif /* CONFIG_SA1100_ASSABET */ ++ ++#ifdef CONFIG_SA1100_BADGE4 ++ ++/* BadgePAD 4 ++ * ^^^^^^^^^^ ++ * ++ * Here we use test point J6 (BADGE4_GPIO_TESTPT_J6 aka GPIO 23) as a ++ * general purpose switch input. We map this to switch #0. ++ */ ++ ++#define BADGE4_SW0_GPIO GPIO_GPIO23 /* aka BADGE4_GPIO_TESTPT_J6 */ ++#define BADGE4_SW0_IRQ IRQ_GPIO23 ++ ++static int badge4_switches_sa1100_init(void) ++{ ++ if (request_irq(BADGE4_SW0_IRQ, switches_sa1100_handler, SA_INTERRUPT, ++ SWITCHES_NAME, NULL) < 0) { ++ printk(KERN_ERR "%s: unable to register IRQ for SW0\n", ++ SWITCHES_NAME); ++ return -EIO; ++ } ++ ++ set_irq_type(BADGE4_SW0_IRQ, IRQT_BOTHEDGE); ++ ++ return 0; ++} ++ ++static void badge4_switches_sa1100_shutdown(void) ++{ ++ free_irq(BADGE4_SW0_IRQ, NULL); ++} ++ ++static irqreturn_t badge4_switches_sa1100_handler(int irq, switches_mask_t *mask) ++{ ++ unsigned int swno, last, this, gpio; ++ static unsigned int states = 0; ++ ++ switch (irq) { ++ case BADGE4_SW0_IRQ: ++ swno = 0; ++ gpio = BADGE4_SW0_GPIO; ++ break; ++ default: ++ return IRQ_NONE; ++ } ++ ++ last = ((states & gpio) != 0); ++ this = ((GPLR & gpio) != 0); ++ ++ if (last == this) /* debounce */ ++ return IRQ_HANDLED; ++ ++ SWITCHES_SET(mask, swno, this); ++ ++ states = this ? (states | gpio) : (states & ~gpio); ++ ++ return IRQ_HANDLED; ++} ++#endif /* CONFIG_SA1100_BADGE4 */ ++ ++ ++#ifdef CONFIG_SA1100_SPOT ++ ++/* Spot ++ * ^^^^ ++ * Spot (R2, R3) has a single general-purpose switch (S1), which is ++ * also the power-on switch. We set bit [1] in the mask we return to ++ * userland. ++ */ ++ ++static int spot_switches_sa1100_init(void) ++{ ++ ++ set_GPIO_IRQ_edge(GPIO_SW1, GPIO_BOTH_EDGES); ++ ++ if (request_irq(IRQ_GPIO_SW1, switches_sa1100_handler, SA_INTERRUPT, ++ SWITCHES_NAME, NULL) < 0) { ++ printk(KERN_ERR "%s: unable to register IRQ for SW1\n", ++ SWITCHES_NAME); ++ return -EIO; ++ } ++ ++ return 0; ++ ++} ++ ++static void spot_switches_sa1100_shutdown(void) ++{ ++ ++ free_irq(IRQ_GPIO_SW1, NULL); ++ ++} ++ ++static irqreturn_t spot_switches_sa1100_handler(int irq, switches_mask_t *mask) ++{ ++ unsigned int s, last, this; ++ static unsigned int states = 0; ++ ++ switch (irq) { ++ ++ case IRQ_GPIO_SW1: s = 0; break; ++ ++ default: return IRQ_NONE; ++ ++ } ++ ++ last = ((states & (1 << s)) != 0); ++ this = ((GPLR & GPIO_GPIO(s)) != 0); ++ ++ if (last == this) /* debounce */ ++ return IRQ_HANDLED; ++ ++ SWITCHES_SET(mask, s + 1, this); ++ ++ states = this ? (states | (1 << s)) : (states & ~(1 << s)); ++ ++ return IRQ_HANDLED; ++ ++} ++#endif /* CONFIG_SA1100_SPOT */ ++ ++ ++/* switches_sa1100_handler() ++ * ^^^^^^^^^^^^^^^^^^^^^^^^^ ++ * This routine is a generalized handler for SA-1100 switches ++ * which manages action descriptors and calls a board-specific ++ * service routine. This routine is appropriate for GPIO switches ++ * or other primary interrupt sources, and can be registered as a ++ * first-class IRQ handler using request_irq(). ++ */ ++static irqreturn_t switches_sa1100_handler(int irq, void *dev_id, ++ struct pt_regs *regs) ++{ ++ switches_mask_t mask; ++ irqreturn_t ret = IRQ_NONE; ++ ++ SWITCHES_ZERO(&mask); ++ ++ /* Porting note: call a board-specific switch interrupt handler ++ * here. The handler can assume that sufficient storage for ++ * `mask' has been allocated, and that the corresponding ++ * switches_mask_t structure has been zeroed. ++ */ ++ ++ if (machine_is_assabet()) { ++#ifdef CONFIG_SA1100_ASSABET ++ ret = assabet_switches_sa1100_handler(irq, &mask); ++#endif ++ } else if (machine_is_badge4()) { ++#ifdef CONFIG_SA1100_BADGE4 ++ ret = badge4_switches_sa1100_handler(irq, &mask); ++#endif ++ } else if (machine_is_spot()) { ++#ifdef CONFIG_SA1100_SPOT ++ ret = spot_switches_sa1100_handler(irq, &mask); ++#endif ++ } ++ ++ switches_event(&mask); ++ ++ return ret; ++} ++ ++int __init switches_sa1100_init(void) ++{ ++ ++ /* Porting note: call a board-specific init routine here. */ ++ ++ if (machine_is_assabet()) { ++#ifdef CONFIG_SA1100_ASSABET ++ if (assabet_switches_sa1100_init() < 0) ++ return -EIO; ++#endif ++ } else if (machine_is_badge4()) { ++#ifdef CONFIG_SA1100_BADGE4 ++ if (badge4_switches_sa1100_init() < 0) ++ return -EIO; ++#endif ++ } else if (machine_is_spot()) { ++#ifdef CONFIG_SA1100_SPOT ++ if (spot_switches_sa1100_init() < 0) ++ return -EIO; ++#endif ++ } ++ ++ return 0; ++ ++} ++ ++void __exit switches_sa1100_exit(void) ++{ ++ ++ /* Porting note: call a board-specific shutdown routine here. */ ++ ++ if (machine_is_assabet()) { ++#ifdef CONFIG_SA1100_ASSABET ++ assabet_switches_sa1100_shutdown(); ++#endif ++ } else if (machine_is_badge4()) { ++#ifdef CONFIG_SA1100_BADGE4 ++ badge4_switches_sa1100_shutdown(); ++#endif ++ } else if (machine_is_spot()) { ++#ifdef CONFIG_SA1100_SPOT ++ spot_switches_sa1100_shutdown(); ++#endif ++ } ++ ++} ++ ++module_init(switches_sa1100_init); ++module_exit(switches_sa1100_exit); ++ ++MODULE_DESCRIPTION("SA-1100 switches driver"); ++MODULE_LICENSE("GPL"); +--- linux-2.6.5/drivers/misc/Makefile~heh 2004-04-03 22:38:17.000000000 -0500 ++++ linux-2.6.5/drivers/misc/Makefile 2004-04-30 20:57:36.000000000 -0400 +@@ -4,3 +4,21 @@ + obj- := misc.o # Dummy rule to force built-in.o to be made + + obj-$(CONFIG_IBM_ASM) += ibmasm/ ++ ++obj-$(CONFIG_MCP) += mcp-core.o ++obj-$(CONFIG_MCP_UCB1200) += ucb1x00-core.o ++obj-$(CONFIG_MCP_UCB1200_AUDIO) += ucb1x00-audio.o ++obj-$(CONFIG_MCP_UCB1200_TS) += ucb1x00-ts.o ++ ++ifeq ($(CONFIG_SA1100_ASSABET),y) ++obj-$(CONFIG_MCP_UCB1200) += ucb1x00-assabet.o ++endif ++ ++obj-$(CONFIG_SWITCHES) += switches-core.o ++obj-$(CONFIG_SWITCHES_SA1100) += switches-sa1100.o ++obj-$(CONFIG_SWITCHES_UCB1X00) += switches-ucb1x00.o ++ ++obj-$(CONFIG_MCP_SA1100) += mcp-sa1100.o ++ ++obj-$(CONFIG_UCB1400_TS) += mcp-pxa.o ucb1x00-core.o ucb1x00-ts.o ++ +--- linux-2.6.5/drivers/i2c/busses/Kconfig~heh 2004-04-03 22:38:10.000000000 -0500 ++++ linux-2.6.5/drivers/i2c/busses/Kconfig 2004-04-30 20:57:36.000000000 -0400 +@@ -70,6 +70,16 @@ + This support is also available as a module. If so, the module + will be called i2c-hydra. + ++config I2C_BIT_SA1100_GPIO ++ bool "SA1100 I2C GPIO adapter" ++ depends on ARCH_SA1100 && I2C_ALGOBIT ++ help ++ This supports I2C on the SA11x0 processor GPIO pins. This ++ shares support with the L3 driver. ++ ++ This support is also available as a module. If so, the module ++ will be called l3-bit-sa1100. ++ + config I2C_I801 + tristate "Intel 801" + depends on I2C && PCI && EXPERIMENTAL +@@ -241,6 +251,18 @@ + This support is also available as a module. If so, the module + will be called i2c-prosavage. + ++config I2C_PXA2XX ++ tristate "PXA I2C Interface" ++ depends on I2C && ARCH_PXA ++ select I2C_ALGOPXA ++ help ++ This supports the use of the PXA I2C interface found on the Intel ++ PXA 25x and PXA 26x systems. Say Y if you have one of these. ++ ++ This support is also available as a module. If you want to compile ++ it as a module, say M here and read Documentation/modules.txt. ++ The module will be called i2c-adap-pxa. ++ + config I2C_RPXLITE + tristate "Embedded Planet RPX Lite/Classic support" + depends on (RPXLITE || RPXCLASSIC) && I2C +--- /dev/null 2003-09-23 18:19:32.000000000 -0400 ++++ linux-2.6.5/drivers/i2c/busses/pxa2xx_i2c.c 2004-04-30 20:57:36.000000000 -0400 +@@ -0,0 +1,388 @@ ++/* ++ * i2c_adap_pxa.c ++ * ++ * I2C adapter for the PXA I2C bus access. ++ * ++ * Copyright (C) 2002 Intrinsyc Software Inc. ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License version 2 as ++ * published by the Free Software Foundation. ++ * ++ * History: ++ * Apr 2002: Initial version [CS] ++ * Jun 2002: Properly seperated algo/adap [FB] ++ * Jan 2003: Fixed several bugs concerning interrupt handling [Kai-Uwe Bloem] ++ * Jan 2003: added limited signal handling [Kai-Uwe Bloem] ++ * Jun 2003: updated for 2.5 [Dustin McIntire] ++ */ ++ ++#include <linux/kernel.h> ++#include <linux/module.h> ++ ++#include <linux/i2c.h> ++#include <linux/i2c-id.h> ++#include <linux/init.h> ++#include <linux/time.h> ++#include <linux/sched.h> ++#include <linux/delay.h> ++#include <linux/errno.h> ++#include <linux/interrupt.h> ++ ++#include <asm/hardware.h> ++#include <asm/irq.h> ++#include <asm/arch/irqs.h> /* for IRQ_I2C */ ++ ++#include <linux/i2c-pxa.h> ++ ++/* ++ * Set this to zero to remove all debug statements via dead code elimination. ++ */ ++//#define DEBUG 1 ++ ++#if DEBUG ++static unsigned int i2c_debug = DEBUG; ++#else ++#define i2c_debug 0 ++#endif ++ ++static int irq = 0; ++static volatile int i2c_pending = 0; /* interrupt pending when 1 */ ++static volatile int bus_error = 0; ++static volatile int tx_finished = 0; ++static volatile int rx_finished = 0; ++ ++static wait_queue_head_t i2c_wait; ++static void i2c_pxa_transfer( int lastbyte, int receive, int midbyte); ++ ++/* place a byte in the transmit register */ ++static void i2c_pxa_write_byte(u8 value) ++{ ++ IDBR = value; ++} ++ ++/* read byte in the receive register */ ++static u8 i2c_pxa_read_byte(void) ++{ ++ return (u8) (0xff & IDBR); ++} ++ ++static void i2c_pxa_start(void) ++{ ++ unsigned long icr = ICR; ++ icr |= ICR_START; ++ icr &= ~(ICR_STOP | ICR_ALDIE | ICR_ACKNAK); ++ ICR = icr; ++ ++ bus_error=0; /* clear any bus_error from previous txfers */ ++ tx_finished=0; /* clear rx and tx interrupts from previous txfers */ ++ rx_finished=0; ++ i2c_pending = 0; ++} ++ ++static void i2c_pxa_repeat_start(void) ++{ ++ unsigned long icr = ICR; ++ icr |= ICR_START; ++ icr &= ~(ICR_STOP | ICR_ALDIE); ++ ICR = icr; ++ ++ bus_error=0; /* clear any bus_error from previous txfers */ ++ tx_finished=0; /* clear rx and tx interrupts from previous txfers */ ++ rx_finished=0; ++ i2c_pending = 0; ++} ++ ++static void i2c_pxa_stop(void) ++{ ++ unsigned long icr = ICR; ++ icr |= ICR_STOP; ++ icr &= ~(ICR_START); ++ ICR = icr; ++} ++ ++static void i2c_pxa_midbyte(void) ++{ ++ unsigned long icr = ICR; ++ icr &= ~(ICR_START | ICR_STOP); ++ ICR = icr; ++} ++ ++static void i2c_pxa_abort(void) ++{ ++ unsigned long timeout = jiffies + HZ/4; ++ ++#ifdef PXA_ABORT_MA ++ while ((long)(timeout - jiffies) > 0 && (ICR & ICR_TB)) { ++ set_current_state(TASK_INTERRUPTIBLE); ++ schedule_timeout(1); ++ } ++ ++ ICR |= ICR_MA; ++ udelay(100); ++#else ++ while ((long)(timeout - jiffies) > 0 && (IBMR & 0x1) == 0) { ++ i2c_pxa_transfer( 1, I2C_RECEIVE, 1); ++ set_current_state(TASK_INTERRUPTIBLE); ++ schedule_timeout(1); ++ } ++#endif ++ ICR &= ~(ICR_MA | ICR_START | ICR_STOP); ++} ++ ++static int i2c_pxa_wait_bus_not_busy( void) ++{ ++ int timeout = DEF_TIMEOUT; ++ ++ while (timeout-- && (ISR & ISR_IBB)) { ++ udelay(100); /* wait for 100 us */ ++ } ++ ++ return (timeout<=0); ++} ++ ++spinlock_t i2c_pxa_irqlock = SPIN_LOCK_UNLOCKED; ++ ++static void i2c_pxa_wait_for_ite(void){ ++ unsigned long flags; ++ if (irq > 0) { ++ spin_lock_irqsave(&i2c_pxa_irqlock, flags); ++ if (i2c_pending == 0) { ++ interruptible_sleep_on_timeout(&i2c_wait, I2C_SLEEP_TIMEOUT ); ++ } ++ i2c_pending = 0; ++ spin_unlock_irqrestore(&i2c_pxa_irqlock, flags); ++ } else { ++ udelay(100); ++ } ++} ++ ++static int i2c_pxa_wait_for_int( int wait_type) ++{ ++ int timeout = DEF_TIMEOUT; ++#ifdef DEBUG ++ if (bus_error) ++ printk(KERN_INFO"i2c_pxa_wait_for_int: Bus error on enter\n"); ++ if (rx_finished) ++ printk(KERN_INFO"i2c_pxa_wait_for_int: Receive interrupt on enter\n"); ++ if (tx_finished) ++ printk(KERN_INFO"i2c_pxa_wait_for_int: Transmit interrupt on enter\n"); ++#endif ++ ++ if (wait_type == I2C_RECEIVE){ /* wait on receive */ ++ ++ do { ++ i2c_pxa_wait_for_ite(); ++ } while (!(rx_finished) && timeout-- && !signal_pending(current)); ++ ++#ifdef DEBUG ++ if (timeout<0){ ++ if (tx_finished) ++ printk("Error: i2c-algo-pxa.o: received a tx" ++ " interrupt while waiting on a rx in wait_for_int"); ++ } ++#endif ++ } else { /* wait on transmit */ ++ ++ do { ++ i2c_pxa_wait_for_ite(); ++ } while (!(tx_finished) && timeout-- && !signal_pending(current)); ++ ++#ifdef DEBUG ++ if (timeout<0){ ++ if (rx_finished) ++ printk("Error: i2c-algo-pxa.o: received a rx" ++ " interrupt while waiting on a tx in wait_for_int"); ++ } ++#endif ++ } ++ ++ udelay(ACK_DELAY); /* this is needed for the bus error */ ++ ++ tx_finished=0; ++ rx_finished=0; ++ ++ if (bus_error){ ++ bus_error=0; ++ if( i2c_debug > 2)printk("wait_for_int: error - no ack.\n"); ++ return BUS_ERROR; ++ } ++ ++ if (signal_pending(current)) { ++ return (-ERESTARTSYS); ++ } else if (timeout < 0) { ++ if( i2c_debug > 2)printk("wait_for_int: timeout.\n"); ++ return(-EIO); ++ } else ++ return(0); ++} ++ ++static void i2c_pxa_transfer( int lastbyte, int receive, int midbyte) ++{ ++ if( lastbyte) ++ { ++ if( receive==I2C_RECEIVE) ICR |= ICR_ACKNAK; ++ i2c_pxa_stop(); ++ } ++ else if( midbyte) ++ { ++ i2c_pxa_midbyte(); ++ } ++ ICR |= ICR_TB; ++} ++ ++static void i2c_pxa_reset( void) ++{ ++#ifdef DEBUG ++ printk("Resetting I2C Controller Unit\n"); ++#endif ++ ++ /* abort any transfer currently under way */ ++ i2c_pxa_abort(); ++ ++ /* reset according to 9.8 */ ++ ICR = ICR_UR; ++ ISR = I2C_ISR_INIT; ++ ICR &= ~ICR_UR; ++ ++ /* set the global I2C clock on */ ++ CKEN |= CKEN14_I2C; ++ ++ /* set our slave address */ ++ ISAR = I2C_PXA_SLAVE_ADDR; ++ ++ /* set control register values */ ++ ICR = I2C_ICR_INIT; ++ ++ /* clear any leftover states from prior transmissions */ ++ i2c_pending = rx_finished = tx_finished = bus_error = 0; ++ ++ /* enable unit */ ++ ICR |= ICR_IUE; ++ udelay(100); ++} ++ ++static irqreturn_t i2c_pxa_handler(int this_irq, void *dev_id, struct pt_regs *regs) ++{ ++ unsigned long flags; ++ int status, wakeup = 0; ++ status = (ISR); ++ ++ if (status & ISR_BED){ ++ (ISR) |= ISR_BED; ++ bus_error=ISR_BED; ++ wakeup = 1; ++ } ++ if (status & ISR_ITE){ ++ (ISR) |= ISR_ITE; ++ tx_finished=ISR_ITE; ++ wakeup = 1; ++ } ++ if (status & ISR_IRF){ ++ (ISR) |= ISR_IRF; ++ rx_finished=ISR_IRF; ++ wakeup = 1; ++ } ++ if (wakeup) { ++ spin_lock_irqsave(&i2c_pxa_irqlock, flags); ++ i2c_pending = 1; ++ spin_unlock_irqrestore(&i2c_pxa_irqlock, flags); ++ wake_up_interruptible(&i2c_wait); ++ } ++ return IRQ_HANDLED; ++} ++ ++static int i2c_pxa_resource_init( void) ++{ ++ init_waitqueue_head(&i2c_wait); ++ ++ if (request_irq(IRQ_I2C, &i2c_pxa_handler, SA_INTERRUPT, "I2C", 0) < 0) { ++ irq = 0; ++ if(i2c_debug) ++ printk(KERN_INFO "I2C: Failed to register I2C irq %i\n", IRQ_I2C); ++ return -ENODEV; ++ } ++ return 0; ++} ++ ++static void i2c_pxa_resource_release( void) ++{ ++ if( irq > 0) ++ { ++ disable_irq(irq); ++ free_irq(irq,0); ++ irq=0; ++ } ++} ++ ++static int i2c_pxa_client_register(struct i2c_client *client) ++{ ++ return 0; ++} ++ ++static int i2c_pxa_client_unregister(struct i2c_client *client) ++{ ++ return 0; ++} ++ ++static struct i2c_algo_pxa_data i2c_pxa_data = { ++ write_byte: i2c_pxa_write_byte, ++ read_byte: i2c_pxa_read_byte, ++ ++ start: i2c_pxa_start, ++ repeat_start: i2c_pxa_repeat_start, ++ stop: i2c_pxa_stop, ++ abort: i2c_pxa_abort, ++ ++ wait_bus_not_busy: i2c_pxa_wait_bus_not_busy, ++ wait_for_interrupt: i2c_pxa_wait_for_int, ++ transfer: i2c_pxa_transfer, ++ reset: i2c_pxa_reset, ++ ++ udelay: 10, ++ timeout: DEF_TIMEOUT, ++}; ++ ++static struct i2c_adapter i2c_pxa_ops = { ++ .owner = THIS_MODULE, ++ .id = I2C_ALGO_PXA, ++ .algo_data = &i2c_pxa_data, ++ .dev = { ++ .name = "PXA I2C Adapter", ++ }, ++ .client_register = i2c_pxa_client_register, ++ .client_unregister = i2c_pxa_client_unregister, ++ .retries = 2, ++}; ++ ++extern int i2c_pxa_add_bus(struct i2c_adapter *); ++extern int i2c_pxa_del_bus(struct i2c_adapter *); ++ ++static int __init i2c_adap_pxa_init(void) ++{ ++ if( i2c_pxa_resource_init() == 0) { ++ ++ if (i2c_pxa_add_bus(&i2c_pxa_ops) < 0) { ++ i2c_pxa_resource_release(); ++ printk(KERN_INFO "I2C: Failed to add bus\n"); ++ return -ENODEV; ++ } ++ } else { ++ return -ENODEV; ++ } ++ ++ printk(KERN_INFO "I2C: Successfully added bus\n"); ++ ++ return 0; ++} ++ ++static void i2c_adap_pxa_exit(void) ++{ ++ i2c_pxa_del_bus( &i2c_pxa_ops); ++ i2c_pxa_resource_release(); ++ ++ printk(KERN_INFO "I2C: Successfully removed bus\n"); ++} ++ ++module_init(i2c_adap_pxa_init); ++module_exit(i2c_adap_pxa_exit); +--- linux-2.6.5/drivers/i2c/busses/Makefile~heh 2004-04-03 22:36:17.000000000 -0500 ++++ linux-2.6.5/drivers/i2c/busses/Makefile 2004-04-30 20:57:36.000000000 -0400 +@@ -21,6 +21,7 @@ + obj-$(CONFIG_I2C_PARPORT_LIGHT) += i2c-parport-light.o + obj-$(CONFIG_I2C_PIIX4) += i2c-piix4.o + obj-$(CONFIG_I2C_PROSAVAGE) += i2c-prosavage.o ++obj-$(CONFIG_I2C_PXA) += pxa2xx_i2c.o + obj-$(CONFIG_I2C_RPXLITE) += i2c-rpx.o + obj-$(CONFIG_I2C_SAVAGE4) += i2c-savage4.o + obj-$(CONFIG_I2C_SIS5595) += i2c-sis5595.o +--- linux-2.6.5/drivers/i2c/algos/Kconfig~heh 2004-04-03 22:37:59.000000000 -0500 ++++ linux-2.6.5/drivers/i2c/algos/Kconfig 2004-04-30 20:57:36.000000000 -0400 +@@ -38,6 +38,18 @@ + This support is also available as a module. If so, the module + will be called i2c-algo-ite. + ++config I2C_ALGOPXA ++ tristate "PXA I2C Algorithm" ++ depends on ARCH_PXA && I2C ++ help ++ This supports the use of the PXA I2C interface found on the Intel ++ PXA 25x and PXA 26x systems. Say Y if you have one of these. ++ You should also say Y for the PXA I2C peripheral driver support below. ++ ++ This support is also available as a module. If you want to compile ++ it as a module, say M here and read Documentation/modules.txt. ++ The module will be called i2c-algo-pxa. ++ + config I2C_ALGO8XX + tristate "MPC8xx CPM I2C interface" + depends on 8xx && I2C +--- /dev/null 2003-09-23 18:19:32.000000000 -0400 ++++ linux-2.6.5/drivers/i2c/algos/i2c-algo-pxa.c 2004-04-30 20:57:36.000000000 -0400 +@@ -0,0 +1,384 @@ ++/* ++ * i2c-algo-pxa.c ++ * ++ * I2C algorithm for the PXA I2C bus access. ++ * Byte driven algorithm similar to pcf. ++ * ++ * Copyright (C) 2002 Intrinsyc Software Inc. ++ * ++ * This program is free software; you can redistribute it and/or modify ++ * it under the terms of the GNU General Public License version 2 as ++ * published by the Free Software Foundation. ++ * ++ * History: ++ * Apr 2002: Initial version [CS] ++ * Jun 2002: Properly seperated algo/adap [FB] ++ * Jan 2003: added limited signal handling [Kai-Uwe Bloem] ++ * Jan 2003: allow SMBUS_QUICK as valid msg [FB] ++ * Jun 2003: updated for 2.5 [Dustin McIntire] ++ * ++ */ ++#include <linux/kernel.h> ++#include <linux/module.h> ++ ++#include <linux/init.h> ++#include <linux/delay.h> ++#include <linux/errno.h> ++#include <linux/i2c.h> /* struct i2c_msg and others */ ++#include <linux/i2c-id.h> ++ ++#include <linux/i2c-pxa.h> ++ ++/* ++ * Set this to zero to remove all the debug statements via dead code elimination. ++ */ ++//#define DEBUG 1 ++ ++#if DEBUG ++static unsigned int i2c_debug = DEBUG; ++#else ++#define i2c_debug 0 ++#endif ++ ++static int pxa_scan = 1; ++ ++static int i2c_pxa_valid_messages( struct i2c_msg msgs[], int num) ++{ ++ int i; ++ if (num < 1 || num > MAX_MESSAGES){ ++ if( i2c_debug) ++ printk(KERN_INFO "Invalid number of messages (max=%d, num=%d)\n", ++ MAX_MESSAGES, num); ++ return -EINVAL; ++ } ++ ++ /* check consistency of our messages */ ++ for (i=0;i<num;i++){ ++ if (&msgs[i]==NULL){ ++ if( i2c_debug) printk(KERN_INFO "Msgs is NULL\n"); ++ return -EINVAL; ++ } else { ++ if (msgs[i].buf == NULL){ ++ if( i2c_debug)printk(KERN_INFO "Length is less than zero"); ++ return -EINVAL; ++ } ++ } ++ } ++ ++ return 1; ++} ++ ++static int i2c_pxa_readbytes(struct i2c_adapter *i2c_adap, char *buf, ++ int count, int last) ++{ ++ ++ int i, timeout=0; ++ struct i2c_algo_pxa_data *adap = i2c_adap->algo_data; ++ ++ /* increment number of bytes to read by one -- read dummy byte */ ++ for (i = 0; i <= count; i++) { ++ if (i!=0){ ++ /* set ACK to NAK for last received byte ICR[ACKNAK] = 1 ++ only if not a repeated start */ ++ ++ if ((i == count) && last) { ++ adap->transfer( last, I2C_RECEIVE, 0); ++ }else{ ++ adap->transfer( 0, I2C_RECEIVE, 1); ++ } ++ ++ timeout = adap->wait_for_interrupt(I2C_RECEIVE); ++ ++#ifdef DEBUG ++ if (timeout==BUS_ERROR){ ++ printk(KERN_INFO "i2c_pxa_readbytes: bus error -> forcing reset\n"); ++ adap->reset(); ++ return I2C_RETRY; ++ } else ++#endif ++ if (timeout == -ERESTARTSYS) { ++ adap->abort(); ++ return timeout; ++ } else ++ if (timeout){ ++#ifdef DEBUG ++ printk(KERN_INFO "i2c_pxa_readbytes: timeout -> forcing reset\n"); ++#endif ++ adap->reset(); ++ return I2C_RETRY; ++ } ++ ++ } ++ ++ if (i) { ++ buf[i - 1] = adap->read_byte(); ++ } else { ++ adap->read_byte(); /* dummy read */ ++ } ++ } ++ return (i - 1); ++} ++ ++static int i2c_pxa_sendbytes(struct i2c_adapter *i2c_adap, const char *buf, ++ int count, int last) ++{ ++ ++ struct i2c_algo_pxa_data *adap = i2c_adap->algo_data; ++ int wrcount, timeout; ++ ++ for (wrcount=0; wrcount<count; ++wrcount) { ++ ++ adap->write_byte(buf[wrcount]); ++ if ((wrcount==(count-1)) && last) { ++ adap->transfer( last, I2C_TRANSMIT, 0); ++ }else{ ++ adap->transfer( 0, I2C_TRANSMIT, 1); ++ } ++ ++ timeout = adap->wait_for_interrupt(I2C_TRANSMIT); ++ ++#ifdef DEBUG ++ if (timeout==BUS_ERROR) { ++ printk(KERN_INFO "i2c_pxa_sendbytes: bus error -> forcing reset.\n"); ++ adap->reset(); ++ return I2C_RETRY; ++ } else ++#endif ++ if (timeout == -ERESTARTSYS) { ++ adap->abort(); ++ return timeout; ++ } else ++ if (timeout) { ++#ifdef DEBUG ++ printk(KERN_INFO "i2c_pxa_sendbytes: timeout -> forcing reset\n"); ++#endif ++ adap->reset(); ++ return I2C_RETRY; ++ } ++ } ++ return (wrcount); ++} ++ ++ ++static inline int i2c_pxa_set_ctrl_byte(struct i2c_algo_pxa_data * adap, struct i2c_msg *msg) ++{ ++ u16 flags = msg->flags; ++ u8 addr; ++ addr = (u8) ( (0x7f & msg->addr) << 1 ); ++ if (flags & I2C_M_RD ) ++ addr |= 1; ++ if (flags & I2C_M_REV_DIR_ADDR ) ++ addr ^= 1; ++ adap->write_byte(addr); ++ return 0; ++} ++ ++static int i2c_pxa_do_xfer(struct i2c_adapter *i2c_adap, struct i2c_msg msgs[], int num) ++{ ++ struct i2c_algo_pxa_data * adap; ++ struct i2c_msg *pmsg=NULL; ++ int i; ++ int ret=0, timeout; ++ ++ adap = i2c_adap->algo_data; ++ ++ timeout = adap->wait_bus_not_busy(); ++ ++ if (timeout) { ++ return I2C_RETRY; ++ } ++ ++ for (i = 0;ret >= 0 && i < num; i++) { ++ int last = i + 1 == num; ++ pmsg = &msgs[i]; ++ ++ ret = i2c_pxa_set_ctrl_byte(adap,pmsg); ++ ++ /* Send START */ ++ if (i == 0) { ++ adap->start(); ++ }else{ ++ adap->repeat_start(); ++ } ++ ++ adap->transfer(0, I2C_TRANSMIT, 0); ++ ++ /* Wait for ITE (transmit empty) */ ++ timeout = adap->wait_for_interrupt(I2C_TRANSMIT); ++ ++#ifdef DEBUG ++ /* Check for ACK (bus error) */ ++ if (timeout==BUS_ERROR){ ++ printk(KERN_INFO "i2c_pxa_do_xfer: bus error -> forcing reset\n"); ++ adap->reset(); ++ return I2C_RETRY; ++ } else ++#endif ++ if (timeout == -ERESTARTSYS) { ++ adap->abort(); ++ return timeout; ++ } else ++ if (timeout) { ++#ifdef DEBUG ++ printk(KERN_INFO "i2c_pxa_do_xfer: timeout -> forcing reset\n"); ++#endif ++ adap->reset(); ++ return I2C_RETRY; ++ } ++/* FIXME: handle arbitration... */ ++#if 0 ++ /* Check for bus arbitration loss */ ++ if (adap->arbitration_loss()){ ++ printk("Arbitration loss detected \n"); ++ adap->reset(); ++ return I2C_RETRY; ++ } ++#endif ++ ++ /* Read */ ++ if (pmsg->flags & I2C_M_RD) { ++ /* read bytes into buffer*/ ++ ret = i2c_pxa_readbytes(i2c_adap, pmsg->buf, pmsg->len, last); ++#if DEBUG > 2 ++ if (ret != pmsg->len) { ++ printk(KERN_INFO"i2c_pxa_do_xfer: read %d/%d bytes.\n", ++ ret, pmsg->len); ++ } else { ++ printk(KERN_INFO"i2c_pxa_do_xfer: read %d bytes.\n",ret); ++ } ++#endif ++ } else { /* Write */ ++ ret = i2c_pxa_sendbytes(i2c_adap, pmsg->buf, pmsg->len, last); ++#if DEBUG > 2 ++ if (ret != pmsg->len) { ++ printk(KERN_INFO"i2c_pxa_do_xfer: wrote %d/%d bytes.\n", ++ ret, pmsg->len); ++ } else { ++ printk(KERN_INFO"i2c_pxa_do_xfer: wrote %d bytes.\n",ret); ++ } ++#endif ++ } ++ } ++ ++ if (ret<0){ ++ return ret; ++ }else{ ++ return i; ++ } ++} ++ ++static int i2c_pxa_xfer(struct i2c_adapter *i2c_adap, struct i2c_msg msgs[], int num) ++{ ++ int retval = i2c_pxa_valid_messages( msgs, num); ++ if( retval > 0) ++ { ++ int i; ++ for (i=i2c_adap->retries; i>=0; i--){ ++ int retval = i2c_pxa_do_xfer(i2c_adap,msgs,num); ++ if (retval!=I2C_RETRY){ ++ return retval; ++ } ++ if( i2c_debug)printk(KERN_INFO"Retrying transmission \n"); ++ udelay(100); ++ } ++ if( i2c_debug)printk(KERN_INFO"Retried %i times\n",i2c_adap->retries); ++ return -EREMOTEIO; ++ ++ } ++ return retval; ++} ++ ++static u32 i2c_pxa_functionality(struct i2c_adapter * adapter) ++{ ++ /* Emulate the SMBUS functions */ ++ return I2C_FUNC_SMBUS_EMUL; ++} ++ ++struct i2c_algorithm i2c_pxa_algorithm = { ++ name: "PXA I2C Algorithm", ++ id: I2C_ALGO_PXA, ++ master_xfer: i2c_pxa_xfer, ++ smbus_xfer: NULL, ++ slave_send: NULL, ++ slave_recv: NULL, ++ algo_control: NULL, ++ functionality: i2c_pxa_functionality, ++}; ++ ++/* ++ * registering functions to load algorithms at runtime ++ */ ++int i2c_pxa_add_bus(struct i2c_adapter *i2c_adap) ++{ ++ struct i2c_algo_pxa_data *adap = i2c_adap->algo_data; ++ ++ printk(KERN_INFO"I2C: Adding %s.\n", i2c_adap->dev.name); ++ ++ i2c_adap->algo = &i2c_pxa_algorithm; ++ ++ MOD_INC_USE_COUNT; ++ ++ /* register new adapter to i2c module... */ ++ i2c_add_adapter(i2c_adap); ++ ++ adap->reset(); ++ ++ /* scan bus */ ++ if (pxa_scan) { ++ int i; ++ printk(KERN_INFO "I2C: Scanning bus "); ++ for (i = 0x02; i < 0xff; i+=2) { ++ if( i==(I2C_PXA_SLAVE_ADDR<<1)) continue; ++ ++ if (adap->wait_bus_not_busy()) { ++ printk(KERN_INFO "I2C: scanning bus %s - TIMEOUT.\n", ++ i2c_adap->dev.name); ++ return -EIO; ++ } ++ adap->write_byte(i); ++ adap->start(); ++ adap->transfer(0, I2C_TRANSMIT, 0); ++ ++ if ((adap->wait_for_interrupt(I2C_TRANSMIT) != BUS_ERROR)) { ++ printk("(%02x)",i>>1); ++ adap->abort(); ++ } else { ++// printk("."); ++ adap->stop(); ++ } ++ udelay(adap->udelay); ++ } ++ printk("\n"); ++ } ++ return 0; ++} ++ ++int i2c_pxa_del_bus(struct i2c_adapter *i2c_adap) ++{ ++ int res; ++ if ((res = i2c_del_adapter(i2c_adap)) < 0) ++ return res; ++ ++ MOD_DEC_USE_COUNT; ++ ++ printk(KERN_INFO "I2C: Removing %s.\n", i2c_adap->dev.name); ++ ++ return 0; ++} ++ ++static int __init i2c_algo_pxa_init (void) ++{ ++ printk(KERN_INFO "I2C: PXA algorithm module loaded.\n"); ++ return 0; ++} ++ ++EXPORT_SYMBOL(i2c_pxa_add_bus); ++EXPORT_SYMBOL(i2c_pxa_del_bus); ++ ++MODULE_PARM(pxa_scan, "i"); ++MODULE_PARM_DESC(pxa_scan, "Scan for active chips on the bus"); ++ ++MODULE_AUTHOR("Intrinsyc Software Inc."); ++MODULE_LICENSE("GPL"); ++ ++module_init(i2c_algo_pxa_init); +--- linux-2.6.5/drivers/i2c/algos/Makefile~heh 2004-04-03 22:37:37.000000000 -0500 ++++ linux-2.6.5/drivers/i2c/algos/Makefile 2004-04-30 20:57:36.000000000 -0400 +@@ -4,6 +4,7 @@ + + obj-$(CONFIG_I2C_ALGOBIT) += i2c-algo-bit.o + obj-$(CONFIG_I2C_ALGOPCF) += i2c-algo-pcf.o ++obj-$(CONFIG_I2C_ALGOPXA) += i2c-algo-pxa.o + obj-$(CONFIG_I2C_ALGOITE) += i2c-algo-ite.o + + ifeq ($(CONFIG_I2C_DEBUG_ALGO),y) +--- linux-2.6.5/Makefile~heh 2004-04-03 22:37:36.000000000 -0500 ++++ linux-2.6.5/Makefile 2004-04-30 20:57:58.000000000 -0400 +@@ -1,7 +1,7 @@ + VERSION = 2 + PATCHLEVEL = 6 + SUBLEVEL = 5 +-EXTRAVERSION = ++EXTRAVERSION = -gnalm1 + NAME=Zonked Quokka + + # *DOCUMENTATION* |