diff options
| author | Koen Kooi <koen@openembedded.org> | 2007-06-22 07:49:23 +0000 |
|---|---|---|
| committer | Koen Kooi <koen@openembedded.org> | 2007-06-22 07:49:23 +0000 |
| commit | a9a32cf9034963872a0ae44036f0ecfb2a7069c0 (patch) | |
| tree | 34871b81e02fcf79ab0618fa30a1c870cfbaa0c5 /packages/linux/linux-ezx-2.6.20.7 | |
| parent | 19d91f3c676370ab78e31ba67d3d9db715ddfc63 (diff) | |
| parent | 005b94b2d0208080b63ccd708fd354cf5717b84c (diff) | |
merge of 'a2a414dc8c26784dc8f35ecddb62ca87e5d0f634'
and 'e41ad38990f6485eb33ce1902f7cd10880deba5b'
Diffstat (limited to 'packages/linux/linux-ezx-2.6.20.7')
22 files changed, 0 insertions, 14323 deletions
diff --git a/packages/linux/linux-ezx-2.6.20.7/.mtn2git_empty b/packages/linux/linux-ezx-2.6.20.7/.mtn2git_empty deleted file mode 100644 index e69de29bb2..0000000000 --- a/packages/linux/linux-ezx-2.6.20.7/.mtn2git_empty +++ /dev/null diff --git a/packages/linux/linux-ezx-2.6.20.7/defconfig-a780 b/packages/linux/linux-ezx-2.6.20.7/defconfig-a780 deleted file mode 100644 index a9300a61f5..0000000000 --- a/packages/linux/linux-ezx-2.6.20.7/defconfig-a780 +++ /dev/null @@ -1,1249 +0,0 @@ -# -# Automatically generated make config: don't edit -# Linux kernel version: 2.6.20.7 -# Sun Apr 22 15:03:36 2007 -# -CONFIG_ARM=y -# CONFIG_GENERIC_TIME is not set -CONFIG_MMU=y -CONFIG_GENERIC_HARDIRQS=y -CONFIG_TRACE_IRQFLAGS_SUPPORT=y -CONFIG_HARDIRQS_SW_RESEND=y -CONFIG_GENERIC_IRQ_PROBE=y -CONFIG_RWSEM_GENERIC_SPINLOCK=y -# CONFIG_ARCH_HAS_ILOG2_U32 is not set -# CONFIG_ARCH_HAS_ILOG2_U64 is not set -CONFIG_GENERIC_HWEIGHT=y -CONFIG_GENERIC_CALIBRATE_DELAY=y -CONFIG_ARCH_MTD_XIP=y -CONFIG_VECTORS_BASE=0xffff0000 -CONFIG_DEFCONFIG_LIST="/lib/modules/$UNAME_RELEASE/.config" - -# -# Code maturity level options -# -CONFIG_EXPERIMENTAL=y -CONFIG_BROKEN_ON_SMP=y -CONFIG_INIT_ENV_ARG_LIMIT=32 - -# -# General setup -# -CONFIG_LOCALVERSION="-ezxdev" -# CONFIG_LOCALVERSION_AUTO is not set -# CONFIG_SWAP is not set -CONFIG_SYSVIPC=y -# CONFIG_IPC_NS is not set -# CONFIG_POSIX_MQUEUE is not set -# CONFIG_BSD_PROCESS_ACCT is not set -# CONFIG_TASKSTATS is not set -# CONFIG_UTS_NS is not set -# CONFIG_AUDIT is not set -CONFIG_IKCONFIG=y -CONFIG_IKCONFIG_PROC=y -# CONFIG_SYSFS_DEPRECATED is not set -# CONFIG_RELAY is not set -CONFIG_INITRAMFS_SOURCE="" -CONFIG_CC_OPTIMIZE_FOR_SIZE=y -CONFIG_SYSCTL=y -# CONFIG_EMBEDDED is not set -CONFIG_UID16=y -CONFIG_SYSCTL_SYSCALL=y -CONFIG_KALLSYMS=y -# CONFIG_KALLSYMS_ALL is not set -# CONFIG_KALLSYMS_EXTRA_PASS is not set -CONFIG_HOTPLUG=y -CONFIG_PRINTK=y -CONFIG_BUG=y -CONFIG_ELF_CORE=y -CONFIG_BASE_FULL=y -CONFIG_FUTEX=y -CONFIG_EPOLL=y -CONFIG_SHMEM=y -CONFIG_SLAB=y -CONFIG_VM_EVENT_COUNTERS=y -CONFIG_RT_MUTEXES=y -# CONFIG_TINY_SHMEM is not set -CONFIG_BASE_SMALL=0 -# CONFIG_SLOB is not set - -# -# Loadable module support -# -CONFIG_MODULES=y -CONFIG_MODULE_UNLOAD=y -CONFIG_MODULE_FORCE_UNLOAD=y -CONFIG_MODVERSIONS=y -# CONFIG_MODULE_SRCVERSION_ALL is not set -CONFIG_KMOD=y - -# -# Block layer -# -CONFIG_BLOCK=y -# CONFIG_LBD is not set -# CONFIG_BLK_DEV_IO_TRACE is not set -# CONFIG_LSF is not set - -# -# IO Schedulers -# -CONFIG_IOSCHED_NOOP=y -CONFIG_IOSCHED_AS=y -CONFIG_IOSCHED_DEADLINE=m -CONFIG_IOSCHED_CFQ=m -CONFIG_DEFAULT_AS=y -# CONFIG_DEFAULT_DEADLINE is not set -# CONFIG_DEFAULT_CFQ is not set -# CONFIG_DEFAULT_NOOP is not set -CONFIG_DEFAULT_IOSCHED="anticipatory" - -# -# System Type -# -# CONFIG_ARCH_AAEC2000 is not set -# CONFIG_ARCH_INTEGRATOR is not set -# CONFIG_ARCH_REALVIEW is not set -# CONFIG_ARCH_VERSATILE is not set -# CONFIG_ARCH_AT91 is not set -# CONFIG_ARCH_CLPS7500 is not set -# CONFIG_ARCH_CLPS711X is not set -# CONFIG_ARCH_CO285 is not set -# CONFIG_ARCH_EBSA110 is not set -# CONFIG_ARCH_EP93XX is not set -# CONFIG_ARCH_FOOTBRIDGE is not set -# CONFIG_ARCH_NETX is not set -# CONFIG_ARCH_H720X is not set -# CONFIG_ARCH_IMX is not set -# CONFIG_ARCH_IOP32X is not set -# CONFIG_ARCH_IOP33X is not set -# CONFIG_ARCH_IOP13XX is not set -# CONFIG_ARCH_IXP4XX is not set -# CONFIG_ARCH_IXP2000 is not set -# CONFIG_ARCH_IXP23XX is not set -# CONFIG_ARCH_L7200 is not set -# CONFIG_ARCH_PNX4008 is not set -CONFIG_ARCH_PXA=y -# CONFIG_ARCH_RPC is not set -# CONFIG_ARCH_SA1100 is not set -# CONFIG_ARCH_S3C2410 is not set -# CONFIG_ARCH_SHARK is not set -# CONFIG_ARCH_LH7A40X is not set -# CONFIG_ARCH_OMAP is not set - -# -# Intel PXA2xx Implementations -# -# CONFIG_ARCH_LUBBOCK is not set -# CONFIG_MACH_LOGICPD_PXA270 is not set -# CONFIG_MACH_MAINSTONE is not set -# CONFIG_ARCH_PXA_IDP is not set -# CONFIG_PXA_SHARPSL is not set -# CONFIG_MACH_TRIZEPS4 is not set -CONFIG_PXA_EZX=y -# CONFIG_PXA_EZX_E680 is not set -CONFIG_PXA_EZX_A780=y -# CONFIG_PXA_EZX_E2 is not set -CONFIG_PXA27x=y -CONFIG_PXA_SSP=y - -# -# Processor Type -# -CONFIG_CPU_32=y -CONFIG_CPU_XSCALE=y -CONFIG_CPU_32v5=y -CONFIG_CPU_ABRT_EV5T=y -CONFIG_CPU_CACHE_VIVT=y -CONFIG_CPU_TLB_V4WBI=y -CONFIG_CPU_CP15=y -CONFIG_CPU_CP15_MMU=y - -# -# Processor Features -# -CONFIG_ARM_THUMB=y -# CONFIG_CPU_DCACHE_DISABLE is not set -CONFIG_IWMMXT=y -CONFIG_XSCALE_PMU=y - -# -# Bus support -# - -# -# PCCARD (PCMCIA/CardBus) support -# -# CONFIG_PCCARD is not set - -# -# Kernel Features -# -# CONFIG_PREEMPT is not set -CONFIG_NO_IDLE_HZ=y -CONFIG_HZ=100 -CONFIG_AEABI=y -CONFIG_OABI_COMPAT=y -# CONFIG_ARCH_DISCONTIGMEM_ENABLE is not set -CONFIG_SELECT_MEMORY_MODEL=y -CONFIG_FLATMEM_MANUAL=y -# CONFIG_DISCONTIGMEM_MANUAL is not set -# CONFIG_SPARSEMEM_MANUAL is not set -CONFIG_FLATMEM=y -CONFIG_FLAT_NODE_MEM_MAP=y -# CONFIG_SPARSEMEM_STATIC is not set -CONFIG_SPLIT_PTLOCK_CPUS=4096 -# CONFIG_RESOURCES_64BIT is not set -CONFIG_ALIGNMENT_TRAP=y - -# -# Boot options -# -CONFIG_ZBOOT_ROM_TEXT=0 -CONFIG_ZBOOT_ROM_BSS=0 -CONFIG_CMDLINE="console=tty1 noinitrd root=/dev/mmcblk0p2 rootfstype=ext3 ip=169.254.1.11:169.254.1.10:169.254.1.10:255.255.255.254:ezx:usb0:off debug mem=32M@0xA0000000 mem=16M@0xAC000000" -# CONFIG_XIP_KERNEL is not set - -# -# Floating point emulation -# - -# -# At least one emulation must be selected -# -CONFIG_FPE_NWFPE=y -# CONFIG_FPE_NWFPE_XP is not set -# CONFIG_FPE_FASTFPE is not set - -# -# Userspace binary formats -# -CONFIG_BINFMT_ELF=y -CONFIG_BINFMT_AOUT=m -CONFIG_BINFMT_MISC=m - -# -# Power management options -# -# CONFIG_PM is not set -# CONFIG_APM is not set - -# -# Networking -# -CONFIG_NET=y - -# -# Networking options -# -# CONFIG_NETDEBUG is not set -CONFIG_PACKET=y -# CONFIG_PACKET_MMAP is not set -CONFIG_UNIX=y -CONFIG_XFRM=y -# CONFIG_XFRM_USER is not set -# CONFIG_XFRM_SUB_POLICY is not set -# CONFIG_NET_KEY is not set -CONFIG_INET=y -# CONFIG_IP_MULTICAST is not set -# CONFIG_IP_ADVANCED_ROUTER is not set -CONFIG_IP_FIB_HASH=y -CONFIG_IP_PNP=y -CONFIG_IP_PNP_DHCP=y -# CONFIG_IP_PNP_BOOTP is not set -# CONFIG_IP_PNP_RARP is not set -# CONFIG_NET_IPIP is not set -# CONFIG_NET_IPGRE is not set -# CONFIG_ARPD is not set -CONFIG_SYN_COOKIES=y -# CONFIG_INET_AH is not set -# CONFIG_INET_ESP is not set -# CONFIG_INET_IPCOMP is not set -# CONFIG_INET_XFRM_TUNNEL is not set -# CONFIG_INET_TUNNEL is not set -CONFIG_INET_XFRM_MODE_TRANSPORT=y -CONFIG_INET_XFRM_MODE_TUNNEL=y -CONFIG_INET_XFRM_MODE_BEET=y -CONFIG_INET_DIAG=y -CONFIG_INET_TCP_DIAG=y -# CONFIG_TCP_CONG_ADVANCED is not set -CONFIG_TCP_CONG_CUBIC=y -CONFIG_DEFAULT_TCP_CONG="cubic" -# CONFIG_TCP_MD5SIG is not set -# CONFIG_IPV6 is not set -# CONFIG_INET6_XFRM_TUNNEL is not set -# CONFIG_INET6_TUNNEL is not set -# CONFIG_NETWORK_SECMARK is not set -# CONFIG_NETFILTER is not set - -# -# DCCP Configuration (EXPERIMENTAL) -# -# CONFIG_IP_DCCP is not set - -# -# SCTP Configuration (EXPERIMENTAL) -# -# CONFIG_IP_SCTP is not set - -# -# TIPC Configuration (EXPERIMENTAL) -# -# CONFIG_TIPC is not set -# CONFIG_ATM is not set -# CONFIG_BRIDGE is not set -# CONFIG_VLAN_8021Q is not set -# CONFIG_DECNET 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_ECONET is not set -# CONFIG_WAN_ROUTER is not set - -# -# QoS and/or fair queueing -# -# CONFIG_NET_SCHED is not set - -# -# Network testing -# -# CONFIG_NET_PKTGEN is not set -# CONFIG_HAMRADIO is not set -# CONFIG_IRDA is not set -CONFIG_BT=m -CONFIG_BT_L2CAP=m -CONFIG_BT_SCO=m -CONFIG_BT_RFCOMM=m -CONFIG_BT_RFCOMM_TTY=y -CONFIG_BT_BNEP=m -CONFIG_BT_BNEP_MC_FILTER=y -CONFIG_BT_BNEP_PROTO_FILTER=y -CONFIG_BT_HIDP=m - -# -# Bluetooth device drivers -# -# CONFIG_BT_HCIUSB is not set -CONFIG_BT_HCIUART=m -CONFIG_BT_HCIUART_H4=y -# CONFIG_BT_HCIUART_BCSP is not set -# CONFIG_BT_HCIBCM203X is not set -# CONFIG_BT_HCIBPA10X is not set -# CONFIG_BT_HCIBFUSB is not set -# CONFIG_BT_HCIVHCI is not set -# CONFIG_IEEE80211 is not set - -# -# Device Drivers -# - -# -# Generic Driver Options -# -CONFIG_STANDALONE=y -CONFIG_PREVENT_FIRMWARE_BUILD=y -CONFIG_FW_LOADER=m -# CONFIG_DEBUG_DRIVER is not set -# CONFIG_SYS_HYPERVISOR is not set - -# -# Connector - unified userspace <-> kernelspace linker -# -CONFIG_CONNECTOR=m - -# -# Memory Technology Devices (MTD) -# -CONFIG_MTD=y -# CONFIG_MTD_DEBUG is not set -CONFIG_MTD_CONCAT=y -CONFIG_MTD_PARTITIONS=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_BLKDEVS=y -CONFIG_MTD_BLOCK=y -# CONFIG_FTL is not set -# CONFIG_NFTL is not set -# CONFIG_INFTL is not set -# CONFIG_RFD_FTL is not set -# CONFIG_SSFDC 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=y -CONFIG_MTD_CFI_NOSWAP=y -# CONFIG_MTD_CFI_BE_BYTE_SWAP is not set -# CONFIG_MTD_CFI_LE_BYTE_SWAP is not set -CONFIG_MTD_CFI_GEOMETRY=y -# CONFIG_MTD_MAP_BANK_WIDTH_1 is not set -CONFIG_MTD_MAP_BANK_WIDTH_2=y -# CONFIG_MTD_MAP_BANK_WIDTH_4 is not set -# CONFIG_MTD_MAP_BANK_WIDTH_8 is not set -# CONFIG_MTD_MAP_BANK_WIDTH_16 is not set -# CONFIG_MTD_MAP_BANK_WIDTH_32 is not set -CONFIG_MTD_CFI_I1=y -# CONFIG_MTD_CFI_I2 is not set -# CONFIG_MTD_CFI_I4 is not set -# CONFIG_MTD_CFI_I8 is not set -# CONFIG_MTD_OTP is not set -CONFIG_MTD_CFI_INTELEXT=y -# CONFIG_MTD_CFI_AMDSTD is not set -# CONFIG_MTD_CFI_STAA is not set -CONFIG_MTD_CFI_UTIL=y -# 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 -CONFIG_MTD_XIP=y - -# -# Mapping drivers for chip access -# -# CONFIG_MTD_COMPLEX_MAPPINGS is not set -# CONFIG_MTD_PHYSMAP is not set -# CONFIG_MTD_ARM_INTEGRATOR is not set -# CONFIG_MTD_SHARP_SL is not set -# CONFIG_MTD_PLATRAM is not set - -# -# Self-contained MTD device drivers -# -# CONFIG_MTD_DATAFLASH is not set -# CONFIG_MTD_M25P80 is not set -# CONFIG_MTD_SLRAM is not set -# CONFIG_MTD_PHRAM is not set -# CONFIG_MTD_MTDRAM is not set -# CONFIG_MTD_BLOCK2MTD is not set - -# -# 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 - -# -# OneNAND Flash Device Drivers -# -# CONFIG_MTD_ONENAND is not set - -# -# Parallel port support -# -# CONFIG_PARPORT is not set - -# -# Plug and Play support -# - -# -# Block devices -# -# CONFIG_BLK_DEV_COW_COMMON is not set -CONFIG_BLK_DEV_LOOP=y -# CONFIG_BLK_DEV_CRYPTOLOOP is not set -# CONFIG_BLK_DEV_NBD is not set -# CONFIG_BLK_DEV_UB is not set -# CONFIG_BLK_DEV_RAM is not set -# CONFIG_BLK_DEV_INITRD is not set -# CONFIG_CDROM_PKTCDVD is not set -# CONFIG_ATA_OVER_ETH is not set - -# -# ATA/ATAPI/MFM/RLL support -# -# CONFIG_IDE is not set - -# -# SCSI device support -# -# CONFIG_RAID_ATTRS is not set -# CONFIG_SCSI is not set -# CONFIG_SCSI_NETLINK is not set - -# -# Serial ATA (prod) and Parallel ATA (experimental) drivers -# -# CONFIG_ATA is not set - -# -# Multi-device support (RAID and LVM) -# -# CONFIG_MD is not set - -# -# Fusion MPT device support -# -# CONFIG_FUSION is not set - -# -# IEEE 1394 (FireWire) support -# - -# -# I2O device support -# - -# -# Network device support -# -CONFIG_NETDEVICES=y -CONFIG_DUMMY=y -# CONFIG_BONDING is not set -# CONFIG_EQUALIZER is not set -# CONFIG_TUN is not set - -# -# PHY device support -# - -# -# Ethernet (10 or 100Mbit) -# -# CONFIG_NET_ETHERNET is not set - -# -# Ethernet (1000 Mbit) -# - -# -# Ethernet (10000 Mbit) -# - -# -# Token Ring devices -# - -# -# Wireless LAN (non-hamradio) -# -# CONFIG_NET_RADIO is not set - -# -# Wan interfaces -# -# CONFIG_WAN is not set -# CONFIG_PPP is not set -# CONFIG_SLIP is not set -# CONFIG_SHAPER is not set -# CONFIG_NETCONSOLE is not set -# CONFIG_NETPOLL is not set -# CONFIG_NET_POLL_CONTROLLER is not set - -# -# ISDN subsystem -# -# CONFIG_ISDN is not set - -# -# Input device support -# -CONFIG_INPUT=y -# CONFIG_INPUT_FF_MEMLESS is not set - -# -# 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=y -CONFIG_INPUT_TSDEV_SCREEN_X=240 -CONFIG_INPUT_TSDEV_SCREEN_Y=320 -CONFIG_INPUT_EVDEV=y -# CONFIG_INPUT_EVBUG is not set - -# -# Input Device Drivers -# -CONFIG_INPUT_KEYBOARD=y -# CONFIG_KEYBOARD_ATKBD is not set -# CONFIG_KEYBOARD_SUNKBD is not set -# CONFIG_KEYBOARD_LKKBD is not set -# CONFIG_KEYBOARD_XTKBD is not set -# CONFIG_KEYBOARD_NEWTON is not set -# CONFIG_KEYBOARD_STOWAWAY is not set -# CONFIG_INPUT_MOUSE is not set -# CONFIG_INPUT_JOYSTICK is not set -CONFIG_INPUT_TOUCHSCREEN=y -# CONFIG_TOUCHSCREEN_ADS7846 is not set -# CONFIG_TOUCHSCREEN_GUNZE is not set -# CONFIG_TOUCHSCREEN_ELO is not set -# CONFIG_TOUCHSCREEN_MTOUCH is not set -# CONFIG_TOUCHSCREEN_MK712 is not set -# CONFIG_TOUCHSCREEN_PENMOUNT is not set -# CONFIG_TOUCHSCREEN_TOUCHRIGHT is not set -# CONFIG_TOUCHSCREEN_TOUCHWIN is not set -# CONFIG_TOUCHSCREEN_UCB1400 is not set -# CONFIG_INPUT_MISC is not set - -# -# Hardware I/O ports -# -CONFIG_SERIO=y -# CONFIG_SERIO_SERPORT is not set -# CONFIG_SERIO_RAW is not set -# CONFIG_GAMEPORT is not set - -# -# Character devices -# -CONFIG_VT=y -CONFIG_VT_CONSOLE=y -CONFIG_HW_CONSOLE=y -# CONFIG_VT_HW_CONSOLE_BINDING is not set -# 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=8 - -# -# IPMI -# -# CONFIG_IPMI_HANDLER is not set - -# -# Watchdog Cards -# -# CONFIG_WATCHDOG is not set -# CONFIG_HW_RANDOM is not set -# CONFIG_NVRAM is not set -# CONFIG_DTLK is not set -# CONFIG_R3964 is not set -# CONFIG_RAW_DRIVER is not set - -# -# TPM devices -# -# CONFIG_TCG_TPM is not set - -# -# I2C support -# -CONFIG_I2C=y -CONFIG_I2C_CHARDEV=y - -# -# I2C Algorithms -# -# CONFIG_I2C_ALGOBIT is not set -# CONFIG_I2C_ALGOPCF is not set -# CONFIG_I2C_ALGOPCA is not set - -# -# I2C Hardware Bus support -# -CONFIG_I2C_PXA=y -# CONFIG_I2C_PXA_SLAVE is not set -# CONFIG_I2C_OCORES is not set -# CONFIG_I2C_PARPORT_LIGHT is not set -# CONFIG_I2C_STUB is not set -# CONFIG_I2C_PCA_ISA is not set - -# -# Miscellaneous I2C Chip support -# -# CONFIG_SENSORS_DS1337 is not set -# CONFIG_SENSORS_DS1374 is not set -# CONFIG_SENSORS_EEPROM is not set -# CONFIG_SENSORS_PCF8574 is not set -# CONFIG_SENSORS_PCA9539 is not set -# CONFIG_SENSORS_PCF8591 is not set -# CONFIG_SENSORS_MAX6875 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 - -# -# SPI support -# -CONFIG_SPI=y -CONFIG_SPI_DEBUG=y -CONFIG_SPI_MASTER=y - -# -# SPI Master Controller Drivers -# -# CONFIG_SPI_BITBANG is not set -CONFIG_SPI_PXA2XX=y - -# -# SPI Protocol Masters -# - -# -# Dallas's 1-wire bus -# -# CONFIG_W1 is not set - -# -# Hardware Monitoring support -# -# CONFIG_HWMON is not set -# CONFIG_HWMON_VID is not set - -# -# Misc devices -# -# CONFIG_TIFM_CORE is not set - -# -# LED devices -# -CONFIG_NEW_LEDS=y -CONFIG_LEDS_CLASS=y - -# -# LED drivers -# - -# -# LED Triggers -# -CONFIG_LEDS_TRIGGERS=y -CONFIG_LEDS_TRIGGER_TIMER=y -CONFIG_LEDS_TRIGGER_HEARTBEAT=y - -# -# Multimedia devices -# -# CONFIG_VIDEO_DEV is not set - -# -# Digital Video Broadcasting Devices -# -# CONFIG_DVB is not set -# CONFIG_USB_DABUSB is not set - -# -# Graphics support -# -# CONFIG_FIRMWARE_EDID is not set -CONFIG_FB=y -CONFIG_FB_CFB_FILLRECT=y -CONFIG_FB_CFB_COPYAREA=y -CONFIG_FB_CFB_IMAGEBLIT=y -# CONFIG_FB_MACMODES is not set -# CONFIG_FB_BACKLIGHT is not set -# CONFIG_FB_MODE_HELPERS is not set -# CONFIG_FB_TILEBLITTING is not set -# CONFIG_FB_S1D13XXX is not set -CONFIG_FB_PXA=y -CONFIG_FB_PXA_PARAMETERS=y -# CONFIG_FB_MBX is not set -# CONFIG_FB_VIRTUAL is not set - -# -# Console display driver support -# -# CONFIG_VGA_CONSOLE is not set -CONFIG_DUMMY_CONSOLE=y -CONFIG_FRAMEBUFFER_CONSOLE=y -# CONFIG_FRAMEBUFFER_CONSOLE_ROTATION is not set -CONFIG_FONTS=y -# CONFIG_FONT_8x8 is not set -# CONFIG_FONT_8x16 is not set -# CONFIG_FONT_6x11 is not set -# CONFIG_FONT_7x14 is not set -# CONFIG_FONT_PEARL_8x8 is not set -# CONFIG_FONT_ACORN_8x8 is not set -CONFIG_FONT_MINI_4x6=y -# CONFIG_FONT_SUN8x16 is not set -# CONFIG_FONT_SUN12x22 is not set -# CONFIG_FONT_10x18 is not set - -# -# Logo configuration -# -# CONFIG_LOGO is not set -# CONFIG_BACKLIGHT_LCD_SUPPORT is not set - -# -# Sound -# -CONFIG_SOUND=y - -# -# Advanced Linux Sound Architecture -# -CONFIG_SND=y -# CONFIG_SND_SEQUENCER is not set -# CONFIG_SND_MIXER_OSS is not set -# CONFIG_SND_PCM_OSS is not set -# CONFIG_SND_DYNAMIC_MINORS is not set -# CONFIG_SND_SUPPORT_OLD_API is not set -# CONFIG_SND_VERBOSE_PROCFS is not set -# CONFIG_SND_VERBOSE_PRINTK is not set -# CONFIG_SND_DEBUG is not set - -# -# Generic devices -# -# CONFIG_SND_DUMMY is not set -# CONFIG_SND_MTPAV is not set -# CONFIG_SND_SERIAL_U16550 is not set -# CONFIG_SND_MPU401 is not set - -# -# ALSA ARM devices -# -# CONFIG_SND_PXA2XX_AC97 is not set - -# -# USB devices -# -# CONFIG_SND_USB_AUDIO is not set - -# -# Open Sound System -# -# CONFIG_SOUND_PRIME is not set - -# -# HID Devices -# -CONFIG_HID=y - -# -# USB support -# -CONFIG_USB_ARCH_HAS_HCD=y -CONFIG_USB_ARCH_HAS_OHCI=y -# CONFIG_USB_ARCH_HAS_EHCI is not set -CONFIG_USB=y -# CONFIG_USB_DEBUG is not set - -# -# Miscellaneous USB options -# -# CONFIG_USB_DEVICEFS is not set -# CONFIG_USB_BANDWIDTH is not set -# CONFIG_USB_DYNAMIC_MINORS is not set -# CONFIG_USB_OTG is not set - -# -# USB Host Controller Drivers -# -# CONFIG_USB_ISP116X_HCD is not set -CONFIG_USB_OHCI_HCD=y -# CONFIG_USB_OHCI_BIG_ENDIAN is not set -CONFIG_USB_OHCI_LITTLE_ENDIAN=y -# CONFIG_USB_SL811_HCD is not set - -# -# USB Device Class drivers -# -# CONFIG_USB_ACM is not set -# CONFIG_USB_PRINTER is not set - -# -# NOTE: USB_STORAGE enables SCSI, and 'SCSI disk support' -# - -# -# may also be needed; see USB_STORAGE Help for more information -# -# CONFIG_USB_LIBUSUAL is not set - -# -# USB Input Devices -# -# CONFIG_USB_HID is not set - -# -# USB HID Boot Protocol drivers -# -# CONFIG_USB_KBD is not set -# CONFIG_USB_MOUSE is not set -# CONFIG_USB_AIPTEK is not set -# CONFIG_USB_WACOM is not set -# CONFIG_USB_ACECAD is not set -# CONFIG_USB_KBTAB is not set -# CONFIG_USB_POWERMATE is not set -# CONFIG_USB_TOUCHSCREEN is not set -# CONFIG_USB_YEALINK is not set -# CONFIG_USB_XPAD is not set -# CONFIG_USB_ATI_REMOTE is not set -# CONFIG_USB_ATI_REMOTE2 is not set -# CONFIG_USB_KEYSPAN_REMOTE is not set -# CONFIG_USB_APPLETOUCH is not set - -# -# USB Imaging devices -# -# CONFIG_USB_MDC800 is not set - -# -# USB Network Adapters -# -# CONFIG_USB_CATC is not set -# CONFIG_USB_KAWETH is not set -# CONFIG_USB_PEGASUS is not set -# CONFIG_USB_RTL8150 is not set -# CONFIG_USB_USBNET_MII is not set -# CONFIG_USB_USBNET is not set -CONFIG_USB_MON=y - -# -# USB port drivers -# - -# -# USB Serial Converter support -# -# CONFIG_USB_SERIAL is not set - -# -# USB Miscellaneous drivers -# -# CONFIG_USB_EMI62 is not set -# CONFIG_USB_EMI26 is not set -# CONFIG_USB_ADUTUX is not set -# CONFIG_USB_AUERSWALD is not set -# CONFIG_USB_RIO500 is not set -# CONFIG_USB_LEGOTOWER is not set -# CONFIG_USB_LCD is not set -# CONFIG_USB_LED is not set -# CONFIG_USB_CYPRESS_CY7C63 is not set -# CONFIG_USB_CYTHERM is not set -# CONFIG_USB_PHIDGET is not set -# CONFIG_USB_IDMOUSE is not set -# CONFIG_USB_FTDI_ELAN is not set -# CONFIG_USB_APPLEDISPLAY is not set -# CONFIG_USB_LD is not set -# CONFIG_USB_TRANCEVIBRATOR is not set - -# -# USB DSL modem support -# - -# -# USB Gadget Support -# -CONFIG_USB_GADGET=y -# CONFIG_USB_GADGET_DEBUG_FILES is not set -CONFIG_USB_GADGET_SELECTED=y -# CONFIG_USB_GADGET_NET2280 is not set -# CONFIG_USB_GADGET_PXA2XX is not set -# CONFIG_USB_GADGET_GOKU is not set -# CONFIG_USB_GADGET_LH7A40X is not set -# CONFIG_USB_GADGET_OMAP is not set -# CONFIG_USB_GADGET_AT91 is not set -CONFIG_USB_GADGET_DUMMY_HCD=y -CONFIG_USB_DUMMY_HCD=y -CONFIG_USB_GADGET_DUALSPEED=y -# CONFIG_USB_ZERO is not set -CONFIG_USB_ETH=y -# CONFIG_USB_ETH_RNDIS is not set -# CONFIG_USB_GADGETFS is not set -# CONFIG_USB_FILE_STORAGE is not set -# CONFIG_USB_G_SERIAL is not set -# CONFIG_USB_MIDI_GADGET is not set - -# -# MMC/SD Card support -# -CONFIG_MMC=y -# CONFIG_MMC_DEBUG is not set -CONFIG_MMC_BLOCK=y -CONFIG_MMC_PXA=y -# CONFIG_MMC_TIFM_SD is not set - -# -# Real Time Clock -# -CONFIG_RTC_LIB=y -CONFIG_RTC_CLASS=y -CONFIG_RTC_HCTOSYS=y -CONFIG_RTC_HCTOSYS_DEVICE="rtc0" -# CONFIG_RTC_DEBUG is not set - -# -# RTC interfaces -# -CONFIG_RTC_INTF_SYSFS=y -CONFIG_RTC_INTF_PROC=y -CONFIG_RTC_INTF_DEV=y -# CONFIG_RTC_INTF_DEV_UIE_EMUL is not set - -# -# RTC drivers -# -# CONFIG_RTC_DRV_X1205 is not set -# CONFIG_RTC_DRV_DS1307 is not set -# CONFIG_RTC_DRV_DS1553 is not set -# CONFIG_RTC_DRV_ISL1208 is not set -# CONFIG_RTC_DRV_DS1672 is not set -# CONFIG_RTC_DRV_DS1742 is not set -# CONFIG_RTC_DRV_PCF8563 is not set -# CONFIG_RTC_DRV_PCF8583 is not set -# CONFIG_RTC_DRV_RS5C348 is not set -# CONFIG_RTC_DRV_RS5C372 is not set -# CONFIG_RTC_DRV_M48T86 is not set -CONFIG_RTC_DRV_SA1100=y -# CONFIG_RTC_DRV_TEST is not set -# CONFIG_RTC_DRV_MAX6902 is not set -# CONFIG_RTC_DRV_V3020 is not set - -# -# File systems -# -CONFIG_EXT2_FS=m -CONFIG_EXT2_FS_XATTR=y -CONFIG_EXT2_FS_POSIX_ACL=y -CONFIG_EXT2_FS_SECURITY=y -# CONFIG_EXT2_FS_XIP is not set -CONFIG_EXT3_FS=y -CONFIG_EXT3_FS_XATTR=y -CONFIG_EXT3_FS_POSIX_ACL=y -CONFIG_EXT3_FS_SECURITY=y -# CONFIG_EXT4DEV_FS is not set -CONFIG_JBD=y -# CONFIG_JBD_DEBUG is not set -CONFIG_FS_MBCACHE=y -CONFIG_REISERFS_FS=m -# CONFIG_REISERFS_CHECK is not set -# CONFIG_REISERFS_PROC_INFO is not set -CONFIG_REISERFS_FS_XATTR=y -CONFIG_REISERFS_FS_POSIX_ACL=y -CONFIG_REISERFS_FS_SECURITY=y -# CONFIG_JFS_FS is not set -CONFIG_FS_POSIX_ACL=y -# CONFIG_XFS_FS is not set -# CONFIG_GFS2_FS is not set -# CONFIG_OCFS2_FS is not set -# CONFIG_MINIX_FS is not set -# CONFIG_ROMFS_FS is not set -CONFIG_INOTIFY=y -CONFIG_INOTIFY_USER=y -# CONFIG_QUOTA is not set -CONFIG_DNOTIFY=y -CONFIG_AUTOFS_FS=y -CONFIG_AUTOFS4_FS=y -# CONFIG_FUSE_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=m -CONFIG_MSDOS_FS=m -CONFIG_VFAT_FS=m -CONFIG_FAT_DEFAULT_CODEPAGE=437 -CONFIG_FAT_DEFAULT_IOCHARSET="iso8859-1" -# CONFIG_NTFS_FS is not set - -# -# Pseudo filesystems -# -CONFIG_PROC_FS=y -CONFIG_PROC_SYSCTL=y -CONFIG_SYSFS=y -CONFIG_TMPFS=y -# CONFIG_TMPFS_POSIX_ACL is not set -# CONFIG_HUGETLB_PAGE is not set -CONFIG_RAMFS=y -# CONFIG_CONFIGFS_FS is not set - -# -# 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_JFFS2_FS 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=y -# CONFIG_NFS_V3_ACL is not set -# CONFIG_NFS_V4 is not set -# CONFIG_NFS_DIRECTIO is not set -CONFIG_NFSD=m -CONFIG_NFSD_V3=y -# CONFIG_NFSD_V3_ACL is not set -# CONFIG_NFSD_V4 is not set -CONFIG_NFSD_TCP=y -# CONFIG_ROOT_NFS is not set -CONFIG_LOCKD=y -CONFIG_LOCKD_V4=y -CONFIG_EXPORTFS=m -CONFIG_NFS_COMMON=y -CONFIG_SUNRPC=y -# CONFIG_RPCSEC_GSS_KRB5 is not set -# CONFIG_RPCSEC_GSS_SPKM3 is not set -CONFIG_SMB_FS=m -# CONFIG_SMB_NLS_DEFAULT is not set -# CONFIG_CIFS is not set -# CONFIG_NCP_FS is not set -# CONFIG_CODA_FS is not set -# CONFIG_AFS_FS is not set -# CONFIG_9P_FS is not set - -# -# Partition Types -# -# CONFIG_PARTITION_ADVANCED is not set -CONFIG_MSDOS_PARTITION=y - -# -# Native Language Support -# -CONFIG_NLS=y -CONFIG_NLS_DEFAULT="iso8859-1" -CONFIG_NLS_CODEPAGE_437=m -CONFIG_NLS_CODEPAGE_737=m -CONFIG_NLS_CODEPAGE_775=m -CONFIG_NLS_CODEPAGE_850=m -CONFIG_NLS_CODEPAGE_852=m -CONFIG_NLS_CODEPAGE_855=m -CONFIG_NLS_CODEPAGE_857=m -CONFIG_NLS_CODEPAGE_860=m -CONFIG_NLS_CODEPAGE_861=m -CONFIG_NLS_CODEPAGE_862=m -CONFIG_NLS_CODEPAGE_863=m -CONFIG_NLS_CODEPAGE_864=m -CONFIG_NLS_CODEPAGE_865=m -CONFIG_NLS_CODEPAGE_866=m -CONFIG_NLS_CODEPAGE_869=m -CONFIG_NLS_CODEPAGE_936=m -CONFIG_NLS_CODEPAGE_950=m -CONFIG_NLS_CODEPAGE_932=m -CONFIG_NLS_CODEPAGE_949=m -CONFIG_NLS_CODEPAGE_874=m -CONFIG_NLS_ISO8859_8=m -CONFIG_NLS_CODEPAGE_1250=m -CONFIG_NLS_CODEPAGE_1251=m -CONFIG_NLS_ASCII=m -CONFIG_NLS_ISO8859_1=m -CONFIG_NLS_ISO8859_2=m -CONFIG_NLS_ISO8859_3=m -CONFIG_NLS_ISO8859_4=m -CONFIG_NLS_ISO8859_5=m -CONFIG_NLS_ISO8859_6=m -CONFIG_NLS_ISO8859_7=m -CONFIG_NLS_ISO8859_9=m -CONFIG_NLS_ISO8859_13=m -CONFIG_NLS_ISO8859_14=m -CONFIG_NLS_ISO8859_15=m -CONFIG_NLS_KOI8_R=m -CONFIG_NLS_KOI8_U=m -CONFIG_NLS_UTF8=m - -# -# Distributed Lock Manager -# -# CONFIG_DLM is not set - -# -# Profiling support -# -# CONFIG_PROFILING is not set - -# -# Kernel hacking -# -# CONFIG_PRINTK_TIME is not set -# CONFIG_ENABLE_MUST_CHECK is not set -# CONFIG_MAGIC_SYSRQ is not set -# CONFIG_UNUSED_SYMBOLS is not set -# CONFIG_DEBUG_FS is not set -# CONFIG_HEADERS_CHECK is not set -CONFIG_DEBUG_KERNEL=y -CONFIG_LOG_BUF_SHIFT=16 -CONFIG_DETECT_SOFTLOCKUP=y -# CONFIG_SCHEDSTATS is not set -# CONFIG_DEBUG_SLAB is not set -CONFIG_DEBUG_RT_MUTEXES=y -CONFIG_DEBUG_PI_LIST=y -# CONFIG_RT_MUTEX_TESTER is not set -CONFIG_DEBUG_SPINLOCK=y -CONFIG_DEBUG_MUTEXES=y -CONFIG_DEBUG_RWSEMS=y -CONFIG_DEBUG_SPINLOCK_SLEEP=y -# CONFIG_DEBUG_LOCKING_API_SELFTESTS is not set -# CONFIG_DEBUG_KOBJECT is not set -CONFIG_DEBUG_BUGVERBOSE=y -# CONFIG_DEBUG_INFO is not set -# CONFIG_DEBUG_VM is not set -# CONFIG_DEBUG_LIST is not set -CONFIG_FRAME_POINTER=y -CONFIG_FORCED_INLINING=y -# CONFIG_RCU_TORTURE_TEST is not set -# CONFIG_DEBUG_USER is not set -CONFIG_DEBUG_ERRORS=y -# CONFIG_DEBUG_LL is not set - -# -# Security options -# -# CONFIG_KEYS is not set -# CONFIG_SECURITY is not set - -# -# Cryptographic options -# -# CONFIG_CRYPTO is not set - -# -# Library routines -# -CONFIG_BITREVERSE=y -CONFIG_CRC_CCITT=y -CONFIG_CRC16=m -CONFIG_CRC32=y -CONFIG_LIBCRC32C=m -CONFIG_ZLIB_INFLATE=y -CONFIG_PLIST=y -CONFIG_IOMAP_COPY=y diff --git a/packages/linux/linux-ezx-2.6.20.7/ezx-core.patch b/packages/linux/linux-ezx-2.6.20.7/ezx-core.patch deleted file mode 100644 index 3b9877ce83..0000000000 --- a/packages/linux/linux-ezx-2.6.20.7/ezx-core.patch +++ /dev/null @@ -1,1120 +0,0 @@ -Index: linux-2.6.20.7/arch/arm/boot/compressed/head-xscale.S -=================================================================== ---- linux-2.6.20.7.orig/arch/arm/boot/compressed/head-xscale.S 2007-04-21 22:31:54.000000000 -0300 -+++ linux-2.6.20.7/arch/arm/boot/compressed/head-xscale.S 2007-04-21 22:32:53.000000000 -0300 -@@ -53,3 +53,6 @@ - str r1, [r0, #0x18] - #endif - -+#ifdef CONFIG_ARCH_EZX -+ mov r7, #MACH_TYPE_EZX -+#endif -Index: linux-2.6.20.7/arch/arm/mach-pxa/Kconfig -=================================================================== ---- linux-2.6.20.7.orig/arch/arm/mach-pxa/Kconfig 2007-04-21 22:31:54.000000000 -0300 -+++ linux-2.6.20.7/arch/arm/mach-pxa/Kconfig 2007-04-22 01:33:15.000000000 -0300 -@@ -37,6 +37,10 @@ - bool "Keith und Koep Trizeps4 DIMM-Module" - select PXA27x - -+config PXA_EZX -+ bool "Motorola EZX Platform" -+ select PXA_SSP -+ - endchoice - - if PXA_SHARPSL -@@ -71,6 +75,27 @@ - - endif - -+if PXA_EZX -+ -+choice -+ prompt "Select target EZX device" -+ -+config PXA_EZX_E680 -+ bool "Motorola E680 GSM Phone" -+ select PXA27x -+ -+config PXA_EZX_A780 -+ bool "Motorola A780 GSM Phone" -+ select PXA27x -+ -+config PXA_EZX_E2 -+ bool "Motorola E2 GSM Phone" -+ select PXA27x -+ -+endchoice -+ -+endif -+ - endmenu - - config MACH_POODLE -@@ -144,4 +169,5 @@ - tristate - help - Enable support for PXA2xx SSP ports -+ - endif -Index: linux-2.6.20.7/arch/arm/mach-pxa/Makefile -=================================================================== ---- linux-2.6.20.7.orig/arch/arm/mach-pxa/Makefile 2007-04-21 22:31:54.000000000 -0300 -+++ linux-2.6.20.7/arch/arm/mach-pxa/Makefile 2007-04-22 01:33:17.000000000 -0300 -@@ -18,6 +18,7 @@ - obj-$(CONFIG_MACH_AKITA) += akita-ioexp.o - obj-$(CONFIG_MACH_POODLE) += poodle.o corgi_ssp.o - obj-$(CONFIG_MACH_TOSA) += tosa.o -+obj-$(CONFIG_PXA_EZX) += ezx.o ezx_lcd.o ezx_ssp.o - - # Support for blinky lights - led-y := leds.o -Index: linux-2.6.20.7/arch/arm/mach-pxa/ezx.c -=================================================================== ---- /dev/null 1970-01-01 00:00:00.000000000 +0000 -+++ linux-2.6.20.7/arch/arm/mach-pxa/ezx.c 2007-04-22 01:33:17.000000000 -0300 -@@ -0,0 +1,379 @@ -+/* -+ * linux/arch/arm/mach-ezx/a780.c -+ * -+ * Support for the Motorola Ezx A780 Development Platform. -+ * -+ * Author: Zhuang Xiaofan -+ * Created: Nov 25, 2003 -+ * Copyright: Motorola 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. -+ */ -+ -+#include <linux/init.h> -+#include <linux/major.h> -+#include <linux/fs.h> -+#include <linux/interrupt.h> -+#include <linux/sched.h> -+#include <linux/bitops.h> -+#include <linux/apm_bios.h> -+#include <linux/platform_device.h> -+#include <linux/input.h> -+ -+#include <asm/types.h> -+#include <asm/setup.h> -+#include <asm/memory.h> -+#include <asm/mach-types.h> -+#include <asm/hardware.h> -+#include <asm/irq.h> -+ -+#include <asm/mach/arch.h> -+#include <asm/mach/map.h> -+#include <asm/mach/irq.h> -+ -+#include <asm/arch/ohci.h> -+#include <asm/arch/pxa-regs.h> -+ -+#include "ezx.h" -+#include "generic.h" -+#include <linux/tty.h> -+#include <linux/apm_bios.h> -+ -+ -+extern void usb_send_readurb(void); -+extern int ezx_ssp_set_machinfo(struct ezxssp_machinfo *); -+//FIXME extern void pm_do_poweroff(void); -+ -+/* BP Handshake */ -+#define FIRST_STEP 2 -+#define LAST_STEP 3 -+#define BP_RDY_TIMEOUT 0x000c0000 -+ -+/* check power down condition */ -+inline void check_power_off(void) -+{ -+ if (!(GPIO_is_high(GPIO_BB_WDI2))) { -+#ifdef CONFIG_PM -+//FIXME pm_do_poweroff(); -+#endif -+ } -+} -+ -+/* SSP */ -+struct platform_device ezxssp_device = { -+ .name = "ezx-ssp", -+ .id = -1, -+}; -+ -+struct ezxssp_machinfo ezx_ssp_machinfo = { -+ .port = 1, -+ .cs_pcap = GPIO_SPI_CE, -+ .clk_pcap = 1, -+}; -+ -+ -+/* OHCI Controller */ -+ -+static int ezx_ohci_init(struct device *dev) -+{ -+ /* for A780 support (connected with Neptune) */ -+ pxa_gpio_mode(GPIO30_USB_P3_2); /* GPIO30 - USB_P3_2/ICL_TXENB */ -+ pxa_gpio_mode(GPIO31_USB_P3_6); /* GPIO31 - USB_P3_6/ICL_VPOUT */ -+ pxa_gpio_mode(GPIO90_USB_P3_5); /* GPIO90 - USB_P3_5/ICL_VPIN */ -+ pxa_gpio_mode(GPIO91_USB_P3_1); /* GPIO91 - USB_P3_1/ICL_XRXD */ -+ pxa_gpio_mode(GPIO56_USB_P3_4); /* GPIO56 - USB_P3_4/ICL_VMOUT */ -+ pxa_gpio_mode(GPIO113_USB_P3_3);/* GPIO113 - USB_P3_3/ICL_VMIN */ -+ UP3OCR = 0x00000002; -+ -+ UHCHR = UHCHR & ~(UHCHR_SSEP2 | UHCHR_SSEP3 | UHCHR_SSE); -+ -+ return 0; -+} -+ -+static struct pxaohci_platform_data ezx_ohci_platform_data = { -+ .port_mode = PMM_NPS_MODE, -+ .init = ezx_ohci_init, -+}; -+ -+static int step = FIRST_STEP; -+void handshake(void) -+{ -+ /* step 1: check MCU_INT_SW or BP_RDY is low (now it is checked in apboot) */ -+ if (step == 1) { -+ int timeout = BP_RDY_TIMEOUT; -+ -+ /* config MCU_INT_SW, BP_RDY as input */ -+ GPDR(GPIO_MCU_INT_SW) &= ~GPIO_bit(GPIO_MCU_INT_SW); -+ GPDR(GPIO_BP_RDY) &= ~GPIO_bit(GPIO_BP_RDY); -+ -+ while ( timeout -- ) { -+ if ( (!(GPIO_is_high(GPIO_MCU_INT_SW))) -+ || (!(GPIO_is_high(GPIO_BP_RDY))) ) { -+ step ++; -+ break; -+ } -+ -+ check_power_off(); -+ } -+ } -+ -+ /* step 2: wait BP_RDY is low */ -+ if (step == 2) { -+ if (!(GPIO_is_high(GPIO_BP_RDY))) { -+ -+ /* config MCU_INT_SW as output */ -+ pxa_gpio_mode(GPIO_MCU_INT_SW | GPIO_OUT); -+ clr_GPIO(GPIO_MCU_INT_SW); -+ -+ step ++; -+ } -+ } -+ -+ /* step 3: wait BP_RDY is high */ -+ if (step == 3) { -+ if (GPIO_is_high(GPIO_BP_RDY)) { -+ step ++; -+ //FIXME delay_bklight(); -+ set_GPIO(GPIO_MCU_INT_SW); -+ } -+ } -+} -+ -+#ifdef CONFIG_APM -+static unsigned long idle_limit = 0; -+int pm_handle_irq(int irq) -+{ -+ -+ //FIXME: extern unsigned long idle_limit; -+ //FIXME: extern int can_idle, can_sleep; -+ static unsigned long tmp_jiffy; /* for temporary store of jiffies */ -+ -+ /* -+ * if idle_limit is zero, never enter idle. -+ * if not OS timer, reset idle timer count -+ */ -+ if (idle_limit == 0) { -+ tmp_jiffy = jiffies; -+ return irq; -+ } -+#if 0 -+ if (irq != IRQ_OST0) { -+ tmp_jiffy = jiffies; -+ can_idle = 0; -+ can_sleep = 0; -+ } else if (jiffies > tmp_jiffy + idle_limit) { -+ -+ /* -+ * I think this is enough to prevent from reentering here -+ * due to jiffies will be stoped -+ */ -+ tmp_jiffy = jiffies; -+ -+ /* if pm idle timer expired, queue event */ -+ apm_queue_event(KRNL_PROC_INACT); -+ can_idle = 1; -+ } -+#endif -+ -+ return irq; -+} -+ -+irqreturn_t bp_wdi_intr(int irq, void *dev_id) -+{ -+//FIXME apm_queue_event(KRNL_BP_WDI); -+ return IRQ_HANDLED; -+} -+ -+static struct irqaction bp_wdi_irq = { -+ .name = "BP wdi", -+ .handler = &bp_wdi_intr, -+}; -+#endif -+ -+int handshake_pass(void) -+{ -+ return (step > LAST_STEP); -+} -+ -+static irqreturn_t bp_rdy_intr(int irq, void *dev_id) -+{ -+ static int usbipc_ready = 0; -+ -+ if (!usbipc_ready) { -+ handshake(); -+ if (handshake_pass()) { -+ disable_irq(IRQ_GPIO(GPIO_BB_WDI2)); -+ -+ /* set bp_rdy handle for usb ipc */ -+ set_irq_type(GPIO_BP_RDY, IRQT_FALLING); -+ usbipc_ready = 1; -+ } -+ } else -+ // FIXME usb_send_readurb(); -+ {} -+ -+ return IRQ_HANDLED; -+} -+ -+static struct irqaction bp_rdy_irq = { -+ .name = "BP rdy", -+ .handler = bp_rdy_intr, -+}; -+ -+static irqreturn_t bp_wdi2_intr(int irq, void *dev_id) -+{ -+#ifdef CONFIG_PM -+//FIXME pm_do_poweroff(); -+#endif -+ return IRQ_HANDLED; -+} -+ -+static struct irqaction bp_wdi2_irq = { -+ .name = "BP wdi2", -+ .handler = bp_wdi2_intr, -+}; -+ -+ -+static struct resource ezx_bp_resources[] = { -+ [0] = { -+ .start = GPIO_BP_RDY, -+ .end = GPIO_BP_RDY, -+ .flags = IORESOURCE_IRQ, -+ }, -+ [1] = { -+ .start = GPIO_BB_WDI2, -+ .end = GPIO_BB_WDI2, -+ .flags = IORESOURCE_IRQ, -+ }, -+#ifdef CONFIG_APM -+ [2] = { -+ .start = GPIO_BB_WDI, -+ .end = GPIO_BB_WDI, -+ .flags = IORESOURCE_IRQ, -+ }, -+#endif -+}; -+ -+static struct platform_device ezx_bp_device = { -+ .name = "ezx-bp", -+ .dev = { -+ //.parent = -+ //.platform_data = -+ }, -+ .id = -1, -+ .num_resources = ARRAY_SIZE(ezx_bp_resources), -+ .resource = ezx_bp_resources, -+}; -+ -+static void __init ezx_init_gpio_irq(void) -+{ -+#ifdef CONFIG_APM -+ set_irq_type(GPIO_BB_WDI, IRQT_FALLING); -+ setup_irq(IRQ_GPIO(GPIO_BB_WDI), &bp_wdi_irq); -+#endif -+ set_irq_type(GPIO_BP_RDY, IRQT_BOTHEDGE); -+ setup_irq(IRQ_GPIO(GPIO_BP_RDY), &bp_rdy_irq); -+ -+ set_irq_type(GPIO_BB_WDI2, IRQT_FALLING); -+ setup_irq(IRQ_GPIO(GPIO_BB_WDI2), &bp_wdi2_irq); -+} -+ -+static void __init a780_init_irq(void) -+{ -+ pxa_init_irq(); -+ -+ /* init ezx specfic gpio irq */ -+ ezx_init_gpio_irq(); -+ -+ check_power_off(); -+ handshake(); -+ if (handshake_pass()) { -+ disable_irq(IRQ_GPIO(GPIO_BP_RDY)); -+ disable_irq(IRQ_GPIO(GPIO_BB_WDI2)); -+ } -+} -+ -+static struct platform_device *devices[] __initdata = { -+ &ezxssp_device, -+ &ezx_bp_device, -+}; -+ -+static void __init a780_init(void) -+{ -+//FIXME CKEN = CKEN9_OSTIMER | CKEN22_MEMC | CKEN5_STUART; -+ -+ ezx_ssp_set_machinfo(&ezx_ssp_machinfo); -+ -+ /* set BB_RESET PIN out put high */ -+ pxa_gpio_mode(GPIO_BB_RESET|GPIO_OUT); -+ set_GPIO(GPIO_BB_RESET); -+ -+ pxa_gpio_mode(GPIO_ICL_FFRXD_MD); -+ pxa_gpio_mode(GPIO_ICL_FFTXD_MD); -+ pxa_gpio_mode(GPIO_ICL_FFCTS_MD); -+ pxa_gpio_mode(GPIO_ICL_FFRTS_MD); -+ -+ pxa_gpio_mode(GPIO42_BTRXD_MD); -+ pxa_gpio_mode(GPIO43_BTTXD_MD); -+ pxa_gpio_mode(GPIO44_BTCTS_MD); -+ pxa_gpio_mode(GPIO45_BTRTS_MD); -+ -+ /* clear EMU MUX1/MUX2 (low) to close the audio path to EMU */ -+ pxa_gpio_mode(GPIO_EMU_MUX1|GPIO_OUT); -+ clr_GPIO(GPIO_EMU_MUX1); -+ pxa_gpio_mode(GPIO_EMU_MUX2|GPIO_OUT); -+ clr_GPIO(GPIO_EMU_MUX2); -+ -+#if defined(CONFIG_PXA_EZX_E680) -+ pxa_gpio_mode(GPIO46_STRXD_MD); -+ pxa_gpio_mode(GPIO47_STTXD_MD); -+ -+ /* setup sleep mode values */ -+ PWER = 0xc000f803; // disable usb 0xdc00f803; -+ PFER = 0x0000f803; -+ PRER = 0x00001802; -+ // keypad wakeup (PKWR,PGSR3) should be in keypad.c -+ PGSR0 = 0x00000010; -+ PGSR1 = 0x02800000; -+ PGSR2 = 0x00040000; -+ PGSR3 = 0x00000000; -+ PCFR = PCFR_DC_EN | PCFR_FS | PCFR_FP | PCFR_OPDE; -+ PSLR = 0x05800f00; -+ -+#elif defined(CONFIG_PXA_EZX_A780) -+ -+ /* Standard UART */ -+ pxa_gpio_mode(GPIO46_STRXD_MD); -+ pxa_gpio_mode(GPIO47_STTXD_MD); -+ -+ /* setup sleep mode values */ -+ PWER = 0xc0007803; // disable usb, GPIO15 NC -+ PFER = 0x00007803; -+ PRER = 0x00001802; -+ // keypad wakeup (PKWR,PGSR3) should be in keypad.c -+ PGSR0 = 0x00000010; -+ PGSR1 = 0x02800000; -+ PGSR2 = 0x00040000; -+ PGSR3 = 0x00000008; -+ PCFR = PCFR_DC_EN | PCFR_FS | PCFR_FP | PCFR_OPDE; -+ PSLR = 0x05800f00; -+ -+#endif -+ pxa_set_ohci_info(&ezx_ohci_platform_data); -+ -+ platform_add_devices(devices, ARRAY_SIZE(devices)); -+ -+} -+ -+MACHINE_START(EZX, "Motorola Ezx Platform") -+ /* Maintainer: Harald Welte <laforge@gnumonks.org> */ -+ .phys_io = 0x40000000, -+ .io_pg_offst = (io_p2v(0x40000000) >> 18) & 0xfffc, -+ .boot_params = 0xa0000100, -+ .map_io = pxa_map_io, -+ .init_irq = a780_init_irq, -+ .timer = &pxa_timer, -+ .init_machine = a780_init, -+MACHINE_END -Index: linux-2.6.20.7/include/asm-arm/arch-pxa/ezx.h -=================================================================== ---- /dev/null 1970-01-01 00:00:00.000000000 +0000 -+++ linux-2.6.20.7/include/asm-arm/arch-pxa/ezx.h 2007-04-21 22:32:53.000000000 -0300 -@@ -0,0 +1,225 @@ -+/* -+ * linux/include/asm-arm/arch-pxa/ezx.h -+ * -+ * Specific macro defines for Motorola Ezx Development Platform -+ * -+ * Author: Zhuang Xiaofan -+ * Created: Nov 25, 2003 -+ * Copyright: Motorola 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. -+ */ -+ -+/* support E680 p3 and ealier PCB */ -+//#define E680_P3_AND_EARLY -+ -+#define GPIO_is_high(x) (GPLR(x) & GPIO_bit(x)) -+#define set_GPIO(x) (GPSR(x) = GPIO_bit(x)) -+#define clr_GPIO(x) (GPCR(x) = GPIO_bit(x)) -+ -+/* -+ * Flags in memory for sleep use -+ */ -+#define FLAG_ADDR PHYS_OFFSET -+#define RESUME_ADDR (PHYS_OFFSET + 4) -+#define BPSIG_ADDR (PHYS_OFFSET + 8) -+ -+#define USER_OFF_FLAG 0x5a5a5a5a -+#define SLEEP_FLAG 0x6b6b6b6b -+#define OFF_FLAG 0x7c7c7c7c -+#define REFLASH_FLAG 0x0C1D2E3F -+#define PASS_THRU_FLAG 0x12345678 -+ -+#define WDI_FLAG 0xbb00dead -+#define NO_FLAG 0xaa00dead -+ -+/* -+ * GPIO control pin, have to change when hardware lock down -+ */ -+ -+#ifdef E680_P3_AND_EARLY -+ -+/* shakehand with BP's PIN */ -+#define GPIO_BP_RDY 0 /* BP_RDY */ -+#define GPIO_BB_WDI 13 /* BB_WDI */ -+#define GPIO_BB_WDI2 3 /* BB_WDI2 */ -+#define GPIO_BB_RESET 57 /* BB_RESET */ -+#define GPIO_MCU_INT_SW 115 /* MCU_INT_SW */ -+#define GPIO_TC_MM_EN 89 /* TC_MM_EN */ -+ -+/* control PCAP direct PIN */ -+#define GPIO_WDI_AP 4 /* WDI_AP */ -+#define GPIO_SYS_RESTART 55 /* restart PCAP power */ -+#define GPIO_AP_STANDBY 28 /* make pcap enter standby mode */ -+ -+/* communicate with PCAP's PIN */ -+#define GPIO_PCAP_SEC_INT 1 /* PCAP interrupt PIN to AP */ -+#define GPIO_SPI_CLK 23 /* PCAP SPI port clock */ -+#define GPIO_SPI_CE 24 /* PCAP SPI port SSPFRM */ -+#define GPIO_SPI_MOSI 25 /* PCAP SPI port SSPTXD */ -+#define GPIO_SPI_MISO 26 /* PCAP SPI port SSPRXD */ -+ -+/* blue tooth control PIN */ -+#define GPIO_BT_WAKEUP 2 /* AP wake up bluetooth module */ -+#define GPIO_BT_HOSTWAKE 14 /* bluetooth module wake up Ap module */ -+#define GPIO_BT_RESET 56 /* AP reset bluetooth module */ -+ -+/* control LCD high - OFF low -- ON */ -+#define GPIO_LCD_OFF 116 /* control LCD */ -+ -+/* FFUART PIN */ -+#define GPIO_ICL_FFRXD_MD (34 | GPIO_ALT_FN_1_IN) -+#define GPIO_ICL_FFCTS_MD (35 | GPIO_ALT_FN_1_IN) -+#define GPIO_ICL_FFTXD_MD (39 | GPIO_ALT_FN_2_OUT) -+#define GPIO_ICL_FFRTS_MD (41 | GPIO_ALT_FN_2_OUT) -+ -+#elif defined(A780_P1_AND_EARLY) -+ -+/* shakehand with BP's PIN */ -+#define GPIO_BP_RDY 0 /* BP_RDY */ -+#define GPIO_BB_WDI 13 /* BB_WDI */ -+#define GPIO_BB_WDI2 3 /* BB_WDI2 */ -+#define GPIO_BB_RESET 82 /* BB_RESET */ -+#define GPIO_MCU_INT_SW 57 /* MCU_INT_SW */ -+#define GPIO_TC_MM_EN 89 /* TC_MM_EN */ -+ -+/* control PCAP direct PIN */ -+#define GPIO_WDI_AP 4 /* WDI_AP */ -+#define GPIO_SYS_RESTART 55 /* restart PCAP power */ -+#define GPIO_AP_STANDBY 28 /* make pcap enter standby mode */ -+ -+/* communicate with PCAP's PIN */ -+#define GPIO_PCAP_SEC_INT 1 /* PCAP interrupt PIN to AP */ -+#define GPIO_SPI_CLK 29 /* PCAP SPI port clock */ -+#define GPIO_SPI_CE 24 /* PCAP SPI port SSPFRM */ -+#define GPIO_SPI_MOSI 25 /* PCAP SPI port SSPTXD */ -+#define GPIO_SPI_MISO 26 /* PCAP SPI port SSPRXD */ -+ -+/* blue tooth control PIN */ -+#define GPIO_BT_WAKEUP 2 /* AP wake up bluetooth module */ -+#define GPIO_BT_HOSTWAKE 14 /* bluetooth module wake up Ap module */ -+#define GPIO_BT_RESET 56 /* AP reset bluetooth module */ -+ -+/* control LCD high - OFF low -- ON */ -+#define GPIO_LCD_OFF 116 /* control LCD */ -+ -+/* FFUART PIN */ -+#define GPIO_ICL_FFRXD_MD (53 | GPIO_ALT_FN_1_IN) -+#define GPIO_ICL_FFCTS_MD (35 | GPIO_ALT_FN_1_IN) -+#define GPIO_ICL_FFTXD_MD (39 | GPIO_ALT_FN_2_OUT) -+#define GPIO_ICL_FFRTS_MD (41 | GPIO_ALT_FN_2_OUT) -+ -+#else -+ -+/* shakehand with BP's PIN */ -+#define GPIO_BP_RDY 0 /* BP_RDY */ -+#define GPIO_BB_WDI 13 /* BB_WDI */ -+#define GPIO_BB_WDI2 3 /* BB_WDI2 */ -+#define GPIO_BB_RESET 82 /* BB_RESET */ -+#define GPIO_MCU_INT_SW 57 /* MCU_INT_SW */ -+#define GPIO_TC_MM_EN 99 /* TC_MM_EN */ -+ -+/* control PCAP direct PIN */ -+#define GPIO_WDI_AP 4 /* WDI_AP */ -+#define GPIO_SYS_RESTART 55 /* restart PCAP power */ -+//#define GPIO_AP_STANDBY 28 /* make pcap enter standby mode */ -+ -+/* communicate with PCAP's PIN */ -+#define GPIO_PCAP_SEC_INT 1 /* PCAP interrupt PIN to AP */ -+#define GPIO_SPI_CLK 29 /* PCAP SPI port clock */ -+#define GPIO_SPI_CE 24 /* PCAP SPI port SSPFRM */ -+#define GPIO_SPI_MOSI 25 /* PCAP SPI port SSPTXD */ -+#define GPIO_SPI_MISO 26 /* PCAP SPI port SSPRXD */ -+ -+/* blue tooth control PIN */ -+#define GPIO_BT_WAKEUP 28 /* AP wake up bluetooth module */ -+#define GPIO_BT_HOSTWAKE 14 /* AP wake up bluetooth module */ -+#define GPIO_BT_RESET 48 /* AP reset bluetooth module */ -+ -+/* control LCD high - OFF low -- ON */ -+#define GPIO_LCD_OFF 116 /* control LCD */ -+ -+/* FFUART PIN */ -+#define GPIO_ICL_FFRXD_MD (53 | GPIO_ALT_FN_1_IN) -+#define GPIO_ICL_FFCTS_MD (35 | GPIO_ALT_FN_1_IN) -+#define GPIO_ICL_FFTXD_MD (39 | GPIO_ALT_FN_2_OUT) -+#define GPIO_ICL_FFRTS_MD (41 | GPIO_ALT_FN_2_OUT) -+ -+#endif -+/* -+ * ezx platform, wake up source edge detect bit -+ */ -+#define PEDR_INT_SEC 1 -+ -+#define GPIO_FLIP_PIN 12 -+/*E680 screen lock button*/ -+ -+#define GPIO_LOCK_SCREEN_PIN GPIO_FLIP_PIN -+ -+/* MMC interface */ -+#define GPIO_MMC_DETECT 11 -+#define GPIO_MMC_CLK 32 -+#define GPIO_MMC_DATA0 92 -+#define GPIO_MMC_WP 107 -+#define GPIO_MMC_DATA1 109 -+#define GPIO_MMC_DATA2 110 -+#define GPIO_MMC_DATA3 111 -+#define GPIO_MMC_CMD 112 -+ -+/* interface function */ -+#define GPIO_MMC_CLK_MD (GPIO_MMC_CLK | GPIO_ALT_FN_2_OUT) -+#define GPIO_MMC_DATA0_MD (GPIO_MMC_DATA0 | GPIO_ALT_FN_1_IN | GPIO_ALT_FN_1_OUT) -+#define GPIO_MMC_DATA1_MD (GPIO_MMC_DATA1 | GPIO_ALT_FN_1_IN | GPIO_ALT_FN_1_OUT) -+#define GPIO_MMC_DATA2_MD (GPIO_MMC_DATA2 | GPIO_ALT_FN_1_IN | GPIO_ALT_FN_1_OUT) -+#define GPIO_MMC_DATA3_MD (GPIO_MMC_DATA3 | GPIO_ALT_FN_1_IN | GPIO_ALT_FN_1_OUT) -+ -+#define GPIO_MMC_CMD_MD (GPIO_MMC_CMD | GPIO_ALT_FN_1_IN | GPIO_ALT_FN_1_OUT) -+ -+/* EMU GPIO 119 ---MUX2 120 --- MUX1 */ -+#define GPIO_EMU_MUX1 120 -+#define GPIO_EMU_MUX2 119 -+#define GPIO_SNP_INT_CTL 86 -+#define GPIO_SNP_INT_IN 87 -+ -+ -+/* audio related pins */ -+#define AP_13MHZ_OUTPUT_PIN 9 -+ -+#ifdef CONFIG_ARCH_EZX_E680 -+#define GPIO_VA_SEL_BUL 79 -+#define GPIO_FLT_SEL_BUL 80 /* out filter select pin */ -+#define GPIO_MIDI_RESET 78 /* GPIO used by MIDI chipset */ -+#define GPIO_MIDI_CS 33 -+#define GPIO_MIDI_IRQ 15 -+#define GPIO_MIDI_NPWE 49 -+#define GPIO_MIDI_RDY 18 -+#endif -+ -+#ifdef CONFIG_ARCH_EZX_A780 -+#define GPIO_HW_ATTENUATE_A780 96 /* hw noise attenuation be used or bypassed, for receiver or louderspeaker mode */ -+#endif -+ -+ -+/* bp status pin */ -+#define GPIO_BP_STATE 41 -+ -+/* define usb related pin */ -+#define GPIO34_TXENB 34 -+#define GPIO35_XRXD 35 -+#define GPIO36_VMOUT 36 -+#define GPIO39_VPOUT 39 -+#define GPIO40_VPIN 40 -+#define GPIO53_VMIN 53 -+ -+/* USB client 6 pin defination */ -+#define GPIO34_TXENB_MD (GPIO34_TXENB | GPIO_ALT_FN_1_OUT) -+#define GPIO35_XRXD_MD (GPIO35_XRXD | GPIO_ALT_FN_2_IN ) -+#define GPIO36_VMOUT_MD (GPIO36_VMOUT | GPIO_ALT_FN_1_OUT) -+#define GPIO39_VPOUT_MD (GPIO39_VPOUT | GPIO_ALT_FN_1_OUT) -+#define GPIO40_VPIN_MD (GPIO40_VPIN | GPIO_ALT_FN_3_IN ) -+#define GPIO53_VMIN_MD (GPIO53_VMIN | GPIO_ALT_FN_2_IN ) -+ -+#define GPIO53_FFRXD_MD (53 | GPIO_ALT_FN_1_IN) -+ -Index: linux-2.6.20.7/include/asm-arm/arch-pxa/pxa-regs.h -=================================================================== ---- linux-2.6.20.7.orig/include/asm/arch/pxa-regs.h 2007-04-21 22:31:54.000000000 -0300 -+++ linux-2.6.20.7/include/asm-arm/arch-pxa/pxa-regs.h 2007-04-21 22:32:53.000000000 -0300 -@@ -854,6 +854,8 @@ - #define UP2OCR_HXOE (1 << 17) /* Host Port 2 Transceiver Output Enable */ - #define UP2OCR_SEOS (1 << 24) /* Single-Ended Output Select */ - -+#define UP3OCR __REG(0x40600024) /* USB Port 3 Output Control register */ -+ - #define UDCCSN(x) __REG2(0x40600100, (x) << 2) - #define UDCCSR0 __REG(0x40600100) /* UDC Control/Status register - Endpoint 0 */ - #define UDCCSR0_SA (1 << 7) /* Setup Active */ -@@ -1257,6 +1259,7 @@ - #define GPIO33_nCS_5 33 /* chip select 5 */ - #define GPIO34_FFRXD 34 /* FFUART receive */ - #define GPIO34_MMCCS0 34 /* MMC Chip Select 0 */ -+#define GPIO34_USB_P2_2 34 /* USB Port2 Pin 2 */ - #define GPIO35_FFCTS 35 /* FFUART Clear to send */ - #define GPIO36_FFDCD 36 /* FFUART Data carrier detect */ - #define GPIO37_FFDSR 37 /* FFUART data set ready */ -@@ -1370,6 +1373,7 @@ - #define GPIO18_RDY_MD (18 | GPIO_ALT_FN_1_IN) - #define GPIO19_DREQ1_MD (19 | GPIO_ALT_FN_1_IN) - #define GPIO20_DREQ0_MD (20 | GPIO_ALT_FN_1_IN) -+#define GPIO22_SCLK2_MD (22 | GPIO_ALT_FN_3_IN) - #define GPIO23_SCLK_MD (23 | GPIO_ALT_FN_2_OUT) - #define GPIO24_SFRM_MD (24 | GPIO_ALT_FN_2_OUT) - #define GPIO25_STXD_MD (25 | GPIO_ALT_FN_2_OUT) -@@ -1380,23 +1384,33 @@ - #define GPIO28_BITCLK_OUT_I2S_MD (28 | GPIO_ALT_FN_1_OUT) - #define GPIO29_SDATA_IN_AC97_MD (29 | GPIO_ALT_FN_1_IN) - #define GPIO29_SDATA_IN_I2S_MD (29 | GPIO_ALT_FN_2_IN) -+#define GPIO29_SCLK_MD (29 | GPIO_ALT_FN_3_IN) - #define GPIO30_SDATA_OUT_AC97_MD (30 | GPIO_ALT_FN_2_OUT) - #define GPIO30_SDATA_OUT_I2S_MD (30 | GPIO_ALT_FN_1_OUT) -+#define GPIO30_USB_P3_2 (30 | GPIO_ALT_FN_3_OUT) - #define GPIO31_SYNC_I2S_MD (31 | GPIO_ALT_FN_1_OUT) - #define GPIO31_SYNC_AC97_MD (31 | GPIO_ALT_FN_2_OUT) -+#define GPIO31_USB_P3_6 (31 | GPIO_ALT_FN_3_OUT) - #define GPIO32_SDATA_IN1_AC97_MD (32 | GPIO_ALT_FN_1_IN) - #define GPIO32_SYSCLK_I2S_MD (32 | GPIO_ALT_FN_1_OUT) - #define GPIO32_MMCCLK_MD ( 32 | GPIO_ALT_FN_2_OUT) - #define GPIO33_nCS_5_MD (33 | GPIO_ALT_FN_2_OUT) - #define GPIO34_FFRXD_MD (34 | GPIO_ALT_FN_1_IN) - #define GPIO34_MMCCS0_MD (34 | GPIO_ALT_FN_2_OUT) -+#define GPIO34_USB_P2_2_MD (34 | GPIO_ALT_FN_1_OUT) - #define GPIO35_FFCTS_MD (35 | GPIO_ALT_FN_1_IN) -+#define GPIO35_USB_P2_1_MD (35 | GPIO_ALT_FN_2_IN) - #define GPIO36_FFDCD_MD (36 | GPIO_ALT_FN_1_IN) -+#define GPIO36_USB_P2_4_MD (36 | GPIO_ALT_FN_1_OUT) - #define GPIO37_FFDSR_MD (37 | GPIO_ALT_FN_1_IN) -+#define GPIO37_SFRM2_MD (37 | GPIO_ALT_FN_2_IN) - #define GPIO38_FFRI_MD (38 | GPIO_ALT_FN_1_IN) -+#define GPIO38_STXD2_MD (38 | GPIO_ALT_FN_2_OUT) - #define GPIO39_MMCCS1_MD (39 | GPIO_ALT_FN_1_OUT) - #define GPIO39_FFTXD_MD (39 | GPIO_ALT_FN_2_OUT) -+#define GPIO39_USB_P2_6_MD (39 | GPIO_ALT_FN_1_OUT) - #define GPIO40_FFDTR_MD (40 | GPIO_ALT_FN_2_OUT) -+#define GPIO40_USB_P2_5_MD (40 | GPIO_ALT_FN_3_IN) - #define GPIO41_FFRTS_MD (41 | GPIO_ALT_FN_2_OUT) - #define GPIO42_BTRXD_MD (42 | GPIO_ALT_FN_1_IN) - #define GPIO42_HWRXD_MD (42 | GPIO_ALT_FN_3_IN) -@@ -1421,13 +1435,17 @@ - #define GPIO51_HWRTS_MD (51 | GPIO_ALT_FN_1_OUT) - #define GPIO51_nPIOW_MD (51 | GPIO_ALT_FN_2_OUT) - #define GPIO52_nPCE_1_MD (52 | GPIO_ALT_FN_2_OUT) -+#define GPIO52_SCLK3_MD (52 | GPIO_ALT_FN_2_OUT) - #define GPIO53_nPCE_2_MD (53 | GPIO_ALT_FN_2_OUT) - #define GPIO53_MMCCLK_MD (53 | GPIO_ALT_FN_1_OUT) -+#define GPIO53_FFRXD_MD (53 | GPIO_ALT_FN_1_IN) -+#define GPIO53_USB_P2_3_MD (53 | GPIO_ALT_FN_2_IN) - #define GPIO54_MMCCLK_MD (54 | GPIO_ALT_FN_1_OUT) - #define GPIO54_nPCE_2_MD (54 | GPIO_ALT_FN_2_OUT) - #define GPIO54_pSKTSEL_MD (54 | GPIO_ALT_FN_2_OUT) - #define GPIO55_nPREG_MD (55 | GPIO_ALT_FN_2_OUT) - #define GPIO56_nPWAIT_MD (56 | GPIO_ALT_FN_1_IN) -+#define GPIO56_USB_P3_4 (56 | GPIO_ALT_FN_1_OUT) - #define GPIO57_nIOIS16_MD (57 | GPIO_ALT_FN_1_IN) - #define GPIO58_LDD_0_MD (58 | GPIO_ALT_FN_2_OUT) - #define GPIO59_LDD_1_MD (59 | GPIO_ALT_FN_2_OUT) -@@ -1463,13 +1481,19 @@ - #define GPIO80_nCS_4_MD (80 | GPIO_ALT_FN_2_OUT) - #define GPIO81_NSSP_CLK_OUT (81 | GPIO_ALT_FN_1_OUT) - #define GPIO81_NSSP_CLK_IN (81 | GPIO_ALT_FN_1_IN) -+#define GPIO81_STXD3_MD (81 | GPIO_ALT_FN_1_OUT) - #define GPIO82_NSSP_FRM_OUT (82 | GPIO_ALT_FN_1_OUT) - #define GPIO82_NSSP_FRM_IN (82 | GPIO_ALT_FN_1_IN) - #define GPIO83_NSSP_TX (83 | GPIO_ALT_FN_1_OUT) - #define GPIO83_NSSP_RX (83 | GPIO_ALT_FN_2_IN) -+#define GPIO83_SFRM3_MD (83 | GPIO_ALT_FN_1_IN) - #define GPIO84_NSSP_TX (84 | GPIO_ALT_FN_1_OUT) - #define GPIO84_NSSP_RX (84 | GPIO_ALT_FN_2_IN) - #define GPIO85_nPCE_1_MD (85 | GPIO_ALT_FN_1_OUT) -+#define GPIO88_SRXD2_MD (88 | GPIO_ALT_FN_2_IN) -+#define GPIO89_SRXD3_MD (89 | GPIO_ALT_FN_1_IN) -+#define GPIO90_USB_P3_5 (90 | GPIO_ALT_FN_2_IN) -+#define GPIO91_USB_P3_1 (91 | GPIO_ALT_FN_2_IN) - #define GPIO92_MMCDAT0_MD (92 | GPIO_ALT_FN_1_OUT) - #define GPIO102_nPCE_1_MD (102 | GPIO_ALT_FN_1_OUT) - #define GPIO104_pSKTSEL_MD (104 | GPIO_ALT_FN_1_OUT) -@@ -1481,6 +1505,7 @@ - #define GPIO112_MMCCMD_MD (112 | GPIO_ALT_FN_1_OUT) - #define GPIO113_I2S_SYSCLK_MD (113 | GPIO_ALT_FN_1_OUT) - #define GPIO113_AC97_RESET_N_MD (113 | GPIO_ALT_FN_2_OUT) -+#define GPIO113_USB_P3_3 (113 | GPIO_ALT_FN_3_IN) - #define GPIO117_I2CSCL_MD (117 | GPIO_ALT_FN_1_OUT) - #define GPIO118_I2CSDA_MD (118 | GPIO_ALT_FN_1_IN) - -@@ -1496,6 +1521,7 @@ - #define PFER __REG(0x40F00014) /* Power Manager GPIO Falling-Edge Detect Enable Register */ - #define PEDR __REG(0x40F00018) /* Power Manager GPIO Edge Detect Status Register */ - #define PCFR __REG(0x40F0001C) /* Power Manager General Configuration Register */ -+#define PGSR(x) (__REG(0x40F00020 + ((unsigned long)(x)/32*4))) - #define PGSR0 __REG(0x40F00020) /* Power Manager GPIO Sleep State Register for GP[31-0] */ - #define PGSR1 __REG(0x40F00024) /* Power Manager GPIO Sleep State Register for GP[63-32] */ - #define PGSR2 __REG(0x40F00028) /* Power Manager GPIO Sleep State Register for GP[84-64] */ -Index: linux-2.6.20.7/arch/arm/boot/compressed/head.S -=================================================================== ---- linux-2.6.20.7.orig/arch/arm/boot/compressed/head.S 2007-04-21 22:31:54.000000000 -0300 -+++ linux-2.6.20.7/arch/arm/boot/compressed/head.S 2007-04-21 22:32:53.000000000 -0300 -@@ -117,6 +117,9 @@ - mov r0, r0 - .endr - -+ mov r1, #0x300 @ mach_id 0x363 is official EZX -+ orr r1, r1, #0x63 @ bootloader JUMP doesn't set r1 -+ - b 1f - .word 0x016f2818 @ Magic numbers to help the loader - .word start @ absolute load/run zImage address -Index: linux-2.6.20.7/include/asm-arm/arch-pxa/uncompress.h -=================================================================== ---- linux-2.6.20.7.orig/include/asm-arm/arch-pxa/uncompress.h 2007-04-21 22:31:54.000000000 -0300 -+++ linux-2.6.20.7/include/asm-arm/arch-pxa/uncompress.h 2007-04-21 22:32:53.000000000 -0300 -@@ -14,14 +14,14 @@ - #define STUART ((volatile unsigned long *)0x40700000) - #define HWUART ((volatile unsigned long *)0x41600000) - --#define UART FFUART -+#define UART STUART - - - static inline void putc(char c) - { -- while (!(UART[5] & 0x20)) -+/* while (!(UART[5] & 0x40)) - barrier(); -- UART[0] = c; -+ UART[0] = c;*/ - } - - /* -Index: linux-2.6.20.7/arch/arm/mach-pxa/ezx_ssp.c -=================================================================== ---- /dev/null 1970-01-01 00:00:00.000000000 +0000 -+++ linux-2.6.20.7/arch/arm/mach-pxa/ezx_ssp.c 2007-04-22 01:36:48.000000000 -0300 -@@ -0,0 +1,130 @@ -+/* -+ * SSP control code for Motorola EZX phones -+ * -+ * Copyright (c) 2007 Daniel Ribeiro <drwyrm@gmail.com> -+ * -+ * 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/kernel.h> -+#include <linux/sched.h> -+#include <linux/slab.h> -+#include <linux/delay.h> -+#include <linux/platform_device.h> -+#include <asm/hardware.h> -+#include <asm/mach-types.h> -+ -+#include <asm/arch/ssp.h> -+#include <asm/arch/pxa-regs.h> -+ -+#include "ezx.h" -+ -+static DEFINE_SPINLOCK(ezx_ssp_lock); -+static struct ssp_dev ezx_ssp_dev; -+static struct ssp_state ezx_ssp_state; -+static struct ezxssp_machinfo *ssp_machinfo; -+ -+/* PCAP */ -+unsigned long ezx_ssp_pcap_putget(ulong data) -+{ -+ unsigned long flag; -+ u32 ret = 0; -+ -+ spin_lock_irqsave(&ezx_ssp_lock, flag); -+ if (ssp_machinfo->cs_pcap >= 0) -+ GPCR(ssp_machinfo->cs_pcap) = GPIO_bit(ssp_machinfo->cs_pcap); -+ -+ ssp_write_word(&ezx_ssp_dev,data); -+ ssp_read_word(&ezx_ssp_dev, &ret); -+ -+ if (ssp_machinfo->cs_pcap >= 0) -+ GPSR(ssp_machinfo->cs_pcap) = GPIO_bit(ssp_machinfo->cs_pcap); -+ spin_unlock_irqrestore(&ezx_ssp_lock, flag); -+ -+ return ret; -+} -+EXPORT_SYMBOL(ezx_ssp_pcap_putget); -+ -+/* ASSP */ -+ -+/* NSSP */ -+ -+void __init ezx_ssp_set_machinfo(struct ezxssp_machinfo *machinfo) -+{ -+ ssp_machinfo = machinfo; -+} -+ -+static int __init ezx_ssp_probe(struct platform_device *dev) -+{ -+ int ret; -+ /* PCAP init */ -+ pxa_gpio_mode(29|GPIO_ALT_FN_3_OUT); -+ pxa_gpio_mode(GPIO24_SFRM_MD); -+ pxa_gpio_mode(GPIO25_STXD_MD); -+ pxa_gpio_mode(GPIO26_SRXD_MD); -+ -+ /* Chip Select - Disable All */ -+ if (ssp_machinfo->cs_pcap >= 0) -+ pxa_gpio_mode(ssp_machinfo->cs_pcap | GPIO_OUT | GPIO_DFLT_HIGH); -+ -+ ret = ssp_init(&ezx_ssp_dev, ssp_machinfo->port, 0); -+ -+ if (ret) -+ printk(KERN_ERR "Unable to register SSP handler!\n"); -+ else { -+ ssp_disable(&ezx_ssp_dev); -+ ssp_config(&ezx_ssp_dev, -+ (SSCR0_Motorola | SSCR0_DataSize(16) | SSCR0_EDSS), -+ (SSCR1_TxTresh(1) | SSCR1_RxTresh(1)), -+ 0, SSCR0_SerClkDiv(ssp_machinfo->clk_pcap)); -+ ssp_enable(&ezx_ssp_dev); -+ } -+ -+ return ret; -+} -+ -+static int ezx_ssp_remove(struct platform_device *dev) -+{ -+ ssp_exit(&ezx_ssp_dev); -+ return 0; -+} -+ -+static int ezx_ssp_suspend(struct platform_device *dev, pm_message_t state) -+{ -+ ssp_flush(&ezx_ssp_dev); -+ ssp_save_state(&ezx_ssp_dev,&ezx_ssp_state); -+ -+ return 0; -+} -+ -+static int ezx_ssp_resume(struct platform_device *dev) -+{ -+ if (ssp_machinfo->cs_pcap >= 0) -+ GPSR(ssp_machinfo->cs_pcap) = GPIO_bit(ssp_machinfo->cs_pcap); -+ ssp_restore_state(&ezx_ssp_dev,&ezx_ssp_state); -+ ssp_enable(&ezx_ssp_dev); -+ -+ return 0; -+} -+ -+static struct platform_driver ezxssp_driver = { -+ .probe = ezx_ssp_probe, -+ .remove = ezx_ssp_remove, -+ .suspend = ezx_ssp_suspend, -+ .resume = ezx_ssp_resume, -+ .driver = { -+ .name = "ezx-ssp", -+ }, -+}; -+ -+int __init ezx_ssp_init(void) -+{ -+ return platform_driver_register(&ezxssp_driver); -+} -+ -+arch_initcall(ezx_ssp_init); -Index: linux-2.6.20.7/arch/arm/mach-pxa/ezx.h -=================================================================== ---- /dev/null 1970-01-01 00:00:00.000000000 +0000 -+++ linux-2.6.20.7/arch/arm/mach-pxa/ezx.h 2007-04-22 01:38:55.000000000 -0300 -@@ -0,0 +1,9 @@ -+#include <asm/arch/ezx.h> -+ -+/* SSP */ -+struct ezxssp_machinfo { -+ int port; -+ int cs_pcap; -+ int clk_pcap; -+}; -+ -Index: linux-2.6.20.7/arch/arm/mach-pxa/ezx_lcd.c -=================================================================== ---- /dev/null 1970-01-01 00:00:00.000000000 +0000 -+++ linux-2.6.20.7/arch/arm/mach-pxa/ezx_lcd.c 2007-04-21 22:32:53.000000000 -0300 -@@ -0,0 +1,112 @@ -+/* -+ * linux/arch/arm/mach-ezx/a780.c -+ * -+ * Support for the Motorola Ezx A780 Development Platform. -+ * -+ * Author: Zhuang Xiaofan -+ * Created: Nov 25, 2003 -+ * Copyright: Motorola 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. -+ */ -+ -+#include <linux/fb.h> -+#include <linux/delay.h> -+#include <asm/arch/pxafb.h> -+#include <asm/arch/pxa-regs.h> -+ -+/* -+ * EZX PXA Framebuffer -+ */ -+ -+static void pxafb_lcd_power(int on, struct fb_var_screeninfo *var) -+{ -+ if (on) { -+// mdelay(1); -+ GPSR3 = 0x00100000; -+ mdelay(10); -+ GPCR3 = 0x00100000; -+ GPDR3 |= 0x00100000; -+ } else { -+ GPSR3 = 0x00100000; -+ PGSR3 |= 0x00100000; -+ mdelay(41); -+ LCCR0 &= ~LCCR0_LDM; /* disable lcd disable done interrupt */ -+ LCCR0 |= LCCR0_DIS; /* normal disable lcd */ -+ mdelay(18); -+ } -+} -+ -+#ifdef CONFIG_PXA_E2 -+static void sumatra_backlight_power(int on) -+{ -+ if (on) { -+ pxa_gpio_mode(GPIO16_PWM0_MD); -+ pxa_set_cken(CKEN0_PWM0, 1); -+ PWM_CTRL0 = 0; -+ PWM_PWDUTY0 = 0x3ff; -+ PWM_PERVAL0 = 0x3ff; -+ } else { -+ PWM_CTRL0 = 0; -+ PWM_PWDUTY0 = 0x0; -+ PWM_PERVAL0 = 0x3FF; -+ pxa_set_cken(CKEN0_PWM0, 0); -+ } -+} -+ -+static struct pxafb_mode_info mode_ezx = { -+ .pixclock = 192308, -+ .xres = 240, -+ .yres = 320, -+ .bpp = 8, -+ .hsync_len = 10, -+ .left_margin = 20, -+ .right_margin = 10, -+ .vsync_len = 2, -+ .upper_margin = 3, -+ .lower_margin = 2, -+ .sync = FB_SYNC_HOR_HIGH_ACT | FB_SYNC_VERT_HIGH_ACT, -+}; -+ -+static struct pxafb_mach_info ezx_fb_info __initdata = { -+ .modes = &mode_ezx, -+ .num_modes = 1, -+ .lccr0 = 0x022008B8, -+ .lccr3 = 0xC130FF13, -+ .pxafb_backlight_power = sumatra_backlight_power, -+ .pxafb_lcd_power = &pxafb_lcd_power, -+}; -+ -+#else -+static struct pxafb_mode_info mode_ezx = { -+ .pixclock = 150000, -+ .xres = 240, -+ .yres = 320, -+ .bpp = 16, -+ .hsync_len = 10, -+ .left_margin = 20, -+ .right_margin = 10, -+ .vsync_len = 2, -+ .upper_margin = 3, -+ .lower_margin = 2, -+ .sync = FB_SYNC_HOR_HIGH_ACT | FB_SYNC_VERT_HIGH_ACT, -+}; -+ -+static struct pxafb_mach_info ezx_fb_info __initdata = { -+ .modes = &mode_ezx, -+ .num_modes = 1, -+ .lccr0 = 0x002008F8, -+ .lccr3 = 0x0430FF09, -+ .pxafb_lcd_power= &pxafb_lcd_power, -+}; -+#endif -+ -+int __init __ezx_lcd_init (void) -+{ -+ set_pxa_fb_info(&ezx_fb_info); -+ return 0; -+} -+ -+arch_initcall(__ezx_lcd_init); -Index: linux-2.6.20.7/arch/arm/mm/init.c -=================================================================== ---- linux-2.6.20.7.orig/arch/arm/mm/init.c 2007-04-21 22:32:57.000000000 -0300 -+++ linux-2.6.20.7/arch/arm/mm/init.c 2007-04-21 22:44:03.000000000 -0300 -@@ -241,6 +241,10 @@ - */ - reserve_bootmem_node(pgdat, boot_pfn << PAGE_SHIFT, - boot_pages << PAGE_SHIFT); -+#ifdef CONFIG_ARCH_EZX -+ /* reserve the first page memory for exiting sleep and user off */ -+ reserve_bootmem_node(pgdat, PHYS_OFFSET, PAGE_SIZE); -+#endif - - #ifdef CONFIG_BLK_DEV_INITRD - /* diff --git a/packages/linux/linux-ezx-2.6.20.7/ezx-emu.patch b/packages/linux/linux-ezx-2.6.20.7/ezx-emu.patch deleted file mode 100644 index de9de60461..0000000000 --- a/packages/linux/linux-ezx-2.6.20.7/ezx-emu.patch +++ /dev/null @@ -1,332 +0,0 @@ -Index: linux-2.6.20.7/arch/arm/mach-pxa/ezx-emu.c -=================================================================== ---- /dev/null 1970-01-01 00:00:00.000000000 +0000 -+++ linux-2.6.20.7/arch/arm/mach-pxa/ezx-emu.c 2007-04-21 12:33:22.000000000 -0300 -@@ -0,0 +1,215 @@ -+/* -+ * EMU Driver for Motorola EZX phones -+ * -+ * Copyright (c) 2007 Daniel Ribeiro <drwyrm@gmail.com> -+ * -+ * 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/kernel.h> -+#include <linux/interrupt.h> -+#include <linux/module.h> -+#include <linux/platform_device.h> -+ -+#include <asm/arch/hardware.h> -+#include <asm/arch/pxa-regs.h> -+#include <asm/arch/ezx.h> -+#include <asm/arch/ezx-pcap.h> -+#include <asm/arch/udc.h> -+ -+static struct pxa2xx_udc_mach_info ezx_udc_info; -+extern int ezx_pcap_bit_set(u_int32_t, u_int8_t); -+extern int ezx_pcap_read_bit(u_int32_t); -+ -+void emu_switch_to_usb(void) -+{ -+ pxa_gpio_mode(GPIO34_USB_P2_2_MD); -+ pxa_gpio_mode(GPIO35_USB_P2_1_MD); -+ pxa_gpio_mode(GPIO36_USB_P2_4_MD); -+ pxa_gpio_mode(GPIO39_USB_P2_6_MD); -+ pxa_gpio_mode(GPIO40_USB_P2_5_MD); -+ pxa_gpio_mode(GPIO53_USB_P2_3_MD); -+ UP2OCR = 0x02000000; -+ ezx_pcap_bit_set(SSP_PCAP_ADJ_BIT_BUSCTRL_RS232ENB, 1); -+ ezx_pcap_bit_set(SSP_PCAP_ADJ_BIT_BUSCTRL_FSENB, 0); -+ ezx_pcap_bit_set(SSP_PCAP_ADJ_BIT_BUSCTRL_VUSB_EN, 1); -+ clr_GPIO(GPIO_EMU_MUX1); -+ clr_GPIO(GPIO_EMU_MUX2); -+} -+EXPORT_SYMBOL(emu_switch_to_usb); -+ -+void emu_switch_to_uart(void) -+{ -+ ezx_pcap_bit_set(SSP_PCAP_ADJ_BIT_BUSCTRL_VUSB_EN,0); -+ ezx_pcap_bit_set(SSP_PCAP_ADJ_BIT_BUSCTRL_RS232ENB, 0); -+ ezx_pcap_bit_set(SSP_PCAP_ADJ_BIT_BUSCTRL_RS232_DIR, 1); -+ set_GPIO(GPIO39_FFTXD); -+ pxa_gpio_mode(GPIO34_TXENB | GPIO_OUT); -+ set_GPIO(GPIO34_TXENB); -+ pxa_gpio_mode(GPIO35_XRXD | GPIO_IN); -+ pxa_gpio_mode(GPIO36_VMOUT | GPIO_IN); -+ pxa_gpio_mode(GPIO40_VPIN | GPIO_IN); -+ pxa_gpio_mode(GPIO39_FFTXD_MD); -+ pxa_gpio_mode(GPIO53_FFRXD_MD); -+ CKEN |= CKEN6_FFUART; -+ clr_GPIO(GPIO_EMU_MUX1); -+ clr_GPIO(GPIO_EMU_MUX2); -+ -+} -+EXPORT_SYMBOL(emu_switch_to_uart); -+ -+void emu_switch_to_audio(int stereo) -+{ -+ clr_GPIO(GPIO39_VPOUT); -+ if (stereo) { -+ pxa_gpio_mode(GPIO34_USB_P2_2 | GPIO_IN); -+ clr_GPIO(GPIO39_VPOUT); -+ } else { -+ pxa_gpio_mode(GPIO34_TXENB | GPIO_OUT); -+ set_GPIO(GPIO34_TXENB); -+ } -+ -+ pxa_gpio_mode(GPIO35_XRXD | GPIO_IN); -+ pxa_gpio_mode(GPIO36_VMOUT | GPIO_IN); -+ pxa_gpio_mode(GPIO39_VPOUT | GPIO_IN); -+ pxa_gpio_mode(GPIO40_VPIN | GPIO_IN); -+ pxa_gpio_mode(GPIO53_VMIN | GPIO_IN); -+ set_GPIO(GPIO_EMU_MUX1); -+ if (stereo) -+ set_GPIO(GPIO_EMU_MUX2); -+ else -+ clr_GPIO(GPIO_EMU_MUX2); -+} -+ -+void emu_switch_to_nothing(void) -+{ -+ ezx_pcap_bit_set(SSP_PCAP_ADJ_BIT_BUSCTRL_VUSB_EN, 0); -+ ezx_pcap_bit_set(SSP_PCAP_ADJ_BIT_BUSCTRL_RS232ENB, 1); -+ pxa_gpio_mode(GPIO34_TXENB | GPIO_OUT); -+ set_GPIO(GPIO34_TXENB); -+ pxa_gpio_mode(GPIO35_XRXD | GPIO_IN); -+ pxa_gpio_mode(GPIO36_VMOUT | GPIO_IN); -+ pxa_gpio_mode(GPIO39_VPOUT | GPIO_IN); -+ pxa_gpio_mode(GPIO40_VPIN | GPIO_IN); -+ pxa_gpio_mode(GPIO53_VMIN | GPIO_IN); -+} -+ -+ -+static irqreturn_t emu_irq(int irq, void *data) -+{ -+ printk("emu_irq(%u) entered: ", irq); -+ -+ switch (irq) { -+ case EZX_IRQ_USB4V: -+ printk("usb 4v\n"); -+ if(ezx_pcap_read_bit(SSP_PCAP_ADJ_BIT_PSTAT_USBDET_4V)) -+#if defined CONFIG_PXA_EZX_EMU_USB -+ emu_switch_to_usb(); -+#elif defined CONFIG_PXA_EZX_EMU_UART -+ emu_switch_to_uart(); -+#else -+ emu_switch_to_nothing(); -+#endif -+ else -+ emu_switch_to_nothing(); -+ break; -+ case EZX_IRQ_USB1V: -+ printk("usb 1v\n"); -+ break; -+ default: -+ printk("unknown\n"); -+ break; -+ } -+ -+ return IRQ_HANDLED; -+} -+ -+static int __init ezx_emu_probe(struct platform_device *dev) -+{ -+ printk("ezx_emu_probe entered!\n"); -+ pxa_gpio_mode(GPIO_SNP_INT_IN | GPIO_IN); -+ pxa_gpio_mode(GPIO_EMU_MUX1 | GPIO_OUT); -+ pxa_gpio_mode(GPIO_EMU_MUX2 | GPIO_OUT); -+ -+ request_irq(EZX_IRQ_USB4V, &emu_irq, SA_INTERRUPT, "usb 4v", NULL); -+ request_irq(EZX_IRQ_USB1V, &emu_irq, SA_INTERRUPT, "usb 1v", NULL); -+ -+ pxa_set_udc_info(&ezx_udc_info); -+ -+#if defined CONFIG_PXA_EZX_EMU_USB -+ emu_switch_to_usb(); -+#elif defined CONFIG_PXA_EZX_EMU_UART -+ emu_switch_to_uart(); -+#else -+ emu_switch_to_nothing(); -+#endif -+ -+ return 0; -+} -+ -+static int ezx_emu_remove(struct platform_device *dev) -+{ -+ free_irq(EZX_IRQ_USB4V, NULL); -+ free_irq(EZX_IRQ_USB1V, NULL); -+ -+ return 0; -+} -+ -+/* USB Device Controller */ -+static int udc_connected_status; -+static void ezx_udc_command(int cmd) -+{ -+ switch (cmd) { -+ case PXA2XX_UDC_CMD_DISCONNECT: -+ printk(KERN_NOTICE "USB cmd disconnect\n"); -+ ezx_pcap_bit_set(SSP_PCAP_ADJ_BIT_BUSCTRL_USB_PU,0); -+ udc_connected_status = 0; -+ break; -+ case PXA2XX_UDC_CMD_CONNECT: -+ printk(KERN_NOTICE "USB cmd connect\n"); -+ ezx_pcap_bit_set(SSP_PCAP_ADJ_BIT_BUSCTRL_USB_PU,1); -+ udc_connected_status = 1; -+ break; -+ } -+} -+ -+static int ezx_udc_is_connected(void) -+{ -+ return udc_connected_status; -+} -+ -+static struct pxa2xx_udc_mach_info ezx_udc_info __initdata = { -+ .udc_is_connected = ezx_udc_is_connected, -+ .udc_command = ezx_udc_command, -+}; -+ -+static struct platform_driver ezxemu_driver = { -+ .probe = ezx_emu_probe, -+ .remove = ezx_emu_remove, -+ //.suspend = ezx_emu_suspend, -+ //.resume = ezx_emu_resume, -+ .driver = { -+ .name = "ezx-emu", -+ .owner = THIS_MODULE, -+ }, -+}; -+ -+int __init ezx_emu_init(void) -+{ -+ return platform_driver_register(&ezxemu_driver); -+} -+ -+void ezx_emu_fini(void) -+{ -+ return platform_driver_unregister(&ezxemu_driver); -+} -+ -+module_init(ezx_emu_init); -+module_exit(ezx_emu_fini); -+ -+MODULE_DESCRIPTION("Motorola Enchanced Mini Usb driver"); -+MODULE_AUTHOR("Daniel Ribeiro <drwyrm@gmail.com>"); -+MODULE_LICENSE("GPL"); -Index: linux-2.6.20.7/arch/arm/mach-pxa/Kconfig -=================================================================== ---- linux-2.6.20.7.orig/arch/arm/mach-pxa/Kconfig 2007-04-21 12:32:50.000000000 -0300 -+++ linux-2.6.20.7/arch/arm/mach-pxa/Kconfig 2007-04-21 12:32:54.000000000 -0300 -@@ -94,6 +94,27 @@ - - endchoice - -+config PXA_EZX_EMU -+ bool "Motorola Enchanced Mini Usb" -+ -+if PXA_EZX_EMU -+ -+choice -+ prompt "Select default EMU mode" -+ -+config PXA_EZX_EMU_USB -+ bool "USB" -+ -+config PXA_EZX_EMU_UART -+ bool "UART" -+ -+config PXA_EZX_EMU_NOTHING -+ bool "nothing" -+ -+endchoice -+ -+endif -+ - endif - - endmenu -Index: linux-2.6.20.7/arch/arm/mach-pxa/Makefile -=================================================================== ---- linux-2.6.20.7.orig/arch/arm/mach-pxa/Makefile 2007-04-21 12:32:50.000000000 -0300 -+++ linux-2.6.20.7/arch/arm/mach-pxa/Makefile 2007-04-21 12:32:54.000000000 -0300 -@@ -19,6 +19,7 @@ - obj-$(CONFIG_MACH_POODLE) += poodle.o corgi_ssp.o - obj-$(CONFIG_MACH_TOSA) += tosa.o - obj-$(CONFIG_PXA_EZX) += ezx.o ezx_lcd.o ezx_ssp.o ezx-pcap.o ezx-mci.o -+obj-$(CONFIG_PXA_EZX_EMU) += ezx-emu.o - - # Support for blinky lights - led-y := leds.o -Index: linux-2.6.20.7/arch/arm/mach-pxa/ezx.c -=================================================================== ---- linux-2.6.20.7.orig/arch/arm/mach-pxa/ezx.c 2007-04-21 12:32:50.000000000 -0300 -+++ linux-2.6.20.7/arch/arm/mach-pxa/ezx.c 2007-04-21 12:32:54.000000000 -0300 -@@ -36,6 +36,7 @@ - #include <asm/arch/ohci.h> - #include <asm/arch/pxa-regs.h> - -+ - #include "ezx.h" - #include "generic.h" - #include <linux/tty.h> -@@ -92,6 +93,30 @@ - .resource = ezxpcap_resources, - }; - -+/* EMU */ -+static struct resource ezxemu_resources[] = { -+ [0] = { -+ .start = EZX_IRQ_USB4V, -+ .end = EZX_IRQ_USB4V, -+ .flags = IORESOURCE_IRQ, -+ }, -+ [1] = { -+ .start = EZX_IRQ_USB1V, -+ .end = EZX_IRQ_USB1V, -+ .flags = IORESOURCE_IRQ, -+ }, -+}; -+ -+struct platform_device ezxemu_device = { -+ .name = "ezx-emu", -+ .id = -1, -+// .dev = { -+// .parent = &ezxpcap_device.dev, -+// }, -+ .num_resources = ARRAY_SIZE(ezxemu_resources), -+ .resource = ezxemu_resources, -+}; -+ - /* OHCI Controller */ - - static int ezx_ohci_init(struct device *dev) -@@ -317,6 +342,7 @@ - &ezxssp_device, - &ezxpcap_device, - &ezxbp_device, -+ &ezxemu_device, - }; - - static void __init a780_init(void) -@@ -383,7 +409,15 @@ - pxa_set_ohci_info(&ezx_ohci_platform_data); - - platform_add_devices(devices, ARRAY_SIZE(devices)); -- -+/* -+#if defined CONFIG_PXA_EZX_EMU_USB -+ emu_switch_to_usb(); -+#elif defined CONFIG_PXA_EZX_EMU_UART -+ emu_switch_to_uart(); -+#else -+ emu_switch_to_nothing(); -+#endif -+*/ - } - - MACHINE_START(EZX, "Motorola Ezx Platform") diff --git a/packages/linux/linux-ezx-2.6.20.7/ezx-fix-usb_pxa27x_udc-r3.patch b/packages/linux/linux-ezx-2.6.20.7/ezx-fix-usb_pxa27x_udc-r3.patch deleted file mode 100644 index c3cbf25a09..0000000000 --- a/packages/linux/linux-ezx-2.6.20.7/ezx-fix-usb_pxa27x_udc-r3.patch +++ /dev/null @@ -1,16 +0,0 @@ -Index: linux-2.6.20.7/drivers/usb/gadget/pxa27x_udc.c -=================================================================== ---- linux-2.6.20.7.orig/drivers/usb/gadget/pxa27x_udc.c 2007-04-21 12:30:51.000000000 -0300 -+++ linux-2.6.20.7/drivers/usb/gadget/pxa27x_udc.c 2007-04-21 12:32:21.000000000 -0300 -@@ -1615,8 +1615,9 @@ - - DMSG("Connecting\n"); - /* RPFIXME */ -- UP2OCR = UP2OCR_HXOE | UP2OCR_DPPUE | UP2OCR_DPPUBE; -- //dev->mach->udc_command(PXA2XX_UDC_CMD_CONNECT); -+ //UP2OCR = UP2OCR_HXOE | UP2OCR_DPPUE | UP2OCR_DPPUBE; -+ UP2OCR = 0x02000000; // temporary solution for ezx. -+ dev->mach->udc_command(PXA2XX_UDC_CMD_CONNECT); - } - - diff --git a/packages/linux/linux-ezx-2.6.20.7/ezx-mci.patch b/packages/linux/linux-ezx-2.6.20.7/ezx-mci.patch deleted file mode 100644 index d16693e3e4..0000000000 --- a/packages/linux/linux-ezx-2.6.20.7/ezx-mci.patch +++ /dev/null @@ -1,177 +0,0 @@ -Index: linux-2.6.20.7/arch/arm/mach-pxa/ezx-mci.c -=================================================================== ---- /dev/null 1970-01-01 00:00:00.000000000 +0000 -+++ linux-2.6.20.7/arch/arm/mach-pxa/ezx-mci.c 2007-04-20 01:10:13.000000000 -0300 -@@ -0,0 +1,159 @@ -+/* -+ * linux/arch/arm/mach-ezx/a780.c -+ * -+ * Support for the Motorola Ezx A780 Development Platform. -+ * -+ * Author: Zhuang Xiaofan -+ * Created: Nov 25, 2003 -+ * Copyright: Motorola 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. -+ */ -+ -+#include <linux/mmc/host.h> -+#include <linux/irq.h> -+#include <asm/irq.h> -+#include <asm/arch/pxa-regs.h> -+#include <asm/arch/ezx-pcap.h> -+#include <asm/arch/mmc.h> -+#include <asm/arch/hardware.h> -+ -+extern int ezx_pcap_mmcsd_power(int); -+extern void ezx_pcap_mmcsd_voltage(u_int32_t); -+ -+static struct pxamci_platform_data ezx_mci_platform_data; -+ -+static int ezx_mci_init(struct device *dev, -+ irqreturn_t (*ezx_detect_int)(int, void *), -+ void *data) -+{ -+ int err; -+ printk("%s entered\n", __FUNCTION__); -+ -+ /* Setup GPIO for PXA27x MMC/SD controller */ -+ pxa_gpio_mode(GPIO32_MMCCLK_MD); -+ pxa_gpio_mode(GPIO112_MMCCMD_MD); -+ pxa_gpio_mode(GPIO92_MMCDAT0_MD); -+ pxa_gpio_mode(GPIO109_MMCDAT1_MD); -+ pxa_gpio_mode(GPIO110_MMCDAT2_MD); -+ pxa_gpio_mode(GPIO111_MMCDAT3_MD); -+ -+ ezx_pcap_mmcsd_power(1); -+ -+ ezx_mci_platform_data.detect_delay = msecs_to_jiffies(250); -+ -+ err = request_irq(0x49, ezx_detect_int, SA_INTERRUPT, -+ "MMC card detect", data); -+ if (err) { -+ printk(KERN_ERR "ezx_mci_detect: MMC/SD: can't request " -+ "MMC card detect IRQ\n"); -+ return -1; -+ } -+ -+ set_irq_type(0x0b, IRQT_BOTHEDGE); -+ -+ return 0; -+} -+ -+static int ezx_mci_get_ro(struct device *dev) -+{ -+ printk("%s entered\n", __FUNCTION__); -+#if defined(CONFIG_PXA_EZX_E680) -+ /* this is only e680, i guess */ -+ // return GPIO_is_high(96+4); -+ return (GPLR3 & 0x800); -+#else -+ return 0; -+#endif -+} -+ -+#if defined(CONFIG_PXA_EZX_A780) -+static u_int8_t mmc_voltage[] = { -+ [MMC_VDD_160] = 5, -+ [MMC_VDD_170] = 5, -+ [MMC_VDD_180] = 6, -+ [MMC_VDD_190] = 6, -+ [MMC_VDD_200] = 7, -+ [MMC_VDD_210] = 7, -+ [MMC_VDD_220] = 8, -+ [MMC_VDD_230] = 8, -+ [MMC_VDD_240] = 9, -+ [MMC_VDD_250] = 9, -+ [MMC_VDD_260] = 10, -+ [MMC_VDD_270] = 10, -+ [MMC_VDD_280] = 11, -+ [MMC_VDD_290] = 11, -+ [MMC_VDD_300] = 12, -+ [MMC_VDD_310] = 12, -+ [MMC_VDD_320] = 13, -+ [MMC_VDD_330] = 13, -+ [MMC_VDD_340] = 14, -+ [MMC_VDD_350] = 14, -+ [MMC_VDD_360] = 15, -+}; -+#elif defined(CONFIG_PXA_EZX_E680) -+static u_int8_t mmc_voltage[] = { -+ [MMC_VDD_160] = 3, -+ [MMC_VDD_170] = 3, -+ [MMC_VDD_180] = 3, -+ [MMC_VDD_190] = 3, -+ [MMC_VDD_200] = 3, -+ [MMC_VDD_210] = 3, -+ [MMC_VDD_220] = 3, -+ [MMC_VDD_230] = 3, -+ [MMC_VDD_240] = 3, -+ [MMC_VDD_250] = 3, -+ [MMC_VDD_260] = 3, -+ [MMC_VDD_270] = 3, -+ [MMC_VDD_280] = 3, -+ [MMC_VDD_290] = 3, -+ [MMC_VDD_300] = 3, -+ [MMC_VDD_310] = 3, -+ [MMC_VDD_320] = 3, -+ [MMC_VDD_330] = 3, -+ [MMC_VDD_340] = 3, -+ [MMC_VDD_350] = 3, -+ [MMC_VDD_360] = 3, -+}; -+#endif -+ -+static void ezx_mci_setpower(struct device *dev, unsigned int vdd) -+{ -+ printk("%s(vdd=%u) entered\n", __FUNCTION__, vdd); -+ if (vdd <= MMC_VDD_360) -+ ezx_pcap_mmcsd_voltage(mmc_voltage[vdd]); -+ -+ ezx_pcap_mmcsd_power(1); -+} -+ -+static void ezx_mci_exit(struct device *dev, void *data) -+{ -+ printk("%s entered\n", __FUNCTION__); -+ ezx_pcap_mmcsd_power(0); -+ free_irq(0x49, data); -+} -+ -+static struct pxamci_platform_data ezx_mci_platform_data = { -+#if defined(CONFIG_PXA_EZX_E680) -+ .ocr_mask = MMC_VDD_27_28, -+#elif defined(CONFIG_PXA_EZX_A780) -+ .ocr_mask = MMC_VDD_160_165|MMC_VDD_18_19|MMC_VDD_20_21 -+ |MMC_VDD_22_23|MMC_VDD_24_25|MMC_VDD_26_27 -+ |MMC_VDD_28_29|MMC_VDD_30_31|MMC_VDD_32_33 -+ |MMC_VDD_34_35|MMC_VDD_35_36, -+#endif -+ .init = ezx_mci_init, -+ .get_ro = ezx_mci_get_ro, -+ .setpower = ezx_mci_setpower, -+ .exit = ezx_mci_exit, -+}; -+ -+int __init __ezx_mci_init (void) -+{ -+ pxa_set_mci_info(&ezx_mci_platform_data); -+ return 0; -+} -+ -+arch_initcall(__ezx_mci_init); -Index: linux-2.6.20.7/arch/arm/mach-pxa/Makefile -=================================================================== ---- linux-2.6.20.7.orig/arch/arm/mach-pxa/Makefile 2007-04-21 02:56:16.000000000 -0300 -+++ linux-2.6.20.7/arch/arm/mach-pxa/Makefile 2007-04-21 03:00:03.000000000 -0300 -@@ -18,7 +18,7 @@ - obj-$(CONFIG_MACH_AKITA) += akita-ioexp.o - obj-$(CONFIG_MACH_POODLE) += poodle.o corgi_ssp.o - obj-$(CONFIG_MACH_TOSA) += tosa.o --obj-$(CONFIG_PXA_EZX) += ezx.o ezx_lcd.o ezx_ssp.o ezx-pcap.o -+obj-$(CONFIG_PXA_EZX) += ezx.o ezx_lcd.o ezx_ssp.o ezx-pcap.o ezx-mci.o - - # Support for blinky lights - led-y := leds.o diff --git a/packages/linux/linux-ezx-2.6.20.7/ezx-mtd-map.patch b/packages/linux/linux-ezx-2.6.20.7/ezx-mtd-map.patch deleted file mode 100644 index f59e31d9a2..0000000000 --- a/packages/linux/linux-ezx-2.6.20.7/ezx-mtd-map.patch +++ /dev/null @@ -1,274 +0,0 @@ -Index: linux-2.6.20.7/drivers/mtd/maps/Kconfig -=================================================================== ---- linux-2.6.20.7.orig/drivers/mtd/maps/Kconfig 2007-04-21 12:47:04.000000000 -0300 -+++ linux-2.6.20.7/drivers/mtd/maps/Kconfig 2007-04-21 13:01:08.000000000 -0300 -@@ -595,6 +595,28 @@ - help - This enables access to the flash chip on the Sharp SL Series of PDAs. - -+config MTD_EZX -+ bool "Map driver for Motorola EZX Platform" -+ depends on MTD && PXA_EZX -+ -+if MTD_EZX -+ -+choice -+ prompt "Select partition mapping for EZX platform" -+ -+config MTD_EZX_A780 -+ bool "A780/E680 Original Mapping" -+ -+config MTD_EZX_A780_ALTERNATE -+ bool "A780/E680 Alternate Mapping for BLOB2" -+ -+config MTD_EZX_E2 -+ bool "E2 Original Mapping" -+ -+endchoice -+ -+endif -+ - config MTD_PLATRAM - tristate "Map driver for platform device RAM (mtd-ram)" - depends on MTD -Index: linux-2.6.20.7/drivers/mtd/maps/Makefile -=================================================================== ---- linux-2.6.20.7.orig/drivers/mtd/maps/Makefile 2007-04-21 12:55:09.000000000 -0300 -+++ linux-2.6.20.7/drivers/mtd/maps/Makefile 2007-04-21 12:55:45.000000000 -0300 -@@ -72,3 +72,4 @@ - obj-$(CONFIG_MTD_OMAP_NOR) += omap_nor.o - obj-$(CONFIG_MTD_MTX1) += mtx-1_flash.o - obj-$(CONFIG_MTD_TQM834x) += tqm834x.o -+obj-$(CONFIG_MTD_EZX) += ezx-flash.o -Index: linux-2.6.20.7/drivers/mtd/maps/ezx-flash.c -=================================================================== ---- /dev/null 1970-01-01 00:00:00.000000000 +0000 -+++ linux-2.6.20.7/drivers/mtd/maps/ezx-flash.c 2007-04-21 13:07:14.000000000 -0300 -@@ -0,0 +1,227 @@ -+/* -+ * $Id: $ -+ * -+ * Map driver for the PXA27x -+ * -+ * Author: Harald Welte -+ * Copyright: (C) 2001 MontaVista 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. -+ * -+ * Mar 3, 2007 - (Daniel Ribeiro) Alternate partition table -+ * -+ */ -+ -+#include <linux/module.h> -+#include <linux/types.h> -+#include <linux/kernel.h> -+#include <linux/init.h> -+#include <linux/dma-mapping.h> -+#include <linux/slab.h> -+ -+#include <linux/mtd/mtd.h> -+#include <linux/mtd/map.h> -+#include <linux/mtd/partitions.h> -+ -+#include <asm/io.h> -+#include <asm/hardware.h> -+#include <asm/arch/pxa-regs.h> -+#include <asm/arch/mainstone.h> -+ -+#define WINDOW_ADDR 0x0 -+#define WINDOW_SIZE (32*1024*1024) -+#define WINDOW_CACHE_ADDR 0x0 -+#define WINDOW_CACHE_SIZE 0x1a00000 -+ -+static void pxa27x_map_inval_cache(struct map_info *map, unsigned long from, -+ ssize_t len) -+{ -+#if 0 -+ unsigned long endaddress, i, j; -+ endaddress = from + len -1; -+ from &= ~(32-1); -+ endaddress &= ~(32-1); -+ for (i = from; i <= endaddress; i += 32) -+ asm("mcr p15, 0, %0, c7, c6, 1"::"r"(i)); -+ -+ asm( "mrc p15, 0, %0, c2, c0, 0\n" -+ "mov %0, %0\n" -+ "sub pc, pc #4" -+ :"=r"(j)); -+#else -+ consistent_sync((char *)map->cached + from, len, DMA_FROM_DEVICE); -+#endif -+} -+ -+ -+struct map_info pxa27x_map = { -+ .name = "PXA27x flash", -+ .size = WINDOW_SIZE, -+ .phys = WINDOW_ADDR, -+ .inval_cache = &pxa27x_map_inval_cache, -+}; -+ -+#if defined CONFIG_MTD_EZX_A780_ALTERNATE -+static struct mtd_partition pxa27x_partitions[] = { -+ { -+ .name = "Bootloader (RO)", -+ .size = 0x00020000, -+ .offset = 0, -+ .mask_flags = MTD_WRITEABLE, -+ }, { -+ .name = "Bootloader 2", -+ .size = 0x00020000, -+ .offset = 0x00020000, -+ } , { -+ .name = "Kernel 1", -+ .size = 0x000e0000, // 896KB -+ .offset = 0x00040000, -+ } , { -+ .name = "rootfs", -+ .size = 0x01760000, -+ .offset = 0x00120000, -+ } , { -+ .name = "Kernel 2", -+ .size = 0x00180000, // 1.5MB -+ .offset = 0x01880000, -+ } , { -+ .name = "VFM_Filesystem", -+ .size = 0x005a0000, -+ .offset = 0x01a00000, -+ } , { -+ .name = "setup", -+ .size = 0x00020000, -+ .offset = 0x01fa0000, -+ } , { -+ .name = "Logo", -+ .size = 0x00020000, -+ .offset = 0x01fc0000, -+ }, -+}; -+#elif defined CONFIG_MTD_EZX_A780 -+static struct mtd_partition pxa27x_partitions[] = { -+ { -+ .name = "Bootloader", -+ .size = 0x00020000, -+ .offset = 0, -+ .mask_flags = MTD_WRITEABLE, -+ }, { -+ .name = "Kernel", -+ .size = 0x000e0000, -+ .offset = 0x00020000, -+ } , { -+ .name = "rootfs", -+ .size = 0x018e0000, -+ .offset = 0x00120000, -+ } , { -+ .name = "VFM_Filesystem", -+ .size = 0x00580000, -+ .offset = 0x01a00000, -+ } , { -+ .name = "setup", -+ .size = 0x00020000, -+ .offset = 0x01fa0000, -+ } , { -+ .name = "Logo", -+ .size = 0x00020000, -+ .offset = 0x01fc0000, -+ }, -+}; -+#else -+#error "please define partition for this PXA27x implementation" -+#endif -+ -+ -+static struct mtd_info *mymtd; -+static struct mtd_partition *parsed_parts; -+ -+static const char *probes[] = { "RedBoot", "cmdlinepart", NULL }; -+ -+static int __init init_pxa27x(void) -+{ -+ struct mtd_partition *parts; -+ int nb_parts = 0; -+ int parsed_nr_parts = 0; -+ char *part_type = "static"; -+ -+ pxa27x_map.bankwidth = (BOOT_DEF & 1) ? 2 : 4; -+ -+ printk("Probing PXA27x flash at physical address 0x%08x (%d-bit bankwidth)\n", -+ WINDOW_ADDR, pxa27x_map.bankwidth * 8); -+ pxa27x_map.virt = ioremap(pxa27x_map.phys, pxa27x_map.size); -+ -+ if (!pxa27x_map.virt) { -+ printk("Failed to ioremap\n"); -+ return -EIO; -+ } -+ -+ mymtd = do_map_probe("cfi_probe", &pxa27x_map); -+ if (!mymtd) { -+ iounmap((void *)pxa27x_map.virt); -+ return -ENXIO; -+ } -+ mymtd->owner = THIS_MODULE; -+ -+#if 0 -+ /* ioremap the first flash chip as cacheable */ -+ pxa27x_map.cached = ioremap_cached(pxa27x_map.phys, pxa27x_map.size); -+ if (!pxa27x_map.cached) { -+ printk("Failed to do cacheable-ioremap\n"); -+ iounmap((void *)pxa27x_map.virt); -+ return -EIO; -+ } -+#endif -+ simple_map_init(&pxa27x_map); -+ -+ if (parsed_nr_parts == 0) { -+ int ret = parse_mtd_partitions(mymtd, probes, &parsed_parts, 0); -+ -+ if (ret > 0) { -+ part_type = "RedBoot"; -+ parsed_nr_parts = ret; -+ } -+ } -+ -+ if (parsed_nr_parts > 0) { -+ parts = parsed_parts; -+ nb_parts = parsed_nr_parts; -+ } else { -+ parts = pxa27x_partitions; -+ nb_parts = ARRAY_SIZE(pxa27x_partitions); -+ } -+ -+ if (nb_parts) { -+ printk(KERN_NOTICE "Using %s partition definition\n", part_type); -+ add_mtd_partitions(mymtd, parts, nb_parts); -+ } else { -+ add_mtd_device(mymtd); -+ } -+#if 0 -+ if (ret = ezx_partition_init()) -+#endif -+ return 0; -+} -+ -+static void __exit cleanup_pxa27x(void) -+{ -+ if (mymtd) { -+ del_mtd_partitions(mymtd); -+ map_destroy(mymtd); -+ if (parsed_parts) -+ kfree(parsed_parts); -+ } -+ if (pxa27x_map.virt) -+ iounmap((void *)pxa27x_map.virt); -+ if (pxa27x_map.cached) -+ iounmap((void *)pxa27x_map.cached); -+ return; -+} -+ -+module_init(init_pxa27x); -+module_exit(cleanup_pxa27x); -+ -+MODULE_LICENSE("GPL"); -+MODULE_AUTHOR("Harald Welte <laforge@gnumonks.org>"); -+MODULE_DESCRIPTION("MTD map driver for Motorola EZX platform"); diff --git a/packages/linux/linux-ezx-2.6.20.7/ezx-pcap.patch b/packages/linux/linux-ezx-2.6.20.7/ezx-pcap.patch deleted file mode 100644 index 22c5d44f36..0000000000 --- a/packages/linux/linux-ezx-2.6.20.7/ezx-pcap.patch +++ /dev/null @@ -1,1197 +0,0 @@ -Index: linux-2.6.20.7/arch/arm/mach-pxa/ezx-pcap.c -=================================================================== ---- /dev/null 1970-01-01 00:00:00.000000000 +0000 -+++ linux-2.6.20.7/arch/arm/mach-pxa/ezx-pcap.c 2007-04-21 08:26:37.000000000 -0300 -@@ -0,0 +1,411 @@ -+/* Driver for Motorola PCAP2 as present in EZX phones -+ * -+ * This is both a SPI device driver for PCAP itself, as well as -+ * an IRQ demultiplexer for handling PCAP generated events such as -+ * headphone jack sense by downstream drivers. -+ * -+ * (C) 2006 by Harald Welte <laforge@openezx.org> -+ * -+ * 2007, April - Daniel Ribeiro <drwyrm@gmail.com> -+ * Altered to work with corgi's SSP code. -+ * Fixed irq handling routine. -+ */ -+ -+#include <linux/module.h> -+#include <linux/kernel.h> -+#include <linux/platform_device.h> -+#include <linux/interrupt.h> -+#include <linux/kernel_stat.h> -+ -+#include <asm/hardware.h> -+#include <asm/mach-types.h> -+ -+#include <asm/arch/ssp.h> -+#include <asm/arch/pxa-regs.h> -+#include <asm/arch/ezx-pcap.h> -+#include <asm/arch/irqs.h> -+#include <asm/mach/irq.h> -+ -+#include "ezx.h" -+ -+#if 0 -+#define DEBUGP(x, args...) printk(x, ## args) -+#else -+#define DEBUGP(x, args...) -+#endif -+ -+extern unsigned long ezx_ssp_pcap_putget(ulong); -+ -+int ezx_pcap_write(u_int8_t reg_num, u_int32_t value) -+{ -+ value &= SSP_PCAP_REGISTER_VALUE_MASK; -+ value |= SSP_PCAP_REGISTER_WRITE_OP_BIT -+ | (reg_num<<SSP_PCAP_REGISTER_ADDRESS_SHIFT); -+ -+ local_irq_disable(); -+ ezx_ssp_pcap_putget(value); -+ local_irq_enable(); -+ -+ DEBUGP("pcap write r%x: 0x%08x\n", reg_num, value); -+ return 0; -+} -+EXPORT_SYMBOL_GPL(ezx_pcap_write); -+ -+int ezx_pcap_read(u_int8_t reg_num, u_int32_t *value) -+{ -+ u_int32_t frame = SSP_PCAP_REGISTER_READ_OP_BIT -+ | (reg_num<<SSP_PCAP_REGISTER_ADDRESS_SHIFT); -+ -+ local_irq_disable(); -+ *value = ezx_ssp_pcap_putget(frame); -+ local_irq_enable(); -+ -+ DEBUGP("pcap read r%x: 0x%08x\n", reg_num, *value); -+ return 0; -+} -+EXPORT_SYMBOL_GPL(ezx_pcap_read); -+ -+int ezx_pcap_bit_set(u_int32_t sspPcapBit, u_int8_t to) -+{ -+ int ret; -+ u_int32_t tmp; -+ u_int32_t bit = (sspPcapBit & SSP_PCAP_REGISTER_VALUE_MASK); -+ u_int8_t reg_num = (sspPcapBit & SSP_PCAP_REGISTER_ADDRESS_MASK) -+ >> SSP_PCAP_REGISTER_ADDRESS_SHIFT; -+ -+ ret = ezx_pcap_read(reg_num, &tmp); -+ if (ret < 0) -+ return ret; -+ -+ if (to == 0) -+ tmp &= ~bit; -+ else -+ tmp |= bit; -+ -+ return ezx_pcap_write(reg_num, tmp); -+} -+EXPORT_SYMBOL_GPL(ezx_pcap_bit_set); -+ -+int ezx_pcap_read_bit(u_int32_t bit) -+{ -+ int ret; -+ u_int32_t tmp; -+ u_int8_t reg_num = (bit & SSP_PCAP_REGISTER_ADDRESS_MASK) -+ >> SSP_PCAP_REGISTER_ADDRESS_SHIFT; -+ -+ ret = ezx_pcap_read(reg_num, &tmp); -+ if (ret < 0) -+ return ret; -+ -+ return tmp & (bit & SSP_PCAP_REGISTER_VALUE_MASK); -+} -+EXPORT_SYMBOL_GPL(ezx_pcap_read_bit); -+ -+ -+static int ezx_pcap_vibrator_level(u_int32_t bit) -+{ -+ /* FIXME */ -+ return 0; -+} -+EXPORT_SYMBOL_GPL(ezx_pcap_vibrator_level); -+ -+ -+static int pcap_init(void) -+{ -+ /* initialize registers */ -+ /* FIXME: this should be board-level, not chip-level */ -+ /* implement a per board pcap init reg array? */ -+ -+ ezx_pcap_bit_set(SSP_PCAP_ADJ_BIT_ISR_USB4VI, 1); -+ ezx_pcap_bit_set(SSP_PCAP_ADJ_BIT_MSR_USB4VM, 0); -+ ezx_pcap_bit_set(SSP_PCAP_ADJ_BIT_ISR_USB1VI, 1); -+ ezx_pcap_bit_set(SSP_PCAP_ADJ_BIT_MSR_USB1VM, 0); -+ // disable all interrupts -+ //ezx_pcap_write(SSP_PCAP_ADJ_MSR_REGISTER, 0x03ffffff); -+ -+ ezx_pcap_bit_set(SSP_PCAP_ADJ_BIT_AUD_RX_AMPS_A1CTRL, 1); -+ ezx_pcap_vibrator_level(PCAP_VIBRATOR_VOLTAGE_LEVEL3); -+ ezx_pcap_vibrator_level(PCAP_VIBRATOR_VOLTAGE_LEVEL3); -+ -+ /* set SW1 sleep to keep SW1 1.3v in sync mode */ -+ ezx_pcap_bit_set(SSP_PCAP_ADJ_BIT_LOWPWR_CTRL_SW1_MODE10, 0); -+ ezx_pcap_bit_set(SSP_PCAP_ADJ_BIT_LOWPWR_CTRL_SW1_MODE11, 0); -+ /* SW1 active in sync mode */ -+ ezx_pcap_bit_set(SSP_PCAP_ADJ_BIT_LOWPWR_CTRL_SW1_MODE00, 1); -+ ezx_pcap_bit_set(SSP_PCAP_ADJ_BIT_LOWPWR_CTRL_SW1_MODE01, 0); -+ /* at SW1 -core voltage to 1.30V */ -+ ezx_pcap_bit_set(SSP_PCAP_ADJ_BIT_LOWPWR_CTRL_SW10_DVS, 1); -+ ezx_pcap_bit_set(SSP_PCAP_ADJ_BIT_LOWPWR_CTRL_SW11_DVS, 1); -+ ezx_pcap_bit_set(SSP_PCAP_ADJ_BIT_LOWPWR_CTRL_SW12_DVS, 1); -+ ezx_pcap_bit_set(SSP_PCAP_ADJ_BIT_LOWPWR_CTRL_SW13_DVS, 0); -+ -+ /* when STANDY2 PIN ACTIVE (high) set V3-- sram V8 -- pll off */ -+ ezx_pcap_bit_set(SSP_PCAP_ADJ_BIT_VREG2_V3_STBY, 1); -+ ezx_pcap_bit_set(SSP_PCAP_ADJ_BIT_VREG2_V3_LOWPWR, 0); -+ -+ ezx_pcap_bit_set(SSP_PCAP_ADJ_BIT_VREG2_V8_STBY, 1); -+ ezx_pcap_bit_set(SSP_PCAP_ADJ_BIT_VREG2_V8_LOWPWR, 0); -+ -+ /* when STANDY2 PIN ACTIVE (high) set V4-- lcd only for e680 V6 --- -+ * camera for e680 */ -+ ezx_pcap_bit_set(SSP_PCAP_ADJ_BIT_VREG2_V4_STBY, 1); -+ ezx_pcap_bit_set(SSP_PCAP_ADJ_BIT_VREG2_V4_LOWPWR, 1); -+ -+ ezx_pcap_bit_set(SSP_PCAP_ADJ_BIT_VREG2_V6_STBY, 1); -+ ezx_pcap_bit_set(SSP_PCAP_ADJ_BIT_VREG2_V6_LOWPWR, 0); -+ -+ /* set Vc to low power mode when AP sleep */ -+ //SSP_PCAP_bit_set( SSP_PCAP_ADJ_BIT_LOWPWR_CTRL_VC_STBY); -+ -+ /* set VAUX2 to voltage 2.775V and low power mode when AP sleep */ -+ ezx_pcap_bit_set(SSP_PCAP_ADJ_BIT_AUX_VREG_VAUX2_1, 1); -+ ezx_pcap_bit_set(SSP_PCAP_ADJ_BIT_AUX_VREG_VAUX2_0, 0); -+ ezx_pcap_bit_set(SSP_PCAP_ADJ_BIT_LOWPWR_CTRL_VAUX2_STBY, 1); -+ ezx_pcap_bit_set(SSP_PCAP_ADJ_BIT_LOWPWR_CTRL_VAUX2_LOWPWR, 1); -+ ezx_pcap_bit_set(SSP_PCAP_ADJ_BIT_AUX_VREG_VAUX2_EN, 1); -+ -+ PGSR(GPIO34_TXENB) |= GPIO_bit(GPIO34_TXENB); -+ -+ return 0; -+} -+/* MMC/SD specific functions */ -+ -+void ezx_pcap_mmcsd_voltage(u_int32_t bits) -+{ -+ unsigned int tmp; -+ ezx_pcap_read(SSP_PCAP_ADJ_AUX_VREG_REGISTER, &tmp); -+#if defined(CONFIG_PXA_EZX_E680) -+ tmp &= 0xffffff9f; /* zero all vaux2 bits */ -+ tmp |= (bits & 0x3) << 5; -+#elif defined(CONFIG_PXA_EZX_A780) -+ tmp &= 0xfffff0ff; /* zero all vaux3 bits */ -+ tmp |= (bits & 0xf) << 8; -+#endif -+ ezx_pcap_write(SSP_PCAP_ADJ_AUX_VREG_REGISTER, tmp); -+} -+EXPORT_SYMBOL(ezx_pcap_mmcsd_voltage); -+ -+int ezx_pcap_mmcsd_power(int on) -+{ -+ if (on) { -+#if defined(CONFIG_PXA_EZX_E680) -+ return ezx_pcap_bit_set(SSP_PCAP_ADJ_BIT_AUX_VREG_VAUX2_EN, 1); -+#else -+ return ezx_pcap_bit_set(SSP_PCAP_ADJ_BIT_AUX_VREG_VAUX3_EN, 1); -+#endif -+ } else { -+#if defined(CONFIG_PXA_EZX_E680) -+ return ezx_pcap_bit_set(SSP_PCAP_ADJ_BIT_AUX_VREG_VAUX2_EN, 0); -+#else -+ return ezx_pcap_bit_set(SSP_PCAP_ADJ_BIT_AUX_VREG_VAUX3_EN, 0); -+#endif -+ } -+} -+EXPORT_SYMBOL_GPL(ezx_pcap_mmcsd_power); -+ -+/* IRQ Handling */ -+ -+/* Array indexed by BIT POSITION of PCAP register, returns IRQ number */ -+static unsigned int pcap2irq[] = { -+ [0] = EZX_IRQ_ADCDONE, -+ [1] = EZX_IRQ_TS, -+ [2] = 0, /* 1HZ */ -+ [3] = 0, /* WI */ -+ [4] = 0, /* WI */ -+ [5] = 0, /* TODA */ -+ [6] = EZX_IRQ_USB4V, -+ [7] = 0, /* ONOFF */ -+ [8] = 0, /* ONOFF2 */ -+ [9] = EZX_IRQ_USB1V, -+ [10] = 0, /* MOBPORT */ -+ [11] = EZX_IRQ_MIC, -+ [12] = EZX_IRQ_HEADJACK, -+ [13] = 0, /* ST */ -+ [14] = 0, /* PC */ -+ [15] = 0, /* WARM */ -+ [16] = 0, /* EOL */ -+ [17] = 0, /* CLK */ -+ [18] = 0, /* SYS_RST */ -+ [19] = 0, -+ [20] = EZX_IRQ_ADCDONE2, -+ [21] = 0, /* SOFT_RESET */ -+ [22] = 0, /* MNEXB */ -+}; -+ -+/* Array indexed by IRQ NUMBER, returns PCAP absolute value */ -+static unsigned int irq2pcap[] = { -+ [EZX_IRQ_ADCDONE] = SSP_PCAP_ADJ_BIT_ISR_ADCDONEI, -+ [EZX_IRQ_TS] = SSP_PCAP_ADJ_BIT_ISR_TSI, -+ [EZX_IRQ_USB4V] = SSP_PCAP_ADJ_BIT_ISR_USB4VI, -+ [EZX_IRQ_USB1V] = SSP_PCAP_ADJ_BIT_ISR_USB1VI, -+ [EZX_IRQ_HEADJACK] = SSP_PCAP_ADJ_BIT_ISR_A1I, -+ [EZX_IRQ_MIC] = SSP_PCAP_ADJ_BIT_ISR_MB2I, -+ [EZX_IRQ_ADCDONE2] = SSP_PCAP_ADJ_BIT_ISR_ADCDONE2I, -+}; -+ -+static void pcap_ack_irq(unsigned int irq) -+{ -+ DEBUGP("pcap_ack_irq: %u\n", irq); -+ ezx_pcap_write(SSP_PCAP_ADJ_ISR_REGISTER, irq2pcap[irq]); -+} -+ -+static void pcap_mask_irq(unsigned int irq) -+{ -+ u_int32_t reg; -+ -+ DEBUGP("pcap_mask_irq: %u\n", irq); -+ -+ /* this needs to be atomic... but we're not on SMP so it is */ -+ ezx_pcap_read(SSP_PCAP_ADJ_MSR_REGISTER, ®); -+ reg |= irq2pcap[irq]; -+ ezx_pcap_write(SSP_PCAP_ADJ_MSR_REGISTER, reg); -+} -+ -+static void pcap_unmask_irq(unsigned int irq) -+{ -+ u_int32_t tmp; -+ DEBUGP("pcap_unmask_irq: %u\n", irq); -+ -+ /* this needs to be atomic... but we're not on SMP so it is */ -+ ezx_pcap_read(SSP_PCAP_ADJ_MSR_REGISTER, &tmp); -+ tmp &= ~irq2pcap[irq]; -+ ezx_pcap_write(SSP_PCAP_ADJ_MSR_REGISTER, tmp); -+} -+ -+static struct irq_chip pcap_chip = { -+ .ack = pcap_ack_irq, -+ .mask = pcap_mask_irq, -+ .unmask = pcap_unmask_irq, -+}; -+ -+/* handler for interrupt received from PCAP via GPIO */ -+static void pcap_irq_demux_handler(unsigned int irq, struct irq_desc *desc) -+{ -+ int i; -+ const unsigned int cpu = smp_processor_id(); -+ u_int32_t reg; -+ -+ DEBUGP("pcap_irq_demux_handler(%u,,) entered\n", irq); -+ -+ spin_lock(&desc->lock); -+ -+ desc->status &= ~(IRQ_REPLAY | IRQ_WAITING); -+ -+ if (unlikely(desc->status & IRQ_INPROGRESS)) { -+ DEBUGP("irq busy, masking it off\n"); -+ desc->status |= (IRQ_PENDING | IRQ_MASKED); -+ desc->chip->mask(irq); -+ desc->chip->ack(irq); -+ goto out_unlock; -+ } -+ -+ kstat_cpu(cpu).irqs[irq]++; -+ desc->status |= IRQ_INPROGRESS; -+ -+ do { -+ if (unlikely((desc->status & -+ (IRQ_PENDING | IRQ_MASKED | IRQ_DISABLED)) == -+ (IRQ_PENDING | IRQ_MASKED))) { -+ DEBUGP("dealing with pending IRQ, unmasking\n"); -+ desc->chip->unmask(irq); -+ desc->status &= ~IRQ_MASKED; -+ } -+ -+ desc->status &= ~IRQ_PENDING; -+ spin_unlock(&desc->lock); -+ -+ ezx_pcap_read(SSP_PCAP_ADJ_ISR_REGISTER, ®); -+ DEBUGP("pcap_irq_demux_handler: ISR=0x%08x\n", reg); -+ -+ for (i = ARRAY_SIZE(pcap2irq)-1; i >= 0; i--) { -+ unsigned int pirq = pcap2irq[i]; -+ if (pirq == 0) -+ continue; -+ -+ if (reg & (1 << i)) { -+ struct irq_desc *subdesc; -+ DEBUGP("found irq %u\n", pirq); -+ subdesc = irq_desc + pirq; -+ -+ // acknowledge pcap irq -+ // do just one pcap irq each time -+ subdesc->chip->ack(pirq); -+ i = 0; -+ -+ handle_IRQ_event(pirq, subdesc->action); -+ } -+ } -+ spin_lock(&desc->lock); -+ -+ } while ((desc->status & (IRQ_PENDING | IRQ_DISABLED)) == IRQ_PENDING); -+ -+ desc->status &= ~IRQ_INPROGRESS; -+ -+out_unlock: -+ spin_unlock(&desc->lock); -+} -+ -+static int ezx_pcap_remove(struct platform_device *pdev) -+{ -+ int irq; -+ DEBUGP("exz_pcap_remove entered\n"); -+ -+ set_irq_chained_handler(IRQ_GPIO1, NULL); -+ -+ for (irq = EZX_IRQ(0); irq <= EZX_IRQ(6); irq++) { -+ set_irq_chip(irq, NULL); -+ set_irq_handler(irq, NULL); -+ set_irq_flags(irq, 0); -+ } -+ -+ return 0; -+} -+ -+static int __init ezx_pcap_probe(struct platform_device *pdev) -+{ -+ unsigned int irq; -+ DEBUGP("ezx_pcap_probe entered\n"); -+ -+ pcap_init(); -+ -+ set_irq_type(IRQ_GPIO1, IRQT_RISING); -+ /* set up interrupt demultiplexing code for PCAP2 irqs */ -+ for (irq = EZX_IRQ(0); irq <= EZX_IRQ(6); irq++) { -+ set_irq_chip(irq, &pcap_chip); -+ set_irq_handler(irq, handle_edge_irq); -+ set_irq_flags(irq, IRQF_VALID); -+ } -+ set_irq_chained_handler(IRQ_GPIO1, pcap_irq_demux_handler); -+ -+ printk("PCAP2 SSP driver registered.\n"); -+ -+ return 0; -+} -+ -+static struct platform_driver ezxpcap_driver = { -+ .probe = ezx_pcap_probe, -+ .remove = ezx_pcap_remove, -+ .driver = { -+ .name = "ezx-pcap", -+ .owner = THIS_MODULE, -+ }, -+}; -+ -+static int __init ezx_pcap_init(void) -+{ -+ DEBUGP("ezx_pcap_init entered\n"); -+ return platform_driver_register(&ezxpcap_driver); -+} -+ -+static void __exit ezx_pcap_exit(void) -+{ -+ return platform_driver_unregister(&ezxpcap_driver); -+} -+ -+module_init(ezx_pcap_init); -+module_exit(ezx_pcap_exit); -+ -+MODULE_LICENSE("GPL"); -+MODULE_AUTHOR("Harald Welte"); -+MODULE_DESCRIPTION("SPI Driver for Motorola PCAP2"); -+ -Index: linux-2.6.20.7/include/asm-arm/arch-pxa/ezx-pcap.h -=================================================================== ---- /dev/null 1970-01-01 00:00:00.000000000 +0000 -+++ linux-2.6.20.7/include/asm-arm/arch-pxa/ezx-pcap.h 2007-04-21 08:26:37.000000000 -0300 -@@ -0,0 +1,665 @@ -+/* (c) Copyright Motorola Beijing 2002 all rights reserved. -+ -+ Project Name : EZX -+ Project No. : -+ Title : -+ File Name : -+ Description : -+ -+ ************** REVISION HISTORY ********************************************** -+ Date Author Reference -+ ======== ========== ========================== -+ 2002-07-01 weiqiang lin create -+*/ -+#ifndef SSP_PCAP_H -+#define SSP_PCAP_H -+ -+#define SSP_vibrate_start_command() SSP_PCAP_bit_set(SSP_PCAP_ADJ_BIT_AUX_VREG_V_VIB_EN); \ -+ SSP_PCAP_bit_set(SSP_PCAP_ADJ_BIT_AUX_VREG_V_VIB_EN) -+ -+#define SSP_vibrate_stop_command() SSP_PCAP_bit_clean(SSP_PCAP_ADJ_BIT_AUX_VREG_V_VIB_EN); \ -+ SSP_PCAP_bit_clean(SSP_PCAP_ADJ_BIT_AUX_VREG_V_VIB_EN) -+ -+#define SSP_PCAP_REGISTER_VALUE_LENGTH 16 -+ -+#define SSP_PCAP_REGISTER_WRITE_OP_BIT 0x80000000 -+#define SSP_PCAP_REGISTER_READ_OP_BIT 0x00000000 -+ -+#define SSP_PCAP_REGISTER_VALUE_UP_WORD_MASK 0xffff0000 -+#define SSP_PCAP_REGISTER_VALUE_DOWN_WORD_MASK 0x0000ffff -+ -+#define SSP_PCAP_REGISTER_VALUE_MASK 0x01ffffff -+#define SSP_PCAP_REGISTER_VALUE_MASK 0x01ffffff -+#define SSP_PCAP_REGISTER_ADDRESS_MASK 0x7c000000 -+#define SSP_PCAP_REGISTER_ADDRESS_SHIFT 26 -+#define SSP_PCAP_REGISTER_NUMBER 32 -+ -+#define SSP_PCAP_ADC_START_VALUE_SET_MASK 0xfffffc00 -+#define SSP_PCAP_ADC_START_VALUE 0x000001dd -+ -+ -+#define SSP_PCAP_PHONE_CDC_CLOCK_MASK 0x000001c0 -+#define SSP_PCAP_STEREO_SAMPLE_RATE_MASK 0x00000f00 -+#define SSP_PCAP_STEREO_BCLK_TIME_SLOT_MASK 0x00018000 -+#define SSP_PCAP_STEREO_CLOCK_MASK 0x0000001c -+#define SSP_PCAP_DIGITAL_AUDIO_MODE_MASK 0x00006000 -+#define SSP_PCAP_TOUCH_PANEL_POSITION_DETECT_MODE_MASK 0x000e0000 -+#define SSP_PCAP_MONO_PGA_MASK 0x00180000 -+ -+#define SSP_PCAP_VIBRATOR_VOLTAGE_LEVEL_MASK 0x00300000 -+ -+#define SSP_PCAP_AUDIO_IN_GAIN_MASK 0x0000001f -+#define SSP_PCAP_AUDIO_IN_GAIN_SHIFT 0 -+#define SSP_PCAP_AUDIO_OUT_GAIN_MASK 0x0001e000 -+#define SSP_PCAP_AUDIO_OUT_GAIN_SHIFT 13 -+ -+ -+#define SSP_PCAP_ADD1_VALUE_MASK 0x000003ff -+#define SSP_PCAP_ADD1_VALUE_SHIFT 0 -+#define SSP_PCAP_ADD2_VALUE_MASK 0x000ffc00 -+#define SSP_PCAP_ADD2_VALUE_SHIFT 10 -+ -+ -+#define PCAP_AUDIO_IN_GAIN_MAX_VALUE 31 -+#define PCAP_AUDIO_OUT_GAIN_MAX_VALUE 15 -+ -+#define PCAP_CLEAR_INTERRUPT_REGISTER 0x00141fdf -+#define PCAP_MASK_ALL_INTERRUPT 0x0013ffff -+ -+#define SSP_PCAP_TS_KEEPER_TIMER 100 /* 1 second */ -+#define START_ADC_DELAY_TIMER 1991 /* 540 us */ -+ -+#define SSP_SEND_PM_ALART_INTERVAL 1000 *HZ/1000 /* 1 second */ -+#define SSP_SEND_MSG_USB_ACCESSORY_INFO_DEBOUNCE 200 *HZ/1000 /* 200ms */ -+ -+struct ssp_interrupt_info -+{ -+ u32 type; -+ u32 status; -+ void* privdata; -+}; -+ -+#ifndef U8 -+#define U8 unsigned char -+#endif -+ -+#ifndef U32 -+#define U32 unsigned long -+#endif -+ -+#ifndef U16 -+#define U16 unsigned short -+#endif -+ -+#ifndef P_U16 -+#define P_U16 U16* -+#endif -+ -+#ifndef P_U32 -+#define P_U32 U32* -+#endif -+ -+#define SSP_SELECT_BUFFER (volatile unsigned long *)(0xf4000000) -+ -+#define SSP_SR_RNE 0x00000008 -+#define SSP_PCAP_BASE 0x00001000 -+/************************ STRUCTURES, ENUMS, AND TYPEDEFS **************************/ -+typedef enum accessoryStatus -+{ -+ ACCESSORY_DEVICE_STATUS_DETACHED = 0, -+ ACCESSORY_DEVICE_STATUS_ATTACHED , -+ ACCESSORY_DEVICE_STATUS_UNKNOW =0x000000ff -+}ACCESSORY_DEVICE_STATUS; -+ -+typedef enum accessoryType -+{ -+ ACCESSORY_DEVICE_NONE = 0, -+ ACCESSORY_DEVICE_SERIAL_PORT , -+ ACCESSORY_DEVICE_USB_PORT , -+ ACCESSORY_DEVICE_UNKNOW =0x000000ff -+}ACCESSORY_TYPE; -+ -+typedef enum pcapReturnStatus -+{ -+ SSP_PCAP_SUCCESS = 0, -+ SSP_PCAP_ERROR_REGISTER = SSP_PCAP_BASE+1, -+ SSP_PCAP_ERROR_VALUE = SSP_PCAP_BASE+2, -+ -+ SSP_PCAP_NOT_RUN = SSP_PCAP_BASE+0xff -+}SSP_PCAP_STATUS; -+ -+typedef enum pcapPortType -+{ -+ SSP_PCAP_SERIAL_PORT = 0x00000000, -+ SSP_PCAP_LOW_USB_PORT = 0x00000001, -+ SSP_PCAP_HIGH_USB_PORT = 0x00000002, -+ SSP_PCAP_UNKNOW_PORT = 0x000000ff -+}SSP_PCAP_PORT_TYPE; -+ -+typedef enum pcapInitDriverType -+{ -+ SSP_PCAP_TS_OPEN = 0x00000000, -+ SSP_PCAP_AUDIO_OPEN = 0x00000001, -+ SSP_PCAP_UNKNOW_DRIVER_OPEN = 0x000000ff -+}SSP_PCAP_INIT_DRIVER_TYPE; -+ -+ -+typedef enum pcapReturnBitStatus -+{ -+ SSP_PCAP_BIT_ZERO = 0x00000000, -+ SSP_PCAP_BIT_ONE = 0x00000001, -+ SSP_PCAP_BIT_ERROR = 0xff000000 -+}SSP_PCAP_BIT_STATUS; -+ -+typedef enum pcapCDCClkType -+{ -+ PCAP_CDC_CLK_IN_13M0 = 0x00000000, -+ PCAP_CDC_CLK_IN_15M36 = 0x00000040, -+ PCAP_CDC_CLK_IN_16M8 = 0x00000080, -+ PCAP_CDC_CLK_IN_19M44 = 0x000000c0, -+ PCAP_CDC_CLK_IN_26M0 = 0x00000100 -+}PHONE_CDC_CLOCK_TYPE; -+ -+typedef enum pcapST_SR -+{ -+ PCAP_ST_SAMPLE_RATE_8K = 0x00000000, -+ PCAP_ST_SAMPLE_RATE_11K = 0x00000100, -+ PCAP_ST_SAMPLE_RATE_12K = 0x00000200, -+ PCAP_ST_SAMPLE_RATE_16K = 0x00000300, -+ PCAP_ST_SAMPLE_RATE_22K = 0x00000400, -+ PCAP_ST_SAMPLE_RATE_24K = 0x00000500, -+ PCAP_ST_SAMPLE_RATE_32K = 0x00000600, -+ PCAP_ST_SAMPLE_RATE_44K = 0x00000700, -+ PCAP_ST_SAMPLE_RATE_48K = 0x00000800 -+}ST_SAMPLE_RATE_TYPE; -+ -+typedef enum pcapST_BCLK -+{ -+ PCAP_ST_BCLK_SLOT_16 = 0x00000000, -+ PCAP_ST_BCLK_SLOT_8 = 0x00008000, -+ PCAP_ST_BCLK_SLOT_4 = 0x00010000, -+ PCAP_ST_BCLK_SLOT_2 = 0x00018000, -+}ST_BCLK_TIME_SLOT_TYPE; -+ -+typedef enum pcapST_CLK -+{ -+ PCAP_ST_CLK_PLL_CLK_IN_13M0 = 0x00000000, -+ PCAP_ST_CLK_PLL_CLK_IN_15M36 = 0x00000004, -+ PCAP_ST_CLK_PLL_CLK_IN_16M8 = 0x00000008, -+ PCAP_ST_CLK_PLL_CLK_IN_19M44 = 0x0000000c, -+ PCAP_ST_CLK_PLL_CLK_IN_26M0 = 0x00000010, -+ PCAP_ST_CLK_PLL_CLK_IN_EXT_MCLK = 0x00000014, -+ PCAP_ST_CLK_PLL_CLK_IN_FSYNC = 0x00000018, -+ PCAP_ST_CLK_PLL_CLK_IN_BITCLK = 0x0000001c -+}ST_CLK_TYPE; -+ -+typedef enum pcapDigitalAudioInterfaceMode -+{ -+ PCAP_DIGITAL_AUDIO_INTERFACE_NORMAL = 0x00000000, -+ PCAP_DIGITAL_AUDIO_INTERFACE_NETWORK = 0x00002000, -+ PCAP_DIGITAL_AUDIO_INTERFACE_I2S = 0x00004000 -+}DIG_AUD_MODE_TYPE; -+ -+typedef enum pcapMono -+{ -+ PCAP_MONO_PGA_R_L_STEREO = 0x00000000, -+ PCAP_MONO_PGA_RL = 0x00080000, -+ PCAP_MONO_PGA_RL_3DB = 0x00100000, -+ PCAP_MONO_PGA_RL_6DB = 0x00180000 -+}MONO_TYPE; -+ -+typedef enum pcapVibratorVoltageLevel -+{ -+ PCAP_VIBRATOR_VOLTAGE_LEVEL0 = 0x00000000, -+ PCAP_VIBRATOR_VOLTAGE_LEVEL1 = 0x00100000, -+ PCAP_VIBRATOR_VOLTAGE_LEVEL2 = 0x00200000, -+ PCAP_VIBRATOR_VOLTAGE_LEVEL3 = 0x00300000 -+}VibratorVoltageLevel_TYPE; -+ -+typedef enum pcapTouchScreenMode -+{ -+ PCAP_TS_POSITION_X_MEASUREMENT = 0x00000000, -+ PCAP_TS_POSITION_XY_MEASUREMENT = 0x00020000, -+ PCAP_TS_PRESSURE_MEASUREMENT = 0x00040000, -+ PCAP_TS_PLATE_X_MEASUREMENT = 0x00060000, -+ PCAP_TS_PLATE_Y_MEASUREMENT = 0x00080000, -+ PCAP_TS_STANDBY_MODE = 0x000a0000, -+ PCAP_TS_NONTS_MODE = 0x000c0000 -+}TOUCH_SCREEN_DETECT_TYPE; -+ -+typedef enum pcapADJRegister -+{ -+ SSP_PCAP_ADJ_ISR_REGISTER = 0x00, -+ SSP_PCAP_ADJ_MSR_REGISTER = 0x01, -+ SSP_PCAP_ADJ_PSTAT_REGISTER = 0x02, -+ SSP_PCAP_ADJ_VREG2_REGISTER = 0x06, -+ SSP_PCAP_ADJ_AUX_VREG_REGISTER = 0x07, -+ SSP_PCAP_ADJ_BATT_DAC_REGISTER = 0x08, -+ SSP_PCAP_ADJ_ADC1_REGISTER = 0x09, -+ SSP_PCAP_ADJ_ADC2_REGISTER = 0x0a, -+ SSP_PCAP_ADJ_AUD_CODEC_REGISTER = 0x0b, -+ SSP_PCAP_ADJ_AUD_RX_AMPS_REGISTER = 0x0c, -+ SSP_PCAP_ADJ_ST_DAC_REGISTER = 0x0d, -+ SSP_PCAP_ADJ_BUSCTRL_REGISTER = 0x14, -+ SSP_PCAP_ADJ_PERIPH_REGISTER = 0x15, -+ SSP_PCAP_ADJ_LOWPWR_CTRL_REGISTER = 0x18, -+ SSP_PCAP_ADJ_TX_AUD_AMPS_REGISTER = 0x1a, -+ SSP_PCAP_ADJ_GP_REG_REGISTER = 0x1b -+}SSP_PCAP_SECONDARY_PROCESSOR_REGISTER; -+ -+typedef enum pcapADJBit_SetType -+{ -+ SSP_PCAP_ADJ_BIT_ISR_ADCDONEI = 0x00000001, -+ SSP_PCAP_ADJ_BIT_ISR_TSI = 0x00000002, -+ SSP_PCAP_ADJ_BIT_ISR_1HZI = 0x00000004, -+ SSP_PCAP_ADJ_BIT_ISR_WHI = 0x00000008, -+ SSP_PCAP_ADJ_BIT_ISR_WLI = 0x00000010, -+ SSP_PCAP_ADJ_BIT_ISR_TODAI = 0x00000020, -+ SSP_PCAP_ADJ_BIT_ISR_USB4VI = 0x00000040, -+ SSP_PCAP_ADJ_BIT_ISR_ONOFFI = 0x00000080, -+ SSP_PCAP_ADJ_BIT_ISR_ONOFF2I = 0x00000100, -+ SSP_PCAP_ADJ_BIT_ISR_USB1VI = 0x00000200, -+ SSP_PCAP_ADJ_BIT_ISR_MOBPORTI = 0x00000400, -+ SSP_PCAP_ADJ_BIT_ISR_MB2I = 0x00000800, -+ SSP_PCAP_ADJ_BIT_ISR_A1I = 0x00001000, -+ SSP_PCAP_ADJ_BIT_ISR_STI = 0x00002000, -+ SSP_PCAP_ADJ_BIT_ISR_PCI = 0x00004000, -+ SSP_PCAP_ADJ_BIT_ISR_WARMI = 0x00008000, -+ SSP_PCAP_ADJ_BIT_ISR_EOLI = 0x00010000, -+ SSP_PCAP_ADJ_BIT_ISR_CLKI = 0x00020000, -+ SSP_PCAP_ADJ_BIT_ISR_SYS_RSTI = 0x00040000, -+ SSP_PCAP_ADJ_BIT_ISR_ADCDONE2I = 0x00100000, -+ SSP_PCAP_ADJ_BIT_ISR_SOFT_RESETI = 0x00200000, -+ SSP_PCAP_ADJ_BIT_ISR_MNEXBI = 0x00400000, -+ -+ SSP_PCAP_ADJ_BIT_MSR_ADCDONEM = 0x04000001, -+ SSP_PCAP_ADJ_BIT_MSR_TSM = 0x04000002, -+ SSP_PCAP_ADJ_BIT_MSR_1HZM = 0x04000004, -+ SSP_PCAP_ADJ_BIT_MSR_WHM = 0x04000008, -+ SSP_PCAP_ADJ_BIT_MSR_WLM = 0x04000010, -+ SSP_PCAP_ADJ_BIT_MSR_TODAM = 0x04000020, -+ SSP_PCAP_ADJ_BIT_MSR_USB4VM = 0x04000040, -+ SSP_PCAP_ADJ_BIT_MSR_ONOFFM = 0x04000080, -+ SSP_PCAP_ADJ_BIT_MSR_ONOFF2M = 0x04000100, -+ SSP_PCAP_ADJ_BIT_MSR_USB1VM = 0x04000200, -+ SSP_PCAP_ADJ_BIT_MSR_MOBPORTM = 0x04000400, -+ SSP_PCAP_ADJ_BIT_MSR_MB2M = 0x04000800, -+ SSP_PCAP_ADJ_BIT_MSR_A1M = 0x04001000, -+ SSP_PCAP_ADJ_BIT_MSR_STM = 0x04002000, -+ SSP_PCAP_ADJ_BIT_MSR_PCM = 0x04004000, -+ SSP_PCAP_ADJ_BIT_MSR_WARMM = 0x04008000, -+ SSP_PCAP_ADJ_BIT_MSR_EOLM = 0x04010000, -+ SSP_PCAP_ADJ_BIT_MSR_CLKM = 0x04020000, -+ SSP_PCAP_ADJ_BIT_MSR_SYS_RSTM = 0x04040000, -+ SSP_PCAP_ADJ_BIT_MSR_ADCDONE2M = 0x04100000, -+ SSP_PCAP_ADJ_BIT_MSR_SOFT_RESETM = 0x04200000, -+ SSP_PCAP_ADJ_BIT_MSR_MNEXBM = 0x04400000, -+ -+ SSP_PCAP_ADJ_BIT_PSTAT_USBDET_4V = 0x08000040, -+ SSP_PCAP_ADJ_BIT_PSTAT_ONOFFSNS = 0x08000080, -+ SSP_PCAP_ADJ_BIT_PSTAT_ONOFFSNS2 = 0x08000100, -+ SSP_PCAP_ADJ_BIT_PSTAT_USBDET_1V = 0x08000200, -+ SSP_PCAP_ADJ_BIT_PSTAT_MOBSENSB = 0x08000400, -+ SSP_PCAP_ADJ_BIT_PSTAT_MB2SNS = 0x08000800, -+ SSP_PCAP_ADJ_BIT_PSTAT_A1SNS = 0x08001000, -+ SSP_PCAP_ADJ_BIT_PSTAT_MSTB = 0x08002000, -+ SSP_PCAP_ADJ_BIT_PSTAT_EOL_STAT = 0x08010000, -+ SSP_PCAP_ADJ_BIT_PSTAT_CLK_STAT = 0x08020000, -+ SSP_PCAP_ADJ_BIT_PSTAT_SYS_RST = 0x08040000, -+ SSP_PCAP_ADJ_BIT_PSTAT_BATTFBSNS = 0x08080000, -+ SSP_PCAP_ADJ_BIT_PSTAT_BATT_DET_IN_SNS = 0x08200000, -+ SSP_PCAP_ADJ_BIT_PSTAT_MNEXBSNS = 0x08400000, -+ SSP_PCAP_ADJ_BIT_PSTAT_WARM_SYS_RST = 0x08800000, -+ -+ SSP_PCAP_ADJ_BIT_VREG2_V1_STBY = 0x18000001, -+ SSP_PCAP_ADJ_BIT_VREG2_V2_STBY = 0x18000002, -+ SSP_PCAP_ADJ_BIT_VREG2_V3_STBY = 0x18000004, -+ SSP_PCAP_ADJ_BIT_VREG2_V4_STBY = 0x18000008, -+ SSP_PCAP_ADJ_BIT_VREG2_V5_STBY = 0x18000010, -+ SSP_PCAP_ADJ_BIT_VREG2_V6_STBY = 0x18000020, -+ SSP_PCAP_ADJ_BIT_VREG2_V7_STBY = 0x18000040, -+ SSP_PCAP_ADJ_BIT_VREG2_V8_STBY = 0x18000080, -+ SSP_PCAP_ADJ_BIT_VREG2_V9_STBY = 0x18000100, -+ SSP_PCAP_ADJ_BIT_VREG2_V10_STBY = 0x18000200, -+ SSP_PCAP_ADJ_BIT_VREG2_V1_LOWPWR = 0x18000400, -+ SSP_PCAP_ADJ_BIT_VREG2_V2_LOWPWR = 0x18000800, -+ SSP_PCAP_ADJ_BIT_VREG2_V3_LOWPWR = 0x18001000, -+ SSP_PCAP_ADJ_BIT_VREG2_V4_LOWPWR = 0x18002000, -+ SSP_PCAP_ADJ_BIT_VREG2_V5_LOWPWR = 0x18004000, -+ SSP_PCAP_ADJ_BIT_VREG2_V6_LOWPWR = 0x18008000, -+ SSP_PCAP_ADJ_BIT_VREG2_V7_LOWPWR = 0x18010000, -+ SSP_PCAP_ADJ_BIT_VREG2_V8_LOWPWR = 0x18020000, -+ SSP_PCAP_ADJ_BIT_VREG2_V9_LOWPWR = 0x18040000, -+ SSP_PCAP_ADJ_BIT_VREG2_V10_LOWPWR = 0x18080000, -+ -+ SSP_PCAP_ADJ_BIT_AUX_VREG_VAUX1_EN = 0x1c000002, -+ SSP_PCAP_ADJ_BIT_AUX_VREG_VAUX1_0 = 0x1c000004, -+ SSP_PCAP_ADJ_BIT_AUX_VREG_VAUX1_1 = 0x1c000008, -+ SSP_PCAP_ADJ_BIT_AUX_VREG_VAUX2_EN = 0x1c000010, -+ SSP_PCAP_ADJ_BIT_AUX_VREG_VAUX2_0 = 0x1c000020, -+ SSP_PCAP_ADJ_BIT_AUX_VREG_VAUX2_1 = 0x1c000040, -+ SSP_PCAP_ADJ_BIT_AUX_VREG_VAUX3_EN = 0x1c000080, -+ SSP_PCAP_ADJ_BIT_AUX_VREG_VAUX3_0 = 0x1c000100, -+ SSP_PCAP_ADJ_BIT_AUX_VREG_VAUX3_1 = 0x1c000200, -+ SSP_PCAP_ADJ_BIT_AUX_VREG_VAUX3_2 = 0x1c000400, -+ SSP_PCAP_ADJ_BIT_AUX_VREG_VAUX3_3 = 0x1c000800, -+ SSP_PCAP_ADJ_BIT_AUX_VREG_VAUX4_EN = 0x1c001000, -+ SSP_PCAP_ADJ_BIT_AUX_VREG_VAUX4_0 = 0x1c002000, -+ SSP_PCAP_ADJ_BIT_AUX_VREG_VAUX4_1 = 0x1c004000, -+ SSP_PCAP_ADJ_BIT_AUX_VREG_VSIM2_EN = 0x1c010000, -+ SSP_PCAP_ADJ_BIT_AUX_VREG_VSIM_EN = 0x1c020000, -+ SSP_PCAP_ADJ_BIT_AUX_VREG_VSIM_0 = 0x1c040000, -+ SSP_PCAP_ADJ_BIT_AUX_VREG_V_VIB_EN = 0x1c080000, -+ SSP_PCAP_ADJ_BIT_AUX_VREG_V_VIB_0 = 0x1c100000, -+ SSP_PCAP_ADJ_BIT_AUX_VREG_V_VIB_1 = 0x1c200000, -+ SSP_PCAP_ADJ_BIT_AUX_VREG_VAUX1_STBY = 0x1c400000, -+ SSP_PCAP_ADJ_BIT_AUX_VREG_VAUX1_LOWPWR = 0x1c800000, -+ SSP_PCAP_ADJ_BIT_AUX_VREG_SW3_STBY = 0x1d000000, -+ -+ SSP_PCAP_ADJ_BIT_BATT_DAC_DAC0 = 0x20000001, -+ SSP_PCAP_ADJ_BIT_BATT_DAC_DAC1 = 0x20000002, -+ SSP_PCAP_ADJ_BIT_BATT_DAC_DAC2 = 0x20000004, -+ SSP_PCAP_ADJ_BIT_BATT_DAC_DAC3 = 0x20000008, -+ SSP_PCAP_ADJ_BIT_BATT_DAC_DAC4 = 0x20000010, -+ SSP_PCAP_ADJ_BIT_BATT_DAC_DAC5 = 0x20000020, -+ SSP_PCAP_ADJ_BIT_BATT_DAC_DAC6 = 0x20000040, -+ SSP_PCAP_ADJ_BIT_BATT_DAC_DAC7 = 0x20000080, -+ SSP_PCAP_ADJ_BIT_BATT_DAC_B_FDBK = 0x20000100, -+ SSP_PCAP_ADJ_BIT_BATT_DAC_EXT_ISENSE = 0x20000200, -+ SSP_PCAP_ADJ_BIT_BATT_DAC_V_COIN0 = 0x20000400, -+ SSP_PCAP_ADJ_BIT_BATT_DAC_V_COIN1 = 0x20000800, -+ SSP_PCAP_ADJ_BIT_BATT_DAC_V_COIN2 = 0x20001000, -+ SSP_PCAP_ADJ_BIT_BATT_DAC_V_COIN3 = 0x20002000, -+ SSP_PCAP_ADJ_BIT_BATT_DAC_I_COIN = 0x20004000, -+ SSP_PCAP_ADJ_BIT_BATT_DAC_COIN_CH_EN = 0x20008000, -+ SSP_PCAP_ADJ_BIT_BATT_DAC_EOL_SEL0 = 0x20020000, -+ SSP_PCAP_ADJ_BIT_BATT_DAC_EOL_SEL1 = 0x20040000, -+ SSP_PCAP_ADJ_BIT_BATT_DAC_EOL_SEL2 = 0x20080000, -+ SSP_PCAP_ADJ_BIT_BATT_DAC_EOL_CMP_EN = 0x20100000, -+ SSP_PCAP_ADJ_BIT_BATT_DAC_BATT_DET_EN = 0x20200000, -+ SSP_PCAP_ADJ_BIT_BATT_DAC_THERMBIAS_CTRL = 0x20400000, -+ -+ SSP_PCAP_ADJ_BIT_ADC1_ADEN = 0x24000001, -+ SSP_PCAP_ADJ_BIT_ADC1_RAND = 0x24000002, -+ SSP_PCAP_ADJ_BIT_ADC1_AD_SEL1 = 0x24000004, -+ SSP_PCAP_ADJ_BIT_ADC1_AD_SEL2 = 0x24000008, -+ SSP_PCAP_ADJ_BIT_ADC1_ADA10 = 0x24000010, -+ SSP_PCAP_ADJ_BIT_ADC1_ADA11 = 0x24000020, -+ SSP_PCAP_ADJ_BIT_ADC1_ADA12 = 0x24000040, -+ SSP_PCAP_ADJ_BIT_ADC1_ADA20 = 0x24000080, -+ SSP_PCAP_ADJ_BIT_ADC1_ADA21 = 0x24000100, -+ SSP_PCAP_ADJ_BIT_ADC1_ADA22 = 0x24000200, -+ SSP_PCAP_ADJ_BIT_ADC1_ATO0 = 0x24000400, -+ SSP_PCAP_ADJ_BIT_ADC1_ATO1 = 0x24000800, -+ SSP_PCAP_ADJ_BIT_ADC1_ATO2 = 0x24001000, -+ SSP_PCAP_ADJ_BIT_ADC1_ATO3 = 0x24002000, -+ SSP_PCAP_ADJ_BIT_ADC1_ATOX = 0x24004000, -+ SSP_PCAP_ADJ_BIT_ADC1_MTR1 = 0x24008000, -+ SSP_PCAP_ADJ_BIT_ADC1_MTR2 = 0x24010000, -+ SSP_PCAP_ADJ_BIT_ADC1_TS_M0 = 0x24020000, -+ SSP_PCAP_ADJ_BIT_ADC1_TS_M1 = 0x24040000, -+ SSP_PCAP_ADJ_BIT_ADC1_TS_M2 = 0x24080000, -+ SSP_PCAP_ADJ_BIT_ADC1_TS_REF_LOWPWR = 0x24100000, -+ SSP_PCAP_ADJ_BIT_ADC1_TS_REFENB = 0x24200000, -+ SSP_PCAP_ADJ_BIT_ADC1_BATT_I_POLARITY = 0x24400000, -+ SSP_PCAP_ADJ_BIT_ADC1_BATT_I_ADC = 0x24800000, -+ -+ SSP_PCAP_ADJ_BIT_ADC2_ADD10 = 0x28000001, -+ SSP_PCAP_ADJ_BIT_ADC2_ADD11 = 0x28000002, -+ SSP_PCAP_ADJ_BIT_ADC2_ADD12 = 0x28000004, -+ SSP_PCAP_ADJ_BIT_ADC2_ADD13 = 0x28000008, -+ SSP_PCAP_ADJ_BIT_ADC2_ADD14 = 0x28000010, -+ SSP_PCAP_ADJ_BIT_ADC2_ADD15 = 0x28000020, -+ SSP_PCAP_ADJ_BIT_ADC2_ADD16 = 0x28000040, -+ SSP_PCAP_ADJ_BIT_ADC2_ADD17 = 0x28000080, -+ SSP_PCAP_ADJ_BIT_ADC2_ADD18 = 0x28000100, -+ SSP_PCAP_ADJ_BIT_ADC2_ADD19 = 0x28000200, -+ SSP_PCAP_ADJ_BIT_ADC2_ADD20 = 0x28000400, -+ SSP_PCAP_ADJ_BIT_ADC2_ADD21 = 0x28000800, -+ SSP_PCAP_ADJ_BIT_ADC2_ADD22 = 0x28001000, -+ SSP_PCAP_ADJ_BIT_ADC2_ADD23 = 0x28002000, -+ SSP_PCAP_ADJ_BIT_ADC2_ADD24 = 0x28004000, -+ SSP_PCAP_ADJ_BIT_ADC2_ADD25 = 0x28008000, -+ SSP_PCAP_ADJ_BIT_ADC2_ADD26 = 0x28010000, -+ SSP_PCAP_ADJ_BIT_ADC2_ADD27 = 0x28020000, -+ SSP_PCAP_ADJ_BIT_ADC2_ADD28 = 0x28040000, -+ SSP_PCAP_ADJ_BIT_ADC2_ADD29 = 0x28080000, -+ SSP_PCAP_ADJ_BIT_ADC2_ADINC1 = 0x28100000, -+ SSP_PCAP_ADJ_BIT_ADC2_ADINC2 = 0x28200000, -+ SSP_PCAP_ADJ_BIT_ADC2_ASC = 0x28400000, -+ -+ SSP_PCAP_ADJ_BIT_AUD_CODEC_AUDIHPF = 0x2c000001, -+ SSP_PCAP_ADJ_BIT_AUD_CODEC_SMB = 0x2c000002, -+ SSP_PCAP_ADJ_BIT_AUD_CODEC_AUDOHPF = 0x2c000004, -+ SSP_PCAP_ADJ_BIT_AUD_CODEC_CD_TS = 0x2c000008, -+ SSP_PCAP_ADJ_BIT_AUD_CODEC_DLM = 0x2c000010, -+ SSP_PCAP_ADJ_BIT_AUD_CODEC_ADITH = 0x2c000020, -+ SSP_PCAP_ADJ_BIT_AUD_CODEC_CDC_CLK0 = 0x2c000040, -+ SSP_PCAP_ADJ_BIT_AUD_CODEC_CDC_CLK1 = 0x2c000080, -+ SSP_PCAP_ADJ_BIT_AUD_CODEC_CDC_CLK2 = 0x2c000100, -+ SSP_PCAP_ADJ_BIT_AUD_CODEC_CLK_INV = 0x2c000200, -+ SSP_PCAP_ADJ_BIT_AUD_CODEC_FS_INV = 0x2c000400, -+ SSP_PCAP_ADJ_BIT_AUD_CODEC_DF_RESET = 0x2c000800, -+ SSP_PCAP_ADJ_BIT_AUD_CODEC_CDC_EN = 0x2c001000, -+ SSP_PCAP_ADJ_BIT_AUD_CODEC_CDC_CLK_EN = 0x2c002000, -+ SSP_PCAP_ADJ_BIT_AUD_CODEC_FS_8K_16K = 0x2c004000, -+ SSP_PCAP_ADJ_BIT_AUD_CODEC_DIG_AUD_IN = 0x2c008000, -+ SSP_PCAP_ADJ_BIT_AUD_CODEC_CLK_IN_SEL = 0x2c010000, -+ SSP_PCAP_ADJ_BIT_AUD_CODEC_MIC2_MUX = 0x2c020000, -+ SSP_PCAP_ADJ_BIT_AUD_CODEC_MIC2IG0 = 0x2c040000, -+ SSP_PCAP_ADJ_BIT_AUD_CODEC_MIC2IG1 = 0x2c080000, -+ SSP_PCAP_ADJ_BIT_AUD_CODEC_MIC2IG2 = 0x2c100000, -+ SSP_PCAP_ADJ_BIT_AUD_CODEC_MIC2IG3 = 0x2c200000, -+ SSP_PCAP_ADJ_BIT_AUD_CODEC_MIC2IG4 = 0x2c400000, -+ SSP_PCAP_ADJ_BIT_AUD_CODEC_MIC2IG_PRI_ADJ = 0x2c800000, -+ SSP_PCAP_ADJ_BIT_AUD_CODEC_CDC_PRI_ADJ = 0x2c200000, -+ -+ SSP_PCAP_ADJ_BIT_AUD_RX_AMPS_A1_EN = 0x30000001, -+ SSP_PCAP_ADJ_BIT_AUD_RX_AMPS_A2_EN = 0x30000002, -+ SSP_PCAP_ADJ_BIT_AUD_RX_AMPS_A4_EN = 0x30000010, -+ SSP_PCAP_ADJ_BIT_AUD_RX_AMPS_ARIGHT_EN = 0x30000020, -+ SSP_PCAP_ADJ_BIT_AUD_RX_AMPS_ALEFT_EN = 0x30000040, -+ SSP_PCAP_ADJ_BIT_AUD_RX_AMPS_CD_BYP = 0x30000080, -+ SSP_PCAP_ADJ_BIT_AUD_RX_AMPS_CDC_SW = 0x30000100, -+ SSP_PCAP_ADJ_BIT_AUD_RX_AMPS_ST_DAC_SW = 0x30000200, -+ SSP_PCAP_ADJ_BIT_AUD_RX_AMPS_PGA_IN_SW = 0x30000400, -+ SSP_PCAP_ADJ_BIT_AUD_RX_AMPS_PGA_R_EN = 0x30000800, -+ SSP_PCAP_ADJ_BIT_AUD_RX_AMPS_PGA_L_EN = 0x30001000, -+ SSP_PCAP_ADJ_BIT_AUD_RX_AMPS_AUDOG0 = 0x30002000, -+ SSP_PCAP_ADJ_BIT_AUD_RX_AMPS_AUDOG1 = 0x30004000, -+ SSP_PCAP_ADJ_BIT_AUD_RX_AMPS_AUDOG2 = 0x30008000, -+ SSP_PCAP_ADJ_BIT_AUD_RX_AMPS_AUDOG3 = 0x30010000, -+ SSP_PCAP_ADJ_BIT_AUD_RX_AMPS_A1CTRL = 0x30020000, -+ SSP_PCAP_ADJ_BIT_AUD_RX_AMPS_MONO0 = 0x30080000, -+ SSP_PCAP_ADJ_BIT_AUD_RX_AMPS_MONO1 = 0x30100000, -+ SSP_PCAP_ADJ_BIT_AUD_RX_AMPS_AUDOG_PRI_ADJ = 0x30200000, -+ SSP_PCAP_ADJ_BIT_AUD_RX_AMPS_MONO_PRI_ADJ = 0x30400000, -+ SSP_PCAP_ADJ_BIT_AUD_RX_AMPS_RX_PRI_ADJ0 = 0x30800000, -+ SSP_PCAP_ADJ_BIT_AUD_RX_AMPS_RX_PRI_ADJ1 = 0x31000000, -+ -+ SSP_PCAP_ADJ_BIT_ST_DAC_SMB_ST_DAC = 0x34000001, -+ SSP_PCAP_ADJ_BIT_ST_DAC_STDET_EN = 0x34000002, -+ SSP_PCAP_ADJ_BIT_ST_DAC_ST_CLK0 = 0x34000004, -+ SSP_PCAP_ADJ_BIT_ST_DAC_ST_CLK1 = 0x34000008, -+ SSP_PCAP_ADJ_BIT_ST_DAC_ST_CLK2 = 0x34000010, -+ SSP_PCAP_ADJ_BIT_ST_DAC_ST_CLK_EN = 0x34000020, -+ SSP_PCAP_ADJ_BIT_ST_DAC_DF_RESET_ST_DAC = 0x34000040, -+ SSP_PCAP_ADJ_BIT_ST_DAC_ST_DAC_EN = 0x34000080, -+ SSP_PCAP_ADJ_BIT_ST_DAC_SR0 = 0x34000100, -+ SSP_PCAP_ADJ_BIT_ST_DAC_SR1 = 0x34000200, -+ SSP_PCAP_ADJ_BIT_ST_DAC_SR2 = 0x34000400, -+ SSP_PCAP_ADJ_BIT_ST_DAC_SR3 = 0x34000800, -+ SSP_PCAP_ADJ_BIT_ST_DAC_DIG_AUD_IN_ST_DAC = 0x34001000, -+ SSP_PCAP_ADJ_BIT_ST_DAC_DIG_AUD_FS0 = 0x34002000, -+ SSP_PCAP_ADJ_BIT_ST_DAC_DIG_AUD_FS1 = 0x34004000, -+ SSP_PCAP_ADJ_BIT_ST_DAC_BCLK0 = 0x34008000, -+ SSP_PCAP_ADJ_BIT_ST_DAC_BCLK1 = 0x34010000, -+ SSP_PCAP_ADJ_BIT_ST_DAC_ST_CLK_INV = 0x34020000, -+ SSP_PCAP_ADJ_BIT_ST_DAC_ST_FS_INV = 0x34040000, -+ SSP_PCAP_ADJ_BIT_ST_DAC_ST_DAC_CLK_IN_SEL = 0x34080000, -+ SSP_PCAP_ADJ_BIT_ST_DAC_ST_DAC_PRI_ADJ = 0x35000000, -+ -+ SSP_PCAP_ADJ_BIT_BUSCTRL_FSENB = 0x50000001, -+ SSP_PCAP_ADJ_BIT_BUSCTRL_USB_SUSPEND = 0x50000002, -+ SSP_PCAP_ADJ_BIT_BUSCTRL_USB_PU = 0x50000004, -+ SSP_PCAP_ADJ_BIT_BUSCTRL_USB_PD = 0x50000008, -+ SSP_PCAP_ADJ_BIT_BUSCTRL_VUSB_EN = 0x50000010, -+ SSP_PCAP_ADJ_BIT_BUSCTRL_USB_PS = 0x50000020, -+ SSP_PCAP_ADJ_BIT_BUSCTRL_VUSB_MSTR_EN = 0x50000040, -+ SSP_PCAP_ADJ_BIT_BUSCTRL_VBUS_PD_ENB = 0x50000080, -+ SSP_PCAP_ADJ_BIT_BUSCTRL_CURRLIM = 0x50000100, -+ SSP_PCAP_ADJ_BIT_BUSCTRL_RS232ENB = 0x50000200, -+ SSP_PCAP_ADJ_BIT_BUSCTRL_RS232_DIR = 0x50000400, -+ SSP_PCAP_ADJ_BIT_BUSCTRL_SE0_CONN = 0x50000800, -+ SSP_PCAP_ADJ_BIT_BUSCTRL_USB_PDM = 0x50001000, -+ SSP_PCAP_ADJ_BIT_BUSCTRL_BUS_PRI_ADJ = 0x51000000, -+ -+ SSP_PCAP_ADJ_BIT_PERIPH_BL_CTRL0 = 0x54000001, -+ SSP_PCAP_ADJ_BIT_PERIPH_BL_CTRL1 = 0x54000002, -+ SSP_PCAP_ADJ_BIT_PERIPH_BL_CTRL2 = 0x54000004, -+ SSP_PCAP_ADJ_BIT_PERIPH_BL_CTRL3 = 0x54000008, -+ SSP_PCAP_ADJ_BIT_PERIPH_BL_CTRL4 = 0x54000010, -+ SSP_PCAP_ADJ_BIT_PERIPH_LEDR_EN = 0x54000020, -+ SSP_PCAP_ADJ_BIT_PERIPH_LEDG_EN = 0x54000040, -+ SSP_PCAP_ADJ_BIT_PERIPH_LEDR_CTRL0 = 0x54000080, -+ SSP_PCAP_ADJ_BIT_PERIPH_LEDR_CTRL1 = 0x54000100, -+ SSP_PCAP_ADJ_BIT_PERIPH_LEDR_CTRL2 = 0x54000200, -+ SSP_PCAP_ADJ_BIT_PERIPH_LEDR_CTRL3 = 0x54000400, -+ SSP_PCAP_ADJ_BIT_PERIPH_LEDG_CTRL0 = 0x54000800, -+ SSP_PCAP_ADJ_BIT_PERIPH_LEDG_CTRL1 = 0x54001000, -+ SSP_PCAP_ADJ_BIT_PERIPH_LEDG_CTRL2 = 0x54002000, -+ SSP_PCAP_ADJ_BIT_PERIPH_LEDG_CTRL3 = 0x54004000, -+ SSP_PCAP_ADJ_BIT_PERIPH_LEDR_I0 = 0x54008000, -+ SSP_PCAP_ADJ_BIT_PERIPH_LEDR_I1 = 0x54010000, -+ SSP_PCAP_ADJ_BIT_PERIPH_LEDG_I0 = 0x54020000, -+ SSP_PCAP_ADJ_BIT_PERIPH_LEDG_I1 = 0x54040000, -+ SSP_PCAP_ADJ_BIT_PERIPH_SKIP = 0x54080000, -+ SSP_PCAP_ADJ_BIT_PERIPH_BL2_CTRL0 = 0x54100000, -+ SSP_PCAP_ADJ_BIT_PERIPH_BL2_CTRL1 = 0x54200000, -+ SSP_PCAP_ADJ_BIT_PERIPH_BL2_CTRL2 = 0x54400000, -+ SSP_PCAP_ADJ_BIT_PERIPH_BL2_CTRL3 = 0x54800000, -+ SSP_PCAP_ADJ_BIT_PERIPH_BL2_CTRL4 = 0x55000000, -+ -+ SSP_PCAP_ADJ_BIT_LOWPWR_CTRL_VAUX2_STBY = 0x60000001, -+ SSP_PCAP_ADJ_BIT_LOWPWR_CTRL_VAUX2_LOWPWR = 0x60000002, -+ SSP_PCAP_ADJ_BIT_LOWPWR_CTRL_VAUX3_STBY = 0x60000004, -+ SSP_PCAP_ADJ_BIT_LOWPWR_CTRL_VAUX3_LOWPWR = 0x60000008, -+ SSP_PCAP_ADJ_BIT_LOWPWR_CTRL_VAUX4_STBY = 0x60000010, -+ SSP_PCAP_ADJ_BIT_LOWPWR_CTRL_VAUX4_LOWPWR = 0x60000020, -+ SSP_PCAP_ADJ_BIT_LOWPWR_CTRL_VSIM_LOWPWR = 0x60000040, -+ SSP_PCAP_ADJ_BIT_LOWPWR_CTRL_VSIM2_LOWPWR = 0x60000080, -+ SSP_PCAP_ADJ_BIT_LOWPWR_CTRL_SW1_MODE00 = 0x60000100, -+ SSP_PCAP_ADJ_BIT_LOWPWR_CTRL_SW1_MODE01 = 0x60000200, -+ SSP_PCAP_ADJ_BIT_LOWPWR_CTRL_SW1_MODE10 = 0x60000400, -+ SSP_PCAP_ADJ_BIT_LOWPWR_CTRL_SW1_MODE11 = 0x60000800, -+ SSP_PCAP_ADJ_BIT_LOWPWR_CTRL_SW10_DVS = 0x60001000, -+ SSP_PCAP_ADJ_BIT_LOWPWR_CTRL_SW11_DVS = 0x60002000, -+ SSP_PCAP_ADJ_BIT_LOWPWR_CTRL_SW12_DVS = 0x60004000, -+ SSP_PCAP_ADJ_BIT_LOWPWR_CTRL_SW13_DVS = 0x60008000, -+ SSP_PCAP_ADJ_BIT_LOWPWR_CTRL_SW2_MODE00 = 0x60010000, -+ SSP_PCAP_ADJ_BIT_LOWPWR_CTRL_SW2_MODE01 = 0x60020000, -+ SSP_PCAP_ADJ_BIT_LOWPWR_CTRL_SW2_MODE10 = 0x60040000, -+ SSP_PCAP_ADJ_BIT_LOWPWR_CTRL_SW2_MODE11 = 0x60080000, -+ SSP_PCAP_ADJ_BIT_LOWPWR_CTRL_SW20_DVS = 0x60100000, -+ SSP_PCAP_ADJ_BIT_LOWPWR_CTRL_SW21_DVS = 0x60200000, -+ SSP_PCAP_ADJ_BIT_LOWPWR_CTRL_SW22_DVS = 0x60400000, -+ SSP_PCAP_ADJ_BIT_LOWPWR_CTRL_SW23_DVS = 0x60800000, -+ SSP_PCAP_ADJ_BIT_LOWPWR_CTRL_VC_STBY = 0x61000000, -+ -+ SSP_PCAP_ADJ_BIT_TX_AUD_AMPS_AUDIG0 = 0x68000001, -+ SSP_PCAP_ADJ_BIT_TX_AUD_AMPS_AUDIG1 = 0x68000002, -+ SSP_PCAP_ADJ_BIT_TX_AUD_AMPS_AUDIG2 = 0x68000004, -+ SSP_PCAP_ADJ_BIT_TX_AUD_AMPS_AUDIG3 = 0x68000008, -+ SSP_PCAP_ADJ_BIT_TX_AUD_AMPS_AUDIG4 = 0x68000010, -+ SSP_PCAP_ADJ_BIT_TX_AUD_AMPS_A3_EN = 0x68000020, -+ SSP_PCAP_ADJ_BIT_TX_AUD_AMPS_A3_MUX = 0x68000040, -+ SSP_PCAP_ADJ_BIT_TX_AUD_AMPS_A5_EN = 0x68000080, -+ SSP_PCAP_ADJ_BIT_TX_AUD_AMPS_A5_MUX = 0x68000100, -+ SSP_PCAP_ADJ_BIT_TX_AUD_AMPS_EXT_MIC_MUX = 0x68000200, -+ SSP_PCAP_ADJ_BIT_TX_AUD_AMPS_MB_ON2 = 0x68000400, -+ SSP_PCAP_ADJ_BIT_TX_AUD_AMPS_MB_ON1 = 0x68000800, -+ SSP_PCAP_ADJ_BIT_TX_AUD_AMPS_A1ID_TX = 0x68001000, -+ SSP_PCAP_ADJ_BIT_TX_AUD_AMPS_A1_CONFIG = 0x68002000, -+ SSP_PCAP_ADJ_BIT_TX_AUD_AMPS_AHS_CONFIG = 0x68004000, -+ SSP_PCAP_ADJ_BIT_TX_AUD_AMPS_A2_CONFIG = 0x68008000, -+ SSP_PCAP_ADJ_BIT_TX_AUD_AMPS_AUDIO_LOWPWR = 0x68080000, -+ SSP_PCAP_ADJ_BIT_TX_AUD_AMPS_AUDIO_STBY = 0x68100000, -+ SSP_PCAP_ADJ_BIT_TX_AUD_AMPS_V2_EN_2 = 0x68200000, -+ SSP_PCAP_ADJ_BIT_TX_AUD_AMPS_AUDIG_PRI_ADJ = 0x68400000, -+ SSP_PCAP_ADJ_BIT_TX_AUD_AMPS_TX_PRI_ADJ0 = 0x68800000, -+ SSP_PCAP_ADJ_BIT_TX_AUD_AMPS_TX_PRI_ADJ1 = 0x69000000, -+ -+ SSP_PCAP_ADJ_BIT_SYS_RST_CLR = 0x6c000001, -+ SSP_PCAP_ADJ_BIT_SYS_RST_MODE0 = 0x6c000002, -+ SSP_PCAP_ADJ_BIT_SYS_RST_MODE1 = 0x6c000004, -+ SSP_PCAP_ADJ_BIT_SYS_VFLASH_0 = 0x6c000008, -+ SSP_PCAP_ADJ_BIT_SYS_VFLASH_1 = 0x6c000010, -+ SSP_PCAP_ADJ_BIT_SYS_MID_SELECT = 0x6c000020, -+ SSP_PCAP_ADJ_BIT_SYS_MID_FET = 0x6c000040, -+ SSP_PCAP_ADJ_BIT_SYS_MAIN_LOW = 0x6c000080, -+ SSP_PCAP_ADJ_BIT_SYS_BATTFB_DIS = 0x6c000100, -+ SSP_PCAP_ADJ_BIT_SYS_GP_REG9 = 0x6c000200, -+ SSP_PCAP_ADJ_BIT_SYS_GP_REG10 = 0x6c000400, -+ SSP_PCAP_ADJ_BIT_SYS_GP_REG11 = 0x6c000800, -+ SSP_PCAP_ADJ_BIT_SYS_GP_REG12 = 0x6c001000, -+ SSP_PCAP_ADJ_BIT_SYS_GP_REG13 = 0x6c002000, -+ SSP_PCAP_ADJ_BIT_SYS_GP_REG14 = 0x6c004000, -+ SSP_PCAP_ADJ_BIT_SYS_GP_REG15 = 0x6c008000, -+ SSP_PCAP_ADJ_BIT_SYS_GP_REG16 = 0x6c010000, -+ SSP_PCAP_ADJ_BIT_SYS_GP_REG17 = 0x6c020000, -+ SSP_PCAP_ADJ_BIT_SYS_GP_REG18 = 0x6c040000, -+ SSP_PCAP_ADJ_BIT_SYS_GP_REG19 = 0x6c080000, -+ SSP_PCAP_ADJ_BIT_SYS_GP_REG20 = 0x6c100000, -+ SSP_PCAP_ADJ_BIT_SYS_GP_REG21 = 0x6c200000, -+ SSP_PCAP_ADJ_BIT_SYS_GP_REG22 = 0x6c400000, -+ SSP_PCAP_ADJ_BIT_SYS_GP_REG23 = 0x6c800000, -+ SSP_PCAP_ADJ_BIT_SYS_GP_REG24 = 0x6d000000 -+ -+}SSP_PCAP_SECONDARY_PROCESSOR_REGISTER_BIT_TYPE; -+ -+/************************ FUNCTION PROTOTYPES **************************************/ -+extern void ssp_pcap_init(void); -+extern void ssp_pcap_release(void); -+ -+extern void ssp_pcap_open(SSP_PCAP_INIT_DRIVER_TYPE portType); -+extern void ssp_pcap_close(void); -+ -+extern void ssp_pcap_intoSleep_callBack(void); -+extern void ssp_pcap_wakeUp_callBack(void); -+ -+ -+extern SSP_PCAP_STATUS SSP_PCAP_write_data_to_PCAP(SSP_PCAP_SECONDARY_PROCESSOR_REGISTER ssp_pcap_register,U32 ssp_pcap_register_value); -+extern SSP_PCAP_STATUS SSP_PCAP_read_data_from_PCAP(SSP_PCAP_SECONDARY_PROCESSOR_REGISTER ssp_pcap_register,P_U32 p_ssp_pcap_register_value); -+ -+extern SSP_PCAP_STATUS SSP_PCAP_bit_set(SSP_PCAP_SECONDARY_PROCESSOR_REGISTER_BIT_TYPE ssp_pcap_bit ) ; -+extern SSP_PCAP_STATUS SSP_PCAP_bit_clean(SSP_PCAP_SECONDARY_PROCESSOR_REGISTER_BIT_TYPE ssp_pcap_bit ) ; -+extern SSP_PCAP_BIT_STATUS SSP_PCAP_get_bit_from_buffer(SSP_PCAP_SECONDARY_PROCESSOR_REGISTER_BIT_TYPE ssp_pcap_bit ) ; -+extern SSP_PCAP_BIT_STATUS SSP_PCAP_get_bit_from_PCAP(SSP_PCAP_SECONDARY_PROCESSOR_REGISTER_BIT_TYPE ssp_pcap_bit ) ; -+extern U32 SSP_PCAP_get_register_value_from_buffer(SSP_PCAP_SECONDARY_PROCESSOR_REGISTER ssp_pcap_register ) ; -+ -+extern SSP_PCAP_STATUS SSP_PCAP_TSI_mode_set(TOUCH_SCREEN_DETECT_TYPE mode_Type ); -+extern SSP_PCAP_STATUS SSP_PCAP_TSI_start_XY_read(void); -+extern SSP_PCAP_STATUS SSP_PCAP_TSI_get_XY_value(P_U16 p_x,P_U16 p_y); -+extern SSP_PCAP_STATUS SSP_PCAP_CDC_CLK_set(PHONE_CDC_CLOCK_TYPE clkType); -+ -+extern SSP_PCAP_STATUS SSP_PCAP_CDC_SR_set(ST_SAMPLE_RATE_TYPE srType); -+extern SSP_PCAP_STATUS SSP_PCAP_BCLK_set(ST_BCLK_TIME_SLOT_TYPE bclkType); -+extern SSP_PCAP_STATUS SSP_PCAP_STCLK_set(ST_CLK_TYPE stClkType); -+extern SSP_PCAP_STATUS SSP_PCAP_DIG_AUD_FS_set(DIG_AUD_MODE_TYPE fsType); -+extern SSP_PCAP_STATUS SSP_PCAP_AUDIG_set(U32 audioInGain); -+extern SSP_PCAP_STATUS SSP_PCAP_MONO_set(MONO_TYPE monoType); -+extern SSP_PCAP_STATUS SSP_PCAP_AUDOG_set(U32 audioOutGain); -+ -+extern SSP_PCAP_STATUS SSP_PCAP_V_VIB_level_set(VibratorVoltageLevel_TYPE VIBLevelType); -+extern SSP_PCAP_STATUS SSP_PCAP_configure_USB_UART_transeiver(SSP_PCAP_PORT_TYPE portType); -+extern SSP_PCAP_BIT_STATUS SSP_PCAP_get_audio_in_status(void); -+ -+/* for log */ -+extern void pcap_log_add_pure_data(u8* pData,u32 len); -+extern void pcap_log_add_data(u8* pData,u32 len); -+ -+/* screen lock on/off handler */ -+extern void ssp_pcap_screenlock_lock(u32 data); -+extern void ssp_pcap_screenlock_unlock(u32 data); -+ -+#endif -Index: linux-2.6.20.7/include/asm-arm/arch-pxa/irqs.h -=================================================================== ---- linux-2.6.20.7.orig/include/asm-arm/arch-pxa/irqs.h 2007-04-21 08:26:32.000000000 -0300 -+++ linux-2.6.20.7/include/asm-arm/arch-pxa/irqs.h 2007-04-21 08:26:37.000000000 -0300 -@@ -176,7 +176,8 @@ - #define NR_IRQS (IRQ_LOCOMO_SPI_TEND + 1) - #elif defined(CONFIG_ARCH_LUBBOCK) || \ - defined(CONFIG_MACH_LOGICPD_PXA270) || \ -- defined(CONFIG_MACH_MAINSTONE) -+ defined(CONFIG_MACH_MAINSTONE) || \ -+ defined(CONFIG_PXA_EZX) - #define NR_IRQS (IRQ_BOARD_END) - #else - #define NR_IRQS (IRQ_BOARD_START) -@@ -222,3 +223,16 @@ - #define IRQ_LOCOMO_GPIO_BASE (IRQ_BOARD_START + 1) - #define IRQ_LOCOMO_LT_BASE (IRQ_BOARD_START + 2) - #define IRQ_LOCOMO_SPI_BASE (IRQ_BOARD_START + 3) -+ -+/* EZX Interrupts (CONFIG_EZX) */ -+#define EZX_IRQ(x) (IRQ_BOARD_START + (x)) -+#define EZX_IRQ_ADCDONE EZX_IRQ(0) /* PCAP */ -+#define EZX_IRQ_TS EZX_IRQ(1) /* PCAP */ -+#define EZX_IRQ_USB4V EZX_IRQ(2) /* PCAP */ -+#define EZX_IRQ_USB1V EZX_IRQ(3) /* PCAP */ -+#define EZX_IRQ_HEADJACK EZX_IRQ(4) /* PCAP */ -+#define EZX_IRQ_MIC EZX_IRQ(5) /* PCAP */ -+#define EZX_IRQ_ADCDONE2 EZX_IRQ(6) /* PCAP */ -+#define EZX_IRQ_ONOFF EZX_IRQ(7) -+#define EZX_IRQ_ONOFF2 EZX_IRQ(8) -+ -Index: linux-2.6.20.7/arch/arm/mach-pxa/Makefile -=================================================================== ---- linux-2.6.20.7.orig/arch/arm/mach-pxa/Makefile 2007-04-21 08:26:37.000000000 -0300 -+++ linux-2.6.20.7/arch/arm/mach-pxa/Makefile 2007-04-21 08:45:09.000000000 -0300 -@@ -18,7 +18,7 @@ - obj-$(CONFIG_MACH_AKITA) += akita-ioexp.o - obj-$(CONFIG_MACH_POODLE) += poodle.o corgi_ssp.o - obj-$(CONFIG_MACH_TOSA) += tosa.o --obj-$(CONFIG_PXA_EZX) += ezx.o ezx_lcd.o ezx_ssp.o -+obj-$(CONFIG_PXA_EZX) += ezx.o ezx_lcd.o ezx_ssp.o ezx-pcap.o - - # Support for blinky lights - led-y := leds.o -Index: linux-2.6.20.7/arch/arm/mach-pxa/ezx.c -=================================================================== ---- linux-2.6.20.7.orig/arch/arm/mach-pxa/ezx.c 2007-04-21 08:26:37.000000000 -0300 -+++ linux-2.6.20.7/arch/arm/mach-pxa/ezx.c 2007-04-21 08:51:15.000000000 -0300 -@@ -73,6 +73,24 @@ - .clk_pcap = 1, - }; - -+/* PCAP */ -+static struct resource ezxpcap_resources[] = { -+ [0] = { -+ .start = IRQ_GPIO1, -+ .end = IRQ_GPIO1, -+ .flags = IORESOURCE_IRQ, -+ }, -+}; -+ -+struct platform_device ezxpcap_device = { -+ .name = "ezx-pcap", -+ .id = -1, -+ .dev = { -+ .parent = &ezxssp_device.dev, -+ }, -+ .num_resources = ARRAY_SIZE(ezxpcap_resources), -+ .resource = ezxpcap_resources, -+}; - - /* OHCI Controller */ - -@@ -236,7 +254,7 @@ - }; - - --static struct resource ezx_bp_resources[] = { -+static struct resource ezxbp_resources[] = { - [0] = { - .start = GPIO_BP_RDY, - .end = GPIO_BP_RDY, -@@ -256,15 +274,15 @@ - #endif - }; - --static struct platform_device ezx_bp_device = { -+static struct platform_device ezxbp_device = { - .name = "ezx-bp", - .dev = { - //.parent = - //.platform_data = - }, - .id = -1, -- .num_resources = ARRAY_SIZE(ezx_bp_resources), -- .resource = ezx_bp_resources, -+ .num_resources = ARRAY_SIZE(ezxbp_resources), -+ .resource = ezxbp_resources, - }; - - static void __init ezx_init_gpio_irq(void) -@@ -297,7 +315,8 @@ - - static struct platform_device *devices[] __initdata = { - &ezxssp_device, -- &ezx_bp_device, -+ &ezxpcap_device, -+ &ezxbp_device, - }; - - static void __init a780_init(void) diff --git a/packages/linux/linux-ezx-2.6.20.7/ezx-serial-bug-workaround.patch b/packages/linux/linux-ezx-2.6.20.7/ezx-serial-bug-workaround.patch deleted file mode 100644 index 9f30cc35fe..0000000000 --- a/packages/linux/linux-ezx-2.6.20.7/ezx-serial-bug-workaround.patch +++ /dev/null @@ -1,45 +0,0 @@ -Work around some errata in the pxa serial code (copied from motorolas 2.4.x tree) - -Index: linux-2.6.20.7/drivers/serial/pxa.c -=================================================================== ---- linux-2.6.20.7.orig/drivers/serial/pxa.c 2007-04-21 13:57:46.000000000 -0300 -+++ linux-2.6.20.7/drivers/serial/pxa.c 2007-04-21 14:05:03.000000000 -0300 -@@ -29,6 +29,10 @@ - #define SUPPORT_SYSRQ - #endif - -+#define pxa_buggy_port(x) ({ \ -+ int cpu_ver; asm("mrc%? p15, 0, %0, c0, c0" : "=r" (cpu_ver)); \ -+ ((x) == PORT_PXA && (cpu_ver & ~1) == 0x69052100); }) -+ - #include <linux/module.h> - #include <linux/ioport.h> - #include <linux/init.h> -@@ -195,7 +199,7 @@ - if (uart_circ_empty(xmit)) - serial_pxa_stop_tx(&up->port); - } -- -+static inline irqreturn_t serial_pxa_irq(int, void *); - static void serial_pxa_start_tx(struct uart_port *port) - { - struct uart_pxa_port *up = (struct uart_pxa_port *)port; -@@ -203,6 +207,8 @@ - if (!(up->ier & UART_IER_THRI)) { - up->ier |= UART_IER_THRI; - serial_out(up, UART_IER, up->ier); -+ if (pxa_buggy_port(up->port.type)) -+ serial_pxa_irq(up->port.irq, NULL); - } - } - -@@ -298,6 +304,9 @@ - - mcr |= up->mcr; - -+ if (pxa_buggy_port(up->port.type) && up->port.irq != 0) -+ mcr ^= UART_MCR_OUT2; -+ - serial_out(up, UART_MCR, mcr); - } - diff --git a/packages/linux/linux-ezx-2.6.20.7/mux-fix-init-errorpath.patch b/packages/linux/linux-ezx-2.6.20.7/mux-fix-init-errorpath.patch deleted file mode 100644 index 716ef86fd1..0000000000 --- a/packages/linux/linux-ezx-2.6.20.7/mux-fix-init-errorpath.patch +++ /dev/null @@ -1,20 +0,0 @@ -Index: linux-2.6.16/drivers/char/ts0710_mux_usb.c -=================================================================== ---- linux-2.6.16.orig/drivers/char/ts0710_mux_usb.c 2007-01-17 00:10:32.000000000 +0100 -+++ linux-2.6.16/drivers/char/ts0710_mux_usb.c 2007-01-17 00:42:23.000000000 +0100 -@@ -811,7 +811,6 @@ - /*init the related mux interface*/ - if (!(bvd_ipc = kzalloc(sizeof(struct ipc_usb_data), GFP_KERNEL))) { - err("usb_ipc_init: Out of memory."); -- usb_deregister(&usb_ipc_driver); - return -ENOMEM; - } - bvd_dbg("usb_ipc_init: Address of bvd_ipc:%p", bvd_ipc); -@@ -819,7 +818,6 @@ - if (!(bvd_ipc->xmit.buf = kmalloc(IPC_USB_XMIT_SIZE, GFP_KERNEL))) { - err("usb_ipc_init: Not enough memory for the input buffer."); - kfree(bvd_ipc); -- usb_deregister(&usb_ipc_driver); - return -ENOMEM; - } - bvd_dbg("usb_ipc_init: bvd_ipc->xmit.buf address:%p", diff --git a/packages/linux/linux-ezx-2.6.20.7/mux-fix-makefile.patch b/packages/linux/linux-ezx-2.6.20.7/mux-fix-makefile.patch deleted file mode 100644 index f7884ca524..0000000000 --- a/packages/linux/linux-ezx-2.6.20.7/mux-fix-makefile.patch +++ /dev/null @@ -1,14 +0,0 @@ -Index: linux-2.6.20.7/drivers/char/Makefile -=================================================================== ---- linux-2.6.20.7.orig/drivers/char/Makefile 2007-04-22 10:51:23.000000000 +0200 -+++ linux-2.6.20.7/drivers/char/Makefile 2007-04-22 10:52:48.000000000 +0200 -@@ -101,7 +101,8 @@ - obj-$(CONFIG_HANGCHECK_TIMER) += hangcheck-timer.o - obj-$(CONFIG_TCG_TPM) += tpm/ - --obj-$(CONFIG_TS0710_MUX) += ts0710_mux.o ts0710_mux_usb.o -+obj-$(CONFIG_TS0710_MUX_USB) += ts0710_mux_usb.o -+obj-$(CONFIG_TS0710_MUX) += ts0710_mux.o - - - # Files generated that shall be removed upon make clean diff --git a/packages/linux/linux-ezx-2.6.20.7/mux-fix-tty-driver.patch b/packages/linux/linux-ezx-2.6.20.7/mux-fix-tty-driver.patch deleted file mode 100644 index 2e1aabd952..0000000000 --- a/packages/linux/linux-ezx-2.6.20.7/mux-fix-tty-driver.patch +++ /dev/null @@ -1,125 +0,0 @@ -Index: linux-2.6.20.7/drivers/char/ts0710_mux.c -=================================================================== ---- linux-2.6.20.7.orig/drivers/char/ts0710_mux.c 2007-04-22 10:51:31.000000000 +0200 -+++ linux-2.6.20.7/drivers/char/ts0710_mux.c 2007-04-22 10:53:05.000000000 +0200 -@@ -241,7 +241,8 @@ - static volatile __u8 mux_recv_info_flags[NR_MUXS]; - static mux_recv_struct *mux_recv_queue = NULL; - --static struct tty_driver mux_driver; -+// Local for 2.6? -+static struct tty_driver *mux_driver; - - #ifdef USB_FOR_MUX - #define COMM_FOR_MUX_DRIVER usb_for_mux_driver -@@ -3007,6 +3008,7 @@ - #else - mux_tty[line]++; - dlci = tty2dlci[line]; -+ mux_table[line] = tty; - - /* if( dlci == 1 ) { */ - /* Open server channel 0 first */ -@@ -3087,6 +3089,7 @@ - } - } - -+ - retval = 0; - #endif - out: -@@ -3894,43 +3897,50 @@ - INIT_WORK(&receive_tqueue, receive_worker, NULL); - INIT_WORK(&post_recv_tqueue, post_recv_worker, NULL); - -- memset(&mux_driver, 0, sizeof(struct tty_driver)); -- memset(&mux_tty, 0, sizeof(mux_tty)); -- mux_driver.magic = TTY_DRIVER_MAGIC; -- mux_driver.driver_name = "ts0710mux"; -- mux_driver.name = "ts0710mux"; -- mux_driver.major = TS0710MUX_MAJOR; -- mux_driver.minor_start = TS0710MUX_MINOR_START; -- mux_driver.num = NR_MUXS; -- mux_driver.type = TTY_DRIVER_TYPE_SERIAL; -- mux_driver.subtype = SERIAL_TYPE_NORMAL; -- mux_driver.init_termios = tty_std_termios; -- mux_driver.init_termios.c_iflag = 0; -- mux_driver.init_termios.c_oflag = 0; -- mux_driver.init_termios.c_cflag = B38400 | CS8 | CREAD; -- mux_driver.init_termios.c_lflag = 0; -- mux_driver.flags = TTY_DRIVER_RESET_TERMIOS | TTY_DRIVER_REAL_RAW; -- -- mux_driver.ttys = mux_table; -- mux_driver.termios = mux_termios; -- mux_driver.termios_locked = mux_termios_locked; -+ mux_driver = alloc_tty_driver(NR_MUXS); -+ if (!mux_driver) -+ return -ENOMEM; -+ -+ mux_driver->owner = THIS_MODULE; -+ mux_driver->driver_name = "ts0710mux"; -+ mux_driver->name = "mux"; -+ mux_driver->devfs_name = "mux"; -+ mux_driver->major = TS0710MUX_MAJOR; -+ mux_driver->minor_start = TS0710MUX_MINOR_START; -+ mux_driver->type = TTY_DRIVER_TYPE_SERIAL; -+ mux_driver->subtype = SERIAL_TYPE_NORMAL; -+ mux_driver->flags = TTY_DRIVER_RESET_TERMIOS | TTY_DRIVER_REAL_RAW; -+ -+ mux_driver->init_termios = tty_std_termios; -+ mux_driver->init_termios.c_iflag = 0; -+ mux_driver->init_termios.c_oflag = 0; -+ mux_driver->init_termios.c_cflag = B38400 | CS8 | CREAD; -+ mux_driver->init_termios.c_lflag = 0; -+ -+// mux_driver.ttys = mux_table; -+ mux_driver->termios = mux_termios; -+ mux_driver->termios_locked = mux_termios_locked; - // mux_driver.driver_state = mux_state; -- mux_driver.other = NULL; -+ mux_driver->other = NULL; - -- mux_driver.open = mux_open; -- mux_driver.close = mux_close; -- mux_driver.write = mux_write; -- mux_driver.write_room = mux_write_room; -- mux_driver.flush_buffer = mux_flush_buffer; -- mux_driver.chars_in_buffer = mux_chars_in_buffer; -- mux_driver.throttle = mux_throttle; -- mux_driver.unthrottle = mux_unthrottle; -- mux_driver.ioctl = mux_ioctl; -- mux_driver.owner = THIS_MODULE; -+ mux_driver->open = mux_open; -+ mux_driver->close = mux_close; -+ mux_driver->write = mux_write; -+ mux_driver->write_room = mux_write_room; -+ mux_driver->flush_buffer = mux_flush_buffer; -+ mux_driver->chars_in_buffer = mux_chars_in_buffer; -+ mux_driver->throttle = mux_throttle; -+ mux_driver->unthrottle = mux_unthrottle; -+ mux_driver->ioctl = mux_ioctl; - -- if (tty_register_driver(&mux_driver)) -+ // FIXME: No panic() here -+ if (tty_register_driver(mux_driver)) - panic("Couldn't register mux driver"); - -+ for (j=0; j<NR_MUXS; j++) -+ tty_register_device(mux_driver, j, NULL); -+ -+ - COMM_MUX_DISPATCHER = mux_dispatcher; - COMM_MUX_SENDER = mux_sender; - -@@ -3964,7 +3974,10 @@ - mux_recv_info[j] = 0; - } - -- if (tty_unregister_driver(&mux_driver)) -+ for (j=0; j<NR_MUXS; j++) -+ tty_unregister_device(mux_driver, j); -+ -+ if (tty_unregister_driver(mux_driver)) - panic("Couldn't unregister mux driver"); - } - diff --git a/packages/linux/linux-ezx-2.6.20.7/mux-fix.patch b/packages/linux/linux-ezx-2.6.20.7/mux-fix.patch deleted file mode 100644 index b820762f41..0000000000 --- a/packages/linux/linux-ezx-2.6.20.7/mux-fix.patch +++ /dev/null @@ -1,164 +0,0 @@ -Index: linux-2.6.20.7/drivers/char/ts0710_mux_usb.c -=================================================================== ---- linux-2.6.20.7.orig/drivers/char/ts0710_mux_usb.c 2007-04-21 18:07:45.000000000 +0200 -+++ linux-2.6.20.7/drivers/char/ts0710_mux_usb.c 2007-04-21 20:55:13.000000000 +0200 -@@ -626,7 +626,6 @@ - } - - interface = &intf->cur_altsetting->desc; -- endpoint = &intf->cur_altsetting->endpoint[0].desc; - /* Start checking for two bulk endpoints or ... FIXME: This is a future - * enhancement...*/ - bvd_dbg("usb_ipc_probe: Number of Endpoints:%d", -@@ -638,30 +637,26 @@ - - ep_cnt = have_bulk_in_mux = have_bulk_out_mux = 0; - -- bvd_dbg("usb_ipc_probe: endpoint[0] is:%x", -- (&endpoint[0])->bEndpointAddress); -- bvd_dbg("usb_ipc_probe: endpoint[1] is:%x ", -- (&endpoint[1])->bEndpointAddress); -- - while (ep_cnt < interface->bNumEndpoints) { -- -- if (!have_bulk_in_mux && IS_EP_BULK_IN(endpoint[ep_cnt])) { -- bvd_dbg("usb_ipc_probe: bEndpointAddress(IN) is:%x ", -- (&endpoint[ep_cnt])->bEndpointAddress); -- have_bulk_in_mux = -- (&endpoint[ep_cnt])->bEndpointAddress; -- readsize = (&endpoint[ep_cnt])->wMaxPacketSize; -+ endpoint = &intf->cur_altsetting->endpoint[ep_cnt].desc; -+ bvd_dbg("usb_ipc_probe: endpoint[%i] is: %x", ep_cnt, -+ endpoint->bEndpointAddress); -+ -+ if (!have_bulk_in_mux && IS_EP_BULK_IN(*endpoint)) { -+ bvd_dbg("usb_ipc_probe: bEndpointAddress(IN) is: %x ", -+ endpoint->bEndpointAddress); -+ have_bulk_in_mux = endpoint->bEndpointAddress; -+ readsize = endpoint->wMaxPacketSize; - bvd_dbg("usb_ipc_probe: readsize=%d", readsize); - ep_cnt++; - continue; - } - -- if (!have_bulk_out_mux && IS_EP_BULK_OUT(endpoint[ep_cnt])) { -- bvd_dbg("usb_ipc_probe: bEndpointAddress(OUT) is:%x ", -- (&endpoint[ep_cnt])->bEndpointAddress); -- have_bulk_out_mux = -- (&endpoint[ep_cnt])->bEndpointAddress; -- writesize = (&endpoint[ep_cnt])->wMaxPacketSize; -+ if (!have_bulk_out_mux && IS_EP_BULK_OUT(*endpoint)) { -+ bvd_dbg("usb_ipc_probe: bEndpointAddress(OUT) is: %x ", -+ endpoint->bEndpointAddress); -+ have_bulk_out_mux = endpoint->bEndpointAddress; -+ writesize = endpoint->wMaxPacketSize; - bvd_dbg("usb_ipc_probe: writesize=%d", writesize); - ep_cnt++; - continue; -@@ -718,21 +713,27 @@ - bvd_ipc->bh_bp.func = usbipc_bh_bp_func; - bvd_ipc->bh_bp.data = (unsigned long) bvd_ipc; - -+ bvd_dbg("after assignements"); - /*Build a write urb*/ -+ usb_init_urb(&bvd_ipc->writeurb_mux); - usb_fill_bulk_urb(&bvd_ipc->writeurb_mux, usbdev, - usb_sndbulkpipe(bvd_ipc->ipc_dev, - bvd_ipc->bulk_out_ep_mux), - bvd_ipc->obuf, writesize, usb_ipc_write_bulk, - bvd_ipc); - //bvd_ipc->writeurb_mux.transfer_flags |= USB_ASYNC_UNLINK; -+ bvd_dbg("after write urb"); - - /*Build a read urb and send a IN token first time*/ -+ usb_init_urb(&bvd_ipc->readurb_mux); - usb_fill_bulk_urb(&bvd_ipc->readurb_mux, usbdev, - usb_rcvbulkpipe(usbdev, bvd_ipc->bulk_in_ep_mux), - bvd_ipc->ibuf, readsize, usb_ipc_read_bulk, bvd_ipc); - //bvd_ipc->readurb_mux.transfer_flags |= USB_ASYNC_UNLINK; -+ bvd_dbg("after read urb"); - -- usb_driver_claim_interface(&usb_ipc_driver, intf, bvd_ipc); -+ //usb_driver_claim_interface(&usb_ipc_driver, intf, bvd_ipc); -+ bvd_dbg("after claim interface"); - //usb_driver_claim_interface(&usb_ipc_driver, &ipccfg->interface[1], bvd_ipc); - - // a2590c: dsplog is not supported by this driver -@@ -740,6 +741,8 @@ - // &ipccfg->interface[2], bvd_ipc); - /*send a IN token first time*/ - bvd_ipc->readurb_mux.dev = bvd_ipc->ipc_dev; -+ bvd_dbg("after assignement"); -+ - if (usb_submit_urb(&bvd_ipc->readurb_mux, GFP_ATOMIC)) - printk("usb_ipc_prob: usb_submit_urb(read mux bulk) failed!\n"); - -@@ -750,7 +753,7 @@ - tasklet_schedule(&bvd_ipc->bh); - } - -- printk("usb_ipc_probe: completed probe!"); -+ printk("usb_ipc_probe: completed probe!\n"); - usb_set_intfdata(intf, &bvd_ipc); - return 0; - } -@@ -760,21 +763,23 @@ - //struct usb_device *usbdev = interface_to_usbdev(intf); - struct ipc_usb_data *bvd_ipc_disconnect = usb_get_intfdata(intf); - -- printk("usb_ipc_disconnect:*** \n"); - -+ printk("usb_ipc_disconnect. bvd_ipc_disconnect address: %p\n", bvd_ipc_disconnect); -+ -+ //FIXME: Memory leak? - if ((UHCRHPS3 & 0x4) == 0) -- usb_unlink_urb(&bvd_ipc_disconnect->readurb_mux); -+ // usb_unlink_urb(&bvd_ipc_disconnect->readurb_mux); - -- usb_unlink_urb(&bvd_ipc_disconnect->writeurb_mux); -+ //usb_unlink_urb(&bvd_ipc_disconnect->writeurb_mux); - - bvd_ipc_disconnect->ipc_flag = IPC_USB_PROBE_NOT_READY; - kfree(bvd_ipc_disconnect->ibuf); - kfree(bvd_ipc_disconnect->obuf); - -- usb_driver_release_interface(&usb_ipc_driver, -- bvd_ipc_disconnect->ipc_dev->actconfig->interface[0]); -- usb_driver_release_interface(&usb_ipc_driver, -- bvd_ipc_disconnect->ipc_dev->actconfig->interface[1]); -+ //usb_driver_release_interface(&usb_ipc_driver, -+ // bvd_ipc_disconnect->ipc_dev->actconfig->interface[0]); -+ //usb_driver_release_interface(&usb_ipc_driver, -+ // bvd_ipc_disconnect->ipc_dev->actconfig->interface[1]); - - //a2590c: dsplog interface is not supported by this driver - //usb_driver_release_interface(&usb_ipc_driver, &bvd_ipc_disconnect->ipc_dev->actconfig->interface[2]); -@@ -803,13 +808,6 @@ - int result; - - bvd_dbg("init usb_ipc"); -- /* register driver at the USB subsystem */ -- result = usb_register(&usb_ipc_driver); -- if (result < 0) { -- err ("usb ipc driver could not be registered"); -- return result; -- } -- - /*init the related mux interface*/ - if (!(bvd_ipc = kzalloc(sizeof(struct ipc_usb_data), GFP_KERNEL))) { - err("usb_ipc_init: Out of memory."); -@@ -836,6 +834,14 @@ - usb_for_mux_driver = &ipcusb_tty_driver; - usb_for_mux_tty = &ipcusb_tty; - -+ /* register driver at the USB subsystem */ -+ // this was called before bvd_ipc was allocated -+ result = usb_register(&usb_ipc_driver); -+ if (result < 0) { -+ err ("usb ipc driver could not be registered"); -+ return result; -+ } -+ - /* init timers for ipcusb read process and usb suspend */ - init_timer(&ipcusb_timer); - ipcusb_timer.function = ipcusb_timeout; diff --git a/packages/linux/linux-ezx-2.6.20.7/mux-ifdef-ezx-features.patch b/packages/linux/linux-ezx-2.6.20.7/mux-ifdef-ezx-features.patch deleted file mode 100644 index f9ad633c76..0000000000 --- a/packages/linux/linux-ezx-2.6.20.7/mux-ifdef-ezx-features.patch +++ /dev/null @@ -1,85 +0,0 @@ -diff -pruN linux-2.6.20.7/drivers/char/ts0710_mux_usb.c linux-2.6.20.7_x386/drivers/char/ts0710_mux_usb.c ---- linux-2.6.20.7/drivers/char/ts0710_mux_usb.c 2007-04-22 10:51:38.000000000 +0200 -+++ linux-2.6.20.7_x386/drivers/char/ts0710_mux_usb.c 2007-04-22 11:44:54.000000000 +0200 -@@ -35,10 +35,14 @@ - #include <linux/list.h> - #include <linux/errno.h> - #include <asm/uaccess.h> -+ -+#ifdef CONFIG_PXA_EZX - #include <asm/hardware.h> - #include <asm/arch/hardware.h> - #include <asm/arch-pxa/pxa-regs.h> - #include <asm/arch-pxa/ezx.h> -+#endif -+ - #include <linux/slab.h> - #include <linux/miscdevice.h> - #include <linux/init.h> -@@ -341,8 +345,10 @@ static void usb_ipc_write_bulk(struct ur - - static void wakeup_timeout(unsigned long data) - { -+#ifdef CONFIG_PXA_EZX - GPSR(GPIO_MCU_INT_SW) = GPIO_bit(GPIO_MCU_INT_SW); - bvd_dbg("wakup_timeout: send GPIO_MCU_INT_SW signal!"); -+#endif - } - - static void suspend_timeout(unsigned long data) -@@ -353,10 +359,12 @@ static void suspend_timeout(unsigned lon - bvd_dbg("suspend_timeout: add the suspend timer again"); - } else { - unlink_urbs(&bvd_ipc->readurb_mux); -+#ifdef CONFIG_PXA_EZX - UHCRHPS3 = 0x4; - mdelay(40); - bvd_dbg("suspend_timeout: send SUSPEND signal! UHCRHPS3=0x%x", - UHCRHPS3); -+#endif - } - } - -@@ -404,6 +412,7 @@ static void ipcusb_xmit_data(void) - bvd_ipc->writeurb_mux.transfer_buffer_length = buf_num; - bvd_dbg("ipcusb_xmit_data: copy data to write urb finished! "); - -+#ifdef CONFIG_PXA_EZX - if ((UHCRHPS3 & 0x4) == 0x4) { - static int ret; - int time = 0; -@@ -442,6 +451,7 @@ static void ipcusb_xmit_data(void) - "failed! status=%d\n", ret); - bvd_dbg("ipcusb_xmit_data: Send a IN token successfully!"); - } -+#endif - - sumbit_times++; - bvd_ipc->write_finished_flag = 0; -@@ -464,12 +474,16 @@ static void usbipc_bh_func(unsigned long - - static void usbipc_bh_bp_func(unsigned long param) - { -+#ifdef CONFIG_PXA_EZX - if ((UHCRHPS3 & 0x4) == 0x4) { - UHCRHPS3 = 0x8; -+#endif - mdelay(40); -+#ifdef CONFIG_PXA_EZX - bvd_dbg("ipcusb_softint_send_readurb: Send RESUME signal! " - "UHCRHPS3=0x%x", UHCRHPS3); - } -+#endif - if (bvd_ipc->ipc_flag == IPC_USB_PROBE_READY) { - //get_halted_bit(); - -@@ -734,7 +748,9 @@ static void usb_ipc_disconnect(struct us - printk("usb_ipc_disconnect. bvd_ipc_disconnect address: %p\n", bvd_ipc_disconnect); - - //FIXME: Memory leak? -+#ifdef CONFIG_PXA_EZX - if ((UHCRHPS3 & 0x4) == 0) -+#endif - // usb_unlink_urb(&bvd_ipc_disconnect->readurb_mux); - - //usb_unlink_urb(&bvd_ipc_disconnect->writeurb_mux); diff --git a/packages/linux/linux-ezx-2.6.20.7/mux-linux-2.6.20.7-fix.patch b/packages/linux/linux-ezx-2.6.20.7/mux-linux-2.6.20.7-fix.patch deleted file mode 100644 index bc6e3972b6..0000000000 --- a/packages/linux/linux-ezx-2.6.20.7/mux-linux-2.6.20.7-fix.patch +++ /dev/null @@ -1,96 +0,0 @@ -diff -pruN linux-2.6.20.7/drivers/char/ts0710.h linux-2.6.20.7_x386/drivers/char/ts0710.h ---- linux-2.6.20.7/drivers/char/ts0710.h 2007-04-22 10:51:23.000000000 +0200 -+++ linux-2.6.20.7_x386/drivers/char/ts0710.h 2007-04-22 11:16:37.000000000 +0200 -@@ -45,7 +45,7 @@ - * 11/18/2002 Modified - */ - --#include <linux/config.h> -+//#include <linux/config.h> - #include <linux/module.h> - - #include <linux/errno.h> -@@ -58,7 +58,7 @@ - #include <linux/major.h> - #include <linux/mm.h> - #include <linux/init.h> --#include <linux/devfs_fs_kernel.h> -+//#include <linux/devfs_fs_kernel.h> - - #include <asm/uaccess.h> - #include <asm/system.h> -diff -pruN linux-2.6.20.7/drivers/char/ts0710_mux.c linux-2.6.20.7_x386/drivers/char/ts0710_mux.c ---- linux-2.6.20.7/drivers/char/ts0710_mux.c 2007-04-22 10:53:05.000000000 +0200 -+++ linux-2.6.20.7_x386/drivers/char/ts0710_mux.c 2007-04-22 11:20:07.000000000 +0200 -@@ -46,7 +46,7 @@ - * 11/18/2002 Second version - * 04/21/2004 Add GPRS PROC - */ --#include <linux/config.h> -+//#include <linux/config.h> - #include <linux/module.h> - #include <linux/types.h> - -@@ -70,7 +70,7 @@ - #include <linux/mm.h> - #include <linux/slab.h> - #include <linux/init.h> --#include <linux/devfs_fs_kernel.h> -+//#include <linux/devfs_fs_kernel.h> - //#include <syslog.h> - - #include <asm/uaccess.h> -@@ -1894,11 +1894,14 @@ int ts0710_recv_data(ts0710_con * ts0710 - if (test_bit(TTY_THROTTLED, &tty->flags)) { - queue_data = 1; - } else { -+ /* - if (test_bit - (TTY_DONT_FLIP, &tty->flags)) { - queue_data = 1; - post_recv = 1; -- } else if (recv_info->total) { -+ } else -+ */ -+ if (recv_info->total) { - queue_data = 1; - post_recv = 1; - } else if (recv_room < uih_len) { -@@ -3499,11 +3502,14 @@ static void post_recv_worker(void *priva - if (test_bit(TTY_THROTTLED, &tty->flags)) { - add_post_recv_queue(&post_recv_q, recv_info); - continue; -- } else if (test_bit(TTY_DONT_FLIP, &tty->flags)) { -+ } -+ /* -+ else if (test_bit(TTY_DONT_FLIP, &tty->flags)) { - post_recv = 1; - add_post_recv_queue(&post_recv_q, recv_info); - continue; - } -+ */ - - flow_control = 0; - recv_packet2 = recv_info->mux_packet; -@@ -3893,9 +3899,9 @@ static int __init mux_init(void) - } - post_recv_count_flag = 0; - -- INIT_WORK(&send_tqueue, send_worker, NULL); -- INIT_WORK(&receive_tqueue, receive_worker, NULL); -- INIT_WORK(&post_recv_tqueue, post_recv_worker, NULL); -+ INIT_WORK(&send_tqueue, send_worker); -+ INIT_WORK(&receive_tqueue, receive_worker); -+ INIT_WORK(&post_recv_tqueue, post_recv_worker); - - mux_driver = alloc_tty_driver(NR_MUXS); - if (!mux_driver) -@@ -3904,7 +3910,7 @@ static int __init mux_init(void) - mux_driver->owner = THIS_MODULE; - mux_driver->driver_name = "ts0710mux"; - mux_driver->name = "mux"; -- mux_driver->devfs_name = "mux"; -+ //mux_driver->devfs_name = "mux"; - mux_driver->major = TS0710MUX_MAJOR; - mux_driver->minor_start = TS0710MUX_MINOR_START; - mux_driver->type = TTY_DRIVER_TYPE_SERIAL; diff --git a/packages/linux/linux-ezx-2.6.20.7/mux-remove-flipbuffers.patch b/packages/linux/linux-ezx-2.6.20.7/mux-remove-flipbuffers.patch deleted file mode 100644 index d4781f9fc7..0000000000 --- a/packages/linux/linux-ezx-2.6.20.7/mux-remove-flipbuffers.patch +++ /dev/null @@ -1,269 +0,0 @@ -Index: linux-2.6.16/drivers/char/ts0710_mux_usb.c -=================================================================== ---- linux-2.6.16.orig/drivers/char/ts0710_mux_usb.c 2007-01-17 00:52:25.000000000 +0100 -+++ linux-2.6.16/drivers/char/ts0710_mux_usb.c 2007-01-17 00:52:26.000000000 +0100 -@@ -133,6 +133,7 @@ - - struct circ_buf xmit; /* write cric bufffer */ - struct list_head in_buf_list; -+ spinlock_t in_buf_lock; - char bulk_in_ep_mux, - bulk_out_ep_mux, - bulk_in_ep_dsplog; -@@ -204,9 +205,39 @@ - return; - } - memcpy(inbuf->body, (unsigned char*)urb->transfer_buffer, count); -+ spin_lock(&bvd_ipc->in_buf_lock); - list_add_tail(&inbuf->list, &bvd_ipc->in_buf_list); -+ spin_unlock(&bvd_ipc->in_buf_lock); - } - -+int get_from_inbuf_list(const unsigned char *buf, int dst_count) -+{ -+ int ret = 0; -+ spin_lock(&bvd_ipc->in_buf_lock); -+ if (!(list_empty(&bvd_ipc->in_buf_list))) { -+ int src_count; -+ buf_list_t *inbuf; -+ struct list_head *ptr; -+ -+ ptr = bvd_ipc->in_buf_list.next; -+ inbuf = list_entry(ptr, buf_list_t, list); -+ src_count = inbuf->size; -+ if (dst_count >= src_count) { -+ memcpy(buf, inbuf->body, src_count); -+ ret = src_count; -+ list_del(ptr); -+ kfree(inbuf->body); -+ kfree(inbuf); -+ } else { -+ bvd_dbg("get_from_inbuf_list: not enough space in destination buffer"); -+ } -+ } -+ spin_unlock(&bvd_ipc->in_buf_lock); -+ -+ return ret; -+} -+EXPORT_SYMBOL(get_from_inbuf_list); -+ - static void ipcusb_timeout(unsigned long data) - { - struct tty_struct *tty = &ipcusb_tty; -@@ -214,13 +245,14 @@ - - bvd_dbg("ipcusb_timeout***"); - -+ spin_lock(&bvd_ipc->in_buf_lock); - while (!(list_empty(&bvd_ipc->in_buf_list))) { - int count; - buf_list_t *inbuf; - struct list_head *ptr = NULL; - - ptr = bvd_ipc->in_buf_list.next; -- inbuf = list_entry (ptr, buf_list_t, list); -+ inbuf = list_entry(ptr, buf_list_t, list); - count = inbuf->size; - if (tty_insert_flip_string(tty, inbuf->body, count) >= count) { - list_del(ptr); -@@ -232,10 +264,12 @@ - break; - } - } -+ spin_unlock(&bvd_ipc->in_buf_lock); - - if (usb_mux_dispatcher) - usb_mux_dispatcher(tty); /**call Liu changhui's func.**/ - -+ spin_lock(&bvd_ipc->in_buf_lock); - if (list_empty(&bvd_ipc->in_buf_list)) { - urb->actual_length = 0; - urb->dev = bvd_ipc->ipc_dev; -@@ -246,6 +280,7 @@ - ipcusb_timer.data = (unsigned long)urb; - mod_timer(&ipcusb_timer, jiffies+(10*HZ/1000)); - } -+ spin_unlock(&bvd_ipc->in_buf_lock); - } - - static void usb_ipc_read_bulk(struct urb *urb, struct pt_regs *regs) -@@ -266,69 +301,11 @@ - if (count > 0 && ((*ipcusb_bp_to_ap) != NULL)) - (*ipcusb_bp_to_ap)(urb->transfer_buffer, urb->actual_length); - -- if (!(list_empty(&bvd_ipc->in_buf_list))) { -- int need_mux = 0; -- -- bvd_dbg("usb_ipc_read_bulk: some urbs in_buf_list"); -- if (count > 0) { -- bvd_ipc->suspend_flag = 1; -- append_to_inbuf_list(urb); /* append the current received urb */ --#if 0 -- if(jiffies - last_jiff > ICL_EVENT_INTERVAL) -- { -- last_jiff = jiffies; -- queue_apm_event(KRNL_ICL, NULL); -- } --#endif -- } -- -- while (!(list_empty(&bvd_ipc->in_buf_list))) { -- struct list_head* ptr = NULL; -- ptr = bvd_ipc->in_buf_list.next; -- inbuf = list_entry(ptr, buf_list_t, list); -- count = inbuf->size; -- need_mux = 1; -- -- tty_insert_flip_string(tty, inbuf->body, count); -- -- list_del(ptr); -- kfree(inbuf->body); -- inbuf->body = NULL; -- kfree(inbuf); -- } -- -- if (usb_mux_dispatcher && need_mux) -- usb_mux_dispatcher(tty); /* call Liu changhui's func. */ -- -- if (list_empty(&bvd_ipc->in_buf_list)) { -- urb->actual_length = 0; -- urb->dev = bvd_ipc->ipc_dev; -- if (usb_submit_urb(urb, GFP_ATOMIC)) -- bvd_dbg("usb_ipc_read_bulk: " -- "failed resubmitting read urb"); -- bvd_dbg("usb_ipc_read_bulk: resubmited read urb"); -- } else { -- ipcusb_timer.data = (unsigned long)urb; -- mod_timer(&ipcusb_timer, jiffies+(10*HZ/1000)); -- } -- } else if (count > 0) { -- bvd_dbg("usb_ipc_read_bulk: no urbs in_buf_list"); -+ if (count > 0) { -+ bvd_dbg("usb_ipc_read_bulk: inserting buffer into in_buf_list"); - bvd_ipc->suspend_flag = 1; - -- if (tty_insert_flip_string(tty, urb->transfer_buffer, -- count) < count) { -- bvd_ipc->suspend_flag = 1; -- append_to_inbuf_list(urb); -- ipcusb_timer.data = (unsigned long)urb; -- mod_timer(&ipcusb_timer, jiffies+(10*HZ/1000)); --#if 0 -- if(jiffies - last_jiff > ICL_EVENT_INTERVAL) -- { -- last_jiff = jiffies; -- queue_apm_event(KRNL_ICL, NULL); -- } --#endif -- } -+ append_to_inbuf_list(urb); - - if (usb_mux_dispatcher) - usb_mux_dispatcher(tty); /* call Liu changhui's func. */ -@@ -337,13 +314,6 @@ - urb->dev = bvd_ipc->ipc_dev; - if (usb_submit_urb(urb, GFP_ATOMIC)) - bvd_dbg("failed resubmitting read urb"); --#if 0 -- if(jiffies - last_jiff > ICL_EVENT_INTERVAL) -- { -- last_jiff = jiffies; -- queue_apm_event(KRNL_ICL, NULL); -- } --#endif - bvd_dbg("usb_ipc_read_bulk: resubmited read urb"); - } - -@@ -705,7 +675,8 @@ - bvd_ipc->bulk_out_ep_mux= have_bulk_out_mux; - bvd_ipc->ipc_dev = usbdev; - bvd_ipc->writesize = writesize; -- INIT_LIST_HEAD (&bvd_ipc->in_buf_list); -+ INIT_LIST_HEAD(&bvd_ipc->in_buf_list); -+ bvd_ipc->in_buf_lock = SPIN_LOCK_UNLOCKED; - - bvd_ipc->bh.func = usbipc_bh_func; - bvd_ipc->bh.data = (unsigned long) bvd_ipc; -Index: linux-2.6.16/drivers/char/ts0710_mux.c -=================================================================== ---- linux-2.6.16.orig/drivers/char/ts0710_mux.c 2007-01-17 00:52:23.000000000 +0100 -+++ linux-2.6.16/drivers/char/ts0710_mux.c 2007-01-17 00:52:26.000000000 +0100 -@@ -3149,7 +3149,7 @@ - static void receive_worker(void *private_) - { - struct tty_struct *tty = COMM_FOR_MUX_TTY; -- int i, count; -+ int i, count, tbuf_free, tbuf_read; - static unsigned char tbuf[TS0710MUX_MAX_BUF_SIZE]; - static unsigned char *tbuf_ptr = &tbuf[0]; - static unsigned char *start_flag = 0; -@@ -3167,29 +3167,39 @@ - - UNUSED_PARAM(private_); - -- if (!tty) -- return; -+ if (!tty) -+ return; -+ -+ while (1) { -+ tbuf_free = TS0710MUX_MAX_BUF_SIZE - (tbuf_ptr - tbuf); -+ TS0710_PRINTK("Reading max %i bytes from ts0710_mux_usb inbuf.\n", tbuf_free); -+ tbuf_read = get_from_inbuf_list(tbuf_ptr, tbuf_free); -+ if (tbuf_read == 0) { -+ break; -+ } else { -+ TS0710_PRINTK("Read %i bytes.\n", tbuf_read); -+ }; -+ tbuf_ptr += tbuf_read; -+ }; -+ -+ count = (tbuf_ptr - tbuf); -+ -+ // Should be impossible? -+ //if (count > (TS0710MUX_MAX_BUF_SIZE - (tbuf_ptr - tbuf))) { -+ // TS0710_PRINTK -+ // ("MUX receive_worker: !!!!! Exceed buffer boundary !!!!!\n"); -+ // count = (TS0710MUX_MAX_BUF_SIZE - (tbuf_ptr - tbuf)); -+ //} - - #ifdef USB_FOR_MUX -- TS0710_DEBUG("Receive following bytes from IPC-USB"); -+ TS0710_DEBUG("Received following bytes from IPC-USB"); - #else -- TS0710_DEBUG("Receive following bytes from UART"); -+ TS0710_DEBUG("Received following bytes from UART"); - #endif -- -- TS0710_DEBUGHEX(cp, count); -- -- if (count > (TS0710MUX_MAX_BUF_SIZE - (tbuf_ptr - tbuf))) { -- TS0710_PRINTK -- ("MUX receive_worker: !!!!! Exceed buffer boundary !!!!!\n"); -- count = (TS0710MUX_MAX_BUF_SIZE - (tbuf_ptr - tbuf)); -- } -- -- count = tty_buffer_request_room(tty, count); -- -- for (i = 0; i < count; i++) -- tty_insert_flip_char(tty, tbuf_ptr[i], TTY_NORMAL); -- -- tbuf_ptr += count; -+ TS0710_DEBUGHEX(tbuf, count); -+ -+ //gets updated above -+ //tbuf_ptr += count; - search = &tbuf[0]; - - if (test_and_set_bit(RECV_RUNNING, &mux_recv_flags)) { -Index: linux-2.6.16/drivers/char/ts0710_mux_usb.h -=================================================================== ---- linux-2.6.16.orig/drivers/char/ts0710_mux_usb.h 2007-01-17 00:52:23.000000000 +0100 -+++ linux-2.6.16/drivers/char/ts0710_mux_usb.h 2007-01-17 00:52:26.000000000 +0100 -@@ -27,3 +27,6 @@ - extern struct tty_struct *usb_for_mux_tty; - extern void (*usb_mux_dispatcher)(struct tty_struct *tty); - extern void (*usb_mux_sender)(void); -+ -+extern int get_from_inbuf_list(const unsigned char *buf, int dst_count); -+ diff --git a/packages/linux/linux-ezx-2.6.20.7/mux-remove-get_halted_bit.patch b/packages/linux/linux-ezx-2.6.20.7/mux-remove-get_halted_bit.patch deleted file mode 100644 index 0ebe27d03b..0000000000 --- a/packages/linux/linux-ezx-2.6.20.7/mux-remove-get_halted_bit.patch +++ /dev/null @@ -1,22 +0,0 @@ -Index: linux-2.6.16/drivers/char/ts0710_mux_usb.c -=================================================================== ---- linux-2.6.16.orig/drivers/char/ts0710_mux_usb.c 2007-01-17 01:06:21.000000000 +0100 -+++ linux-2.6.16/drivers/char/ts0710_mux_usb.c 2007-01-17 01:06:31.000000000 +0100 -@@ -461,7 +461,7 @@ - ipcusb_xmit_data(); - } - --extern void get_halted_bit(void); -+//extern void get_halted_bit(void); - - static void usbipc_bh_bp_func(unsigned long param) - { -@@ -472,7 +472,7 @@ - "UHCRHPS3=0x%x", UHCRHPS3); - } - if (bvd_ipc->ipc_flag == IPC_USB_PROBE_READY) { -- get_halted_bit(); -+ //get_halted_bit(); - - /*send a IN token*/ - bvd_ipc->readurb_mux.dev = bvd_ipc->ipc_dev; diff --git a/packages/linux/linux-ezx-2.6.20.7/mux-remove-usbh_finished_resume.patch b/packages/linux/linux-ezx-2.6.20.7/mux-remove-usbh_finished_resume.patch deleted file mode 100644 index c415ded428..0000000000 --- a/packages/linux/linux-ezx-2.6.20.7/mux-remove-usbh_finished_resume.patch +++ /dev/null @@ -1,22 +0,0 @@ -Index: linux-2.6.16/drivers/char/ts0710_mux_usb.c -=================================================================== ---- linux-2.6.16.orig/drivers/char/ts0710_mux_usb.c 2007-01-17 01:12:23.000000000 +0100 -+++ linux-2.6.16/drivers/char/ts0710_mux_usb.c 2007-01-17 01:12:37.000000000 +0100 -@@ -97,7 +97,6 @@ - static int sumbit_times = 0; - static int callback_times = 0; - //static unsigned long last_jiff = 0; --extern int usbh_finished_resume; - /*end global values defined*/ - - MODULE_AUTHOR(DRIVER_AUTHOR); -@@ -546,9 +545,6 @@ - void usb_send_readurb(void) - { - //printk("usb_send_readurb: begining!UHCRHPS3=0x%x, usbh_finished_resume=%d\n", UHCRHPS3, usbh_finished_resume); -- -- if (usbh_finished_resume == 0) -- return; - - tasklet_schedule(&bvd_ipc->bh_bp); - } diff --git a/packages/linux/linux-ezx-2.6.20.7/mux_cli.patch b/packages/linux/linux-ezx-2.6.20.7/mux_cli.patch deleted file mode 100644 index c86e3b40e4..0000000000 --- a/packages/linux/linux-ezx-2.6.20.7/mux_cli.patch +++ /dev/null @@ -1,5395 +0,0 @@ -Index: linux-2.6.20.7/drivers/char/Kconfig -=================================================================== ---- linux-2.6.20.7.orig/drivers/char/Kconfig 2007-04-13 22:48:14.000000000 +0200 -+++ linux-2.6.20.7/drivers/char/Kconfig 2007-04-21 18:04:56.000000000 +0200 -@@ -1030,5 +1030,17 @@ - sysfs directory, /sys/devices/platform/telco_clock, with a number of - files for controlling the behavior of this hardware. - -+config TS0710_MUX -+ tristate "GSM TS 07.10 Multiplex driver" -+ help -+ This implements the GSM 07.10 multiplex. -+ -+config TS0710_MUX_USB -+ tristate "Motorola USB support for TS 07.10 Multiplex driver" -+ depends on TS0710_MUX -+ help -+ This ads support for TS 07.10 over USB, as found in motorola -+ Smartphones. -+ - endmenu - -Index: linux-2.6.20.7/drivers/char/Makefile -=================================================================== ---- linux-2.6.20.7.orig/drivers/char/Makefile 2007-04-13 22:48:14.000000000 +0200 -+++ linux-2.6.20.7/drivers/char/Makefile 2007-04-21 18:06:42.000000000 +0200 -@@ -101,6 +101,9 @@ - obj-$(CONFIG_HANGCHECK_TIMER) += hangcheck-timer.o - obj-$(CONFIG_TCG_TPM) += tpm/ - -+obj-$(CONFIG_TS0710_MUX) += ts0710_mux.o ts0710_mux_usb.o -+ -+ - # Files generated that shall be removed upon make clean - clean-files := consolemap_deftbl.c defkeymap.c - -Index: linux-2.6.20.7/drivers/char/ts0710.h -=================================================================== ---- /dev/null 1970-01-01 00:00:00.000000000 +0000 -+++ linux-2.6.20.7/drivers/char/ts0710.h 2007-04-21 18:04:56.000000000 +0200 -@@ -0,0 +1,368 @@ -+/* -+ * File: ts0710.h -+ * -+ * Portions derived from rfcomm.c, original header as follows: -+ * -+ * Copyright (C) 2000, 2001 Axis Communications AB -+ * -+ * Author: Mats Friden <mats.friden@axis.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, 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. -+ * -+ * Exceptionally, Axis Communications AB grants discretionary and -+ * conditional permissions for additional use of the text contained -+ * in the company's release of the AXIS OpenBT Stack under the -+ * provisions set forth hereunder. -+ * -+ * Provided that, if you use the AXIS OpenBT Stack with other files, -+ * that do not implement functionality as specified in the Bluetooth -+ * System specification, to produce an executable, this does not by -+ * itself cause the resulting executable to be covered by the GNU -+ * General Public License. Your use of that executable is in no way -+ * restricted on account of using the AXIS OpenBT Stack code with it. -+ * -+ * This exception does not however invalidate any other reasons why -+ * the executable file might be covered by the provisions of the GNU -+ * General Public License. -+ * -+ */ -+/* -+ * Copyright (C) 2002 Motorola -+ * -+ * 07/28/2002 Initial version based on rfcomm.c -+ * 11/18/2002 Modified -+ */ -+ -+#include <linux/config.h> -+#include <linux/module.h> -+ -+#include <linux/errno.h> -+#include <linux/sched.h> -+#include <linux/interrupt.h> -+#include <linux/tty.h> -+#include <linux/tty_flip.h> -+#include <linux/fcntl.h> -+#include <linux/string.h> -+#include <linux/major.h> -+#include <linux/mm.h> -+#include <linux/init.h> -+#include <linux/devfs_fs_kernel.h> -+ -+#include <asm/uaccess.h> -+#include <asm/system.h> -+#include <asm/bitops.h> -+ -+#include <asm/byteorder.h> -+#include <asm/types.h> -+ -+#define TS0710_MAX_CHN 14 -+ -+#define SET_PF(ctr) ((ctr) | (1 << 4)) -+#define CLR_PF(ctr) ((ctr) & 0xef) -+#define GET_PF(ctr) (((ctr) >> 4) & 0x1) -+ -+#define GET_PN_MSG_FRAME_SIZE(pn) ( ((pn)->frame_sizeh << 8) | ((pn)->frame_sizel)) -+#define SET_PN_MSG_FRAME_SIZE(pn, size) ({ (pn)->frame_sizel = (size) & 0xff; \ -+ (pn)->frame_sizeh = (size) >> 8; }) -+ -+#define GET_LONG_LENGTH(a) ( ((a).h_len << 7) | ((a).l_len) ) -+#define SET_LONG_LENGTH(a, length) ({ (a).ea = 0; \ -+ (a).l_len = length & 0x7F; \ -+ (a).h_len = (length >> 7) & 0xFF; }) -+ -+#define SHORT_CRC_CHECK 3 -+#define LONG_CRC_CHECK 4 -+ -+/* FIXME: Should thsi one be define here? */ -+#define SHORT_PAYLOAD_SIZE 127 -+ -+#define EA 1 -+#define FCS_SIZE 1 -+#define FLAG_SIZE 2 -+ -+#define TS0710_MAX_HDR_SIZE 5 -+#define DEF_TS0710_MTU 256 -+ -+#define TS0710_BASIC_FLAG 0xF9 -+/* the control field */ -+#define SABM 0x2f -+#define SABM_SIZE 4 -+#define UA 0x63 -+#define UA_SIZE 4 -+#define DM 0x0f -+#define DISC 0x43 -+#define UIH 0xef -+ -+/* the type field in a multiplexer command packet */ -+#define TEST 0x8 -+#define FCON 0x28 -+#define FCOFF 0x18 -+#define MSC 0x38 -+#define RPN 0x24 -+#define RLS 0x14 -+#define PN 0x20 -+#define NSC 0x4 -+ -+/* V.24 modem control signals */ -+#define FC 0x2 -+#define RTC 0x4 -+#define RTR 0x8 -+#define IC 0x40 -+#define DV 0x80 -+ -+#define CTRL_CHAN 0 /* The control channel is defined as DLCI 0 */ -+#define MCC_CMD 1 /* Multiplexer command cr */ -+#define MCC_RSP 0 /* Multiplexer response cr */ -+ -+#ifdef __LITTLE_ENDIAN_BITFIELD -+ -+typedef struct { -+ __u8 ea:1; -+ __u8 cr:1; -+ __u8 d:1; -+ __u8 server_chn:5; -+} __attribute__ ((packed)) address_field; -+ -+typedef struct { -+ __u8 ea:1; -+ __u8 len:7; -+} __attribute__ ((packed)) short_length; -+ -+typedef struct { -+ __u8 ea:1; -+ __u8 l_len:7; -+ __u8 h_len; -+} __attribute__ ((packed)) long_length; -+ -+typedef struct { -+ address_field addr; -+ __u8 control; -+ short_length length; -+} __attribute__ ((packed)) short_frame_head; -+ -+typedef struct { -+ short_frame_head h; -+ __u8 data[0]; -+} __attribute__ ((packed)) short_frame; -+ -+typedef struct { -+ address_field addr; -+ __u8 control; -+ long_length length; -+ __u8 data[0]; -+} __attribute__ ((packed)) long_frame_head; -+ -+typedef struct { -+ long_frame_head h; -+ __u8 data[0]; -+} __attribute__ ((packed)) long_frame; -+ -+/* Typedefinitions for structures used for the multiplexer commands */ -+typedef struct { -+ __u8 ea:1; -+ __u8 cr:1; -+ __u8 type:6; -+} __attribute__ ((packed)) mcc_type; -+ -+typedef struct { -+ mcc_type type; -+ short_length length; -+ __u8 value[0]; -+} __attribute__ ((packed)) mcc_short_frame_head; -+ -+typedef struct { -+ mcc_short_frame_head h; -+ __u8 value[0]; -+} __attribute__ ((packed)) mcc_short_frame; -+ -+typedef struct { -+ mcc_type type; -+ long_length length; -+ __u8 value[0]; -+} __attribute__ ((packed)) mcc_long_frame_head; -+ -+typedef struct { -+ mcc_long_frame_head h; -+ __u8 value[0]; -+} __attribute__ ((packed)) mcc_long_frame; -+ -+/* MSC-command */ -+typedef struct { -+ __u8 ea:1; -+ __u8 fc:1; -+ __u8 rtc:1; -+ __u8 rtr:1; -+ __u8 reserved:2; -+ __u8 ic:1; -+ __u8 dv:1; -+} __attribute__ ((packed)) v24_sigs; -+ -+typedef struct { -+ __u8 ea:1; -+ __u8 b1:1; -+ __u8 b2:1; -+ __u8 b3:1; -+ __u8 len:4; -+} __attribute__ ((packed)) brk_sigs; -+ -+typedef struct { -+ short_frame_head s_head; -+ mcc_short_frame_head mcc_s_head; -+ address_field dlci; -+ __u8 v24_sigs; -+ //brk_sigs break_signals; -+ __u8 fcs; -+} __attribute__ ((packed)) msc_msg; -+ -+#if 0 -+/* conflict with termios.h */ -+/* RPN command */ -+#define B2400 0 -+#define B4800 1 -+#define B7200 2 -+#define B9600 3 -+#define B19200 4 -+#define B38400 5 -+#define B57600 6 -+#define B115200 7 -+#define D230400 8 -+#endif -+ -+/* -+typedef struct{ -+ __u8 bit_rate:1; -+ __u8 data_bits:1; -+ __u8 stop_bit:1; -+ __u8 parity:1; -+ __u8 parity_type:1; -+ __u8 xon_u8:1; -+ __u8 xoff_u8:1; -+ __u8 res1:1; -+ __u8 xon_input:1; -+ __u8 xon_output:1; -+ __u8 rtr_input:1; -+ __u8 rtr_output:1; -+ __u8 rtc_input:1; -+ __u8 rtc_output:1; -+ __u8 res2:2; -+} __attribute__((packed)) parameter_mask; -+ -+typedef struct{ -+ __u8 bit_rate; -+ __u8 data_bits:2; -+ __u8 stop_bit:1; -+ __u8 parity:1; -+ __u8 parity_type:2; -+ __u8 res1:2; -+ __u8 xon_input:1; -+ __u8 xon_output:1; -+ __u8 rtr_input:1; -+ __u8 rtr_output:1; -+ __u8 rtc_input:1; -+ __u8 rtc_output:1; -+ __u8 res2:2; -+ __u8 xon_u8; -+ __u8 xoff_u8; -+ parameter_mask pm; -+} __attribute__((packed)) rpn_values; -+ -+typedef struct{ -+ short_frame_head s_head; -+ mcc_short_frame_head mcc_s_head; -+ address_field dlci; -+ rpn_values rpn_val; -+ __u8 fcs; -+} __attribute__((packed)) rpn_msg; -+*/ -+ -+/* RLS-command */ -+/* -+typedef struct{ -+ short_frame_head s_head; -+ mcc_short_frame_head mcc_s_head; -+ address_field dlci; -+ __u8 error:4; -+ __u8 res:4; -+ __u8 fcs; -+} __attribute__((packed)) rls_msg; -+*/ -+ -+/* PN-command */ -+typedef struct { -+ short_frame_head s_head; -+ mcc_short_frame_head mcc_s_head; -+ __u8 dlci:6; -+ __u8 res1:2; -+ __u8 frame_type:4; -+ __u8 credit_flow:4; -+ __u8 prior:6; -+ __u8 res2:2; -+ __u8 ack_timer; -+ __u8 frame_sizel; -+ __u8 frame_sizeh; -+ __u8 max_nbrof_retrans; -+ __u8 credits; -+ __u8 fcs; -+} __attribute__ ((packed)) pn_msg; -+ -+/* NSC-command */ -+typedef struct { -+ short_frame_head s_head; -+ mcc_short_frame_head mcc_s_head; -+ mcc_type command_type; -+ __u8 fcs; -+} __attribute__ ((packed)) nsc_msg; -+ -+#else -+#error Only littel-endianess supported now! -+#endif -+ -+enum { -+ REJECTED = 0, -+ DISCONNECTED, -+ CONNECTING, -+ NEGOTIATING, -+ CONNECTED, -+ DISCONNECTING, -+ FLOW_STOPPED -+}; -+ -+enum ts0710_events { -+ CONNECT_IND, -+ CONNECT_CFM, -+ DISCONN_CFM -+}; -+ -+typedef struct { -+ volatile __u8 state; -+ volatile __u8 flow_control; -+ volatile __u8 initiated; -+ volatile __u8 initiator; -+ volatile __u16 mtu; -+ wait_queue_head_t open_wait; -+ wait_queue_head_t close_wait; -+} dlci_struct; -+ -+/* user space interfaces */ -+typedef struct { -+ volatile __u8 initiator; -+ volatile __u8 c_dlci; -+ volatile __u16 mtu; -+ volatile __u8 be_testing; -+ volatile __u32 test_errs; -+ wait_queue_head_t test_wait; -+ -+ dlci_struct dlci[TS0710_MAX_CHN]; -+} ts0710_con; -Index: linux-2.6.20.7/drivers/char/ts0710_mux.c -=================================================================== ---- /dev/null 1970-01-01 00:00:00.000000000 +0000 -+++ linux-2.6.20.7/drivers/char/ts0710_mux.c 2007-04-21 18:08:02.000000000 +0200 -@@ -0,0 +1,3966 @@ -+/* -+ * File: mux_driver.c -+ * -+ * Portions derived from rfcomm.c, original header as follows: -+ * -+ * Copyright (C) 2000, 2001 Axis Communications AB -+ * -+ * Author: Mats Friden <mats.friden@axis.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, 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. -+ * -+ * Exceptionally, Axis Communications AB grants discretionary and -+ * conditional permissions for additional use of the text contained -+ * in the company's release of the AXIS OpenBT Stack under the -+ * provisions set forth hereunder. -+ * -+ * Provided that, if you use the AXIS OpenBT Stack with other files, -+ * that do not implement functionality as specified in the Bluetooth -+ * System specification, to produce an executable, this does not by -+ * itself cause the resulting executable to be covered by the GNU -+ * General Public License. Your use of that executable is in no way -+ * restricted on account of using the AXIS OpenBT Stack code with it. -+ * -+ * This exception does not however invalidate any other reasons why -+ * the executable file might be covered by the provisions of the GNU -+ * General Public License. -+ * -+ */ -+/* -+ * Copyright (C) 2002-2004 Motorola -+ * Copyright (C) 2006 Harald Welte <laforge@openezx.org> -+ * -+ * 07/28/2002 Initial version -+ * 11/18/2002 Second version -+ * 04/21/2004 Add GPRS PROC -+ */ -+#include <linux/config.h> -+#include <linux/module.h> -+#include <linux/types.h> -+ -+#include <linux/kernel.h> -+#include <linux/proc_fs.h> -+ -+#define USB_FOR_MUX -+ -+#ifndef USB_FOR_MUX -+#include <linux/serial.h> -+#endif -+ -+#include <linux/errno.h> -+#include <linux/sched.h> -+#include <linux/interrupt.h> -+#include <linux/tty.h> -+#include <linux/tty_flip.h> -+#include <linux/fcntl.h> -+#include <linux/string.h> -+#include <linux/major.h> -+#include <linux/mm.h> -+#include <linux/slab.h> -+#include <linux/init.h> -+#include <linux/devfs_fs_kernel.h> -+//#include <syslog.h> -+ -+#include <asm/uaccess.h> -+#include <asm/system.h> -+#include <asm/bitops.h> -+ -+#ifdef USB_FOR_MUX -+//#include <linux/usb.h> -+#include "ts0710_mux_usb.h" -+#endif -+ -+#include "ts0710.h" -+#include "ts0710_mux.h" -+ -+#define TS0710MUX_GPRS_SESSION_MAX 2 -+#define TS0710MUX_MAJOR 250 -+#define TS0710MUX_MINOR_START 0 -+#define NR_MUXS 16 -+ -+ /*#define TS0710MUX_TIME_OUT 30 *//* 300ms */ -+#define TS0710MUX_TIME_OUT 250 /* 2500ms, for BP UART hardware flow control AP UART */ -+ -+#define TS0710MUX_IO_DLCI_FC_ON 0x54F2 -+#define TS0710MUX_IO_DLCI_FC_OFF 0x54F3 -+#define TS0710MUX_IO_FC_ON 0x54F4 -+#define TS0710MUX_IO_FC_OFF 0x54F5 -+ -+#define TS0710MUX_MAX_BUF_SIZE 2048 -+ -+#define TS0710MUX_SEND_BUF_OFFSET 10 -+#define TS0710MUX_SEND_BUF_SIZE (DEF_TS0710_MTU + TS0710MUX_SEND_BUF_OFFSET + 34) -+#define TS0710MUX_RECV_BUF_SIZE TS0710MUX_SEND_BUF_SIZE -+ -+/*For BP UART problem Begin*/ -+#ifdef TS0710SEQ2 -+#define ACK_SPACE 66 /* 6 * 11(ACK frame size) */ -+#else -+#define ACK_SPACE 42 /* 6 * 7(ACK frame size) */ -+#endif -+/*For BP UART problem End*/ -+ -+ /*#define TS0710MUX_SERIAL_BUF_SIZE (DEF_TS0710_MTU + TS0710_MAX_HDR_SIZE)*//* For BP UART problem */ -+#define TS0710MUX_SERIAL_BUF_SIZE (DEF_TS0710_MTU + TS0710_MAX_HDR_SIZE + ACK_SPACE) /* For BP UART problem: ACK_SPACE */ -+ -+#define TS0710MUX_MAX_TOTAL_FRAME_SIZE (DEF_TS0710_MTU + TS0710_MAX_HDR_SIZE + FLAG_SIZE) -+#define TS0710MUX_MAX_CHARS_IN_BUF 65535 -+#define TS0710MUX_THROTTLE_THRESHOLD DEF_TS0710_MTU -+ -+#define TEST_PATTERN_SIZE 250 -+ -+#define CMDTAG 0x55 -+#define DATATAG 0xAA -+ -+#define ACK 0x4F /*For BP UART problem */ -+ -+/*For BP UART problem Begin*/ -+#ifdef TS0710SEQ2 -+#define FIRST_BP_SEQ_OFFSET 1 /*offset from start flag */ -+#define SECOND_BP_SEQ_OFFSET 2 /*offset from start flag */ -+#define FIRST_AP_SEQ_OFFSET 3 /*offset from start flag */ -+#define SECOND_AP_SEQ_OFFSET 4 /*offset from start flag */ -+#define SLIDE_BP_SEQ_OFFSET 5 /*offset from start flag */ -+#define SEQ_FIELD_SIZE 5 -+#else -+#define SLIDE_BP_SEQ_OFFSET 1 /*offset from start flag */ -+#define SEQ_FIELD_SIZE 1 -+#endif -+ -+#define ADDRESS_FIELD_OFFSET (1 + SEQ_FIELD_SIZE) /*offset from start flag */ -+/*For BP UART problem End*/ -+ -+#ifndef UNUSED_PARAM -+#define UNUSED_PARAM(v) (void)(v) -+#endif -+ -+#define TS0710MUX_GPRS1_DLCI 7 -+#define TS0710MUX_GPRS2_DLCI 8 -+ -+#define TS0710MUX_GPRS1_RECV_COUNT_IDX 0 -+#define TS0710MUX_GPRS1_SEND_COUNT_IDX 1 -+#define TS0710MUX_GPRS2_RECV_COUNT_IDX 2 -+#define TS0710MUX_GPRS2_SEND_COUNT_IDX 3 -+#define TS0710MUX_COUNT_MAX_IDX 3 -+#define TS0710MUX_COUNT_IDX_NUM (TS0710MUX_COUNT_MAX_IDX + 1) -+ -+static volatile int mux_data_count[TS0710MUX_COUNT_IDX_NUM] = { 0, 0, 0, 0 }; -+static volatile int mux_data_count2[TS0710MUX_COUNT_IDX_NUM] = { 0, 0, 0, 0 }; -+static struct semaphore mux_data_count_mutex[TS0710MUX_COUNT_IDX_NUM]; -+static volatile __u8 post_recv_count_flag = 0; -+ -+/*PROC file*/ -+struct proc_dir_entry *gprs_proc_file = NULL; -+ssize_t file_proc_read(struct file *file, char *buf, size_t size, -+ loff_t * ppos); -+ssize_t file_proc_write(struct file *file, const char *buf, size_t count, -+ loff_t * ppos); -+struct file_operations file_proc_operations = { -+ read:file_proc_read, -+ write:file_proc_write, -+}; -+typedef struct { -+ int recvBytes; -+ int sentBytes; -+} gprs_bytes; -+ -+static __u8 tty2dlci[NR_MUXS] = -+ { 1, 2, 3, 4, 5, 6, 7, 8, 6, 7, 8, 9, 10, 11, 12, 13 }; -+static __u8 iscmdtty[NR_MUXS] = -+ { 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0 }; -+typedef struct { -+ __u8 cmdtty; -+ __u8 datatty; -+} dlci_tty; -+static dlci_tty dlci2tty[] = { {0, 0}, /* DLCI 0 */ -+{0, 0}, /* DLCI 1 */ -+{1, 1}, /* DLCI 2 */ -+{2, 2}, /* DLCI 3 */ -+{3, 3}, /* DLCI 4 */ -+{4, 4}, /* DLCI 5 */ -+{5, 8}, /* DLCI 6 */ -+{6, 9}, /* DLCI 7 */ -+{7, 10}, /* DLCI 8 */ -+{11, 11}, /* DLCI 9 */ -+{12, 12}, /* DLCI 10 */ -+{13, 13}, /* DLCI 11 */ -+{14, 14}, /* DLCI 12 */ -+{15, 15} -+}; /* DLCI 13 */ -+ -+typedef struct { -+ volatile __u8 buf[TS0710MUX_SEND_BUF_SIZE]; -+ volatile __u8 *frame; -+ unsigned long flags; -+ volatile __u16 length; -+ volatile __u8 filled; -+ volatile __u8 dummy; /* Allignment to 4*n bytes */ -+} mux_send_struct; -+ -+/* Bit number in flags of mux_send_struct */ -+#define BUF_BUSY 0 -+ -+struct mux_recv_packet_tag { -+ __u8 *data; -+ __u32 length; -+ struct mux_recv_packet_tag *next; -+}; -+typedef struct mux_recv_packet_tag mux_recv_packet; -+ -+struct mux_recv_struct_tag { -+ __u8 data[TS0710MUX_RECV_BUF_SIZE]; -+ __u32 length; -+ __u32 total; -+ mux_recv_packet *mux_packet; -+ struct mux_recv_struct_tag *next; -+ int no_tty; -+ volatile __u8 post_unthrottle; -+}; -+typedef struct mux_recv_struct_tag mux_recv_struct; -+ -+#define RECV_RUNNING 0 -+static unsigned long mux_recv_flags = 0; -+ -+static mux_send_struct *mux_send_info[NR_MUXS]; -+static volatile __u8 mux_send_info_flags[NR_MUXS]; -+static volatile __u8 mux_send_info_idx = NR_MUXS; -+ -+static mux_recv_struct *mux_recv_info[NR_MUXS]; -+static volatile __u8 mux_recv_info_flags[NR_MUXS]; -+static mux_recv_struct *mux_recv_queue = NULL; -+ -+static struct tty_driver mux_driver; -+ -+#ifdef USB_FOR_MUX -+#define COMM_FOR_MUX_DRIVER usb_for_mux_driver -+#define COMM_FOR_MUX_TTY usb_for_mux_tty -+#define COMM_MUX_DISPATCHER usb_mux_dispatcher -+#define COMM_MUX_SENDER usb_mux_sender -+#else -+#define COMM_FOR_MUX_DRIVER serial_for_mux_driver -+#define COMM_FOR_MUX_TTY serial_for_mux_tty -+#define COMM_MUX_DISPATCHER serial_mux_dispatcher -+#define COMM_MUX_SENDER serial_mux_sender -+ -+extern struct list_head *tq_serial_for_mux; -+#endif -+ -+extern struct tty_driver *COMM_FOR_MUX_DRIVER; -+extern struct tty_struct *COMM_FOR_MUX_TTY; -+extern void (*COMM_MUX_DISPATCHER) (struct tty_struct * tty); -+extern void (*COMM_MUX_SENDER) (void); -+ -+static struct work_struct send_tqueue; -+static struct work_struct receive_tqueue; -+static struct work_struct post_recv_tqueue; -+ -+static struct tty_struct *mux_table[NR_MUXS]; -+static struct termios *mux_termios[NR_MUXS]; -+static struct termios *mux_termios_locked[NR_MUXS]; -+static volatile short int mux_tty[NR_MUXS]; -+ -+#ifdef min -+#undef min -+#define min(a,b) ( (a)<(b) ? (a):(b) ) -+#endif -+ -+static int get_count(__u8 idx); -+static int set_count(__u8 idx, int count); -+static int add_count(__u8 idx, int count); -+ -+static int send_ua(ts0710_con * ts0710, __u8 dlci); -+static int send_dm(ts0710_con * ts0710, __u8 dlci); -+static int send_sabm(ts0710_con * ts0710, __u8 dlci); -+static int send_disc(ts0710_con * ts0710, __u8 dlci); -+static void queue_uih(mux_send_struct * send_info, __u16 len, -+ ts0710_con * ts0710, __u8 dlci); -+static int send_pn_msg(ts0710_con * ts0710, __u8 prior, __u32 frame_size, -+ __u8 credit_flow, __u8 credits, __u8 dlci, __u8 cr); -+static int send_nsc_msg(ts0710_con * ts0710, mcc_type cmd, __u8 cr); -+static void set_uih_hdr(short_frame * uih_pkt, __u8 dlci, __u32 len, __u8 cr); -+ -+static __u32 crc_check(__u8 * data, __u32 length, __u8 check_sum); -+static __u8 crc_calc(__u8 * data, __u32 length); -+static void create_crctable(__u8 table[]); -+ -+static void mux_sched_send(void); -+ -+static __u8 crctable[256]; -+ -+static ts0710_con ts0710_connection; -+/* -+static rpn_values rpn_val; -+*/ -+ -+static int valid_dlci(__u8 dlci) -+{ -+ if ((dlci < TS0710_MAX_CHN) && (dlci > 0)) -+ return 1; -+ else -+ return 0; -+} -+ -+#ifdef TS0710DEBUG -+ -+#ifdef PRINT_OUTPUT_PRINTK -+#define TS0710_DEBUG(fmt, arg...) printk(KERN_INFO "MUX " __FUNCTION__ ": " fmt "\n" , ## arg) -+#else -+#include "ezxlog.h" -+static __u8 strDebug[256]; -+#define TS0710_DEBUG(fmt, arg...) ({ snprintf(strDebug, sizeof(strDebug), "MUX " __FUNCTION__ ": " fmt "\n" , ## arg); \ -+ /*printk("%s", strDebug)*/ezxlogk("MX", strDebug, strlen(strDebug)); }) -+#endif /* End #ifdef PRINT_OUTPUT_PRINTK */ -+ -+#else -+#define TS0710_DEBUG(fmt...) -+#endif /* End #ifdef TS0710DEBUG */ -+ -+#ifdef TS0710LOG -+static unsigned char g_tbuf[TS0710MUX_MAX_BUF_SIZE]; -+#ifdef PRINT_OUTPUT_PRINTK -+#define TS0710_LOG(fmt, arg...) printk(fmt, ## arg) -+#define TS0710_PRINTK(fmt, arg...) printk(fmt, ## arg) -+#else -+#include "ezxlog.h" -+static __u8 strLog[256]; -+#define TS0710_LOG(fmt, arg...) ({ snprintf(strLog, sizeof(strLog), fmt, ## arg); \ -+ /*printk("%s", strLog)*/ezxlogk("MX", strLog, strlen(strLog)); }) -+#define TS0710_PRINTK(fmt, arg...) ({ printk(fmt, ## arg); \ -+ TS0710_LOG(fmt, ## arg); }) -+#endif /* End #ifdef PRINT_OUTPUT_PRINTK */ -+ -+#else -+#define TS0710_LOG(fmt...) -+#define TS0710_PRINTK(fmt, arg...) printk(fmt, ## arg) -+#endif /* End #ifdef TS0710LOG */ -+ -+#ifdef TS0710DEBUG -+static void TS0710_DEBUGHEX(__u8 * buf, int len) -+{ -+ static unsigned char tbuf[TS0710MUX_MAX_BUF_SIZE]; -+ -+ int i; -+ int c; -+ -+ if (len <= 0) { -+ return; -+ } -+ -+ c = 0; -+ for (i = 0; (i < len) && (c < (TS0710MUX_MAX_BUF_SIZE - 3)); i++) { -+ sprintf(&tbuf[c], "%02x ", buf[i]); -+ c += 3; -+ } -+ tbuf[c] = 0; -+ -+#ifdef PRINT_OUTPUT_PRINTK -+ TS0710_DEBUG("%s", tbuf); -+#else -+ /*printk("%s\n", tbuf) */ ezxlogk("MX", tbuf, c); -+#endif -+} -+static void TS0710_DEBUGSTR(__u8 * buf, int len) -+{ -+ static unsigned char tbuf[TS0710MUX_MAX_BUF_SIZE]; -+ -+ if (len <= 0) { -+ return; -+ } -+ -+ if (len > (TS0710MUX_MAX_BUF_SIZE - 1)) { -+ len = (TS0710MUX_MAX_BUF_SIZE - 1); -+ } -+ -+ memcpy(tbuf, buf, len); -+ tbuf[len] = 0; -+ -+#ifdef PRINT_OUTPUT_PRINTK -+ /* 0x00 byte in the string pointed by tbuf may truncate the print result */ -+ TS0710_DEBUG("%s", tbuf); -+#else -+ /*printk("%s\n", tbuf) */ ezxlogk("MX", tbuf, len); -+#endif -+} -+#else -+#define TS0710_DEBUGHEX(buf, len) -+#define TS0710_DEBUGSTR(buf, len) -+#endif /* End #ifdef TS0710DEBUG */ -+ -+#ifdef TS0710LOG -+static void TS0710_LOGSTR_FRAME(__u8 send, __u8 * data, int len) -+{ -+ short_frame *short_pkt; -+ long_frame *long_pkt; -+ __u8 *uih_data_start; -+ __u32 uih_len; -+ __u8 dlci; -+ int pos; -+ -+ if (len <= 0) { -+ return; -+ } -+ -+ pos = 0; -+ if (send) { -+ pos += sprintf(&g_tbuf[pos], "<"); -+ short_pkt = (short_frame *) (data + 1); /*For BP UART problem */ -+ } else { -+ /*For BP UART problem */ -+ /*pos += sprintf(&g_tbuf[pos], ">"); */ -+ pos += sprintf(&g_tbuf[pos], ">%d ", *(data + SLIDE_BP_SEQ_OFFSET)); /*For BP UART problem */ -+ -+#ifdef TS0710SEQ2 -+ pos += sprintf(&g_tbuf[pos], "%02x %02x %02x %02x ", *(data + FIRST_BP_SEQ_OFFSET), *(data + SECOND_BP_SEQ_OFFSET), *(data + FIRST_AP_SEQ_OFFSET), *(data + SECOND_AP_SEQ_OFFSET)); /*For BP UART problem */ -+#endif -+ -+ short_pkt = (short_frame *) (data + ADDRESS_FIELD_OFFSET); /*For BP UART problem */ -+ } -+ -+ /*For BP UART problem */ -+ /*short_pkt = (short_frame *)(data + 1); */ -+ -+ dlci = short_pkt->h.addr.server_chn << 1 | short_pkt->h.addr.d; -+ switch (CLR_PF(short_pkt->h.control)) { -+ case SABM: -+ pos += sprintf(&g_tbuf[pos], "C SABM %d ::", dlci); -+ break; -+ case UA: -+ pos += sprintf(&g_tbuf[pos], "C UA %d ::", dlci); -+ break; -+ case DM: -+ pos += sprintf(&g_tbuf[pos], "C DM %d ::", dlci); -+ break; -+ case DISC: -+ pos += sprintf(&g_tbuf[pos], "C DISC %d ::", dlci); -+ break; -+ -+ /*For BP UART problem Begin */ -+ case ACK: -+ pos += sprintf(&g_tbuf[pos], "C ACK %d ", short_pkt->data[0]); -+ -+#ifdef TS0710SEQ2 -+ pos += sprintf(&g_tbuf[pos], "%02x %02x %02x %02x ", short_pkt->data[1], short_pkt->data[2], short_pkt->data[3], short_pkt->data[4]); /*For BP UART problem */ -+#endif -+ -+ pos += sprintf(&g_tbuf[pos], "::"); -+ break; -+ /*For BP UART problem End */ -+ -+ case UIH: -+ if (!dlci) { -+ pos += sprintf(&g_tbuf[pos], "C MCC %d ::", dlci); -+ } else { -+ -+ if ((short_pkt->h.length.ea) == 0) { -+ long_pkt = (long_frame *) short_pkt; -+ uih_len = GET_LONG_LENGTH(long_pkt->h.length); -+ uih_data_start = long_pkt->h.data; -+ } else { -+ uih_len = short_pkt->h.length.len; -+ uih_data_start = short_pkt->data; -+ } -+ switch (*uih_data_start) { -+ case CMDTAG: -+ pos += -+ sprintf(&g_tbuf[pos], "I %d A %d ::", dlci, -+ uih_len); -+ break; -+ case DATATAG: -+ default: -+ pos += -+ sprintf(&g_tbuf[pos], "I %d D %d ::", dlci, -+ uih_len); -+ break; -+ } -+ -+ } -+ break; -+ default: -+ pos += sprintf(&g_tbuf[pos], "N!!! %d ::", dlci); -+ break; -+ } -+ -+ if (len > (sizeof(g_tbuf) - pos - 1)) { -+ len = (sizeof(g_tbuf) - pos - 1); -+ } -+ -+ memcpy(&g_tbuf[pos], data, len); -+ pos += len; -+ g_tbuf[pos] = 0; -+ -+#ifdef PRINT_OUTPUT_PRINTK -+ /* 0x00 byte in the string pointed by g_tbuf may truncate the print result */ -+ TS0710_LOG("%s\n", g_tbuf); -+#else -+ /*printk("%s\n", g_tbuf) */ ezxlogk("MX", g_tbuf, pos); -+#endif -+} -+#else -+#define TS0710_LOGSTR_FRAME(send, data, len) -+#endif -+ -+#ifdef TS0710SIG -+#define my_for_each_task(p) \ -+ for ((p) = current; ((p) = (p)->next_task) != current; ) -+ -+static void TS0710_SIG2APLOGD(void) -+{ -+ struct task_struct *p; -+ static __u8 sig = 0; -+ -+ if (sig) { -+ return; -+ } -+ -+ read_lock(&tasklist_lock); -+ my_for_each_task(p) { -+ if (strncmp(p->comm, "aplogd", 6) == 0) { -+ sig = 1; -+ if (send_sig(SIGUSR2, p, 1) == 0) { -+ TS0710_PRINTK -+ ("MUX: success to send SIGUSR2 to aplogd!\n"); -+ } else { -+ TS0710_PRINTK -+ ("MUX: failure to send SIGUSR2 to aplogd!\n"); -+ } -+ break; -+ } -+ } -+ read_unlock(&tasklist_lock); -+ -+ if (!sig) { -+ TS0710_PRINTK("MUX: not found aplogd!\n"); -+ } -+} -+#else -+#define TS0710_SIG2APLOGD() -+#endif -+ -+static int basic_write(ts0710_con * ts0710, __u8 * buf, int len) -+{ -+ int res; -+ -+ UNUSED_PARAM(ts0710); -+ -+ buf[0] = TS0710_BASIC_FLAG; -+ buf[len + 1] = TS0710_BASIC_FLAG; -+ -+ if ((COMM_FOR_MUX_DRIVER == 0) || (COMM_FOR_MUX_TTY == 0)) { -+ TS0710_PRINTK -+ ("MUX basic_write: (COMM_FOR_MUX_DRIVER == 0) || (COMM_FOR_MUX_TTY == 0)\n"); -+ -+#ifndef USB_FOR_MUX -+ TS0710_PRINTK -+ ("MUX basic_write: tapisrv might be down!!! (serial_for_mux_driver == 0) || (serial_for_mux_tty == 0)\n"); -+ TS0710_SIG2APLOGD(); -+#endif -+ -+ return -1; -+ } -+ -+ TS0710_LOGSTR_FRAME(1, buf, len + 2); -+ TS0710_DEBUGHEX(buf, len + 2); -+ -+ res = COMM_FOR_MUX_DRIVER->write(COMM_FOR_MUX_TTY, buf, len + 2); -+ -+ if (res != len + 2) { -+ TS0710_PRINTK("MUX basic_write: Write Error!\n"); -+ return -1; -+ } -+ -+ return len + 2; -+} -+ -+/* Functions for the crc-check and calculation */ -+ -+#define CRC_VALID 0xcf -+ -+static __u32 crc_check(__u8 * data, __u32 length, __u8 check_sum) -+{ -+ __u8 fcs = 0xff; -+ -+ while (length--) { -+ fcs = crctable[fcs ^ *data++]; -+ } -+ fcs = crctable[fcs ^ check_sum]; -+ TS0710_DEBUG("fcs : %d\n", fcs); -+ if (fcs == (uint) 0xcf) { /*CRC_VALID) */ -+ TS0710_DEBUG("crc_check: CRC check OK\n"); -+ return 0; -+ } else { -+ TS0710_PRINTK("MUX crc_check: CRC check failed\n"); -+ return 1; -+ } -+} -+ -+/* Calculates the checksum according to the ts0710 specification */ -+ -+static __u8 crc_calc(__u8 * data, __u32 length) -+{ -+ __u8 fcs = 0xff; -+ -+ while (length--) { -+ fcs = crctable[fcs ^ *data++]; -+ } -+ -+ return 0xff - fcs; -+} -+ -+/* Calulates a reversed CRC table for the FCS check */ -+ -+static void create_crctable(__u8 table[]) -+{ -+ int i, j; -+ -+ __u8 data; -+ __u8 code_word = (__u8) 0xe0; -+ __u8 sr = (__u8) 0; -+ -+ for (j = 0; j < 256; j++) { -+ data = (__u8) j; -+ -+ for (i = 0; i < 8; i++) { -+ if ((data & 0x1) ^ (sr & 0x1)) { -+ sr >>= 1; -+ sr ^= code_word; -+ } else { -+ sr >>= 1; -+ } -+ -+ data >>= 1; -+ sr &= 0xff; -+ } -+ -+ table[j] = sr; -+ sr = 0; -+ } -+} -+ -+static void ts0710_reset_dlci(__u8 j) -+{ -+ if (j >= TS0710_MAX_CHN) -+ return; -+ -+ ts0710_connection.dlci[j].state = DISCONNECTED; -+ ts0710_connection.dlci[j].flow_control = 0; -+ ts0710_connection.dlci[j].mtu = DEF_TS0710_MTU; -+ ts0710_connection.dlci[j].initiated = 0; -+ ts0710_connection.dlci[j].initiator = 0; -+ init_waitqueue_head(&ts0710_connection.dlci[j].open_wait); -+ init_waitqueue_head(&ts0710_connection.dlci[j].close_wait); -+} -+ -+static void ts0710_reset_con(void) -+{ -+ __u8 j; -+ -+ ts0710_connection.initiator = 0; -+ ts0710_connection.mtu = DEF_TS0710_MTU + TS0710_MAX_HDR_SIZE; -+ ts0710_connection.be_testing = 0; -+ ts0710_connection.test_errs = 0; -+ init_waitqueue_head(&ts0710_connection.test_wait); -+ -+ for (j = 0; j < TS0710_MAX_CHN; j++) { -+ ts0710_reset_dlci(j); -+ } -+} -+ -+static void ts0710_init(void) -+{ -+ create_crctable(crctable); -+ -+ ts0710_reset_con(); -+ -+ /* Set the values in the rpn octets */ -+/* -+ rpn_val.bit_rate = 7; -+ rpn_val.data_bits = 3; -+ rpn_val.stop_bit = 0; -+ rpn_val.parity = 0; -+ rpn_val.parity_type = 0; -+ rpn_val.res1 = 0; -+ rpn_val.xon_input = 0; -+ rpn_val.xon_output = 0; -+ rpn_val.rtr_input = 0; -+ rpn_val.rtr_output = 0; -+ rpn_val.rtc_input = 0; -+ rpn_val.rtc_output = 0; -+ rpn_val.res2 = 0; -+ rpn_val.xon_u8 = 0x11; -+ rpn_val.xoff_u8 = 0x13; -+ memset(&rpn_val.pm, 0 , 2); *//* Set the mask to zero */ -+} -+ -+static void ts0710_upon_disconnect(void) -+{ -+ ts0710_con *ts0710 = &ts0710_connection; -+ __u8 j; -+ -+ for (j = 0; j < TS0710_MAX_CHN; j++) { -+ ts0710->dlci[j].state = DISCONNECTED; -+ wake_up_interruptible(&ts0710->dlci[j].open_wait); -+ wake_up_interruptible(&ts0710->dlci[j].close_wait); -+ } -+ ts0710->be_testing = 0; -+ wake_up_interruptible(&ts0710->test_wait); -+ ts0710_reset_con(); -+} -+ -+/* Sending packet functions */ -+ -+/* Creates a UA packet and puts it at the beginning of the pkt pointer */ -+ -+static int send_ua(ts0710_con * ts0710, __u8 dlci) -+{ -+ __u8 buf[sizeof(short_frame) + FCS_SIZE + FLAG_SIZE]; -+ short_frame *ua; -+ -+ TS0710_DEBUG("send_ua: Creating UA packet to DLCI %d\n", dlci); -+ -+ ua = (short_frame *) (buf + 1); -+ ua->h.addr.ea = 1; -+ ua->h.addr.cr = ((~(ts0710->initiator)) & 0x1); -+ ua->h.addr.d = (dlci) & 0x1; -+ ua->h.addr.server_chn = (dlci) >> 0x1; -+ ua->h.control = SET_PF(UA); -+ ua->h.length.ea = 1; -+ ua->h.length.len = 0; -+ ua->data[0] = crc_calc((__u8 *) ua, SHORT_CRC_CHECK); -+ -+ return basic_write(ts0710, buf, sizeof(short_frame) + FCS_SIZE); -+} -+ -+/* Creates a DM packet and puts it at the beginning of the pkt pointer */ -+ -+static int send_dm(ts0710_con * ts0710, __u8 dlci) -+{ -+ __u8 buf[sizeof(short_frame) + FCS_SIZE + FLAG_SIZE]; -+ short_frame *dm; -+ -+ TS0710_DEBUG("send_dm: Creating DM packet to DLCI %d\n", dlci); -+ -+ dm = (short_frame *) (buf + 1); -+ dm->h.addr.ea = 1; -+ dm->h.addr.cr = ((~(ts0710->initiator)) & 0x1); -+ dm->h.addr.d = dlci & 0x1; -+ dm->h.addr.server_chn = dlci >> 0x1; -+ dm->h.control = SET_PF(DM); -+ dm->h.length.ea = 1; -+ dm->h.length.len = 0; -+ dm->data[0] = crc_calc((__u8 *) dm, SHORT_CRC_CHECK); -+ -+ return basic_write(ts0710, buf, sizeof(short_frame) + FCS_SIZE); -+} -+ -+static int send_sabm(ts0710_con * ts0710, __u8 dlci) -+{ -+ __u8 buf[sizeof(short_frame) + FCS_SIZE + FLAG_SIZE]; -+ short_frame *sabm; -+ -+ TS0710_DEBUG("send_sabm: Creating SABM packet to DLCI %d\n", dlci); -+ -+ sabm = (short_frame *) (buf + 1); -+ sabm->h.addr.ea = 1; -+ sabm->h.addr.cr = ((ts0710->initiator) & 0x1); -+ sabm->h.addr.d = dlci & 0x1; -+ sabm->h.addr.server_chn = dlci >> 0x1; -+ sabm->h.control = SET_PF(SABM); -+ sabm->h.length.ea = 1; -+ sabm->h.length.len = 0; -+ sabm->data[0] = crc_calc((__u8 *) sabm, SHORT_CRC_CHECK); -+ -+ return basic_write(ts0710, buf, sizeof(short_frame) + FCS_SIZE); -+} -+ -+static int send_disc(ts0710_con * ts0710, __u8 dlci) -+{ -+ __u8 buf[sizeof(short_frame) + FCS_SIZE + FLAG_SIZE]; -+ short_frame *disc; -+ -+ TS0710_DEBUG("send_disc: Creating DISC packet to DLCI %d\n", dlci); -+ -+ disc = (short_frame *) (buf + 1); -+ disc->h.addr.ea = 1; -+ disc->h.addr.cr = ((ts0710->initiator) & 0x1); -+ disc->h.addr.d = dlci & 0x1; -+ disc->h.addr.server_chn = dlci >> 0x1; -+ disc->h.control = SET_PF(DISC); -+ disc->h.length.ea = 1; -+ disc->h.length.len = 0; -+ disc->data[0] = crc_calc((__u8 *) disc, SHORT_CRC_CHECK); -+ -+ return basic_write(ts0710, buf, sizeof(short_frame) + FCS_SIZE); -+} -+ -+static void queue_uih(mux_send_struct * send_info, __u16 len, -+ ts0710_con * ts0710, __u8 dlci) -+{ -+ __u32 size; -+ -+ TS0710_DEBUG -+ ("queue_uih: Creating UIH packet with %d bytes data to DLCI %d\n", -+ len, dlci); -+ -+ if (len > SHORT_PAYLOAD_SIZE) { -+ long_frame *l_pkt; -+ -+ size = sizeof(long_frame) + len + FCS_SIZE; -+ l_pkt = (long_frame *) (send_info->frame - sizeof(long_frame)); -+ set_uih_hdr((void *)l_pkt, dlci, len, ts0710->initiator); -+ l_pkt->data[len] = crc_calc((__u8 *) l_pkt, LONG_CRC_CHECK); -+ send_info->frame = ((__u8 *) l_pkt) - 1; -+ } else { -+ short_frame *s_pkt; -+ -+ size = sizeof(short_frame) + len + FCS_SIZE; -+ s_pkt = -+ (short_frame *) (send_info->frame - sizeof(short_frame)); -+ set_uih_hdr((void *)s_pkt, dlci, len, ts0710->initiator); -+ s_pkt->data[len] = crc_calc((__u8 *) s_pkt, SHORT_CRC_CHECK); -+ send_info->frame = ((__u8 *) s_pkt) - 1; -+ } -+ send_info->length = size; -+} -+ -+/* Multiplexer command packets functions */ -+ -+/* Turns on the ts0710 flow control */ -+ -+static int ts0710_fcon_msg(ts0710_con * ts0710, __u8 cr) -+{ -+ __u8 buf[30]; -+ mcc_short_frame *mcc_pkt; -+ short_frame *uih_pkt; -+ __u32 size; -+ -+ size = sizeof(short_frame) + sizeof(mcc_short_frame) + FCS_SIZE; -+ uih_pkt = (short_frame *) (buf + 1); -+ set_uih_hdr(uih_pkt, CTRL_CHAN, sizeof(mcc_short_frame), -+ ts0710->initiator); -+ uih_pkt->data[sizeof(mcc_short_frame)] = -+ crc_calc((__u8 *) uih_pkt, SHORT_CRC_CHECK); -+ mcc_pkt = (mcc_short_frame *) (uih_pkt->data); -+ -+ mcc_pkt->h.type.ea = EA; -+ mcc_pkt->h.type.cr = cr; -+ mcc_pkt->h.type.type = FCON; -+ mcc_pkt->h.length.ea = EA; -+ mcc_pkt->h.length.len = 0; -+ -+ return basic_write(ts0710, buf, size); -+} -+ -+/* Turns off the ts0710 flow control */ -+ -+static int ts0710_fcoff_msg(ts0710_con * ts0710, __u8 cr) -+{ -+ __u8 buf[30]; -+ mcc_short_frame *mcc_pkt; -+ short_frame *uih_pkt; -+ __u32 size; -+ -+ size = (sizeof(short_frame) + sizeof(mcc_short_frame) + FCS_SIZE); -+ uih_pkt = (short_frame *) (buf + 1); -+ set_uih_hdr(uih_pkt, CTRL_CHAN, sizeof(mcc_short_frame), -+ ts0710->initiator); -+ uih_pkt->data[sizeof(mcc_short_frame)] = -+ crc_calc((__u8 *) uih_pkt, SHORT_CRC_CHECK); -+ mcc_pkt = (mcc_short_frame *) (uih_pkt->data); -+ -+ mcc_pkt->h.type.ea = 1; -+ mcc_pkt->h.type.cr = cr; -+ mcc_pkt->h.type.type = FCOFF; -+ mcc_pkt->h.length.ea = 1; -+ mcc_pkt->h.length.len = 0; -+ -+ return basic_write(ts0710, buf, size); -+} -+ -+/* -+static int ts0710_rpn_msg(ts0710_con *ts0710, __u8 cr, __u8 dlci, __u8 req) -+{ -+ char buf[100]; -+ rpn_msg* rpn_pkt; -+ __u32 fsize; -+ __u32 psize; -+ -+ fsize = sizeof(rpn_msg); -+ -+ if (req) { -+ fsize -= sizeof(rpn_values); -+ } -+ -+ psize = (fsize - sizeof(short_frame) - FCS_SIZE); -+ -+ rpn_pkt = (rpn_msg *) buf; -+ -+ set_uih_hdr((short_frame *) rpn_pkt, CTRL_CHAN, psize, ts0710->initiator); -+ -+ rpn_pkt->fcs = crc_calc((__u8*) rpn_pkt, SHORT_CRC_CHECK); -+ -+ rpn_pkt->mcc_s_head.type.ea = EA; -+ rpn_pkt->mcc_s_head.type.cr = cr; -+ rpn_pkt->mcc_s_head.type.type = RPN; -+ rpn_pkt->mcc_s_head.length.ea = EA; -+ -+ rpn_pkt->dlci.ea = EA; -+ rpn_pkt->dlci.cr = 1; -+ rpn_pkt->dlci.d = dlci & 1; -+ rpn_pkt->dlci.server_chn = (dlci >> 1); -+ -+ if (req) { -+ rpn_pkt->mcc_s_head.length.len = 1; -+ rpn_pkt->rpn_val.bit_rate = rpn_pkt->fcs; -+ } else { -+ rpn_pkt->mcc_s_head.length.len = 8; -+ memcpy(&(rpn_pkt->rpn_val), &rpn_val, sizeof(rpn_values)); -+ } -+ return basic_write(ts0710, buf, fsize); -+} -+*/ -+/* -+static int ts0710_rls_msg(ts0710_con *ts0710, __u8 cr, __u8 dlci, __u8 err_code) -+{ -+ char buf[100]; -+ rls_msg *rls_pkt; -+ __u32 fsize; -+ __u32 psize; -+ -+ fsize = sizeof(rls_msg); -+ psize = fsize - sizeof(short_frame) - FCS_SIZE; -+ rls_pkt = (rls_msg *) buf; -+ -+ set_uih_hdr((short_frame *) rls_pkt, CTRL_CHAN, psize, ts0710->initiator); -+ rls_pkt->fcs = crc_calc((__u8*) rls_pkt, SHORT_CRC_CHECK); -+ -+ rls_pkt->mcc_s_head.type.ea = EA; -+ rls_pkt->mcc_s_head.type.cr = cr; -+ rls_pkt->mcc_s_head.type.type = RLS; -+ rls_pkt->mcc_s_head.length.ea = EA; -+ rls_pkt->mcc_s_head.length.len = 2; -+ -+ rls_pkt->dlci.ea = EA; -+ rls_pkt->dlci.cr = 1; -+ rls_pkt->dlci.d = dlci & 1; -+ rls_pkt->dlci.server_chn = dlci >> 1; -+ rls_pkt->error = err_code; -+ rls_pkt->res = 0; -+ -+ return basic_write(ts0710, buf, fsize); -+} -+*/ -+ -+/* Sends an PN-messages and sets the not negotiable parameters to their -+ default values in ts0710 */ -+ -+static int send_pn_msg(ts0710_con * ts0710, __u8 prior, __u32 frame_size, -+ __u8 credit_flow, __u8 credits, __u8 dlci, __u8 cr) -+{ -+ __u8 buf[30]; -+ pn_msg *pn_pkt; -+ __u32 size; -+ TS0710_DEBUG -+ ("send_pn_msg: DLCI 0x%02x, prior:0x%02x, frame_size:%d, credit_flow:%x, credits:%d, cr:%x\n", -+ dlci, prior, frame_size, credit_flow, credits, cr); -+ -+ size = sizeof(pn_msg); -+ pn_pkt = (pn_msg *) (buf + 1); -+ -+ set_uih_hdr((void *)pn_pkt, CTRL_CHAN, -+ size - (sizeof(short_frame) + FCS_SIZE), ts0710->initiator); -+ pn_pkt->fcs = crc_calc((__u8 *) pn_pkt, SHORT_CRC_CHECK); -+ -+ pn_pkt->mcc_s_head.type.ea = 1; -+ pn_pkt->mcc_s_head.type.cr = cr; -+ pn_pkt->mcc_s_head.type.type = PN; -+ pn_pkt->mcc_s_head.length.ea = 1; -+ pn_pkt->mcc_s_head.length.len = 8; -+ -+ pn_pkt->res1 = 0; -+ pn_pkt->res2 = 0; -+ pn_pkt->dlci = dlci; -+ pn_pkt->frame_type = 0; -+ pn_pkt->credit_flow = credit_flow; -+ pn_pkt->prior = prior; -+ pn_pkt->ack_timer = 0; -+ SET_PN_MSG_FRAME_SIZE(pn_pkt, frame_size); -+ pn_pkt->credits = credits; -+ pn_pkt->max_nbrof_retrans = 0; -+ -+ return basic_write(ts0710, buf, size); -+} -+ -+/* Send a Not supported command - command, which needs 3 bytes */ -+ -+static int send_nsc_msg(ts0710_con * ts0710, mcc_type cmd, __u8 cr) -+{ -+ __u8 buf[30]; -+ nsc_msg *nsc_pkt; -+ __u32 size; -+ -+ size = sizeof(nsc_msg); -+ nsc_pkt = (nsc_msg *) (buf + 1); -+ -+ set_uih_hdr((void *)nsc_pkt, CTRL_CHAN, -+ sizeof(nsc_msg) - sizeof(short_frame) - FCS_SIZE, -+ ts0710->initiator); -+ -+ nsc_pkt->fcs = crc_calc((__u8 *) nsc_pkt, SHORT_CRC_CHECK); -+ -+ nsc_pkt->mcc_s_head.type.ea = 1; -+ nsc_pkt->mcc_s_head.type.cr = cr; -+ nsc_pkt->mcc_s_head.type.type = NSC; -+ nsc_pkt->mcc_s_head.length.ea = 1; -+ nsc_pkt->mcc_s_head.length.len = 1; -+ -+ nsc_pkt->command_type.ea = 1; -+ nsc_pkt->command_type.cr = cmd.cr; -+ nsc_pkt->command_type.type = cmd.type; -+ -+ return basic_write(ts0710, buf, size); -+} -+ -+static int ts0710_msc_msg(ts0710_con * ts0710, __u8 value, __u8 cr, __u8 dlci) -+{ -+ __u8 buf[30]; -+ msc_msg *msc_pkt; -+ __u32 size; -+ -+ size = sizeof(msc_msg); -+ msc_pkt = (msc_msg *) (buf + 1); -+ -+ set_uih_hdr((void *)msc_pkt, CTRL_CHAN, -+ sizeof(msc_msg) - sizeof(short_frame) - FCS_SIZE, -+ ts0710->initiator); -+ -+ msc_pkt->fcs = crc_calc((__u8 *) msc_pkt, SHORT_CRC_CHECK); -+ -+ msc_pkt->mcc_s_head.type.ea = 1; -+ msc_pkt->mcc_s_head.type.cr = cr; -+ msc_pkt->mcc_s_head.type.type = MSC; -+ msc_pkt->mcc_s_head.length.ea = 1; -+ msc_pkt->mcc_s_head.length.len = 2; -+ -+ msc_pkt->dlci.ea = 1; -+ msc_pkt->dlci.cr = 1; -+ msc_pkt->dlci.d = dlci & 1; -+ msc_pkt->dlci.server_chn = (dlci >> 1) & 0x1f; -+ -+ msc_pkt->v24_sigs = value; -+ -+ return basic_write(ts0710, buf, size); -+} -+ -+static int ts0710_test_msg(ts0710_con * ts0710, __u8 * test_pattern, __u32 len, -+ __u8 cr, __u8 * f_buf /*Frame buf */ ) -+{ -+ __u32 size; -+ -+ if (len > SHORT_PAYLOAD_SIZE) { -+ long_frame *uih_pkt; -+ mcc_long_frame *mcc_pkt; -+ -+ size = -+ (sizeof(long_frame) + sizeof(mcc_long_frame) + len + -+ FCS_SIZE); -+ uih_pkt = (long_frame *) (f_buf + 1); -+ -+ set_uih_hdr((short_frame *) uih_pkt, CTRL_CHAN, len + -+ sizeof(mcc_long_frame), ts0710->initiator); -+ uih_pkt->data[GET_LONG_LENGTH(uih_pkt->h.length)] = -+ crc_calc((__u8 *) uih_pkt, LONG_CRC_CHECK); -+ mcc_pkt = (mcc_long_frame *) uih_pkt->data; -+ -+ mcc_pkt->h.type.ea = EA; -+ /* cr tells whether it is a commmand (1) or a response (0) */ -+ mcc_pkt->h.type.cr = cr; -+ mcc_pkt->h.type.type = TEST; -+ SET_LONG_LENGTH(mcc_pkt->h.length, len); -+ memcpy(mcc_pkt->value, test_pattern, len); -+ } else if (len > (SHORT_PAYLOAD_SIZE - sizeof(mcc_short_frame))) { -+ long_frame *uih_pkt; -+ mcc_short_frame *mcc_pkt; -+ -+ /* Create long uih packet and short mcc packet */ -+ size = -+ (sizeof(long_frame) + sizeof(mcc_short_frame) + len + -+ FCS_SIZE); -+ uih_pkt = (long_frame *) (f_buf + 1); -+ -+ set_uih_hdr((short_frame *) uih_pkt, CTRL_CHAN, -+ len + sizeof(mcc_short_frame), ts0710->initiator); -+ uih_pkt->data[GET_LONG_LENGTH(uih_pkt->h.length)] = -+ crc_calc((__u8 *) uih_pkt, LONG_CRC_CHECK); -+ mcc_pkt = (mcc_short_frame *) uih_pkt->data; -+ -+ mcc_pkt->h.type.ea = EA; -+ mcc_pkt->h.type.cr = cr; -+ mcc_pkt->h.type.type = TEST; -+ mcc_pkt->h.length.ea = EA; -+ mcc_pkt->h.length.len = len; -+ memcpy(mcc_pkt->value, test_pattern, len); -+ } else { -+ short_frame *uih_pkt; -+ mcc_short_frame *mcc_pkt; -+ -+ size = -+ (sizeof(short_frame) + sizeof(mcc_short_frame) + len + -+ FCS_SIZE); -+ uih_pkt = (short_frame *) (f_buf + 1); -+ -+ set_uih_hdr((void *)uih_pkt, CTRL_CHAN, len -+ + sizeof(mcc_short_frame), ts0710->initiator); -+ uih_pkt->data[uih_pkt->h.length.len] = -+ crc_calc((__u8 *) uih_pkt, SHORT_CRC_CHECK); -+ mcc_pkt = (mcc_short_frame *) uih_pkt->data; -+ -+ mcc_pkt->h.type.ea = EA; -+ mcc_pkt->h.type.cr = cr; -+ mcc_pkt->h.type.type = TEST; -+ mcc_pkt->h.length.ea = EA; -+ mcc_pkt->h.length.len = len; -+ memcpy(mcc_pkt->value, test_pattern, len); -+ -+ } -+ return basic_write(ts0710, f_buf, size); -+} -+ -+static void set_uih_hdr(short_frame * uih_pkt, __u8 dlci, __u32 len, __u8 cr) -+{ -+ uih_pkt->h.addr.ea = 1; -+ uih_pkt->h.addr.cr = cr; -+ uih_pkt->h.addr.d = dlci & 0x1; -+ uih_pkt->h.addr.server_chn = dlci >> 1; -+ uih_pkt->h.control = CLR_PF(UIH); -+ -+ if (len > SHORT_PAYLOAD_SIZE) { -+ SET_LONG_LENGTH(((long_frame *) uih_pkt)->h.length, len); -+ } else { -+ uih_pkt->h.length.ea = 1; -+ uih_pkt->h.length.len = len; -+ } -+} -+ -+/* Parses a multiplexer control channel packet */ -+ -+void process_mcc(__u8 * data, __u32 len, ts0710_con * ts0710, int longpkt) -+{ -+ __u8 *tbuf = NULL; -+ mcc_short_frame *mcc_short_pkt; -+ int j; -+ -+ if (longpkt) { -+ mcc_short_pkt = -+ (mcc_short_frame *) (((long_frame *) data)->data); -+ } else { -+ mcc_short_pkt = -+ (mcc_short_frame *) (((short_frame *) data)->data); -+ } -+ -+ switch (mcc_short_pkt->h.type.type) { -+ case TEST: -+ if (mcc_short_pkt->h.type.cr == MCC_RSP) { -+ TS0710_DEBUG("Received test command response\n"); -+ -+ if (ts0710->be_testing) { -+ if ((mcc_short_pkt->h.length.ea) == 0) { -+ mcc_long_frame *mcc_long_pkt; -+ mcc_long_pkt = -+ (mcc_long_frame *) mcc_short_pkt; -+ if (GET_LONG_LENGTH -+ (mcc_long_pkt->h.length) != -+ TEST_PATTERN_SIZE) { -+ ts0710->test_errs = -+ TEST_PATTERN_SIZE; -+ TS0710_DEBUG -+ ("Err: received test pattern is %d bytes long, not expected %d\n", -+ GET_LONG_LENGTH -+ (mcc_long_pkt->h.length), -+ TEST_PATTERN_SIZE); -+ } else { -+ ts0710->test_errs = 0; -+ for (j = 0; -+ j < TEST_PATTERN_SIZE; -+ j++) { -+ if (mcc_long_pkt-> -+ value[j] != -+ (j & 0xFF)) { -+ (ts0710-> -+ test_errs)++; -+ } -+ } -+ } -+ -+ } else { -+ -+#if TEST_PATTERN_SIZE < 128 -+ if (mcc_short_pkt->h.length.len != -+ TEST_PATTERN_SIZE) { -+#endif -+ -+ ts0710->test_errs = -+ TEST_PATTERN_SIZE; -+ TS0710_DEBUG -+ ("Err: received test pattern is %d bytes long, not expected %d\n", -+ mcc_short_pkt->h.length. -+ len, TEST_PATTERN_SIZE); -+ -+#if TEST_PATTERN_SIZE < 128 -+ } else { -+ ts0710->test_errs = 0; -+ for (j = 0; -+ j < TEST_PATTERN_SIZE; -+ j++) { -+ if (mcc_short_pkt-> -+ value[j] != -+ (j & 0xFF)) { -+ (ts0710-> -+ test_errs)++; -+ } -+ } -+ } -+#endif -+ -+ } -+ -+ ts0710->be_testing = 0; /* Clear the flag */ -+ wake_up_interruptible(&ts0710->test_wait); -+ } else { -+ TS0710_DEBUG -+ ("Err: shouldn't or late to get test cmd response\n"); -+ } -+ } else { -+ tbuf = (__u8 *) kmalloc(len + 32, GFP_ATOMIC); -+ if (!tbuf) { -+ break; -+ } -+ -+ if ((mcc_short_pkt->h.length.ea) == 0) { -+ mcc_long_frame *mcc_long_pkt; -+ mcc_long_pkt = (mcc_long_frame *) mcc_short_pkt; -+ ts0710_test_msg(ts0710, mcc_long_pkt->value, -+ GET_LONG_LENGTH(mcc_long_pkt->h. -+ length), -+ MCC_RSP, tbuf); -+ } else { -+ ts0710_test_msg(ts0710, mcc_short_pkt->value, -+ mcc_short_pkt->h.length.len, -+ MCC_RSP, tbuf); -+ } -+ -+ kfree(tbuf); -+ } -+ break; -+ -+ case FCON: /*Flow control on command */ -+ TS0710_PRINTK -+ ("MUX Received Flow control(all channels) on command\n"); -+ if (mcc_short_pkt->h.type.cr == MCC_CMD) { -+ ts0710->dlci[0].state = CONNECTED; -+ ts0710_fcon_msg(ts0710, MCC_RSP); -+ mux_sched_send(); -+ } -+ break; -+ -+ case FCOFF: /*Flow control off command */ -+ TS0710_PRINTK -+ ("MUX Received Flow control(all channels) off command\n"); -+ if (mcc_short_pkt->h.type.cr == MCC_CMD) { -+ for (j = 0; j < TS0710_MAX_CHN; j++) { -+ ts0710->dlci[j].state = FLOW_STOPPED; -+ } -+ ts0710_fcoff_msg(ts0710, MCC_RSP); -+ } -+ break; -+ -+ case MSC: /*Modem status command */ -+ { -+ __u8 dlci; -+ __u8 v24_sigs; -+ -+ dlci = (mcc_short_pkt->value[0]) >> 2; -+ v24_sigs = mcc_short_pkt->value[1]; -+ -+ if ((ts0710->dlci[dlci].state != CONNECTED) -+ && (ts0710->dlci[dlci].state != FLOW_STOPPED)) { -+ send_dm(ts0710, dlci); -+ break; -+ } -+ if (mcc_short_pkt->h.type.cr == MCC_CMD) { -+ TS0710_DEBUG("Received Modem status command\n"); -+ if (v24_sigs & 2) { -+ if (ts0710->dlci[dlci].state == -+ CONNECTED) { -+ TS0710_LOG -+ ("MUX Received Flow off on dlci %d\n", -+ dlci); -+ ts0710->dlci[dlci].state = -+ FLOW_STOPPED; -+ } -+ } else { -+ if (ts0710->dlci[dlci].state == -+ FLOW_STOPPED) { -+ ts0710->dlci[dlci].state = -+ CONNECTED; -+ TS0710_LOG -+ ("MUX Received Flow on on dlci %d\n", -+ dlci); -+ mux_sched_send(); -+ } -+ } -+ -+ ts0710_msc_msg(ts0710, v24_sigs, MCC_RSP, dlci); -+/* -+ if (!(ts0710->dlci[dlci].initiated) && !(ts0710->dlci[dlci].initiator)) { -+ ts0710_msc_msg(ts0710, EA | RTR | RTC | DV, MCC_CMD, dlci); -+ ts0710->dlci[dlci].initiated = 1; -+ } -+*/ -+ } else { -+ TS0710_DEBUG -+ ("Received Modem status response\n"); -+ -+ if (v24_sigs & 2) { -+ TS0710_DEBUG("Flow stop accepted\n"); -+ } -+ } -+ break; -+ } -+ -+ /* case RPN: *//*Remote port negotiation command */ -+ -+/* { -+ __u8 dlci; -+ -+ dlci = (mcc_short_pkt->value[0]) >> 2; -+ -+ if (mcc_short_pkt->h.type.cr == MCC_CMD) { -+ if (mcc_short_pkt->h.length.len == 1) { -+ TS0710_DEBUG("Received Remote port negotiation command\n"); -+ ts0710_rpn_msg(ts0710, MCC_RSP, dlci, 0); -+ } else { -+*/ -+ /* Accept the other sides settings (accept all for now) */ -+/* TS0710_DEBUG("Received Remote port negotiation respons\n"); -+ memcpy(&rpn_val, &mcc_short_pkt->value[1], 8); -+ ts0710_rpn_msg(ts0710, MCC_RSP, dlci, 0); -+*/ -+ /* Zero the parametermask after response */ -+/* memset(&rpn_val.pm, 0, 2); -+ } -+ } -+ break; -+ } -+*/ -+/* -+ case RLS: *//*Remote line status */ -+/* { -+ __u8 dlci; -+ __u8 err_code; -+ -+ TS0710_DEBUG("Received Remote line status\n"); -+ if (mcc_short_pkt->h.type.cr == MCC_CMD) { -+ dlci = mcc_short_pkt->value[0] >> 2; -+ err_code = mcc_short_pkt->value[1]; -+ -+ ts0710_rls_msg(ts0710, MCC_RSP, dlci, err_code); -+ } -+ break; -+ } -+*/ -+ case PN: /*DLC parameter negotiation */ -+ { -+ __u8 dlci; -+ __u16 frame_size; -+ pn_msg *pn_pkt; -+ -+ pn_pkt = (pn_msg *) data; -+ dlci = pn_pkt->dlci; -+ frame_size = GET_PN_MSG_FRAME_SIZE(pn_pkt); -+ TS0710_DEBUG -+ ("Received DLC parameter negotiation, PN\n"); -+ if (pn_pkt->mcc_s_head.type.cr == MCC_CMD) { -+ TS0710_DEBUG("received PN command with:\n"); -+ TS0710_DEBUG("Frame size:%d\n", frame_size); -+ -+ frame_size = -+ min(frame_size, ts0710->dlci[dlci].mtu); -+ send_pn_msg(ts0710, pn_pkt->prior, frame_size, -+ 0, 0, dlci, MCC_RSP); -+ ts0710->dlci[dlci].mtu = frame_size; -+ TS0710_DEBUG("process_mcc : mtu set to %d\n", -+ ts0710->dlci[dlci].mtu); -+ } else { -+ TS0710_DEBUG("received PN response with:\n"); -+ TS0710_DEBUG("Frame size:%d\n", frame_size); -+ -+ frame_size = -+ min(frame_size, ts0710->dlci[dlci].mtu); -+ ts0710->dlci[dlci].mtu = frame_size; -+ -+ TS0710_DEBUG -+ ("process_mcc : mtu set on dlci:%d to %d\n", -+ dlci, ts0710->dlci[dlci].mtu); -+ -+ if (ts0710->dlci[dlci].state == NEGOTIATING) { -+ ts0710->dlci[dlci].state = CONNECTING; -+ wake_up_interruptible(&ts0710-> -+ dlci[dlci]. -+ open_wait); -+ } -+ } -+ break; -+ } -+ -+ case NSC: /*Non supported command resonse */ -+ TS0710_LOG("MUX Received Non supported command response\n"); -+ break; -+ -+ default: /*Non supported command received */ -+ TS0710_LOG("MUX Received a non supported command\n"); -+ send_nsc_msg(ts0710, mcc_short_pkt->h.type, MCC_RSP); -+ break; -+ } -+} -+ -+static mux_recv_packet *get_mux_recv_packet(__u32 size) -+{ -+ mux_recv_packet *recv_packet; -+ -+ TS0710_DEBUG("Enter into get_mux_recv_packet"); -+ -+ recv_packet = -+ (mux_recv_packet *) kmalloc(sizeof(mux_recv_packet), GFP_ATOMIC); -+ if (!recv_packet) { -+ return 0; -+ } -+ -+ recv_packet->data = (__u8 *) kmalloc(size, GFP_ATOMIC); -+ if (!(recv_packet->data)) { -+ kfree(recv_packet); -+ return 0; -+ } -+ recv_packet->length = 0; -+ recv_packet->next = 0; -+ return recv_packet; -+} -+ -+static void free_mux_recv_packet(mux_recv_packet * recv_packet) -+{ -+ TS0710_DEBUG("Enter into free_mux_recv_packet"); -+ -+ if (!recv_packet) { -+ return; -+ } -+ -+ if (recv_packet->data) { -+ kfree(recv_packet->data); -+ } -+ kfree(recv_packet); -+} -+ -+static void free_mux_recv_struct(mux_recv_struct * recv_info) -+{ -+ mux_recv_packet *recv_packet1, *recv_packet2; -+ -+ if (!recv_info) { -+ return; -+ } -+ -+ recv_packet1 = recv_info->mux_packet; -+ while (recv_packet1) { -+ recv_packet2 = recv_packet1->next; -+ free_mux_recv_packet(recv_packet1); -+ recv_packet1 = recv_packet2; -+ } -+ -+ kfree(recv_info); -+} -+ -+static inline void add_post_recv_queue(mux_recv_struct ** head, -+ mux_recv_struct * new_item) -+{ -+ new_item->next = *head; -+ *head = new_item; -+} -+ -+static void ts0710_flow_on(__u8 dlci, ts0710_con * ts0710) -+{ -+ int i; -+ __u8 cmdtty; -+ __u8 datatty; -+ struct tty_struct *tty; -+ mux_recv_struct *recv_info; -+ -+ if ((ts0710->dlci[0].state != CONNECTED) -+ && (ts0710->dlci[0].state != FLOW_STOPPED)) { -+ return; -+ } else if ((ts0710->dlci[dlci].state != CONNECTED) -+ && (ts0710->dlci[dlci].state != FLOW_STOPPED)) { -+ return; -+ } -+ -+ if (!(ts0710->dlci[dlci].flow_control)) { -+ return; -+ } -+ -+ cmdtty = dlci2tty[dlci].cmdtty; -+ datatty = dlci2tty[dlci].datatty; -+ -+ if (cmdtty != datatty) { -+ /* Check AT cmd tty */ -+ tty = mux_table[cmdtty]; -+ if (mux_tty[cmdtty] && tty) { -+ if (test_bit(TTY_THROTTLED, &tty->flags)) { -+ return; -+ } -+ } -+ recv_info = mux_recv_info[cmdtty]; -+ if (mux_recv_info_flags[cmdtty] && recv_info) { -+ if (recv_info->total) { -+ return; -+ } -+ } -+ -+ /* Check data tty */ -+ tty = mux_table[datatty]; -+ if (mux_tty[datatty] && tty) { -+ if (test_bit(TTY_THROTTLED, &tty->flags)) { -+ return; -+ } -+ } -+ recv_info = mux_recv_info[datatty]; -+ if (mux_recv_info_flags[datatty] && recv_info) { -+ if (recv_info->total) { -+ return; -+ } -+ } -+ } -+ -+ for (i = 0; i < 3; i++) { -+ if (ts0710_msc_msg(ts0710, EA | RTC | RTR | DV, MCC_CMD, dlci) < -+ 0) { -+ continue; -+ } else { -+ TS0710_LOG("MUX send Flow on on dlci %d\n", dlci); -+ ts0710->dlci[dlci].flow_control = 0; -+ break; -+ } -+ } -+} -+ -+static void ts0710_flow_off(struct tty_struct *tty, __u8 dlci, -+ ts0710_con * ts0710) -+{ -+ int i; -+ -+ if (test_and_set_bit(TTY_THROTTLED, &tty->flags)) { -+ return; -+ } -+ -+ if ((ts0710->dlci[0].state != CONNECTED) -+ && (ts0710->dlci[0].state != FLOW_STOPPED)) { -+ return; -+ } else if ((ts0710->dlci[dlci].state != CONNECTED) -+ && (ts0710->dlci[dlci].state != FLOW_STOPPED)) { -+ return; -+ } -+ -+ if (ts0710->dlci[dlci].flow_control) { -+ return; -+ } -+ -+ for (i = 0; i < 3; i++) { -+ if (ts0710_msc_msg -+ (ts0710, EA | FC | RTC | RTR | DV, MCC_CMD, dlci) < 0) { -+ continue; -+ } else { -+ TS0710_LOG("MUX send Flow off on dlci %d\n", dlci); -+ ts0710->dlci[dlci].flow_control = 1; -+ break; -+ } -+ } -+} -+ -+int ts0710_recv_data(ts0710_con * ts0710, char *data, int len) -+{ -+ short_frame *short_pkt; -+ long_frame *long_pkt; -+ __u8 *uih_data_start; -+ __u32 uih_len; -+ __u8 dlci; -+ __u8 be_connecting; -+#ifdef TS0710DEBUG -+ unsigned long t; -+#endif -+ -+ short_pkt = (short_frame *) data; -+ -+ dlci = short_pkt->h.addr.server_chn << 1 | short_pkt->h.addr.d; -+ switch (CLR_PF(short_pkt->h.control)) { -+ case SABM: -+ TS0710_DEBUG("SABM-packet received\n"); -+ -+/*For BP UART problem -+ if( crc_check((__u8*) short_pkt, SHORT_CRC_CHECK, short_pkt->data[0]) ) -+ break; -+*/ -+ -+ if (!dlci) { -+ TS0710_DEBUG("server channel == 0\n"); -+ ts0710->dlci[0].state = CONNECTED; -+ -+ TS0710_DEBUG("sending back UA - control channel\n"); -+ send_ua(ts0710, dlci); -+ wake_up_interruptible(&ts0710->dlci[0].open_wait); -+ -+ } else if (valid_dlci(dlci)) { -+ -+ TS0710_DEBUG("Incomming connect on channel %d\n", dlci); -+ -+ TS0710_DEBUG("sending UA, dlci %d\n", dlci); -+ send_ua(ts0710, dlci); -+ -+ ts0710->dlci[dlci].state = CONNECTED; -+ wake_up_interruptible(&ts0710->dlci[dlci].open_wait); -+ -+ } else { -+ TS0710_DEBUG("invalid dlci %d, sending DM\n", dlci); -+ send_dm(ts0710, dlci); -+ } -+ -+ break; -+ -+ case UA: -+ TS0710_DEBUG("UA packet received\n"); -+ -+/*For BP UART problem -+ if( crc_check((__u8*) short_pkt, SHORT_CRC_CHECK, short_pkt->data[0]) ) -+ break; -+*/ -+ -+ if (!dlci) { -+ TS0710_DEBUG("server channel == 0\n"); -+ -+ if (ts0710->dlci[0].state == CONNECTING) { -+ ts0710->dlci[0].state = CONNECTED; -+ wake_up_interruptible(&ts0710->dlci[0]. -+ open_wait); -+ } else if (ts0710->dlci[0].state == DISCONNECTING) { -+ ts0710_upon_disconnect(); -+ } else { -+ TS0710_DEBUG -+ (" Something wrong receiving UA packet\n"); -+ } -+ } else if (valid_dlci(dlci)) { -+ TS0710_DEBUG("Incomming UA on channel %d\n", dlci); -+ -+ if (ts0710->dlci[dlci].state == CONNECTING) { -+ ts0710->dlci[dlci].state = CONNECTED; -+ wake_up_interruptible(&ts0710->dlci[dlci]. -+ open_wait); -+ } else if (ts0710->dlci[dlci].state == DISCONNECTING) { -+ ts0710->dlci[dlci].state = DISCONNECTED; -+ wake_up_interruptible(&ts0710->dlci[dlci]. -+ open_wait); -+ wake_up_interruptible(&ts0710->dlci[dlci]. -+ close_wait); -+ ts0710_reset_dlci(dlci); -+ } else { -+ TS0710_DEBUG -+ (" Something wrong receiving UA packet\n"); -+ } -+ } else { -+ TS0710_DEBUG("invalid dlci %d\n", dlci); -+ } -+ -+ break; -+ -+ case DM: -+ TS0710_DEBUG("DM packet received\n"); -+ -+/*For BP UART problem -+ if( crc_check((__u8*) short_pkt, SHORT_CRC_CHECK, short_pkt->data[0]) ) -+ break; -+*/ -+ -+ if (!dlci) { -+ TS0710_DEBUG("server channel == 0\n"); -+ -+ if (ts0710->dlci[0].state == CONNECTING) { -+ be_connecting = 1; -+ } else { -+ be_connecting = 0; -+ } -+ ts0710_upon_disconnect(); -+ if (be_connecting) { -+ ts0710->dlci[0].state = REJECTED; -+ } -+ } else if (valid_dlci(dlci)) { -+ TS0710_DEBUG("Incomming DM on channel %d\n", dlci); -+ -+ if (ts0710->dlci[dlci].state == CONNECTING) { -+ ts0710->dlci[dlci].state = REJECTED; -+ } else { -+ ts0710->dlci[dlci].state = DISCONNECTED; -+ } -+ wake_up_interruptible(&ts0710->dlci[dlci].open_wait); -+ wake_up_interruptible(&ts0710->dlci[dlci].close_wait); -+ ts0710_reset_dlci(dlci); -+ } else { -+ TS0710_DEBUG("invalid dlci %d\n", dlci); -+ } -+ -+ break; -+ -+ case DISC: -+ TS0710_DEBUG("DISC packet received\n"); -+ -+/*For BP UART problem -+ if( crc_check((__u8*) short_pkt, SHORT_CRC_CHECK, short_pkt->data[0]) ) -+ break; -+*/ -+ -+ if (!dlci) { -+ TS0710_DEBUG("server channel == 0\n"); -+ -+ send_ua(ts0710, dlci); -+ TS0710_DEBUG("DISC, sending back UA\n"); -+ -+ ts0710_upon_disconnect(); -+ } else if (valid_dlci(dlci)) { -+ TS0710_DEBUG("Incomming DISC on channel %d\n", dlci); -+ -+ send_ua(ts0710, dlci); -+ TS0710_DEBUG("DISC, sending back UA\n"); -+ -+ ts0710->dlci[dlci].state = DISCONNECTED; -+ wake_up_interruptible(&ts0710->dlci[dlci].open_wait); -+ wake_up_interruptible(&ts0710->dlci[dlci].close_wait); -+ ts0710_reset_dlci(dlci); -+ } else { -+ TS0710_DEBUG("invalid dlci %d\n", dlci); -+ } -+ -+ break; -+ -+ case UIH: -+ TS0710_DEBUG("UIH packet received\n"); -+ -+ if ((dlci >= TS0710_MAX_CHN)) { -+ TS0710_DEBUG("invalid dlci %d\n", dlci); -+ send_dm(ts0710, dlci); -+ break; -+ } -+ -+ if (GET_PF(short_pkt->h.control)) { -+ TS0710_LOG -+ ("MUX Error %s: UIH packet with P/F set, discard it!\n", -+ __FUNCTION__); -+ break; -+ } -+ -+ if ((ts0710->dlci[dlci].state != CONNECTED) -+ && (ts0710->dlci[dlci].state != FLOW_STOPPED)) { -+ TS0710_LOG -+ ("MUX Error %s: DLCI %d not connected, discard it!\n", -+ __FUNCTION__, dlci); -+ send_dm(ts0710, dlci); -+ break; -+ } -+ -+ if ((short_pkt->h.length.ea) == 0) { -+ TS0710_DEBUG("Long UIH packet received\n"); -+ long_pkt = (long_frame *) data; -+ uih_len = GET_LONG_LENGTH(long_pkt->h.length); -+ uih_data_start = long_pkt->h.data; -+ TS0710_DEBUG("long packet length %d\n", uih_len); -+ -+/*For BP UART problem -+ if (crc_check(data, LONG_CRC_CHECK, *(uih_data_start + uih_len))) -+ break; -+*/ -+ } else { -+ TS0710_DEBUG("Short UIH pkt received\n"); -+ uih_len = short_pkt->h.length.len; -+ uih_data_start = short_pkt->data; -+ -+/*For BP UART problem -+ if (crc_check(data, SHORT_CRC_CHECK, *(uih_data_start + uih_len))) -+ break; -+*/ -+ } -+ -+ if (dlci == 0) { -+ TS0710_DEBUG("UIH on serv_channel 0\n"); -+ process_mcc(data, len, ts0710, -+ !(short_pkt->h.length.ea)); -+ } else if (valid_dlci(dlci)) { -+ /* do tty dispatch */ -+ __u8 tag; -+ __u8 tty_idx; -+ struct tty_struct *tty; -+ __u8 queue_data; -+ __u8 post_recv; -+ __u8 flow_control; -+ mux_recv_struct *recv_info; -+ int recv_room; -+ mux_recv_packet *recv_packet, *recv_packet2; -+ -+ TS0710_DEBUG("UIH on channel %d\n", dlci); -+ -+ if (uih_len > ts0710->dlci[dlci].mtu) { -+ TS0710_PRINTK -+ ("MUX Error: DLCI:%d, uih_len:%d is bigger than mtu:%d, discard data!\n", -+ dlci, uih_len, ts0710->dlci[dlci].mtu); -+ break; -+ } -+ -+ tag = *uih_data_start; -+ uih_data_start++; -+ uih_len--; -+ -+ if (!uih_len) { -+ break; -+ } -+ -+ switch (tag) { -+ case CMDTAG: -+ tty_idx = dlci2tty[dlci].cmdtty; -+ TS0710_DEBUG("CMDTAG on DLCI:%d, /dev/mux%d\n", -+ dlci, tty_idx); -+ TS0710_DEBUGSTR(uih_data_start, uih_len); -+ if (!(iscmdtty[tty_idx])) { -+ TS0710_PRINTK -+ ("MUX Error: %s: Wrong CMDTAG on DLCI:%d, /dev/mux%d\n", -+ __FUNCTION__, dlci, tty_idx); -+ } -+ break; -+ case DATATAG: -+ default: -+ tty_idx = dlci2tty[dlci].datatty; -+ TS0710_DEBUG -+ ("NON-CMDTAG on DLCI:%d, /dev/mux%d\n", -+ dlci, tty_idx); -+ if (iscmdtty[tty_idx]) { -+ TS0710_PRINTK -+ ("MUX Error: %s: Wrong NON-CMDTAG on DLCI:%d, /dev/mux%d\n", -+ __FUNCTION__, dlci, tty_idx); -+ } -+ break; -+ } -+ tty = mux_table[tty_idx]; -+ if ((!mux_tty[tty_idx]) || (!tty)) { -+ TS0710_PRINTK -+ ("MUX: No application waiting for, discard it! /dev/mux%d\n", -+ tty_idx); -+ } else { /* Begin processing received data */ -+ if ((!mux_recv_info_flags[tty_idx]) -+ || (!mux_recv_info[tty_idx])) { -+ TS0710_PRINTK -+ ("MUX Error: No mux_recv_info, discard it! /dev/mux%d\n", -+ tty_idx); -+ break; -+ } -+ -+ recv_info = mux_recv_info[tty_idx]; -+ if (recv_info->total > 8192) { -+ TS0710_PRINTK -+ ("MUX : discard data for tty_idx:%d, recv_info->total > 8192 \n", -+ tty_idx); -+ break; -+ } -+ -+ queue_data = 0; -+ post_recv = 0; -+ flow_control = 0; -+ recv_room = 65535; -+ if (tty->receive_room) -+ recv_room = tty->receive_room; -+ -+ if (test_bit(TTY_THROTTLED, &tty->flags)) { -+ queue_data = 1; -+ } else { -+ if (test_bit -+ (TTY_DONT_FLIP, &tty->flags)) { -+ queue_data = 1; -+ post_recv = 1; -+ } else if (recv_info->total) { -+ queue_data = 1; -+ post_recv = 1; -+ } else if (recv_room < uih_len) { -+ queue_data = 1; -+ flow_control = 1; -+ } -+ -+ if ((recv_room - -+ (uih_len + recv_info->total)) < -+ ts0710->dlci[dlci].mtu) { -+ flow_control = 1; -+ } -+ } -+ -+ if (!queue_data) { -+ /* Put received data into read buffer of tty */ -+ TS0710_DEBUG -+ ("Put received data into read buffer of /dev/mux%d", -+ tty_idx); -+ -+#ifdef TS0710DEBUG -+ t = jiffies; -+#endif -+ -+ (tty->ldisc.receive_buf) (tty, -+ uih_data_start, -+ NULL, -+ uih_len); -+ -+#ifdef TS0710DEBUG -+ TS0710_DEBUG -+ ("tty->ldisc.receive_buf take ticks: %lu", -+ (jiffies - t)); -+#endif -+ -+ } else { /* Queue data */ -+ -+ TS0710_DEBUG -+ ("Put received data into recv queue of /dev/mux%d", -+ tty_idx); -+ if (recv_info->total) { -+ /* recv_info is already linked into mux_recv_queue */ -+ -+ recv_packet = -+ get_mux_recv_packet -+ (uih_len); -+ if (!recv_packet) { -+ TS0710_PRINTK -+ ("MUX %s: no memory\n", -+ __FUNCTION__); -+ break; -+ } -+ -+ memcpy(recv_packet->data, -+ uih_data_start, uih_len); -+ recv_packet->length = uih_len; -+ recv_info->total += uih_len; -+ recv_packet->next = NULL; -+ -+ if (!(recv_info->mux_packet)) { -+ recv_info->mux_packet = -+ recv_packet; -+ } else { -+ recv_packet2 = -+ recv_info-> -+ mux_packet; -+ while (recv_packet2-> -+ next) { -+ recv_packet2 = -+ recv_packet2-> -+ next; -+ } -+ recv_packet2->next = -+ recv_packet; -+ } /* End if( !(recv_info->mux_packet) ) */ -+ } else { /* recv_info->total == 0 */ -+ if (uih_len > -+ TS0710MUX_RECV_BUF_SIZE) { -+ TS0710_PRINTK -+ ("MUX Error: tty_idx:%d, uih_len == %d is too big\n", -+ tty_idx, uih_len); -+ uih_len = -+ TS0710MUX_RECV_BUF_SIZE; -+ } -+ memcpy(recv_info->data, -+ uih_data_start, uih_len); -+ recv_info->length = uih_len; -+ recv_info->total = uih_len; -+ -+ add_post_recv_queue -+ (&mux_recv_queue, -+ recv_info); -+ } /* End recv_info->total == 0 */ -+ } /* End Queue data */ -+ -+ if (flow_control) { -+ /* Do something for flow control */ -+ ts0710_flow_off(tty, dlci, ts0710); -+ } -+ -+ if (tty_idx == -+ dlci2tty[TS0710MUX_GPRS1_DLCI].datatty) { -+ if (add_count -+ (TS0710MUX_GPRS1_RECV_COUNT_IDX, -+ uih_len) < 0) { -+ post_recv_count_flag = 1; -+ post_recv = 1; -+ mux_data_count2 -+ [TS0710MUX_GPRS1_RECV_COUNT_IDX] -+ += uih_len; -+ } -+ } else if (tty_idx == -+ dlci2tty[TS0710MUX_GPRS2_DLCI]. -+ datatty) { -+ if (add_count -+ (TS0710MUX_GPRS2_RECV_COUNT_IDX, -+ uih_len) < 0) { -+ post_recv_count_flag = 1; -+ post_recv = 1; -+ mux_data_count2 -+ [TS0710MUX_GPRS2_RECV_COUNT_IDX] -+ += uih_len; -+ } -+ } -+ -+ if (post_recv) -+ schedule_work(&post_recv_tqueue); -+ } /* End processing received data */ -+ } else { -+ TS0710_DEBUG("invalid dlci %d\n", dlci); -+ } -+ -+ break; -+ -+ default: -+ TS0710_DEBUG("illegal packet\n"); -+ break; -+ } -+ return 0; -+} -+ -+/* -+int ts0710_send_data(ts0710_con *ts0710, __u8 dlci, __u8 *data, __u32 count) -+{ -+ __u32 c, total = 0; -+ __u8 tag, first; -+ -+ if( ts0710->dlci[0].state == FLOW_STOPPED ){ -+ TS0710_DEBUG("Flow stopped on all channels, returning zero\n"); -+*/ -+/* -+ return -EFLOWSTOPPED; -+ } else if( ts0710->dlci[dlci].state == FLOW_STOPPED ){ -+ TS0710_DEBUG("Flow stopped, returning zero\n"); -+*/ -+/* -+ return -EFLOWSTOPPED; -+ } else if( ts0710->dlci[dlci].state == CONNECTED ){ -+ -+ TS0710_DEBUG("trying to send %d bytes\n", count); -+ tag = *data; -+ first = 1; -+*/ -+ /* The first byte is always a Cmd/Data tag */ -+/* -+ while( count > 1 ){ -+ -+ c = min(count, ts0710->dlci[dlci].mtu); -+ if( queue_uih(data, c, ts0710, dlci) <= 0 ) { -+ break; -+ } -+ -+ total += (c - 1); -+ data += (c - 1); -+ *data = tag; -+ count -= (c - 1); -+ -+ if( first ) { -+ first = 0; -+ total++; -+ } -+ } -+ TS0710_DEBUG("sent %d bytes\n", total); -+ return total; -+ } else { -+ TS0710_DEBUG("DLCI %d not connected\n", dlci); -+ return -EDISCONNECTED; -+ } -+} -+*/ -+ -+/* Close ts0710 channel */ -+static void ts0710_close_channel(__u8 dlci) -+{ -+ ts0710_con *ts0710 = &ts0710_connection; -+ int try; -+ unsigned long t; -+ -+ TS0710_DEBUG("ts0710_disc_command on channel %d\n", dlci); -+ -+ if ((ts0710->dlci[dlci].state == DISCONNECTED) -+ || (ts0710->dlci[dlci].state == REJECTED)) { -+ return; -+ } else if (ts0710->dlci[dlci].state == DISCONNECTING) { -+ /* Reentry */ -+ return; -+ } else { -+ ts0710->dlci[dlci].state = DISCONNECTING; -+ try = 3; -+ while (try--) { -+ t = jiffies; -+ send_disc(ts0710, dlci); -+ interruptible_sleep_on_timeout(&ts0710->dlci[dlci]. -+ close_wait, -+ TS0710MUX_TIME_OUT); -+ if (ts0710->dlci[dlci].state == DISCONNECTED) { -+ break; -+ } else if (signal_pending(current)) { -+ TS0710_PRINTK -+ ("MUX DLCI %d Send DISC got signal!\n", -+ dlci); -+ break; -+ } else if ((jiffies - t) >= TS0710MUX_TIME_OUT) { -+ TS0710_PRINTK -+ ("MUX DLCI %d Send DISC timeout!\n", dlci); -+ continue; -+ } -+ } -+ -+ if (ts0710->dlci[dlci].state != DISCONNECTED) { -+ if (dlci == 0) { /* Control Channel */ -+ ts0710_upon_disconnect(); -+ } else { /* Other Channel */ -+ ts0710->dlci[dlci].state = DISCONNECTED; -+ wake_up_interruptible(&ts0710->dlci[dlci]. -+ close_wait); -+ ts0710_reset_dlci(dlci); -+ } -+ } -+ } -+} -+ -+int ts0710_open_channel(__u8 dlci) -+{ -+ ts0710_con *ts0710 = &ts0710_connection; -+ int try; -+ int retval; -+ unsigned long t; -+ -+ retval = -ENODEV; -+ if (dlci == 0) { // control channel -+ if ((ts0710->dlci[0].state == CONNECTED) -+ || (ts0710->dlci[0].state == FLOW_STOPPED)) { -+ return 0; -+ } else if (ts0710->dlci[0].state == CONNECTING) { -+ /* Reentry */ -+ TS0710_PRINTK -+ ("MUX DLCI: 0, reentry to open DLCI 0, pid: %d, %s !\n", -+ current->pid, current->comm); -+ try = 11; -+ while (try--) { -+ t = jiffies; -+ interruptible_sleep_on_timeout(&ts0710->dlci[0]. -+ open_wait, -+ TS0710MUX_TIME_OUT); -+ if ((ts0710->dlci[0].state == CONNECTED) -+ || (ts0710->dlci[0].state == -+ FLOW_STOPPED)) { -+ retval = 0; -+ break; -+ } else if (ts0710->dlci[0].state == REJECTED) { -+ retval = -EREJECTED; -+ break; -+ } else if (ts0710->dlci[0].state == -+ DISCONNECTED) { -+ break; -+ } else if (signal_pending(current)) { -+ TS0710_PRINTK -+ ("MUX DLCI:%d Wait for connecting got signal!\n", -+ dlci); -+ retval = -EAGAIN; -+ break; -+ } else if ((jiffies - t) >= TS0710MUX_TIME_OUT) { -+ TS0710_PRINTK -+ ("MUX DLCI:%d Wait for connecting timeout!\n", -+ dlci); -+ continue; -+ } else if (ts0710->dlci[0].state == CONNECTING) { -+ continue; -+ } -+ } -+ -+ if (ts0710->dlci[0].state == CONNECTING) { -+ ts0710->dlci[0].state = DISCONNECTED; -+ } -+ } else if ((ts0710->dlci[0].state != DISCONNECTED) -+ && (ts0710->dlci[0].state != REJECTED)) { -+ TS0710_PRINTK("MUX DLCI:%d state is invalid!\n", dlci); -+ return retval; -+ } else { -+ ts0710->initiator = 1; -+ ts0710->dlci[0].state = CONNECTING; -+ ts0710->dlci[0].initiator = 1; -+ try = 10; -+ while (try--) { -+ t = jiffies; -+ send_sabm(ts0710, 0); -+ interruptible_sleep_on_timeout(&ts0710->dlci[0]. -+ open_wait, -+ TS0710MUX_TIME_OUT); -+ if ((ts0710->dlci[0].state == CONNECTED) -+ || (ts0710->dlci[0].state == -+ FLOW_STOPPED)) { -+ retval = 0; -+ break; -+ } else if (ts0710->dlci[0].state == REJECTED) { -+ TS0710_PRINTK -+ ("MUX DLCI:%d Send SABM got rejected!\n", -+ dlci); -+ retval = -EREJECTED; -+ break; -+ } else if (signal_pending(current)) { -+ TS0710_PRINTK -+ ("MUX DLCI:%d Send SABM got signal!\n", -+ dlci); -+ retval = -EAGAIN; -+ break; -+ } else if ((jiffies - t) >= TS0710MUX_TIME_OUT) { -+ TS0710_PRINTK -+ ("MUX DLCI:%d Send SABM timeout!\n", -+ dlci); -+ continue; -+ } -+ } -+ -+ if (ts0710->dlci[0].state == CONNECTING) { -+ ts0710->dlci[0].state = DISCONNECTED; -+ } -+ wake_up_interruptible(&ts0710->dlci[0].open_wait); -+ } -+ } else { // other channel -+ if ((ts0710->dlci[0].state != CONNECTED) -+ && (ts0710->dlci[0].state != FLOW_STOPPED)) { -+ return retval; -+ } else if ((ts0710->dlci[dlci].state == CONNECTED) -+ || (ts0710->dlci[dlci].state == FLOW_STOPPED)) { -+ return 0; -+ } else if ((ts0710->dlci[dlci].state == NEGOTIATING) -+ || (ts0710->dlci[dlci].state == CONNECTING)) { -+ /* Reentry */ -+ try = 8; -+ while (try--) { -+ t = jiffies; -+ interruptible_sleep_on_timeout(&ts0710-> -+ dlci[dlci]. -+ open_wait, -+ TS0710MUX_TIME_OUT); -+ if ((ts0710->dlci[dlci].state == CONNECTED) -+ || (ts0710->dlci[dlci].state == -+ FLOW_STOPPED)) { -+ retval = 0; -+ break; -+ } else if (ts0710->dlci[dlci].state == REJECTED) { -+ retval = -EREJECTED; -+ break; -+ } else if (ts0710->dlci[dlci].state == -+ DISCONNECTED) { -+ break; -+ } else if (signal_pending(current)) { -+ TS0710_PRINTK -+ ("MUX DLCI:%d Wait for connecting got signal!\n", -+ dlci); -+ retval = -EAGAIN; -+ break; -+ } else if ((jiffies - t) >= TS0710MUX_TIME_OUT) { -+ TS0710_PRINTK -+ ("MUX DLCI:%d Wait for connecting timeout!\n", -+ dlci); -+ continue; -+ } else -+ if ((ts0710->dlci[dlci].state == -+ NEGOTIATING) -+ || (ts0710->dlci[dlci].state == -+ CONNECTING)) { -+ continue; -+ } -+ } -+ -+ if ((ts0710->dlci[dlci].state == NEGOTIATING) -+ || (ts0710->dlci[dlci].state == CONNECTING)) { -+ ts0710->dlci[dlci].state = DISCONNECTED; -+ } -+ } else if ((ts0710->dlci[dlci].state != DISCONNECTED) -+ && (ts0710->dlci[dlci].state != REJECTED)) { -+ TS0710_PRINTK("MUX DLCI:%d state is invalid!\n", dlci); -+ return retval; -+ } else { -+ ts0710->dlci[dlci].state = NEGOTIATING; -+ ts0710->dlci[dlci].initiator = 1; -+ try = 3; -+ while (try--) { -+ t = jiffies; -+ send_pn_msg(ts0710, 7, ts0710->dlci[dlci].mtu, -+ 0, 0, dlci, 1); -+ interruptible_sleep_on_timeout(&ts0710-> -+ dlci[dlci]. -+ open_wait, -+ TS0710MUX_TIME_OUT); -+ if (ts0710->dlci[dlci].state == CONNECTING) { -+ break; -+ } else if (signal_pending(current)) { -+ TS0710_PRINTK -+ ("MUX DLCI:%d Send pn_msg got signal!\n", -+ dlci); -+ retval = -EAGAIN; -+ break; -+ } else if ((jiffies - t) >= TS0710MUX_TIME_OUT) { -+ TS0710_PRINTK -+ ("MUX DLCI:%d Send pn_msg timeout!\n", -+ dlci); -+ continue; -+ } -+ } -+ -+ if (ts0710->dlci[dlci].state == CONNECTING) { -+ try = 3; -+ while (try--) { -+ t = jiffies; -+ send_sabm(ts0710, dlci); -+ interruptible_sleep_on_timeout(&ts0710-> -+ dlci -+ [dlci]. -+ open_wait, -+ TS0710MUX_TIME_OUT); -+ if ((ts0710->dlci[dlci].state == -+ CONNECTED) -+ || (ts0710->dlci[dlci].state == -+ FLOW_STOPPED)) { -+ retval = 0; -+ break; -+ } else if (ts0710->dlci[dlci].state == -+ REJECTED) { -+ TS0710_PRINTK -+ ("MUX DLCI:%d Send SABM got rejected!\n", -+ dlci); -+ retval = -EREJECTED; -+ break; -+ } else if (signal_pending(current)) { -+ TS0710_PRINTK -+ ("MUX DLCI:%d Send SABM got signal!\n", -+ dlci); -+ retval = -EAGAIN; -+ break; -+ } else if ((jiffies - t) >= -+ TS0710MUX_TIME_OUT) { -+ TS0710_PRINTK -+ ("MUX DLCI:%d Send SABM timeout!\n", -+ dlci); -+ continue; -+ } -+ } -+ } -+ -+ if ((ts0710->dlci[dlci].state == NEGOTIATING) -+ || (ts0710->dlci[dlci].state == CONNECTING)) { -+ ts0710->dlci[dlci].state = DISCONNECTED; -+ } -+ wake_up_interruptible(&ts0710->dlci[dlci].open_wait); -+ } -+ } -+ return retval; -+} -+ -+static int ts0710_exec_test_cmd(void) -+{ -+ ts0710_con *ts0710 = &ts0710_connection; -+ __u8 *f_buf; /* Frame buffer */ -+ __u8 *d_buf; /* Data buffer */ -+ int retval = -EFAULT; -+ int j; -+ unsigned long t; -+ -+ if (ts0710->be_testing) { -+ /* Reentry */ -+ t = jiffies; -+ interruptible_sleep_on_timeout(&ts0710->test_wait, -+ 3 * TS0710MUX_TIME_OUT); -+ if (ts0710->be_testing == 0) { -+ if (ts0710->test_errs == 0) { -+ retval = 0; -+ } else { -+ retval = -EFAULT; -+ } -+ } else if (signal_pending(current)) { -+ TS0710_DEBUG -+ ("Wait for Test_cmd response got signal!\n"); -+ retval = -EAGAIN; -+ } else if ((jiffies - t) >= 3 * TS0710MUX_TIME_OUT) { -+ TS0710_DEBUG("Wait for Test_cmd response timeout!\n"); -+ retval = -EFAULT; -+ } -+ } else { -+ ts0710->be_testing = 1; /* Set the flag */ -+ -+ f_buf = (__u8 *) kmalloc(TEST_PATTERN_SIZE + 32, GFP_KERNEL); -+ d_buf = (__u8 *) kmalloc(TEST_PATTERN_SIZE + 32, GFP_KERNEL); -+ if ((!f_buf) || (!d_buf)) { -+ if (f_buf) { -+ kfree(f_buf); -+ } -+ if (d_buf) { -+ kfree(d_buf); -+ } -+ -+ ts0710->be_testing = 0; /* Clear the flag */ -+ ts0710->test_errs = TEST_PATTERN_SIZE; -+ wake_up_interruptible(&ts0710->test_wait); -+ return -ENOMEM; -+ } -+ -+ for (j = 0; j < TEST_PATTERN_SIZE; j++) { -+ d_buf[j] = j & 0xFF; -+ } -+ -+ t = jiffies; -+ ts0710_test_msg(ts0710, d_buf, TEST_PATTERN_SIZE, MCC_CMD, -+ f_buf); -+ interruptible_sleep_on_timeout(&ts0710->test_wait, -+ 2 * TS0710MUX_TIME_OUT); -+ if (ts0710->be_testing == 0) { -+ if (ts0710->test_errs == 0) { -+ retval = 0; -+ } else { -+ retval = -EFAULT; -+ } -+ } else if (signal_pending(current)) { -+ TS0710_DEBUG("Send Test_cmd got signal!\n"); -+ retval = -EAGAIN; -+ } else if ((jiffies - t) >= 2 * TS0710MUX_TIME_OUT) { -+ TS0710_DEBUG("Send Test_cmd timeout!\n"); -+ ts0710->test_errs = TEST_PATTERN_SIZE; -+ retval = -EFAULT; -+ } -+ -+ ts0710->be_testing = 0; /* Clear the flag */ -+ wake_up_interruptible(&ts0710->test_wait); -+ -+ /* Release buffer */ -+ if (f_buf) { -+ kfree(f_buf); -+ } -+ if (d_buf) { -+ kfree(d_buf); -+ } -+ } -+ -+ return retval; -+} -+ -+static void mux_sched_send(void) -+{ -+ -+#ifdef USB_FOR_MUX -+ schedule_work(&send_tqueue); -+#else -+ if (!tq_serial_for_mux) { -+ TS0710_PRINTK("MUX Error: %s: tq_serial_for_mux == 0\n", -+ __FUNCTION__); -+ return; -+ } -+ schedule_work(&send_tqueue); -+ mark_bh(SERIAL_BH); -+#endif -+ -+} -+ -+/**************************** -+ * TTY driver routines -+*****************************/ -+ -+static void mux_close(struct tty_struct *tty, struct file *filp) -+{ -+ ts0710_con *ts0710 = &ts0710_connection; -+ int line; -+ __u8 dlci; -+ __u8 cmdtty; -+ __u8 datatty; -+ -+ UNUSED_PARAM(filp); -+ -+ if (!tty) { -+ return; -+ } -+ line = tty->index; -+ if ((line < 0) || (line >= NR_MUXS)) { -+ return; -+ } -+ if (mux_tty[line] > 0) -+ mux_tty[line]--; -+ -+ dlci = tty2dlci[line]; -+ cmdtty = dlci2tty[dlci].cmdtty; -+ datatty = dlci2tty[dlci].datatty; -+ if ((mux_tty[cmdtty] == 0) && (mux_tty[datatty] == 0)) { -+ if (dlci == 1) { -+ ts0710_close_channel(0); -+ TS0710_PRINTK -+ ("MUX mux_close: tapisrv might be down!!! Close DLCI 1\n"); -+ TS0710_SIG2APLOGD(); -+ } -+ ts0710_close_channel(dlci); -+ } -+ -+ if (mux_tty[line] == 0) { -+ if ((mux_send_info_flags[line]) -+ && (mux_send_info[line]) -+ /*&& (mux_send_info[line]->filled == 0) */ -+ ) { -+ mux_send_info_flags[line] = 0; -+ kfree(mux_send_info[line]); -+ mux_send_info[line] = 0; -+ TS0710_DEBUG("Free mux_send_info for /dev/mux%d", line); -+ } -+ -+ if ((mux_recv_info_flags[line]) -+ && (mux_recv_info[line]) -+ && (mux_recv_info[line]->total == 0)) { -+ mux_recv_info_flags[line] = 0; -+ free_mux_recv_struct(mux_recv_info[line]); -+ mux_recv_info[line] = 0; -+ TS0710_DEBUG("Free mux_recv_info for /dev/mux%d", line); -+ } -+ -+ ts0710_flow_on(dlci, ts0710); -+ schedule_work(&post_recv_tqueue); -+ -+ wake_up_interruptible(&tty->read_wait); -+ wake_up_interruptible(&tty->write_wait); -+ tty->packet = 0; -+ } -+} -+ -+static void mux_throttle(struct tty_struct *tty) -+{ -+ ts0710_con *ts0710 = &ts0710_connection; -+ int line; -+ int i; -+ __u8 dlci; -+ -+ if (!tty) { -+ return; -+ } -+ -+ line = tty->index; -+ if ((line < 0) || (line >= NR_MUXS)) { -+ return; -+ } -+ -+ TS0710_DEBUG("Enter into %s, minor number is: %d\n", __FUNCTION__, -+ line); -+ -+ dlci = tty2dlci[line]; -+ if ((ts0710->dlci[0].state != CONNECTED) -+ && (ts0710->dlci[0].state != FLOW_STOPPED)) { -+ return; -+ } else if ((ts0710->dlci[dlci].state != CONNECTED) -+ && (ts0710->dlci[dlci].state != FLOW_STOPPED)) { -+ return; -+ } -+ -+ if (ts0710->dlci[dlci].flow_control) { -+ return; -+ } -+ -+ for (i = 0; i < 3; i++) { -+ if (ts0710_msc_msg -+ (ts0710, EA | FC | RTC | RTR | DV, MCC_CMD, dlci) < 0) { -+ continue; -+ } else { -+ TS0710_LOG("MUX Send Flow off on dlci %d\n", dlci); -+ ts0710->dlci[dlci].flow_control = 1; -+ break; -+ } -+ } -+} -+ -+static void mux_unthrottle(struct tty_struct *tty) -+{ -+ ts0710_con *ts0710 = &ts0710_connection; -+ int line; -+ __u8 dlci; -+ mux_recv_struct *recv_info; -+ -+ if (!tty) { -+ return; -+ } -+ line = tty->index; -+ if ((line < 0) || (line >= NR_MUXS)) { -+ return; -+ } -+ -+ if ((!mux_recv_info_flags[line]) || (!mux_recv_info[line])) { -+ return; -+ } -+ -+ TS0710_DEBUG("Enter into %s, minor number is: %d\n", __FUNCTION__, -+ line); -+ -+ recv_info = mux_recv_info[line]; -+ dlci = tty2dlci[line]; -+ -+ if (recv_info->total) { -+ recv_info->post_unthrottle = 1; -+ schedule_work(&post_recv_tqueue); -+ } else { -+ ts0710_flow_on(dlci, ts0710); -+ } -+} -+ -+static int mux_chars_in_buffer(struct tty_struct *tty) -+{ -+ ts0710_con *ts0710 = &ts0710_connection; -+ int retval; -+ int line; -+ __u8 dlci; -+ mux_send_struct *send_info; -+ -+ retval = TS0710MUX_MAX_CHARS_IN_BUF; -+ if (!tty) { -+ goto out; -+ } -+ line = tty->index; -+ if ((line < 0) || (line >= NR_MUXS)) { -+ goto out; -+ } -+ -+ dlci = tty2dlci[line]; -+ if (ts0710->dlci[0].state == FLOW_STOPPED) { -+ TS0710_DEBUG -+ ("Flow stopped on all channels, returning MAX chars in buffer\n"); -+ goto out; -+ } else if (ts0710->dlci[dlci].state == FLOW_STOPPED) { -+ TS0710_DEBUG("Flow stopped, returning MAX chars in buffer\n"); -+ goto out; -+ } else if (ts0710->dlci[dlci].state != CONNECTED) { -+ TS0710_DEBUG("DLCI %d not connected\n", dlci); -+ goto out; -+ } -+ -+ if (!(mux_send_info_flags[line])) { -+ goto out; -+ } -+ send_info = mux_send_info[line]; -+ if (!send_info) { -+ goto out; -+ } -+ if (send_info->filled) { -+ goto out; -+ } -+ -+ retval = 0; -+ -+ out: -+ return retval; -+} -+ -+static int mux_chars_in_serial_buffer(struct tty_struct *tty) -+{ -+ UNUSED_PARAM(tty); -+ -+ if ((COMM_FOR_MUX_DRIVER == 0) || (COMM_FOR_MUX_TTY == 0)) { -+ TS0710_PRINTK -+ ("MUX %s: (COMM_FOR_MUX_DRIVER == 0) || (COMM_FOR_MUX_TTY == 0)\n", -+ __FUNCTION__); -+ -+#ifndef USB_FOR_MUX -+ TS0710_PRINTK -+ ("MUX %s: tapisrv might be down!!! (serial_for_mux_driver == 0) || (serial_for_mux_tty == 0)\n", -+ __FUNCTION__); -+ TS0710_SIG2APLOGD(); -+#endif -+ -+ return 0; -+ } -+ return COMM_FOR_MUX_DRIVER->chars_in_buffer(COMM_FOR_MUX_TTY); -+} -+ -+static int mux_write(struct tty_struct *tty, -+ const unsigned char *buf, int count) -+{ -+ ts0710_con *ts0710 = &ts0710_connection; -+ int line; -+ __u8 dlci; -+ mux_send_struct *send_info; -+ __u8 *d_buf; -+ __u16 c; -+ __u8 post_recv; -+ -+ if (count <= 0) { -+ return 0; -+ } -+ -+ if (!tty) { -+ return 0; -+ } -+ -+ line = tty->index; -+ if ((line < 0) || (line >= NR_MUXS)) -+ return -ENODEV; -+ -+ dlci = tty2dlci[line]; -+ if (ts0710->dlci[0].state == FLOW_STOPPED) { -+ TS0710_DEBUG -+ ("Flow stopped on all channels, returning zero /dev/mux%d\n", -+ line); -+ return 0; -+ } else if (ts0710->dlci[dlci].state == FLOW_STOPPED) { -+ TS0710_DEBUG("Flow stopped, returning zero /dev/mux%d\n", line); -+ return 0; -+ } else if (ts0710->dlci[dlci].state == CONNECTED) { -+ -+ if (!(mux_send_info_flags[line])) { -+ TS0710_PRINTK -+ ("MUX Error: mux_write: mux_send_info_flags[%d] == 0\n", -+ line); -+ return -ENODEV; -+ } -+ send_info = mux_send_info[line]; -+ if (!send_info) { -+ TS0710_PRINTK -+ ("MUX Error: mux_write: mux_send_info[%d] == 0\n", -+ line); -+ return -ENODEV; -+ } -+ -+ c = min(count, (ts0710->dlci[dlci].mtu - 1)); -+ if (c <= 0) { -+ return 0; -+ } -+ -+ if (test_and_set_bit(BUF_BUSY, &send_info->flags)) -+ return 0; -+ -+ if (send_info->filled) { -+ clear_bit(BUF_BUSY, &send_info->flags); -+ return 0; -+ } -+ -+ d_buf = ((__u8 *) send_info->buf) + TS0710MUX_SEND_BUF_OFFSET; -+ memcpy(&d_buf[1], buf, c); -+ -+ TS0710_DEBUG("Prepare to send %d bytes from /dev/mux%d", c, -+ line); -+ if (iscmdtty[line]) { -+ TS0710_DEBUGSTR(&d_buf[1], c); -+ TS0710_DEBUG("CMDTAG"); -+ d_buf[0] = CMDTAG; -+ } else { -+ TS0710_DEBUG("DATATAG"); -+ d_buf[0] = DATATAG; -+ } -+ -+ TS0710_DEBUGHEX(d_buf, c + 1); -+ -+ send_info->frame = d_buf; -+ queue_uih(send_info, c + 1, ts0710, dlci); -+ send_info->filled = 1; -+ clear_bit(BUF_BUSY, &send_info->flags); -+ -+ post_recv = 0; -+ if (dlci == TS0710MUX_GPRS1_DLCI) { -+ if (add_count -+ (TS0710MUX_GPRS1_SEND_COUNT_IDX, c) < 0) { -+ post_recv_count_flag = 1; -+ post_recv = 1; -+ mux_data_count2[TS0710MUX_GPRS1_SEND_COUNT_IDX] -+ += c; -+ } -+ } else if (dlci == TS0710MUX_GPRS2_DLCI) { -+ if (add_count -+ (TS0710MUX_GPRS2_SEND_COUNT_IDX, c) < 0) { -+ post_recv_count_flag = 1; -+ post_recv = 1; -+ mux_data_count2[TS0710MUX_GPRS2_SEND_COUNT_IDX] -+ += c; -+ } -+ } -+ -+ if (post_recv) -+ schedule_work(&post_recv_tqueue); -+ -+ if (mux_chars_in_serial_buffer(COMM_FOR_MUX_TTY) == 0) { -+ /* Sending bottom half should be -+ run after return from this function */ -+ mux_sched_send(); -+ } -+ return c; -+ } else { -+ TS0710_PRINTK("MUX mux_write: DLCI %d not connected\n", dlci); -+ return -EDISCONNECTED; -+ } -+} -+ -+static int mux_write_room(struct tty_struct *tty) -+{ -+ ts0710_con *ts0710 = &ts0710_connection; -+ int retval; -+ int line; -+ __u8 dlci; -+ mux_send_struct *send_info; -+ -+ retval = 0; -+ if (!tty) { -+ goto out; -+ } -+ line = tty->index; -+ if ((line < 0) || (line >= NR_MUXS)) { -+ goto out; -+ } -+ -+ dlci = tty2dlci[line]; -+ if (ts0710->dlci[0].state == FLOW_STOPPED) { -+ TS0710_DEBUG("Flow stopped on all channels, returning ZERO\n"); -+ goto out; -+ } else if (ts0710->dlci[dlci].state == FLOW_STOPPED) { -+ TS0710_DEBUG("Flow stopped, returning ZERO\n"); -+ goto out; -+ } else if (ts0710->dlci[dlci].state != CONNECTED) { -+ TS0710_DEBUG("DLCI %d not connected\n", dlci); -+ goto out; -+ } -+ -+ if (!(mux_send_info_flags[line])) { -+ goto out; -+ } -+ send_info = mux_send_info[line]; -+ if (!send_info) { -+ goto out; -+ } -+ if (send_info->filled) { -+ goto out; -+ } -+ -+ retval = ts0710->dlci[dlci].mtu - 1; -+ -+ out: -+ return retval; -+} -+ -+static int mux_ioctl(struct tty_struct *tty, struct file *file, -+ unsigned int cmd, unsigned long arg) -+{ -+ ts0710_con *ts0710 = &ts0710_connection; -+ int line; -+ __u8 dlci; -+ -+ UNUSED_PARAM(file); -+ UNUSED_PARAM(arg); -+ -+ if (!tty) { -+ return -EIO; -+ } -+ line = tty->index; -+ if ((line < 0) || (line >= NR_MUXS)) { -+ return -ENODEV; -+ } -+ -+ dlci = tty2dlci[line]; -+ switch (cmd) { -+ case TS0710MUX_IO_MSC_HANGUP: -+ if (ts0710_msc_msg(ts0710, EA | RTR | DV, MCC_CMD, dlci) < 0) { -+ return -EAGAIN; -+ } else { -+ return 0; -+ } -+ -+ case TS0710MUX_IO_TEST_CMD: -+ return ts0710_exec_test_cmd(); -+/* -+ case TS0710MUX_IO_DLCI_FC_ON: -+ if( line == 0 ) { -+ break; -+ } -+ if( ts0710_msc_msg(ts0710, EA | RTC | RTR | DV, MCC_CMD, (__u8)line) < 0) { -+ return -EAGAIN; -+ } else { -+ return 0; -+ } -+ -+ case TS0710MUX_IO_DLCI_FC_OFF: -+ if( line == 0 ) { -+ break; -+ } -+ if( ts0710_msc_msg(ts0710, EA | FC | RTC | RTR | DV, MCC_CMD, (__u8)line) < 0) { -+ return -EAGAIN; -+ } else { -+ return 0; -+ } -+ -+ case TS0710MUX_IO_FC_ON: -+ if( line != 0 ) { -+ break; -+ } -+ if( ts0710_fcon_msg(ts0710, MCC_CMD) < 0) { -+ return -EAGAIN; -+ } else { -+ return 0; -+ } -+ -+ case TS0710MUX_IO_FC_OFF: -+ if( line != 0 ) { -+ break; -+ } -+ if( ts0710_fcoff_msg(ts0710, MCC_CMD) < 0) { -+ return -EAGAIN; -+ } else { -+ return 0; -+ } -+*/ -+ default: -+ break; -+ } -+ return -ENOIOCTLCMD; -+} -+ -+static void mux_flush_buffer(struct tty_struct *tty) -+{ -+ int line; -+ -+ if (!tty) { -+ return; -+ } -+ -+ line = tty->index; -+ if ((line < 0) || (line >= NR_MUXS)) { -+ return; -+ } -+ -+ TS0710_PRINTK("MUX %s: line is:%d\n", __FUNCTION__, line); -+ -+ if ((mux_send_info_flags[line]) -+ && (mux_send_info[line]) -+ && (mux_send_info[line]->filled)) { -+ -+ mux_send_info[line]->filled = 0; -+ } -+ -+ wake_up_interruptible(&tty->write_wait); -+#ifdef SERIAL_HAVE_POLL_WAIT -+ wake_up_interruptible(&tty->poll_wait); -+#endif -+ if ((tty->flags & (1 << TTY_DO_WRITE_WAKEUP)) && -+ tty->ldisc.write_wakeup) { -+ (tty->ldisc.write_wakeup) (tty); -+ } -+ -+/* -+ if( (COMM_FOR_MUX_DRIVER == 0) || (COMM_FOR_MUX_TTY == 0) ) { -+ TS0710_PRINTK("MUX %s: (COMM_FOR_MUX_DRIVER == 0) || (COMM_FOR_MUX_TTY == 0)\n", __FUNCTION__); -+ -+#ifndef USB_FOR_MUX -+ TS0710_PRINTK("MUX %s: tapisrv might be down!!! (serial_for_mux_driver == 0) || (serial_for_mux_tty == 0)\n", __FUNCTION__); -+ TS0710_SIG2APLOGD(); -+#endif -+ -+ return; -+ } -+ return COMM_FOR_MUX_DRIVER->flush_buffer(COMM_FOR_MUX_TTY); -+*/ -+} -+ -+static int mux_open(struct tty_struct *tty, struct file *filp) -+{ -+ int retval; -+ int line; -+ __u8 dlci; -+ __u8 cmdtty; -+ __u8 datatty; -+ mux_send_struct *send_info; -+ mux_recv_struct *recv_info; -+ -+ UNUSED_PARAM(filp); -+ -+ retval = -ENODEV; -+ if ((COMM_FOR_MUX_DRIVER == NULL) || (COMM_FOR_MUX_TTY == NULL)) { -+ -+#ifdef USB_FOR_MUX -+ TS0710_PRINTK("MUX: please install and open IPC-USB first\n"); -+#else -+ TS0710_PRINTK("MUX: please install and open ttyS0 first\n"); -+#endif -+ -+ goto out; -+ } -+ -+ if (!tty) { -+ goto out; -+ } -+ line = tty->index; -+ if ((line < 0) || (line >= NR_MUXS)) { -+ goto out; -+ } -+#ifdef TS0710SERVER -+ /* do nothing as a server */ -+ mux_tty[line]++; -+ retval = 0; -+#else -+ mux_tty[line]++; -+ dlci = tty2dlci[line]; -+ -+/* if( dlci == 1 ) { */ -+ /* Open server channel 0 first */ -+ if ((retval = ts0710_open_channel(0)) != 0) { -+ TS0710_PRINTK("MUX: Can't connect server channel 0!\n"); -+ ts0710_init(); -+ -+ mux_tty[line]--; -+ goto out; -+ } -+/* } */ -+ -+ /* Allocate memory first. As soon as connection has been established, MUX may receive */ -+ if (mux_send_info_flags[line] == 0) { -+ send_info = -+ (mux_send_struct *) kmalloc(sizeof(mux_send_struct), -+ GFP_KERNEL); -+ if (!send_info) { -+ retval = -ENOMEM; -+ -+ mux_tty[line]--; -+ goto out; -+ } -+ send_info->length = 0; -+ send_info->flags = 0; -+ send_info->filled = 0; -+ mux_send_info[line] = send_info; -+ mux_send_info_flags[line] = 1; -+ TS0710_DEBUG("Allocate mux_send_info for /dev/mux%d", line); -+ } -+ -+ if (mux_recv_info_flags[line] == 0) { -+ recv_info = -+ (mux_recv_struct *) kmalloc(sizeof(mux_recv_struct), -+ GFP_KERNEL); -+ if (!recv_info) { -+ mux_send_info_flags[line] = 0; -+ kfree(mux_send_info[line]); -+ mux_send_info[line] = 0; -+ TS0710_DEBUG("Free mux_send_info for /dev/mux%d", line); -+ retval = -ENOMEM; -+ -+ mux_tty[line]--; -+ goto out; -+ } -+ recv_info->length = 0; -+ recv_info->total = 0; -+ recv_info->mux_packet = 0; -+ recv_info->next = 0; -+ recv_info->no_tty = line; -+ recv_info->post_unthrottle = 0; -+ mux_recv_info[line] = recv_info; -+ mux_recv_info_flags[line] = 1; -+ TS0710_DEBUG("Allocate mux_recv_info for /dev/mux%d", line); -+ } -+ -+ /* Now establish DLCI connection */ -+ cmdtty = dlci2tty[dlci].cmdtty; -+ datatty = dlci2tty[dlci].datatty; -+ if ((mux_tty[cmdtty] > 0) || (mux_tty[datatty] > 0)) { -+ if ((retval = ts0710_open_channel(dlci)) != 0) { -+ TS0710_PRINTK("MUX: Can't connected channel %d!\n", -+ dlci); -+ ts0710_reset_dlci(dlci); -+ -+ mux_send_info_flags[line] = 0; -+ kfree(mux_send_info[line]); -+ mux_send_info[line] = 0; -+ TS0710_DEBUG("Free mux_send_info for /dev/mux%d", line); -+ -+ mux_recv_info_flags[line] = 0; -+ free_mux_recv_struct(mux_recv_info[line]); -+ mux_recv_info[line] = 0; -+ TS0710_DEBUG("Free mux_recv_info for /dev/mux%d", line); -+ -+ mux_tty[line]--; -+ goto out; -+ } -+ } -+ -+ retval = 0; -+#endif -+ out: -+ return retval; -+} -+ -+/* mux dispatcher, call from serial.c receiver_chars() */ -+void mux_dispatcher(struct tty_struct *tty) -+{ -+ UNUSED_PARAM(tty); -+ -+ schedule_work(&receive_tqueue); -+} -+ -+/*For BP UART problem Begin*/ -+#ifdef TS0710SEQ2 -+static int send_ack(ts0710_con * ts0710, __u8 seq_num, __u8 bp_seq1, -+ __u8 bp_seq2) -+#else -+static int send_ack(ts0710_con * ts0710, __u8 seq_num) -+#endif -+{ -+ __u8 buf[20]; -+ short_frame *ack; -+ -+#ifdef TS0710SEQ2 -+ static __u16 ack_seq = 0; -+#endif -+ -+ ack = (short_frame *) (buf + 1); -+ ack->h.addr.ea = 1; -+ ack->h.addr.cr = ((ts0710->initiator) & 0x1); -+ ack->h.addr.d = 0; -+ ack->h.addr.server_chn = 0; -+ ack->h.control = ACK; -+ ack->h.length.ea = 1; -+ -+#ifdef TS0710SEQ2 -+ ack->h.length.len = 5; -+ ack->data[0] = seq_num; -+ ack->data[1] = bp_seq1; -+ ack->data[2] = bp_seq2; -+ ack->data[3] = (ack_seq & 0xFF); -+ ack->data[4] = (ack_seq >> 8) & 0xFF; -+ ack_seq++; -+ ack->data[5] = crc_calc((__u8 *) ack, SHORT_CRC_CHECK); -+#else -+ ack->h.length.len = 1; -+ ack->data[0] = seq_num; -+ ack->data[1] = crc_calc((__u8 *) ack, SHORT_CRC_CHECK); -+#endif -+ -+ return basic_write(ts0710, buf, -+ (sizeof(short_frame) + FCS_SIZE + -+ ack->h.length.len)); -+} -+ -+/*For BP UART problem End*/ -+ -+static void receive_worker(void *private_) -+{ -+ struct tty_struct *tty = COMM_FOR_MUX_TTY; -+ int i, count; -+ static unsigned char tbuf[TS0710MUX_MAX_BUF_SIZE]; -+ static unsigned char *tbuf_ptr = &tbuf[0]; -+ static unsigned char *start_flag = 0; -+ unsigned char *search, *to, *from; -+ short_frame *short_pkt; -+ long_frame *long_pkt; -+ static int framelen = -1; -+ -+ /*For BP UART problem Begin */ -+ static __u8 expect_seq = 0; -+ __u32 crc_error; -+ __u8 *uih_data_start; -+ __u32 uih_len; -+ /*For BP UART problem End */ -+ -+ UNUSED_PARAM(private_); -+ -+ if (!tty) -+ return; -+ -+#ifdef USB_FOR_MUX -+ TS0710_DEBUG("Receive following bytes from IPC-USB"); -+#else -+ TS0710_DEBUG("Receive following bytes from UART"); -+#endif -+ -+ TS0710_DEBUGHEX(cp, count); -+ -+ if (count > (TS0710MUX_MAX_BUF_SIZE - (tbuf_ptr - tbuf))) { -+ TS0710_PRINTK -+ ("MUX receive_worker: !!!!! Exceed buffer boundary !!!!!\n"); -+ count = (TS0710MUX_MAX_BUF_SIZE - (tbuf_ptr - tbuf)); -+ } -+ -+ count = tty_buffer_request_room(tty, count); -+ -+ for (i = 0; i < count; i++) -+ tty_insert_flip_char(tty, tbuf_ptr[i], TTY_NORMAL); -+ -+ tbuf_ptr += count; -+ search = &tbuf[0]; -+ -+ if (test_and_set_bit(RECV_RUNNING, &mux_recv_flags)) { -+ schedule_work(&receive_tqueue); -+ return; -+ } -+ -+ if ((start_flag != 0) && (framelen != -1)) { -+ if ((tbuf_ptr - start_flag) < framelen) { -+ clear_bit(RECV_RUNNING, &mux_recv_flags); -+ return; -+ } -+ } -+ -+ while (1) { -+ if (start_flag == 0) { /* Frame Start Flag not found */ -+ framelen = -1; -+ while (search < tbuf_ptr) { -+ if (*search == TS0710_BASIC_FLAG) { -+ start_flag = search; -+ break; -+ } -+#ifdef TS0710LOG -+ else { -+ TS0710_LOG(">S %02x %c\n", *search, -+ *search); -+ } -+#endif -+ -+ search++; -+ } -+ -+ if (start_flag == 0) { -+ tbuf_ptr = &tbuf[0]; -+ break; -+ } -+ } else { /* Frame Start Flag found */ -+ /* 1 start flag + 1 address + 1 control + 1 or 2 length + lengths data + 1 FCS + 1 end flag */ -+ /* For BP UART problem 1 start flag + 1 seq_num + 1 address + ...... */ -+ /*if( (framelen == -1) && ((tbuf_ptr - start_flag) > TS0710_MAX_HDR_SIZE) ) */ -+ if ((framelen == -1) && ((tbuf_ptr - start_flag) > (TS0710_MAX_HDR_SIZE + SEQ_FIELD_SIZE))) { /*For BP UART problem */ -+ /*short_pkt = (short_frame *) (start_flag + 1); */ -+ short_pkt = (short_frame *) (start_flag + ADDRESS_FIELD_OFFSET); /*For BP UART problem */ -+ if (short_pkt->h.length.ea == 1) { /* short frame */ -+ /*framelen = TS0710_MAX_HDR_SIZE + short_pkt->h.length.len + 1; */ -+ framelen = TS0710_MAX_HDR_SIZE + short_pkt->h.length.len + 1 + SEQ_FIELD_SIZE; /*For BP UART problem */ -+ } else { /* long frame */ -+ /*long_pkt = (long_frame *) (start_flag + 1); */ -+ long_pkt = (long_frame *) (start_flag + ADDRESS_FIELD_OFFSET); /*For BP UART problem */ -+ /*framelen = TS0710_MAX_HDR_SIZE + GET_LONG_LENGTH( long_pkt->h.length ) + 2; */ -+ framelen = TS0710_MAX_HDR_SIZE + GET_LONG_LENGTH(long_pkt->h.length) + 2 + SEQ_FIELD_SIZE; /*For BP UART problem */ -+ } -+ -+ /*if( framelen > TS0710MUX_MAX_TOTAL_FRAME_SIZE ) { */ -+ if (framelen > (TS0710MUX_MAX_TOTAL_FRAME_SIZE + SEQ_FIELD_SIZE)) { /*For BP UART problem */ -+ TS0710_LOGSTR_FRAME(0, start_flag, -+ (tbuf_ptr - -+ start_flag)); -+ TS0710_PRINTK -+ ("MUX Error: %s: frame length:%d is bigger than Max total frame size:%d\n", -+ /*__FUNCTION__, framelen, TS0710MUX_MAX_TOTAL_FRAME_SIZE);*/ -+ __FUNCTION__, framelen, (TS0710MUX_MAX_TOTAL_FRAME_SIZE + SEQ_FIELD_SIZE)); /*For BP UART problem */ -+ search = start_flag + 1; -+ start_flag = 0; -+ framelen = -1; -+ continue; -+ } -+ } -+ -+ if ((framelen != -1) -+ && ((tbuf_ptr - start_flag) >= framelen)) { -+ if (*(start_flag + framelen - 1) == TS0710_BASIC_FLAG) { /* OK, We got one frame */ -+ -+ /*For BP UART problem Begin */ -+ TS0710_LOGSTR_FRAME(0, start_flag, -+ framelen); -+ TS0710_DEBUGHEX(start_flag, framelen); -+ -+ short_pkt = -+ (short_frame *) (start_flag + -+ ADDRESS_FIELD_OFFSET); -+ if ((short_pkt->h.length.ea) == 0) { -+ long_pkt = -+ (long_frame *) (start_flag + -+ ADDRESS_FIELD_OFFSET); -+ uih_len = -+ GET_LONG_LENGTH(long_pkt->h. -+ length); -+ uih_data_start = -+ long_pkt->h.data; -+ -+ crc_error = -+ crc_check((__u8 -+ *) (start_flag + -+ SLIDE_BP_SEQ_OFFSET), -+ LONG_CRC_CHECK + -+ 1, -+ *(uih_data_start + -+ uih_len)); -+ } else { -+ uih_len = -+ short_pkt->h.length.len; -+ uih_data_start = -+ short_pkt->data; -+ -+ crc_error = -+ crc_check((__u8 -+ *) (start_flag + -+ SLIDE_BP_SEQ_OFFSET), -+ SHORT_CRC_CHECK + -+ 1, -+ *(uih_data_start + -+ uih_len)); -+ } -+ -+ if (!crc_error) { -+ if (expect_seq == -+ *(start_flag + -+ SLIDE_BP_SEQ_OFFSET)) { -+ expect_seq++; -+ if (expect_seq >= 4) { -+ expect_seq = 0; -+ } -+#ifdef TS0710SEQ2 -+ send_ack -+ (&ts0710_connection, -+ expect_seq, -+ *(start_flag + -+ FIRST_BP_SEQ_OFFSET), -+ *(start_flag + -+ SECOND_BP_SEQ_OFFSET)); -+#else -+ send_ack -+ (&ts0710_connection, -+ expect_seq); -+#endif -+ -+ ts0710_recv_data -+ (&ts0710_connection, -+ start_flag + -+ ADDRESS_FIELD_OFFSET, -+ framelen - 2 - -+ SEQ_FIELD_SIZE); -+ } else { -+ -+#ifdef TS0710DEBUG -+ if (* -+ (start_flag + -+ SLIDE_BP_SEQ_OFFSET) -+ != 0x9F) { -+#endif -+ -+ TS0710_LOG -+ ("MUX sequence number %d is not expected %d, discard data!\n", -+ * -+ (start_flag -+ + -+ SLIDE_BP_SEQ_OFFSET), -+ expect_seq); -+ -+#ifdef TS0710SEQ2 -+ send_ack -+ (&ts0710_connection, -+ expect_seq, -+ * -+ (start_flag -+ + -+ FIRST_BP_SEQ_OFFSET), -+ * -+ (start_flag -+ + -+ SECOND_BP_SEQ_OFFSET)); -+#else -+ send_ack -+ (&ts0710_connection, -+ expect_seq); -+#endif -+ -+#ifdef TS0710DEBUG -+ } else { -+ *(uih_data_start -+ + uih_len) = -+ 0; -+ TS0710_PRINTK -+ ("MUX bp log: %s\n", -+ uih_data_start); -+ } -+#endif -+ -+ } -+ } else { /* crc_error */ -+ search = start_flag + 1; -+ start_flag = 0; -+ framelen = -1; -+ continue; -+ } /*End if(!crc_error) */ -+ -+ /*For BP UART problem End */ -+ -+/*For BP UART problem -+ TS0710_LOGSTR_FRAME(0, start_flag, framelen); -+ TS0710_DEBUGHEX(start_flag, framelen); -+ ts0710_recv_data(&ts0710_connection, start_flag + 1, framelen - 2); -+*/ -+ search = start_flag + framelen; -+ } else { -+ TS0710_LOGSTR_FRAME(0, start_flag, -+ framelen); -+ TS0710_DEBUGHEX(start_flag, framelen); -+ TS0710_PRINTK -+ ("MUX: Lost synchronization!\n"); -+ search = start_flag + 1; -+ } -+ -+ start_flag = 0; -+ framelen = -1; -+ continue; -+ } -+ -+ if (start_flag != &tbuf[0]) { -+ to = tbuf; -+ from = start_flag; -+ count = tbuf_ptr - start_flag; -+ while (count--) { -+ *to++ = *from++; -+ } -+ -+ tbuf_ptr -= (start_flag - tbuf); -+ start_flag = tbuf; -+ } -+ break; -+ } /* End Frame Start Flag found */ -+ } /* End while(1) */ -+ -+ clear_bit(RECV_RUNNING, &mux_recv_flags); -+} -+ -+static void post_recv_worker(void *private_) -+{ -+ ts0710_con *ts0710 = &ts0710_connection; -+ int tty_idx; -+ struct tty_struct *tty; -+ __u8 post_recv; -+ __u8 flow_control; -+ __u8 dlci; -+ mux_recv_struct *recv_info, *recv_info2, *post_recv_q; -+ int recv_room; -+ mux_recv_packet *recv_packet, *recv_packet2; -+ __u8 j; -+ -+ UNUSED_PARAM(private_); -+ -+ if (test_and_set_bit(RECV_RUNNING, &mux_recv_flags)) { -+ schedule_work(&post_recv_tqueue); -+ return; -+ } -+ -+ TS0710_DEBUG("Enter into post_recv_worker"); -+ -+ post_recv = 0; -+ if (!mux_recv_queue) { -+ goto out; -+ } -+ -+ post_recv_q = NULL; -+ recv_info2 = mux_recv_queue; -+ while ((recv_info = recv_info2)) { -+ recv_info2 = recv_info->next; -+ -+ if (!(recv_info->total)) { -+ TS0710_PRINTK -+ ("MUX Error: %s: Should not get here, recv_info->total == 0 \n", -+ __FUNCTION__); -+ continue; -+ } -+ -+ tty_idx = recv_info->no_tty; -+ dlci = tty2dlci[tty_idx]; -+ tty = mux_table[tty_idx]; -+ if ((!mux_tty[tty_idx]) || (!tty)) { -+ TS0710_PRINTK -+ ("MUX: No application waiting for, free recv_info! tty_idx:%d\n", -+ tty_idx); -+ mux_recv_info_flags[tty_idx] = 0; -+ free_mux_recv_struct(mux_recv_info[tty_idx]); -+ mux_recv_info[tty_idx] = 0; -+ ts0710_flow_on(dlci, ts0710); -+ continue; -+ } -+ -+ TS0710_DEBUG("/dev/mux%d recv_info->total is: %d", tty_idx, -+ recv_info->total); -+ -+ if (test_bit(TTY_THROTTLED, &tty->flags)) { -+ add_post_recv_queue(&post_recv_q, recv_info); -+ continue; -+ } else if (test_bit(TTY_DONT_FLIP, &tty->flags)) { -+ post_recv = 1; -+ add_post_recv_queue(&post_recv_q, recv_info); -+ continue; -+ } -+ -+ flow_control = 0; -+ recv_packet2 = recv_info->mux_packet; -+ while (recv_info->total) { -+ recv_room = 65535; -+ if (tty->receive_room) -+ recv_room = tty->receive_room; -+ -+ if (recv_info->length) { -+ if (recv_room < recv_info->length) { -+ flow_control = 1; -+ break; -+ } -+ -+ /* Put queued data into read buffer of tty */ -+ TS0710_DEBUG -+ ("Put queued recv data into read buffer of /dev/mux%d", -+ tty_idx); -+ TS0710_DEBUGHEX(recv_info->data, -+ recv_info->length); -+ (tty->ldisc.receive_buf) (tty, recv_info->data, -+ NULL, -+ recv_info->length); -+ recv_info->total -= recv_info->length; -+ recv_info->length = 0; -+ } else { /* recv_info->length == 0 */ -+ if ((recv_packet = recv_packet2)) { -+ recv_packet2 = recv_packet->next; -+ -+ if (recv_room < recv_packet->length) { -+ flow_control = 1; -+ recv_info->mux_packet = -+ recv_packet; -+ break; -+ } -+ -+ /* Put queued data into read buffer of tty */ -+ TS0710_DEBUG -+ ("Put queued recv data into read buffer of /dev/mux%d", -+ tty_idx); -+ TS0710_DEBUGHEX(recv_packet->data, -+ recv_packet->length); -+ (tty->ldisc.receive_buf) (tty, -+ recv_packet-> -+ data, NULL, -+ recv_packet-> -+ length); -+ recv_info->total -= recv_packet->length; -+ free_mux_recv_packet(recv_packet); -+ } else { -+ TS0710_PRINTK -+ ("MUX Error: %s: Should not get here, recv_info->total is:%u \n", -+ __FUNCTION__, recv_info->total); -+ } -+ } /* End recv_info->length == 0 */ -+ } /* End while( recv_info->total ) */ -+ -+ if (!(recv_info->total)) { -+ /* Important clear */ -+ recv_info->mux_packet = 0; -+ -+ if (recv_info->post_unthrottle) { -+ /* Do something for post_unthrottle */ -+ ts0710_flow_on(dlci, ts0710); -+ recv_info->post_unthrottle = 0; -+ } -+ } else { -+ add_post_recv_queue(&post_recv_q, recv_info); -+ -+ if (flow_control) { -+ /* Do something for flow control */ -+ if (recv_info->post_unthrottle) { -+ set_bit(TTY_THROTTLED, &tty->flags); -+ recv_info->post_unthrottle = 0; -+ } else { -+ ts0710_flow_off(tty, dlci, ts0710); -+ } -+ } /* End if( flow_control ) */ -+ } -+ } /* End while( (recv_info = recv_info2) ) */ -+ -+ mux_recv_queue = post_recv_q; -+ -+ out: -+ if (post_recv_count_flag) { -+ post_recv_count_flag = 0; -+ for (j = 0; j < TS0710MUX_COUNT_IDX_NUM; j++) { -+ if (mux_data_count2[j] > 0) { -+ if (add_count(j, mux_data_count2[j]) == 0) { -+ mux_data_count2[j] = 0; -+ } else { -+ post_recv_count_flag = 1; -+ post_recv = 1; -+ } -+ } -+ } /* End for (j = 0; j < TS0710MUX_COUNT_IDX_NUM; j++) */ -+ } -+ /* End if( post_recv_count_flag ) */ -+ if (post_recv) -+ schedule_work(&post_recv_tqueue); -+ clear_bit(RECV_RUNNING, &mux_recv_flags); -+} -+ -+/* mux sender, call from serial.c transmit_chars() */ -+void mux_sender(void) -+{ -+ mux_send_struct *send_info; -+ int chars; -+ __u8 idx; -+ -+ chars = mux_chars_in_serial_buffer(COMM_FOR_MUX_TTY); -+ if (!chars) { -+ /* chars == 0 */ -+ TS0710_LOG("<[]\n"); -+ mux_sched_send(); -+ return; -+ } -+ -+ idx = mux_send_info_idx; -+ if ((idx < NR_MUXS) && (mux_send_info_flags[idx])) { -+ send_info = mux_send_info[idx]; -+ if ((send_info) -+ && (send_info->filled) -+ && (send_info->length <= -+ (TS0710MUX_SERIAL_BUF_SIZE - chars))) { -+ -+ mux_sched_send(); -+ } -+ } -+} -+ -+static void send_worker(void *private_) -+{ -+ ts0710_con *ts0710 = &ts0710_connection; -+ __u8 j; -+ mux_send_struct *send_info; -+ int chars; -+ struct tty_struct *tty; -+ __u8 dlci; -+ -+ UNUSED_PARAM(private_); -+ -+ TS0710_DEBUG("Enter into send_worker"); -+ -+ mux_send_info_idx = NR_MUXS; -+ -+ if (ts0710->dlci[0].state == FLOW_STOPPED) { -+ TS0710_DEBUG("Flow stopped on all channels\n"); -+ return; -+ } -+ -+ for (j = 0; j < NR_MUXS; j++) { -+ -+ if (!(mux_send_info_flags[j])) { -+ continue; -+ } -+ -+ send_info = mux_send_info[j]; -+ if (!send_info) { -+ continue; -+ } -+ -+ if (!(send_info->filled)) { -+ continue; -+ } -+ -+ dlci = tty2dlci[j]; -+ if (ts0710->dlci[dlci].state == FLOW_STOPPED) { -+ TS0710_DEBUG("Flow stopped on channel DLCI: %d\n", -+ dlci); -+ continue; -+ } else if (ts0710->dlci[dlci].state != CONNECTED) { -+ TS0710_DEBUG("DLCI %d not connected\n", dlci); -+ send_info->filled = 0; -+ continue; -+ } -+ -+ chars = mux_chars_in_serial_buffer(COMM_FOR_MUX_TTY); -+ if (send_info->length <= (TS0710MUX_SERIAL_BUF_SIZE - chars)) { -+ TS0710_DEBUG("Send queued UIH for /dev/mux%d", j); -+ basic_write(ts0710, (__u8 *) send_info->frame, -+ send_info->length); -+ send_info->length = 0; -+ send_info->filled = 0; -+ } else { -+ mux_send_info_idx = j; -+ break; -+ } -+ } /* End for() loop */ -+ -+ /* Queue UIH data to be transmitted */ -+ for (j = 0; j < NR_MUXS; j++) { -+ -+ if (!(mux_send_info_flags[j])) { -+ continue; -+ } -+ -+ send_info = mux_send_info[j]; -+ if (!send_info) { -+ continue; -+ } -+ -+ if (send_info->filled) { -+ continue; -+ } -+ -+ /* Now queue UIH data to send_info->buf */ -+ -+ if (!mux_tty[j]) { -+ continue; -+ } -+ -+ tty = mux_table[j]; -+ if (!tty) { -+ continue; -+ } -+ -+ dlci = tty2dlci[j]; -+ if (ts0710->dlci[dlci].state == FLOW_STOPPED) { -+ TS0710_DEBUG("Flow stopped on channel DLCI: %d\n", -+ dlci); -+ continue; -+ } else if (ts0710->dlci[dlci].state != CONNECTED) { -+ TS0710_DEBUG("DLCI %d not connected\n", dlci); -+ continue; -+ } -+ -+ if ((tty->flags & (1 << TTY_DO_WRITE_WAKEUP)) -+ && tty->ldisc.write_wakeup) { -+ (tty->ldisc.write_wakeup) (tty); -+ } -+ wake_up_interruptible(&tty->write_wait); -+ -+#ifdef SERIAL_HAVE_POLL_WAIT -+ wake_up_interruptible(&tty->poll_wait); -+#endif -+ -+ if (send_info->filled) { -+ if (j < mux_send_info_idx) { -+ mux_send_info_idx = j; -+ } -+ } -+ } /* End for() loop */ -+} -+ -+static int get_count(__u8 idx) -+{ -+ int ret; -+ -+ if (idx > TS0710MUX_COUNT_MAX_IDX) { -+ TS0710_PRINTK("MUX get_count: invalid idx: %d!\n", idx); -+ return -1; -+ } -+ -+ down(&mux_data_count_mutex[idx]); -+ ret = mux_data_count[idx]; -+ up(&mux_data_count_mutex[idx]); -+ -+ return ret; -+} -+ -+static int set_count(__u8 idx, int count) -+{ -+ if (idx > TS0710MUX_COUNT_MAX_IDX) { -+ TS0710_PRINTK("MUX set_count: invalid idx: %d!\n", idx); -+ return -1; -+ } -+ if (count < 0) { -+ TS0710_PRINTK("MUX set_count: invalid count: %d!\n", count); -+ return -1; -+ } -+ -+ down(&mux_data_count_mutex[idx]); -+ mux_data_count[idx] = count; -+ up(&mux_data_count_mutex[idx]); -+ -+ return 0; -+} -+ -+static int add_count(__u8 idx, int count) -+{ -+ if (idx > TS0710MUX_COUNT_MAX_IDX) { -+ TS0710_PRINTK("MUX add_count: invalid idx: %d!\n", idx); -+ return -1; -+ } -+ if (count <= 0) { -+ TS0710_PRINTK("MUX add_count: invalid count: %d!\n", count); -+ return -1; -+ } -+ -+ if (down_trylock(&mux_data_count_mutex[idx])) -+ return -1; -+ mux_data_count[idx] += count; -+ up(&mux_data_count_mutex[idx]); -+ -+ return 0; -+} -+ -+ssize_t file_proc_read(struct file * file, char *buf, size_t size, -+ loff_t * ppos) -+{ -+ gprs_bytes gprsData[TS0710MUX_GPRS_SESSION_MAX]; -+ int bufLen = sizeof(gprs_bytes) * TS0710MUX_GPRS_SESSION_MAX; -+ -+ UNUSED_PARAM(file); -+ UNUSED_PARAM(size); -+ UNUSED_PARAM(ppos); -+ -+ gprsData[0].recvBytes = get_count(TS0710MUX_GPRS1_RECV_COUNT_IDX); -+ gprsData[0].sentBytes = get_count(TS0710MUX_GPRS1_SEND_COUNT_IDX); -+ gprsData[TS0710MUX_GPRS_SESSION_MAX - 1].recvBytes = -+ get_count(TS0710MUX_GPRS2_RECV_COUNT_IDX); -+ gprsData[TS0710MUX_GPRS_SESSION_MAX - 1].sentBytes = -+ get_count(TS0710MUX_GPRS2_SEND_COUNT_IDX); -+ -+ copy_to_user(buf, gprsData, bufLen); -+ -+ return bufLen; -+} -+ -+ssize_t file_proc_write(struct file * file, const char *buf, size_t count, -+ loff_t * ppos) -+{ -+ gprs_bytes gprsData[TS0710MUX_GPRS_SESSION_MAX]; -+ int bufLen = sizeof(gprs_bytes) * TS0710MUX_GPRS_SESSION_MAX; -+ -+ UNUSED_PARAM(file); -+ UNUSED_PARAM(count); -+ UNUSED_PARAM(ppos); -+ -+ memset(gprsData, 0, bufLen); -+ -+ copy_from_user(gprsData, buf, bufLen); -+ -+ set_count(TS0710MUX_GPRS1_RECV_COUNT_IDX, gprsData[0].recvBytes); -+ set_count(TS0710MUX_GPRS1_SEND_COUNT_IDX, gprsData[0].sentBytes); -+ set_count(TS0710MUX_GPRS2_RECV_COUNT_IDX, -+ gprsData[TS0710MUX_GPRS_SESSION_MAX - 1].recvBytes); -+ set_count(TS0710MUX_GPRS2_SEND_COUNT_IDX, -+ gprsData[TS0710MUX_GPRS_SESSION_MAX - 1].sentBytes); -+ -+ return bufLen; -+} -+ -+static void gprs_proc_init(void) -+{ -+ gprs_proc_file = -+ create_proc_entry("gprsbytes", S_IRUSR | S_IWUSR, NULL); -+ gprs_proc_file->proc_fops = &file_proc_operations; -+} -+ -+static void gprs_proc_exit(void) -+{ -+ remove_proc_entry("gprsbytes", gprs_proc_file); -+} -+ -+static int __init mux_init(void) -+{ -+ __u8 j; -+ -+ if (COMM_FOR_MUX_DRIVER == NULL) { -+ -+#ifdef USB_FOR_MUX -+ panic("please install IPC-USB first\n"); -+#else -+ panic("please install ttyS0 first\n"); -+#endif -+ -+ } -+ -+ ts0710_init(); -+ -+ for (j = 0; j < NR_MUXS; j++) { -+ mux_send_info_flags[j] = 0; -+ mux_send_info[j] = 0; -+ mux_recv_info_flags[j] = 0; -+ mux_recv_info[j] = 0; -+ } -+ mux_send_info_idx = NR_MUXS; -+ mux_recv_queue = NULL; -+ mux_recv_flags = 0; -+ -+ for (j = 0; j < TS0710MUX_COUNT_IDX_NUM; j++) { -+ mux_data_count[j] = 0; -+ mux_data_count2[j] = 0; -+ init_MUTEX(&mux_data_count_mutex[j]); -+ } -+ post_recv_count_flag = 0; -+ -+ INIT_WORK(&send_tqueue, send_worker, NULL); -+ INIT_WORK(&receive_tqueue, receive_worker, NULL); -+ INIT_WORK(&post_recv_tqueue, post_recv_worker, NULL); -+ -+ memset(&mux_driver, 0, sizeof(struct tty_driver)); -+ memset(&mux_tty, 0, sizeof(mux_tty)); -+ mux_driver.magic = TTY_DRIVER_MAGIC; -+ mux_driver.driver_name = "ts0710mux"; -+ mux_driver.name = "ts0710mux"; -+ mux_driver.major = TS0710MUX_MAJOR; -+ mux_driver.minor_start = TS0710MUX_MINOR_START; -+ mux_driver.num = NR_MUXS; -+ mux_driver.type = TTY_DRIVER_TYPE_SERIAL; -+ mux_driver.subtype = SERIAL_TYPE_NORMAL; -+ mux_driver.init_termios = tty_std_termios; -+ mux_driver.init_termios.c_iflag = 0; -+ mux_driver.init_termios.c_oflag = 0; -+ mux_driver.init_termios.c_cflag = B38400 | CS8 | CREAD; -+ mux_driver.init_termios.c_lflag = 0; -+ mux_driver.flags = TTY_DRIVER_RESET_TERMIOS | TTY_DRIVER_REAL_RAW; -+ -+ mux_driver.ttys = mux_table; -+ mux_driver.termios = mux_termios; -+ mux_driver.termios_locked = mux_termios_locked; -+// mux_driver.driver_state = mux_state; -+ mux_driver.other = NULL; -+ -+ mux_driver.open = mux_open; -+ mux_driver.close = mux_close; -+ mux_driver.write = mux_write; -+ mux_driver.write_room = mux_write_room; -+ mux_driver.flush_buffer = mux_flush_buffer; -+ mux_driver.chars_in_buffer = mux_chars_in_buffer; -+ mux_driver.throttle = mux_throttle; -+ mux_driver.unthrottle = mux_unthrottle; -+ mux_driver.ioctl = mux_ioctl; -+ mux_driver.owner = THIS_MODULE; -+ -+ if (tty_register_driver(&mux_driver)) -+ panic("Couldn't register mux driver"); -+ -+ COMM_MUX_DISPATCHER = mux_dispatcher; -+ COMM_MUX_SENDER = mux_sender; -+ -+ gprs_proc_init(); -+ -+ return 0; -+} -+ -+static void __exit mux_exit(void) -+{ -+ __u8 j; -+ -+ COMM_MUX_DISPATCHER = NULL; -+ COMM_MUX_SENDER = NULL; -+ -+ gprs_proc_exit(); -+ -+ mux_send_info_idx = NR_MUXS; -+ mux_recv_queue = NULL; -+ for (j = 0; j < NR_MUXS; j++) { -+ if ((mux_send_info_flags[j]) && (mux_send_info[j])) { -+ kfree(mux_send_info[j]); -+ } -+ mux_send_info_flags[j] = 0; -+ mux_send_info[j] = 0; -+ -+ if ((mux_recv_info_flags[j]) && (mux_recv_info[j])) { -+ free_mux_recv_struct(mux_recv_info[j]); -+ } -+ mux_recv_info_flags[j] = 0; -+ mux_recv_info[j] = 0; -+ } -+ -+ if (tty_unregister_driver(&mux_driver)) -+ panic("Couldn't unregister mux driver"); -+} -+ -+module_init(mux_init); -+module_exit(mux_exit); -+ -+MODULE_LICENSE("GPL"); -+MODULE_AUTHOR("Harald Welte <laforge@openezx.org>"); -+MODULE_DESCRIPTION("TS 07.10 Multiplexer"); -Index: linux-2.6.20.7/drivers/char/ts0710_mux.h -=================================================================== ---- /dev/null 1970-01-01 00:00:00.000000000 +0000 -+++ linux-2.6.20.7/drivers/char/ts0710_mux.h 2007-04-21 18:04:56.000000000 +0200 -@@ -0,0 +1,103 @@ -+/* -+ * mux_macro.h -+ * -+ * Copyright (C) 2002 2005 Motorola -+ * -+ * 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. -+ * -+ * -+ * 11/18/2002 (Motorola) - Initial version -+ * -+ */ -+ -+/* -+* This header file should be included by both MUX and other applications -+* which access MUX device files. It gives the additional macro definitions -+* shared between MUX and applications. -+*/ -+ -+/* MUX DLCI(Data Link Connection Identifier) Configuration */ -+/* -+* DLCI Service -+* 0 Control Channel -+* 1 Voice Call & Network-related -+* 2 SMS MO -+* 3 SMS MT -+* 4 Phonebook & related -+* 5 MISC -+* 6 CSD/FAX -+* 7 GPRS1 -+* 8 GPRS2 -+* 9 Logger CMD -+* 10 Logger Data -+* 11 Test CMD -+* 12 AGPS -+* 13 Net Monitor -+*/ -+ -+/* Mapping between DLCI and MUX device files */ -+/* -+* File Name Minor DLCI AT Command/Data -+* /dev/mux0 0 1 AT Command -+* /dev/mux1 1 2 AT Command -+* /dev/mux2 2 3 AT Command -+* /dev/mux3 3 4 AT Command -+* /dev/mux4 4 5 AT Command -+* /dev/mux5 5 6 AT Command -+* /dev/mux6 6 7 AT Command -+* /dev/mux7 7 8 AT Command -+* /dev/mux8 8 6 Data -+* /dev/mux9 9 7 Data -+* /dev/mux10 10 8 Data -+* /dev/mux11 11 9 Data -+* /dev/mux12 12 10 Data -+* /dev/mux13 13 11 Data -+* /dev/mux14 14 12 Data -+* /dev/mux15 15 13 Data -+*/ -+ -+#define MUX_CMD_FILE_VOICE_CALL "/dev/mux0" -+#define MUX_CMD_FILE_SMS_MO "/dev/mux1" -+#define MUX_CMD_FILE_SMS_MT "/dev/mux2" -+#define MUX_CMD_FILE_PHONEBOOK "/dev/mux3" -+#define MUX_CMD_FILE_MISC "/dev/mux4" -+#define MUX_CMD_FILE_CSD "/dev/mux5" -+#define MUX_CMD_FILE_GPRS1 "/dev/mux6" -+#define MUX_CMD_FILE_GPRS2 "/dev/mux7" -+ -+#define MUX_DATA_FILE_CSD "/dev/mux8" -+#define MUX_DATA_FILE_GPRS1 "/dev/mux9" -+#define MUX_DATA_FILE_GPRS2 "/dev/mux10" -+#define MUX_DATA_FILE_LOGGER_CMD "/dev/mux11" -+#define MUX_DATA_FILE_LOGGER_DATA "/dev/mux12" -+#define MUX_DATA_FILE_TEST_CMD "/dev/mux13" -+#define MUX_DATA_FILE_AGPS "/dev/mux14" -+#define MUX_DATA_FILE_NET_MONITOR "/dev/mux15" -+ -+#define NUM_MUX_CMD_FILES 8 -+#define NUM_MUX_DATA_FILES 8 -+#define NUM_MUX_FILES ( NUM_MUX_CMD_FILES + NUM_MUX_DATA_FILES ) -+ -+/* Special ioctl() upon a MUX device file for hanging up a call */ -+#define TS0710MUX_IO_MSC_HANGUP 0x54F0 -+ -+/* Special ioctl() upon a MUX device file for MUX loopback test */ -+#define TS0710MUX_IO_TEST_CMD 0x54F1 -+ -+/* Special Error code might be return from write() to a MUX device file */ -+#define EDISCONNECTED 900 /* Logical data link is disconnected */ -+ -+/* Special Error code might be return from open() to a MUX device file */ -+#define EREJECTED 901 /* Logical data link connection request is rejected */ -Index: linux-2.6.20.7/drivers/char/ts0710_mux_usb.c -=================================================================== ---- /dev/null 1970-01-01 00:00:00.000000000 +0000 -+++ linux-2.6.20.7/drivers/char/ts0710_mux_usb.c 2007-04-21 18:07:45.000000000 +0200 -@@ -0,0 +1,868 @@ -+/* -+ * linux/drivers/usb/ipcusb.c -+ * -+ * Implementation of a ipc driver based Intel's Bulverde USB Host -+ * Controller. -+ * -+ * Copyright (C) 2003-2005 Motorola -+ * Copyright (C) 2006 Harald Welte <laforge@openezx.org> -+ * -+ * 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 -+ * -+ * 2003-Nov-03 - (Motorola) created -+ * 2004-Feb-20 - (Motorola) Add Power Manager codes -+ * 2004-Apr-14 - (Motorola) Update Suspend/Resume codes -+ * 2004-May-10 - (Motorola) Add unlink_urbs codes and do some updates of send -+ * out urb sequence -+ * 2006-Jun-22 - (Harald Welte) port to Linux 2.6.x -+ * -+ */ -+ -+#include <linux/kernel.h> -+#include <linux/module.h> -+#include <linux/list.h> -+#include <linux/errno.h> -+#include <asm/uaccess.h> -+#include <asm/hardware.h> -+#include <asm/arch/hardware.h> -+#include <asm/arch-pxa/pxa-regs.h> -+#include <asm/arch-pxa/ezx.h> -+#include <linux/slab.h> -+#include <linux/miscdevice.h> -+#include <linux/init.h> -+#include <linux/timer.h> -+#include <linux/delay.h> -+#include <linux/sched.h> -+#include <linux/tty.h> -+#include <linux/tty_driver.h> -+#include <linux/tty_flip.h> -+#include <linux/circ_buf.h> -+#include <linux/usb.h> -+ -+#include "ts0710_mux_usb.h" -+ -+/*Macro defined for this driver*/ -+#define DRIVER_VERSION "1.0alpha1" -+#define DRIVER_AUTHOR "Motorola / Harald Welte <laforge@openezx.org>" -+#define DRIVER_DESC "USB IPC Driver (TS07.10 lowlevel)" -+#define MOTO_IPC_VID 0x22b8 -+#define MOTO_IPC_PID 0x3006 -+#define IBUF_SIZE 32 /*urb size*/ -+#define IPC_USB_XMIT_SIZE 1024 -+#define IPC_URB_SIZE 32 -+#define IPC_USB_WRITE_INIT 0 -+#define IPC_USB_WRITE_XMIT 1 -+#define IPC_USB_PROBE_READY 3 -+#define IPC_USB_PROBE_NOT_READY 4 -+#define DBG_MAX_BUF_SIZE 1024 -+#define ICL_EVENT_INTERVAL (HZ) -+#undef BVD_DEBUG -+ -+#define IS_EP_BULK(ep) ((ep).bmAttributes == USB_ENDPOINT_XFER_BULK ? 1 : 0) -+#define IS_EP_BULK_IN(ep) (IS_EP_BULK(ep) && ((ep).bEndpointAddress & USB_ENDPOINT_DIR_MASK) == USB_DIR_IN) -+#define IS_EP_BULK_OUT(ep) (IS_EP_BULK(ep) && ((ep).bEndpointAddress & USB_ENDPOINT_DIR_MASK) == USB_DIR_OUT) -+/*End defined macro*/ -+ -+/*global values defined*/ -+static struct usb_driver usb_ipc_driver; -+static struct timer_list ipcusb_timer; -+static struct timer_list suspend_timer; -+static struct timer_list wakeup_timer; -+static struct tty_struct ipcusb_tty; /* the coresponding tty struct, we just use flip buffer here. */ -+static struct tty_driver ipcusb_tty_driver; /* the coresponding tty driver, we just use write and chars in buff here*/ -+struct tty_driver *usb_for_mux_driver = NULL; -+struct tty_struct *usb_for_mux_tty = NULL; -+void (*usb_mux_dispatcher)(struct tty_struct *tty) = NULL; -+void (*usb_mux_sender)(void) = NULL; -+void (*ipcusb_ap_to_bp)(unsigned char*, int) = NULL; -+void (*ipcusb_bp_to_ap)(unsigned char*, int) = NULL; -+EXPORT_SYMBOL(usb_for_mux_driver); -+EXPORT_SYMBOL(usb_for_mux_tty); -+EXPORT_SYMBOL(usb_mux_dispatcher); -+EXPORT_SYMBOL(usb_mux_sender); -+EXPORT_SYMBOL(ipcusb_ap_to_bp); -+EXPORT_SYMBOL(ipcusb_bp_to_ap); -+static int sumbit_times = 0; -+static int callback_times = 0; -+//static unsigned long last_jiff = 0; -+extern int usbh_finished_resume; -+/*end global values defined*/ -+ -+MODULE_AUTHOR(DRIVER_AUTHOR); -+MODULE_DESCRIPTION(DRIVER_DESC); -+MODULE_LICENSE("GPL"); -+ -+#ifdef BVD_DEBUG -+#define bvd_dbg(format, arg...) printk(__FILE__ ": " format "\n" , ## arg) -+#else -+#define bvd_dbg(format, arg...) do {} while (0) -+#endif -+ -+/* USB device context */ -+typedef struct { -+ struct list_head list; -+ int size; -+ char *body; -+} buf_list_t; -+ -+struct ipc_usb_data { -+ u_int8_t write_finished_flag; -+ u_int8_t write_flag, -+ ipc_flag, -+ suspend_flag; -+ struct usb_device *ipc_dev; -+ struct urb readurb_mux, -+ writeurb_mux, -+ writeurb_dsplog; -+ char *obuf, *ibuf; -+ int writesize; /* max packet size for the -+ output bulk endpoint * -+ transfer buffers */ -+ -+ struct circ_buf xmit; /* write cric bufffer */ -+ struct list_head in_buf_list; -+ char bulk_in_ep_mux, -+ bulk_out_ep_mux, -+ bulk_in_ep_dsplog; -+ unsigned int ifnum; -+ -+ struct tasklet_struct bh, -+ bh_bp; -+ -+ spinlock_t lock; -+}; -+ -+struct ipc_usb_data *bvd_ipc; -+ -+#ifdef BVD_DEBUG -+static void bvd_dbg_hex(__u8 *buf, int len) -+{ -+ static unsigned char tbuf[DBG_MAX_BUF_SIZE]; -+ int i, c; -+ -+ if (len <= 0) -+ return; -+ -+ c = 0; -+ for (i=0; (i < len) && (c < (DBG_MAX_BUF_SIZE - 3)); i++) { -+ sprintf(&tbuf[c], "%02x ",buf[i]); -+ c += 3; -+ } -+ tbuf[c] = 0; -+ -+ printk("%s: %s\n", __FUNCTION__, tbuf); -+} -+#else -+#define bvd_dbg_hex(buf, len) -+#endif -+ -+static int unlink_urbs(struct urb *urb) -+{ -+ unsigned long flags; -+ int retval; -+ -+ spin_lock_irqsave(&bvd_ipc->lock, flags); -+ -+ retval = usb_unlink_urb(urb); -+ if (retval != -EINPROGRESS && retval != 0) -+ printk("unlink urb err, %d", retval); -+ -+ spin_unlock_irqrestore(&bvd_ipc->lock, flags); -+ return retval; -+} -+ -+static void append_to_inbuf_list(struct urb *urb) -+{ -+ buf_list_t *inbuf; -+ int count = urb->actual_length; -+ -+ inbuf = kmalloc(sizeof(buf_list_t), GFP_KERNEL); -+ if (!inbuf) { -+ printk("append_to_inbuf_list: (%d) out of memory!\n", -+ sizeof(buf_list_t)); -+ return; -+ } -+ -+ inbuf->size = count; -+ inbuf->body = kmalloc(sizeof(char)*count, GFP_KERNEL); -+ if (!inbuf->body) { -+ kfree(inbuf); -+ printk("append_to_inbuf_list: (%d) out of memory!\n", -+ sizeof(char)*count); -+ return; -+ } -+ memcpy(inbuf->body, (unsigned char*)urb->transfer_buffer, count); -+ list_add_tail(&inbuf->list, &bvd_ipc->in_buf_list); -+} -+ -+static void ipcusb_timeout(unsigned long data) -+{ -+ struct tty_struct *tty = &ipcusb_tty; -+ struct urb *urb = (struct urb *)data; -+ -+ bvd_dbg("ipcusb_timeout***"); -+ -+ while (!(list_empty(&bvd_ipc->in_buf_list))) { -+ int count; -+ buf_list_t *inbuf; -+ struct list_head *ptr = NULL; -+ -+ ptr = bvd_ipc->in_buf_list.next; -+ inbuf = list_entry (ptr, buf_list_t, list); -+ count = inbuf->size; -+ if (tty_insert_flip_string(tty, inbuf->body, count) >= count) { -+ list_del(ptr); -+ kfree(inbuf->body); -+ inbuf->body = NULL; -+ kfree(inbuf); -+ } else { -+ bvd_dbg("ipcusb_timeout: bvd_ipc->in_buf_list empty!"); -+ break; -+ } -+ } -+ -+ if (usb_mux_dispatcher) -+ usb_mux_dispatcher(tty); /**call Liu changhui's func.**/ -+ -+ if (list_empty(&bvd_ipc->in_buf_list)) { -+ urb->actual_length = 0; -+ urb->dev = bvd_ipc->ipc_dev; -+ if (usb_submit_urb(urb, GFP_ATOMIC)) -+ bvd_dbg("ipcusb_timeout: failed resubmitting read urb"); -+ bvd_dbg("ipcusb_timeout: resubmited read urb"); -+ } else { -+ ipcusb_timer.data = (unsigned long)urb; -+ mod_timer(&ipcusb_timer, jiffies+(10*HZ/1000)); -+ } -+} -+ -+static void usb_ipc_read_bulk(struct urb *urb, struct pt_regs *regs) -+{ -+ buf_list_t *inbuf; -+ int count = urb->actual_length; -+ struct tty_struct *tty = &ipcusb_tty; -+ -+ bvd_dbg("usb_ipc_read_bulk: begining!"); -+ if (urb->status) -+ printk("nonzero read bulk status received: %d\n", urb->status); -+ -+ bvd_dbg("usb_ipc_read_bulk: urb->actual_length=%d", urb->actual_length); -+ bvd_dbg("usb_ipc_read_bulk: urb->transfer_buffer:"); -+ -+ bvd_dbg_hex((unsigned char*)urb->transfer_buffer, urb->actual_length); -+ -+ if (count > 0 && ((*ipcusb_bp_to_ap) != NULL)) -+ (*ipcusb_bp_to_ap)(urb->transfer_buffer, urb->actual_length); -+ -+ if (!(list_empty(&bvd_ipc->in_buf_list))) { -+ int need_mux = 0; -+ -+ bvd_dbg("usb_ipc_read_bulk: some urbs in_buf_list"); -+ if (count > 0) { -+ bvd_ipc->suspend_flag = 1; -+ append_to_inbuf_list(urb); /* append the current received urb */ -+#if 0 -+ if(jiffies - last_jiff > ICL_EVENT_INTERVAL) -+ { -+ last_jiff = jiffies; -+ queue_apm_event(KRNL_ICL, NULL); -+ } -+#endif -+ } -+ -+ while (!(list_empty(&bvd_ipc->in_buf_list))) { -+ struct list_head* ptr = NULL; -+ ptr = bvd_ipc->in_buf_list.next; -+ inbuf = list_entry(ptr, buf_list_t, list); -+ count = inbuf->size; -+ need_mux = 1; -+ -+ tty_insert_flip_string(tty, inbuf->body, count); -+ -+ list_del(ptr); -+ kfree(inbuf->body); -+ inbuf->body = NULL; -+ kfree(inbuf); -+ } -+ -+ if (usb_mux_dispatcher && need_mux) -+ usb_mux_dispatcher(tty); /* call Liu changhui's func. */ -+ -+ if (list_empty(&bvd_ipc->in_buf_list)) { -+ urb->actual_length = 0; -+ urb->dev = bvd_ipc->ipc_dev; -+ if (usb_submit_urb(urb, GFP_ATOMIC)) -+ bvd_dbg("usb_ipc_read_bulk: " -+ "failed resubmitting read urb"); -+ bvd_dbg("usb_ipc_read_bulk: resubmited read urb"); -+ } else { -+ ipcusb_timer.data = (unsigned long)urb; -+ mod_timer(&ipcusb_timer, jiffies+(10*HZ/1000)); -+ } -+ } else if (count > 0) { -+ bvd_dbg("usb_ipc_read_bulk: no urbs in_buf_list"); -+ bvd_ipc->suspend_flag = 1; -+ -+ if (tty_insert_flip_string(tty, urb->transfer_buffer, -+ count) < count) { -+ bvd_ipc->suspend_flag = 1; -+ append_to_inbuf_list(urb); -+ ipcusb_timer.data = (unsigned long)urb; -+ mod_timer(&ipcusb_timer, jiffies+(10*HZ/1000)); -+#if 0 -+ if(jiffies - last_jiff > ICL_EVENT_INTERVAL) -+ { -+ last_jiff = jiffies; -+ queue_apm_event(KRNL_ICL, NULL); -+ } -+#endif -+ } -+ -+ if (usb_mux_dispatcher) -+ usb_mux_dispatcher(tty); /* call Liu changhui's func. */ -+ -+ urb->actual_length = 0; -+ urb->dev = bvd_ipc->ipc_dev; -+ if (usb_submit_urb(urb, GFP_ATOMIC)) -+ bvd_dbg("failed resubmitting read urb"); -+#if 0 -+ if(jiffies - last_jiff > ICL_EVENT_INTERVAL) -+ { -+ last_jiff = jiffies; -+ queue_apm_event(KRNL_ICL, NULL); -+ } -+#endif -+ bvd_dbg("usb_ipc_read_bulk: resubmited read urb"); -+ } -+ -+ bvd_dbg("usb_ipc_read_bulk: completed!!!"); -+} -+ -+static void usb_ipc_write_bulk(struct urb *urb, struct pt_regs *regs) -+{ -+ callback_times++; -+ bvd_ipc->write_finished_flag = 1; -+ -+ bvd_dbg("usb_ipc_write_bulk: begining!"); -+ //printk("%s: write_finished_flag=%d\n", __FUNCTION__, bvd_ipc->write_finished_flag); -+ -+ if (urb->status) -+ printk("nonzero write bulk status received: %d\n", urb->status); -+ -+ if (usb_mux_sender) -+ usb_mux_sender(); /**call Liu changhui's func**/ -+ -+ //printk("usb_ipc_write_bulk: mark ipcusb_softint!\n"); -+ tasklet_schedule(&bvd_ipc->bh); -+ -+ bvd_dbg("usb_ipc_write_bulk: finished!"); -+} -+ -+static void wakeup_timeout(unsigned long data) -+{ -+ GPSR(GPIO_MCU_INT_SW) = GPIO_bit(GPIO_MCU_INT_SW); -+ bvd_dbg("wakup_timeout: send GPIO_MCU_INT_SW signal!"); -+} -+ -+static void suspend_timeout(unsigned long data) -+{ -+ if (bvd_ipc->suspend_flag == 1) { -+ bvd_ipc->suspend_flag = 0; -+ mod_timer(&suspend_timer, jiffies+(5000*HZ/1000)); -+ bvd_dbg("suspend_timeout: add the suspend timer again"); -+ } else { -+ unlink_urbs(&bvd_ipc->readurb_mux); -+ UHCRHPS3 = 0x4; -+ mdelay(40); -+ bvd_dbg("suspend_timeout: send SUSPEND signal! UHCRHPS3=0x%x", -+ UHCRHPS3); -+ } -+} -+ -+static void ipcusb_xmit_data(void) -+{ -+ int c, count = IPC_URB_SIZE; -+ int result = 0; -+ int buf_flag = 0; -+ int buf_num = 0; -+ -+ //printk("%s: sumbit_times=%d, callback_times=%d\n", __FUNCTION__, sumbit_times, callback_times); -+ if (bvd_ipc->write_finished_flag == 0) -+ return; -+ -+ while (1) { -+ c = CIRC_CNT_TO_END(bvd_ipc->xmit.head, bvd_ipc->xmit.tail, -+ IPC_USB_XMIT_SIZE); -+ if (count < c) -+ c = count; -+ if (c <= 0) -+ break; -+ -+ memcpy(bvd_ipc->obuf+buf_num, -+ bvd_ipc->xmit.buf + bvd_ipc->xmit.tail, c); -+ buf_flag = 1; -+ bvd_ipc->xmit.tail = ((bvd_ipc->xmit.tail + c) -+ & (IPC_USB_XMIT_SIZE-1)); -+ count -= c; -+ buf_num += c; -+ } -+ -+ if (buf_num == 0) { -+ bvd_dbg("ipcusb_xmit_data: buf_num=%d, add suspend_timer", -+ buf_num); -+ bvd_ipc->suspend_flag = 0; -+ mod_timer(&suspend_timer, jiffies+(5000*HZ/1000)); -+ } -+ -+ bvd_dbg("ipcusb_xmit_data: buf_num=%d", buf_num); -+ bvd_dbg("ipcusb_xmit_data: bvd_ipc->obuf: "); -+ -+ bvd_dbg_hex((bvd_ipc->obuf)-buf_num, buf_num); -+ -+ if (buf_flag) { -+ bvd_ipc->writeurb_mux.transfer_buffer_length = buf_num; -+ bvd_dbg("ipcusb_xmit_data: copy data to write urb finished! "); -+ -+ if ((UHCRHPS3 & 0x4) == 0x4) { -+ static int ret; -+ int time = 0; -+ -+ /* if BP sleep, wake up BP first */ -+ pxa_gpio_mode(GPIO_IN | 41); -+ if (GPIO_is_high(41)) { -+ if (GPIO_is_high(GPIO_MCU_INT_SW)) -+ GPCR(GPIO_MCU_INT_SW) = GPIO_bit(GPIO_MCU_INT_SW); -+ else -+ GPSR(GPIO_MCU_INT_SW) = GPIO_bit(GPIO_MCU_INT_SW); -+ -+ time = jiffies; -+ while (GPIO_is_high(41) && (jiffies < (time+HZ))); -+ -+ if (GPIO_is_high(41)) { -+ printk("%s: Wakeup BP timeout! BP state is %d\n", -+ __FUNCTION__, GPIO_is_high(41)); -+ } -+ if (GPIO_is_high(GPIO_MCU_INT_SW)) -+ GPCR(GPIO_MCU_INT_SW) = GPIO_bit(GPIO_MCU_INT_SW); -+ else -+ GPSR(GPIO_MCU_INT_SW) = GPIO_bit(GPIO_MCU_INT_SW); -+ } -+ -+ /* Resume BP */ -+ UHCRHPS3 = 0x8; -+ mdelay(40); -+ bvd_dbg("ipcusb_xmit_data: Send RESUME signal! UHCRHPS3=0x%x", -+ UHCRHPS3); -+ /*send IN token*/ -+ bvd_ipc->readurb_mux.actual_length = 0; -+ bvd_ipc->readurb_mux.dev = bvd_ipc->ipc_dev; -+ if (ret = usb_submit_urb(&bvd_ipc->readurb_mux, GFP_ATOMIC)) -+ printk("ipcusb_xmit_data: usb_submit_urb(read mux bulk)" -+ "failed! status=%d\n", ret); -+ bvd_dbg("ipcusb_xmit_data: Send a IN token successfully!"); -+ } -+ -+ sumbit_times++; -+ bvd_ipc->write_finished_flag = 0; -+ //printk("%s: clear write_finished_flag:%d\n", __FUNCTION__, bvd_ipc->write_finished_flag); -+ bvd_ipc->writeurb_mux.dev = bvd_ipc->ipc_dev; -+ if (result = usb_submit_urb(&bvd_ipc->writeurb_mux, GFP_ATOMIC)) -+ warn("ipcusb_xmit_data: funky result! result=%d\n", result); -+ -+ bvd_dbg("ipcusb_xmit_data: usb_submit_urb finished! result:%d", result); -+ -+ } -+} -+ -+static void usbipc_bh_func(unsigned long param) -+{ -+ ipcusb_xmit_data(); -+} -+ -+extern void get_halted_bit(void); -+ -+static void usbipc_bh_bp_func(unsigned long param) -+{ -+ if ((UHCRHPS3 & 0x4) == 0x4) { -+ UHCRHPS3 = 0x8; -+ mdelay(40); -+ bvd_dbg("ipcusb_softint_send_readurb: Send RESUME signal! " -+ "UHCRHPS3=0x%x", UHCRHPS3); -+ } -+ if (bvd_ipc->ipc_flag == IPC_USB_PROBE_READY) { -+ get_halted_bit(); -+ -+ /*send a IN token*/ -+ bvd_ipc->readurb_mux.dev = bvd_ipc->ipc_dev; -+ if (usb_submit_urb(&bvd_ipc->readurb_mux, GFP_ATOMIC)) { -+ bvd_dbg("ipcusb_softint_send_readurb: " -+ "usb_submit_urb(read mux bulk) failed!"); -+ } -+ bvd_dbg("ipcusb_softint_send_readurb: Send a IN token successfully!"); -+ bvd_ipc->suspend_flag = 0; -+ bvd_dbg("ipcusb_softint_send_readurb: add suspend_timer"); -+ mod_timer(&suspend_timer, jiffies+(5000*HZ/1000)); -+ } -+} -+ -+static int usb_ipc_write(struct tty_struct *tty, -+ const unsigned char *buf, int count) -+{ -+ int c, ret = 0; -+ -+ bvd_dbg("usb_ipc_write: count=%d, buf: ", count); -+ bvd_dbg_hex(buf, count); -+ -+ if (count <= 0) -+ return 0; -+ -+ if (*ipcusb_ap_to_bp != NULL) -+ (*ipcusb_ap_to_bp)(buf, count); -+ -+ bvd_ipc->suspend_flag = 1; -+ -+ if ((bvd_ipc->ipc_flag == IPC_USB_PROBE_READY) && -+ (bvd_ipc->xmit.head == bvd_ipc->xmit.tail)) { -+ bvd_dbg("usb_ipc_write: set write_flag"); -+ bvd_ipc->write_flag = IPC_USB_WRITE_XMIT; -+ } -+ -+ while (1) { -+ c = CIRC_SPACE_TO_END(bvd_ipc->xmit.head, -+ bvd_ipc->xmit.tail, IPC_USB_XMIT_SIZE); -+ if (count < c) -+ c = count; -+ if (c <= 0) -+ break; -+ -+ memcpy(bvd_ipc->xmit.buf + bvd_ipc->xmit.head, buf, c); -+ bvd_ipc->xmit.head = ((bvd_ipc->xmit.head + c) -+ & (IPC_USB_XMIT_SIZE-1)); -+ buf += c; -+ count -= c; -+ ret += c; -+ } -+ bvd_dbg("usb_ipc_write: ret=%d, bvd_ipc->xmit.buf: ", ret); -+ -+ bvd_dbg_hex(bvd_ipc->xmit.buf, ret); -+ -+ if (bvd_ipc->write_flag == IPC_USB_WRITE_XMIT) { -+ bvd_ipc->write_flag = IPC_USB_WRITE_INIT; -+ bvd_dbg("usb_ipc_write: mark ipcusb_softint"); -+ tasklet_schedule(&bvd_ipc->bh); -+ } -+ -+ bvd_dbg("usb_ipc_write: ret=%d\n", ret); -+ return ret; -+} -+ -+static int usb_ipc_chars_in_buffer(struct tty_struct *tty) -+{ -+ return CIRC_CNT(bvd_ipc->xmit.head, bvd_ipc->xmit.tail, IPC_USB_XMIT_SIZE); -+} -+ -+void usb_send_readurb(void) -+{ -+ //printk("usb_send_readurb: begining!UHCRHPS3=0x%x, usbh_finished_resume=%d\n", UHCRHPS3, usbh_finished_resume); -+ -+ if (usbh_finished_resume == 0) -+ return; -+ -+ tasklet_schedule(&bvd_ipc->bh_bp); -+} -+ -+static int usb_ipc_probe(struct usb_interface *intf, -+ const struct usb_device_id *id) -+{ -+ struct usb_device *usbdev = interface_to_usbdev(intf); -+ struct usb_config_descriptor *ipccfg; -+ struct usb_interface_descriptor *interface; -+ struct usb_endpoint_descriptor *endpoint; -+ int ep_cnt, readsize, writesize; -+ char have_bulk_in_mux, have_bulk_out_mux; -+ -+ bvd_dbg("usb_ipc_probe: vendor id 0x%x, device id 0x%x", -+ usbdev->descriptor.idVendor, usbdev->descriptor.idProduct); -+ -+ if ((usbdev->descriptor.idVendor != MOTO_IPC_VID) || -+ (usbdev->descriptor.idProduct != MOTO_IPC_PID)) -+ return -ENODEV; -+ -+ /* a2590c : dsplog interface is not supported by this driver */ -+ if (intf->minor == 2) /* dsplog interface number is 2 */ -+ return -1; -+ -+ bvd_dbg("usb_ipc_probe: USB dev address:%p", usbdev); -+ bvd_dbg("usb_ipc_probe: ifnum:%u", intf->minor); -+ -+ ipccfg = &usbdev->actconfig->desc; -+ bvd_dbg("usb_ipc_prob: config%d", ipccfg->bConfigurationValue); -+ bvd_dbg("usb_ipc_prob: bNumInterfaces = %d", ipccfg->bNumInterfaces); -+ -+ /* After this point we can be a little noisy about what we are trying -+ * to configure, hehe. */ -+ if (usbdev->descriptor.bNumConfigurations != 1) { -+ info("usb_ipc_probe: Only one device configuration " -+ "is supported."); -+ return -1; -+ } -+ -+ if (usbdev->config[0].desc.bNumInterfaces != 3) { -+ info("usb_ipc_probe: Only three device interfaces are " -+ "supported."); -+ return -1; -+ } -+ -+ interface = &intf->cur_altsetting->desc; -+ endpoint = &intf->cur_altsetting->endpoint[0].desc; -+ /* Start checking for two bulk endpoints or ... FIXME: This is a future -+ * enhancement...*/ -+ bvd_dbg("usb_ipc_probe: Number of Endpoints:%d", -+ (int) interface->bNumEndpoints); -+ if (interface->bNumEndpoints != 2) { -+ info("usb_ipc_probe: Only two endpoints supported."); -+ return -1; -+ } -+ -+ ep_cnt = have_bulk_in_mux = have_bulk_out_mux = 0; -+ -+ bvd_dbg("usb_ipc_probe: endpoint[0] is:%x", -+ (&endpoint[0])->bEndpointAddress); -+ bvd_dbg("usb_ipc_probe: endpoint[1] is:%x ", -+ (&endpoint[1])->bEndpointAddress); -+ -+ while (ep_cnt < interface->bNumEndpoints) { -+ -+ if (!have_bulk_in_mux && IS_EP_BULK_IN(endpoint[ep_cnt])) { -+ bvd_dbg("usb_ipc_probe: bEndpointAddress(IN) is:%x ", -+ (&endpoint[ep_cnt])->bEndpointAddress); -+ have_bulk_in_mux = -+ (&endpoint[ep_cnt])->bEndpointAddress; -+ readsize = (&endpoint[ep_cnt])->wMaxPacketSize; -+ bvd_dbg("usb_ipc_probe: readsize=%d", readsize); -+ ep_cnt++; -+ continue; -+ } -+ -+ if (!have_bulk_out_mux && IS_EP_BULK_OUT(endpoint[ep_cnt])) { -+ bvd_dbg("usb_ipc_probe: bEndpointAddress(OUT) is:%x ", -+ (&endpoint[ep_cnt])->bEndpointAddress); -+ have_bulk_out_mux = -+ (&endpoint[ep_cnt])->bEndpointAddress; -+ writesize = (&endpoint[ep_cnt])->wMaxPacketSize; -+ bvd_dbg("usb_ipc_probe: writesize=%d", writesize); -+ ep_cnt++; -+ continue; -+ } -+ -+ info("usb_ipc_probe: Undetected endpoint ^_^ "); -+ /* Shouldn't ever get here unless we have something weird */ -+ return -1; -+ } -+ -+ /* Perform a quick check to make sure that everything worked as it -+ * should have. */ -+ -+ switch (interface->bNumEndpoints) { -+ case 2: -+ if (!have_bulk_in_mux || !have_bulk_out_mux) { -+ info("usb_ipc_probe: Two bulk endpoints required."); -+ return -1; -+ } -+ break; -+ default: -+ info("usb_ipc_probe: Endpoint determination failed ^_^ "); -+ return -1; -+ } -+ -+ /* Ok, now initialize all the relevant values */ -+ if (!(bvd_ipc->obuf = (char *)kmalloc(writesize, GFP_KERNEL))) { -+ err("usb_ipc_probe: Not enough memory for the output buffer."); -+ kfree(bvd_ipc); -+ return -1; -+ } -+ bvd_dbg("usb_ipc_probe: obuf address:%p", bvd_ipc->obuf); -+ -+ if (!(bvd_ipc->ibuf = (char *)kmalloc(readsize, GFP_KERNEL))) { -+ err("usb_ipc_probe: Not enough memory for the input buffer."); -+ kfree(bvd_ipc->obuf); -+ kfree(bvd_ipc); -+ return -1; -+ } -+ bvd_dbg("usb_ipc_probe: ibuf address:%p", bvd_ipc->ibuf); -+ -+ bvd_ipc->ipc_flag = IPC_USB_PROBE_READY; -+ bvd_ipc->write_finished_flag = 1; -+ bvd_ipc->suspend_flag = 1; -+ bvd_ipc->bulk_in_ep_mux= have_bulk_in_mux; -+ bvd_ipc->bulk_out_ep_mux= have_bulk_out_mux; -+ bvd_ipc->ipc_dev = usbdev; -+ bvd_ipc->writesize = writesize; -+ INIT_LIST_HEAD (&bvd_ipc->in_buf_list); -+ -+ bvd_ipc->bh.func = usbipc_bh_func; -+ bvd_ipc->bh.data = (unsigned long) bvd_ipc; -+ -+ bvd_ipc->bh_bp.func = usbipc_bh_bp_func; -+ bvd_ipc->bh_bp.data = (unsigned long) bvd_ipc; -+ -+ /*Build a write urb*/ -+ usb_fill_bulk_urb(&bvd_ipc->writeurb_mux, usbdev, -+ usb_sndbulkpipe(bvd_ipc->ipc_dev, -+ bvd_ipc->bulk_out_ep_mux), -+ bvd_ipc->obuf, writesize, usb_ipc_write_bulk, -+ bvd_ipc); -+ //bvd_ipc->writeurb_mux.transfer_flags |= USB_ASYNC_UNLINK; -+ -+ /*Build a read urb and send a IN token first time*/ -+ usb_fill_bulk_urb(&bvd_ipc->readurb_mux, usbdev, -+ usb_rcvbulkpipe(usbdev, bvd_ipc->bulk_in_ep_mux), -+ bvd_ipc->ibuf, readsize, usb_ipc_read_bulk, bvd_ipc); -+ //bvd_ipc->readurb_mux.transfer_flags |= USB_ASYNC_UNLINK; -+ -+ usb_driver_claim_interface(&usb_ipc_driver, intf, bvd_ipc); -+ //usb_driver_claim_interface(&usb_ipc_driver, &ipccfg->interface[1], bvd_ipc); -+ -+ // a2590c: dsplog is not supported by this driver -+ // usb_driver_claim_interface(&usb_ipc_driver, -+ // &ipccfg->interface[2], bvd_ipc); -+ /*send a IN token first time*/ -+ bvd_ipc->readurb_mux.dev = bvd_ipc->ipc_dev; -+ if (usb_submit_urb(&bvd_ipc->readurb_mux, GFP_ATOMIC)) -+ printk("usb_ipc_prob: usb_submit_urb(read mux bulk) failed!\n"); -+ -+ bvd_dbg("usb_ipc_prob: Send a IN token successfully!"); -+ -+ if (bvd_ipc->xmit.head != bvd_ipc->xmit.tail) { -+ printk("usb_ipc_probe: mark ipcusb_softint!\n"); -+ tasklet_schedule(&bvd_ipc->bh); -+ } -+ -+ printk("usb_ipc_probe: completed probe!"); -+ usb_set_intfdata(intf, &bvd_ipc); -+ return 0; -+} -+ -+static void usb_ipc_disconnect(struct usb_interface *intf) -+{ -+ //struct usb_device *usbdev = interface_to_usbdev(intf); -+ struct ipc_usb_data *bvd_ipc_disconnect = usb_get_intfdata(intf); -+ -+ printk("usb_ipc_disconnect:*** \n"); -+ -+ if ((UHCRHPS3 & 0x4) == 0) -+ usb_unlink_urb(&bvd_ipc_disconnect->readurb_mux); -+ -+ usb_unlink_urb(&bvd_ipc_disconnect->writeurb_mux); -+ -+ bvd_ipc_disconnect->ipc_flag = IPC_USB_PROBE_NOT_READY; -+ kfree(bvd_ipc_disconnect->ibuf); -+ kfree(bvd_ipc_disconnect->obuf); -+ -+ usb_driver_release_interface(&usb_ipc_driver, -+ bvd_ipc_disconnect->ipc_dev->actconfig->interface[0]); -+ usb_driver_release_interface(&usb_ipc_driver, -+ bvd_ipc_disconnect->ipc_dev->actconfig->interface[1]); -+ -+ //a2590c: dsplog interface is not supported by this driver -+ //usb_driver_release_interface(&usb_ipc_driver, &bvd_ipc_disconnect->ipc_dev->actconfig->interface[2]); -+ -+ bvd_ipc_disconnect->ipc_dev = NULL; -+ -+ usb_set_intfdata(intf, NULL); -+ -+ printk("usb_ipc_disconnect completed!\n"); -+} -+ -+static struct usb_device_id usb_ipc_id_table[] = { -+ { USB_DEVICE(MOTO_IPC_VID, MOTO_IPC_PID) }, -+ { } /* Terminating entry */ -+}; -+ -+static struct usb_driver usb_ipc_driver = { -+ .name = "usb ipc", -+ .probe = usb_ipc_probe, -+ .disconnect = usb_ipc_disconnect, -+ .id_table = usb_ipc_id_table, -+}; -+ -+static int __init usb_ipc_init(void) -+{ -+ int result; -+ -+ bvd_dbg("init usb_ipc"); -+ /* register driver at the USB subsystem */ -+ result = usb_register(&usb_ipc_driver); -+ if (result < 0) { -+ err ("usb ipc driver could not be registered"); -+ return result; -+ } -+ -+ /*init the related mux interface*/ -+ if (!(bvd_ipc = kzalloc(sizeof(struct ipc_usb_data), GFP_KERNEL))) { -+ err("usb_ipc_init: Out of memory."); -+ usb_deregister(&usb_ipc_driver); -+ return -ENOMEM; -+ } -+ bvd_dbg("usb_ipc_init: Address of bvd_ipc:%p", bvd_ipc); -+ -+ if (!(bvd_ipc->xmit.buf = kmalloc(IPC_USB_XMIT_SIZE, GFP_KERNEL))) { -+ err("usb_ipc_init: Not enough memory for the input buffer."); -+ kfree(bvd_ipc); -+ usb_deregister(&usb_ipc_driver); -+ return -ENOMEM; -+ } -+ bvd_dbg("usb_ipc_init: bvd_ipc->xmit.buf address:%p", -+ bvd_ipc->xmit.buf); -+ bvd_ipc->ipc_dev = NULL; -+ bvd_ipc->xmit.head = bvd_ipc->xmit.tail = 0; -+ bvd_ipc->write_flag = IPC_USB_WRITE_INIT; -+ -+ ipcusb_tty_driver.write = usb_ipc_write; -+ ipcusb_tty_driver.chars_in_buffer = usb_ipc_chars_in_buffer; -+ -+ usb_for_mux_driver = &ipcusb_tty_driver; -+ usb_for_mux_tty = &ipcusb_tty; -+ -+ /* init timers for ipcusb read process and usb suspend */ -+ init_timer(&ipcusb_timer); -+ ipcusb_timer.function = ipcusb_timeout; -+ -+ init_timer(&suspend_timer); -+ suspend_timer.function = suspend_timeout; -+ -+ init_timer(&wakeup_timer); -+ wakeup_timer.function = wakeup_timeout; -+ -+ info("USB Host(Bulverde) IPC driver registered."); -+ info(DRIVER_VERSION ":" DRIVER_DESC); -+ -+ return 0; -+} -+ -+static void __exit usb_ipc_exit(void) -+{ -+ bvd_dbg("cleanup bvd_ipc"); -+ -+ kfree(bvd_ipc->xmit.buf); -+ kfree(bvd_ipc); -+ usb_deregister(&usb_ipc_driver); -+ -+ info("USB Host(Bulverde) IPC driver deregistered."); -+} -+ -+module_init(usb_ipc_init); -+module_exit(usb_ipc_exit); -+EXPORT_SYMBOL(usb_send_readurb); -Index: linux-2.6.20.7/drivers/char/ts0710_mux_usb.h -=================================================================== ---- /dev/null 1970-01-01 00:00:00.000000000 +0000 -+++ linux-2.6.20.7/drivers/char/ts0710_mux_usb.h 2007-04-21 18:07:21.000000000 +0200 -@@ -0,0 +1,29 @@ -+/* -+ * linux/drivers/usb/ipcusb.h -+ * -+ * Implementation of a ipc driver based Intel's Bulverde USB Host -+ * Controller. -+ * -+ * Copyright (C) 2003-2005 Motorola -+ * -+ * 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 -+ * -+ * 2003-Nov-18 - (Motorola) created -+ * -+ */ -+extern struct tty_driver *usb_for_mux_driver; -+extern struct tty_struct *usb_for_mux_tty; -+extern void (*usb_mux_dispatcher)(struct tty_struct *tty); -+extern void (*usb_mux_sender)(void); diff --git a/packages/linux/linux-ezx-2.6.20.7/mux_debug.patch b/packages/linux/linux-ezx-2.6.20.7/mux_debug.patch deleted file mode 100644 index 58cb25a0b6..0000000000 --- a/packages/linux/linux-ezx-2.6.20.7/mux_debug.patch +++ /dev/null @@ -1,551 +0,0 @@ -Index: linux-2.6.20.7/drivers/char/ts0710_mux.c -=================================================================== ---- linux-2.6.20.7.orig/drivers/char/ts0710_mux.c 2007-04-22 12:24:18.000000000 +0200 -+++ linux-2.6.20.7/drivers/char/ts0710_mux.c 2007-04-22 12:26:47.000000000 +0200 -@@ -85,6 +85,9 @@ - #include "ts0710.h" - #include "ts0710_mux.h" - -+#define TS0710DEBUG -+#define PRINT_OUTPUT_PRINTK -+ - #define TS0710MUX_GPRS_SESSION_MAX 2 - #define TS0710MUX_MAJOR 250 - #define TS0710MUX_MINOR_START 0 -@@ -316,7 +319,7 @@ - #ifdef TS0710DEBUG - - #ifdef PRINT_OUTPUT_PRINTK --#define TS0710_DEBUG(fmt, arg...) printk(KERN_INFO "MUX " __FUNCTION__ ": " fmt "\n" , ## arg) -+#define TS0710_DEBUG(fmt, arg...) printk(KERN_INFO "MUX %s: " fmt "\n" , __func__, ## arg) - #else - #include "ezxlog.h" - static __u8 strDebug[256]; -@@ -530,10 +533,10 @@ - if (strncmp(p->comm, "aplogd", 6) == 0) { - sig = 1; - if (send_sig(SIGUSR2, p, 1) == 0) { -- TS0710_PRINTK -+ TS0710_DEBUG - ("MUX: success to send SIGUSR2 to aplogd!\n"); - } else { -- TS0710_PRINTK -+ TS0710_DEBUG - ("MUX: failure to send SIGUSR2 to aplogd!\n"); - } - break; -@@ -542,7 +545,7 @@ - read_unlock(&tasklist_lock); - - if (!sig) { -- TS0710_PRINTK("MUX: not found aplogd!\n"); -+ TS0710_DEBUG("MUX: not found aplogd!\n"); - } - } - #else -@@ -559,11 +562,11 @@ - buf[len + 1] = TS0710_BASIC_FLAG; - - if ((COMM_FOR_MUX_DRIVER == 0) || (COMM_FOR_MUX_TTY == 0)) { -- TS0710_PRINTK -+ TS0710_DEBUG - ("MUX basic_write: (COMM_FOR_MUX_DRIVER == 0) || (COMM_FOR_MUX_TTY == 0)\n"); - - #ifndef USB_FOR_MUX -- TS0710_PRINTK -+ TS0710_DEBUG - ("MUX basic_write: tapisrv might be down!!! (serial_for_mux_driver == 0) || (serial_for_mux_tty == 0)\n"); - TS0710_SIG2APLOGD(); - #endif -@@ -577,7 +580,7 @@ - res = COMM_FOR_MUX_DRIVER->write(COMM_FOR_MUX_TTY, buf, len + 2); - - if (res != len + 2) { -- TS0710_PRINTK("MUX basic_write: Write Error!\n"); -+ TS0710_DEBUG("MUX basic_write: Write Error!\n"); - return -1; - } - -@@ -601,7 +604,7 @@ - TS0710_DEBUG("crc_check: CRC check OK\n"); - return 0; - } else { -- TS0710_PRINTK("MUX crc_check: CRC check failed\n"); -+ TS0710_DEBUG("MUX crc_check: CRC check failed\n"); - return 1; - } - } -@@ -1266,7 +1269,7 @@ - break; - - case FCON: /*Flow control on command */ -- TS0710_PRINTK -+ TS0710_DEBUG - ("MUX Received Flow control(all channels) on command\n"); - if (mcc_short_pkt->h.type.cr == MCC_CMD) { - ts0710->dlci[0].state = CONNECTED; -@@ -1276,7 +1279,7 @@ - break; - - case FCOFF: /*Flow control off command */ -- TS0710_PRINTK -+ TS0710_DEBUG - ("MUX Received Flow control(all channels) off command\n"); - if (mcc_short_pkt->h.type.cr == MCC_CMD) { - for (j = 0; j < TS0710_MAX_CHN; j++) { -@@ -1823,7 +1826,7 @@ - TS0710_DEBUG("UIH on channel %d\n", dlci); - - if (uih_len > ts0710->dlci[dlci].mtu) { -- TS0710_PRINTK -+ TS0710_DEBUG - ("MUX Error: DLCI:%d, uih_len:%d is bigger than mtu:%d, discard data!\n", - dlci, uih_len, ts0710->dlci[dlci].mtu); - break; -@@ -1844,7 +1847,7 @@ - dlci, tty_idx); - TS0710_DEBUGSTR(uih_data_start, uih_len); - if (!(iscmdtty[tty_idx])) { -- TS0710_PRINTK -+ TS0710_DEBUG - ("MUX Error: %s: Wrong CMDTAG on DLCI:%d, /dev/mux%d\n", - __FUNCTION__, dlci, tty_idx); - } -@@ -1856,7 +1859,7 @@ - ("NON-CMDTAG on DLCI:%d, /dev/mux%d\n", - dlci, tty_idx); - if (iscmdtty[tty_idx]) { -- TS0710_PRINTK -+ TS0710_DEBUG - ("MUX Error: %s: Wrong NON-CMDTAG on DLCI:%d, /dev/mux%d\n", - __FUNCTION__, dlci, tty_idx); - } -@@ -1864,13 +1867,14 @@ - } - tty = mux_table[tty_idx]; - if ((!mux_tty[tty_idx]) || (!tty)) { -- TS0710_PRINTK -+ TS0710_DEBUG - ("MUX: No application waiting for, discard it! /dev/mux%d\n", - tty_idx); -+ TS0710_DEBUG("MUX: mux_tty[%d] = %d, tty is at %i", tty_idx, mux_tty[tty_idx], tty); - } else { /* Begin processing received data */ - if ((!mux_recv_info_flags[tty_idx]) - || (!mux_recv_info[tty_idx])) { -- TS0710_PRINTK -+ TS0710_DEBUG - ("MUX Error: No mux_recv_info, discard it! /dev/mux%d\n", - tty_idx); - break; -@@ -1878,7 +1882,7 @@ - - recv_info = mux_recv_info[tty_idx]; - if (recv_info->total > 8192) { -- TS0710_PRINTK -+ TS0710_DEBUG - ("MUX : discard data for tty_idx:%d, recv_info->total > 8192 \n", - tty_idx); - break; -@@ -1949,7 +1953,7 @@ - get_mux_recv_packet - (uih_len); - if (!recv_packet) { -- TS0710_PRINTK -+ TS0710_DEBUG - ("MUX %s: no memory\n", - __FUNCTION__); - break; -@@ -1980,7 +1984,7 @@ - } else { /* recv_info->total == 0 */ - if (uih_len > - TS0710MUX_RECV_BUF_SIZE) { -- TS0710_PRINTK -+ TS0710_DEBUG - ("MUX Error: tty_idx:%d, uih_len == %d is too big\n", - tty_idx, uih_len); - uih_len = -@@ -2120,12 +2124,12 @@ - if (ts0710->dlci[dlci].state == DISCONNECTED) { - break; - } else if (signal_pending(current)) { -- TS0710_PRINTK -+ TS0710_DEBUG - ("MUX DLCI %d Send DISC got signal!\n", - dlci); - break; - } else if ((jiffies - t) >= TS0710MUX_TIME_OUT) { -- TS0710_PRINTK -+ TS0710_DEBUG - ("MUX DLCI %d Send DISC timeout!\n", dlci); - continue; - } -@@ -2158,7 +2162,7 @@ - return 0; - } else if (ts0710->dlci[0].state == CONNECTING) { - /* Reentry */ -- TS0710_PRINTK -+ TS0710_DEBUG - ("MUX DLCI: 0, reentry to open DLCI 0, pid: %d, %s !\n", - current->pid, current->comm); - try = 11; -@@ -2179,13 +2183,13 @@ - DISCONNECTED) { - break; - } else if (signal_pending(current)) { -- TS0710_PRINTK -+ TS0710_DEBUG - ("MUX DLCI:%d Wait for connecting got signal!\n", - dlci); - retval = -EAGAIN; - break; - } else if ((jiffies - t) >= TS0710MUX_TIME_OUT) { -- TS0710_PRINTK -+ TS0710_DEBUG - ("MUX DLCI:%d Wait for connecting timeout!\n", - dlci); - continue; -@@ -2199,7 +2203,7 @@ - } - } else if ((ts0710->dlci[0].state != DISCONNECTED) - && (ts0710->dlci[0].state != REJECTED)) { -- TS0710_PRINTK("MUX DLCI:%d state is invalid!\n", dlci); -+ TS0710_DEBUG("MUX DLCI:%d state is invalid!\n", dlci); - return retval; - } else { - ts0710->initiator = 1; -@@ -2218,19 +2222,19 @@ - retval = 0; - break; - } else if (ts0710->dlci[0].state == REJECTED) { -- TS0710_PRINTK -+ TS0710_DEBUG - ("MUX DLCI:%d Send SABM got rejected!\n", - dlci); - retval = -EREJECTED; - break; - } else if (signal_pending(current)) { -- TS0710_PRINTK -+ TS0710_DEBUG - ("MUX DLCI:%d Send SABM got signal!\n", - dlci); - retval = -EAGAIN; - break; - } else if ((jiffies - t) >= TS0710MUX_TIME_OUT) { -- TS0710_PRINTK -+ TS0710_DEBUG - ("MUX DLCI:%d Send SABM timeout!\n", - dlci); - continue; -@@ -2271,13 +2275,13 @@ - DISCONNECTED) { - break; - } else if (signal_pending(current)) { -- TS0710_PRINTK -+ TS0710_DEBUG - ("MUX DLCI:%d Wait for connecting got signal!\n", - dlci); - retval = -EAGAIN; - break; - } else if ((jiffies - t) >= TS0710MUX_TIME_OUT) { -- TS0710_PRINTK -+ TS0710_DEBUG - ("MUX DLCI:%d Wait for connecting timeout!\n", - dlci); - continue; -@@ -2296,7 +2300,7 @@ - } - } else if ((ts0710->dlci[dlci].state != DISCONNECTED) - && (ts0710->dlci[dlci].state != REJECTED)) { -- TS0710_PRINTK("MUX DLCI:%d state is invalid!\n", dlci); -+ TS0710_DEBUG("MUX DLCI:%d state is invalid!\n", dlci); - return retval; - } else { - ts0710->dlci[dlci].state = NEGOTIATING; -@@ -2313,13 +2317,13 @@ - if (ts0710->dlci[dlci].state == CONNECTING) { - break; - } else if (signal_pending(current)) { -- TS0710_PRINTK -+ TS0710_DEBUG - ("MUX DLCI:%d Send pn_msg got signal!\n", - dlci); - retval = -EAGAIN; - break; - } else if ((jiffies - t) >= TS0710MUX_TIME_OUT) { -- TS0710_PRINTK -+ TS0710_DEBUG - ("MUX DLCI:%d Send pn_msg timeout!\n", - dlci); - continue; -@@ -2344,20 +2348,20 @@ - break; - } else if (ts0710->dlci[dlci].state == - REJECTED) { -- TS0710_PRINTK -+ TS0710_DEBUG - ("MUX DLCI:%d Send SABM got rejected!\n", - dlci); - retval = -EREJECTED; - break; - } else if (signal_pending(current)) { -- TS0710_PRINTK -+ TS0710_DEBUG - ("MUX DLCI:%d Send SABM got signal!\n", - dlci); - retval = -EAGAIN; - break; - } else if ((jiffies - t) >= - TS0710MUX_TIME_OUT) { -- TS0710_PRINTK -+ TS0710_DEBUG - ("MUX DLCI:%d Send SABM timeout!\n", - dlci); - continue; -@@ -2468,7 +2472,7 @@ - schedule_work(&send_tqueue); - #else - if (!tq_serial_for_mux) { -- TS0710_PRINTK("MUX Error: %s: tq_serial_for_mux == 0\n", -+ TS0710_DEBUG("MUX Error: %s: tq_serial_for_mux == 0\n", - __FUNCTION__); - return; - } -@@ -2508,7 +2512,7 @@ - if ((mux_tty[cmdtty] == 0) && (mux_tty[datatty] == 0)) { - if (dlci == 1) { - ts0710_close_channel(0); -- TS0710_PRINTK -+ TS0710_DEBUG - ("MUX mux_close: tapisrv might be down!!! Close DLCI 1\n"); - TS0710_SIG2APLOGD(); - } -@@ -2673,12 +2677,12 @@ - UNUSED_PARAM(tty); - - if ((COMM_FOR_MUX_DRIVER == 0) || (COMM_FOR_MUX_TTY == 0)) { -- TS0710_PRINTK -+ TS0710_DEBUG - ("MUX %s: (COMM_FOR_MUX_DRIVER == 0) || (COMM_FOR_MUX_TTY == 0)\n", - __FUNCTION__); - - #ifndef USB_FOR_MUX -- TS0710_PRINTK -+ TS0710_DEBUG - ("MUX %s: tapisrv might be down!!! (serial_for_mux_driver == 0) || (serial_for_mux_tty == 0)\n", - __FUNCTION__); - TS0710_SIG2APLOGD(); -@@ -2724,14 +2728,14 @@ - } else if (ts0710->dlci[dlci].state == CONNECTED) { - - if (!(mux_send_info_flags[line])) { -- TS0710_PRINTK -+ TS0710_DEBUG - ("MUX Error: mux_write: mux_send_info_flags[%d] == 0\n", - line); - return -ENODEV; - } - send_info = mux_send_info[line]; - if (!send_info) { -- TS0710_PRINTK -+ TS0710_DEBUG - ("MUX Error: mux_write: mux_send_info[%d] == 0\n", - line); - return -ENODEV; -@@ -2800,7 +2804,7 @@ - } - return c; - } else { -- TS0710_PRINTK("MUX mux_write: DLCI %d not connected\n", dlci); -+ TS0710_DEBUG("MUX mux_write: DLCI %d not connected\n", dlci); - return -EDISCONNECTED; - } - } -@@ -2940,7 +2944,7 @@ - return; - } - -- TS0710_PRINTK("MUX %s: line is:%d\n", __FUNCTION__, line); -+ TS0710_DEBUG("MUX %s: line is:%d\n", __FUNCTION__, line); - - if ((mux_send_info_flags[line]) - && (mux_send_info[line]) -@@ -2960,10 +2964,10 @@ - - /* - if( (COMM_FOR_MUX_DRIVER == 0) || (COMM_FOR_MUX_TTY == 0) ) { -- TS0710_PRINTK("MUX %s: (COMM_FOR_MUX_DRIVER == 0) || (COMM_FOR_MUX_TTY == 0)\n", __FUNCTION__); -+ TS0710_DEBUG("MUX %s: (COMM_FOR_MUX_DRIVER == 0) || (COMM_FOR_MUX_TTY == 0)\n", __FUNCTION__); - - #ifndef USB_FOR_MUX -- TS0710_PRINTK("MUX %s: tapisrv might be down!!! (serial_for_mux_driver == 0) || (serial_for_mux_tty == 0)\n", __FUNCTION__); -+ TS0710_DEBUG("MUX %s: tapisrv might be down!!! (serial_for_mux_driver == 0) || (serial_for_mux_tty == 0)\n", __FUNCTION__); - TS0710_SIG2APLOGD(); - #endif - -@@ -2989,9 +2993,9 @@ - if ((COMM_FOR_MUX_DRIVER == NULL) || (COMM_FOR_MUX_TTY == NULL)) { - - #ifdef USB_FOR_MUX -- TS0710_PRINTK("MUX: please install and open IPC-USB first\n"); -+ TS0710_DEBUG("MUX: please install and open IPC-USB first\n"); - #else -- TS0710_PRINTK("MUX: please install and open ttyS0 first\n"); -+ TS0710_DEBUG("MUX: please install and open ttyS0 first\n"); - #endif - - goto out; -@@ -3016,7 +3020,7 @@ - /* if( dlci == 1 ) { */ - /* Open server channel 0 first */ - if ((retval = ts0710_open_channel(0)) != 0) { -- TS0710_PRINTK("MUX: Can't connect server channel 0!\n"); -+ TS0710_DEBUG("MUX: Can't connect server channel 0!\n"); - ts0710_init(); - - mux_tty[line]--; -@@ -3073,7 +3077,7 @@ - datatty = dlci2tty[dlci].datatty; - if ((mux_tty[cmdtty] > 0) || (mux_tty[datatty] > 0)) { - if ((retval = ts0710_open_channel(dlci)) != 0) { -- TS0710_PRINTK("MUX: Can't connected channel %d!\n", -+ TS0710_DEBUG("MUX: Can't connected channel %d!\n", - dlci); - ts0710_reset_dlci(dlci); - -@@ -3096,6 +3100,7 @@ - retval = 0; - #endif - out: -+ TS0710_DEBUG("returning %d for open of /dev/mux%d (mux_tty[%d] = %d", retval, line, line, mux_tty[line]); - return retval; - } - -@@ -3178,12 +3183,12 @@ - - while (1) { - tbuf_free = TS0710MUX_MAX_BUF_SIZE - (tbuf_ptr - tbuf); -- TS0710_PRINTK("Reading max %i bytes from ts0710_mux_usb inbuf.\n", tbuf_free); -+ TS0710_DEBUG("Reading max %i bytes from ts0710_mux_usb inbuf.\n", tbuf_free); - tbuf_read = get_from_inbuf_list(tbuf_ptr, tbuf_free); - if (tbuf_read == 0) { - break; - } else { -- TS0710_PRINTK("Read %i bytes.\n", tbuf_read); -+ TS0710_DEBUG("Read %i bytes.\n", tbuf_read); - }; - tbuf_ptr += tbuf_read; - }; -@@ -3192,7 +3197,7 @@ - - // Should be impossible? - //if (count > (TS0710MUX_MAX_BUF_SIZE - (tbuf_ptr - tbuf))) { -- // TS0710_PRINTK -+ // TS0710_DEBUG - // ("MUX receive_worker: !!!!! Exceed buffer boundary !!!!!\n"); - // count = (TS0710MUX_MAX_BUF_SIZE - (tbuf_ptr - tbuf)); - //} -@@ -3264,7 +3269,7 @@ - TS0710_LOGSTR_FRAME(0, start_flag, - (tbuf_ptr - - start_flag)); -- TS0710_PRINTK -+ TS0710_DEBUG - ("MUX Error: %s: frame length:%d is bigger than Max total frame size:%d\n", - /*__FUNCTION__, framelen, TS0710MUX_MAX_TOTAL_FRAME_SIZE);*/ - __FUNCTION__, framelen, (TS0710MUX_MAX_TOTAL_FRAME_SIZE + SEQ_FIELD_SIZE)); /*For BP UART problem */ -@@ -3389,7 +3394,7 @@ - *(uih_data_start - + uih_len) = - 0; -- TS0710_PRINTK -+ TS0710_DEBUG - ("MUX bp log: %s\n", - uih_data_start); - } -@@ -3415,7 +3420,7 @@ - TS0710_LOGSTR_FRAME(0, start_flag, - framelen); - TS0710_DEBUGHEX(start_flag, framelen); -- TS0710_PRINTK -+ TS0710_DEBUG - ("MUX: Lost synchronization!\n"); - search = start_flag + 1; - } -@@ -3476,7 +3481,7 @@ - recv_info2 = recv_info->next; - - if (!(recv_info->total)) { -- TS0710_PRINTK -+ TS0710_DEBUG - ("MUX Error: %s: Should not get here, recv_info->total == 0 \n", - __FUNCTION__); - continue; -@@ -3486,7 +3491,7 @@ - dlci = tty2dlci[tty_idx]; - tty = mux_table[tty_idx]; - if ((!mux_tty[tty_idx]) || (!tty)) { -- TS0710_PRINTK -+ TS0710_DEBUG - ("MUX: No application waiting for, free recv_info! tty_idx:%d\n", - tty_idx); - mux_recv_info_flags[tty_idx] = 0; -@@ -3560,7 +3565,7 @@ - recv_info->total -= recv_packet->length; - free_mux_recv_packet(recv_packet); - } else { -- TS0710_PRINTK -+ TS0710_DEBUG - ("MUX Error: %s: Should not get here, recv_info->total is:%u \n", - __FUNCTION__, recv_info->total); - } -@@ -3760,7 +3765,7 @@ - int ret; - - if (idx > TS0710MUX_COUNT_MAX_IDX) { -- TS0710_PRINTK("MUX get_count: invalid idx: %d!\n", idx); -+ TS0710_DEBUG("MUX get_count: invalid idx: %d!\n", idx); - return -1; - } - -@@ -3774,11 +3779,11 @@ - static int set_count(__u8 idx, int count) - { - if (idx > TS0710MUX_COUNT_MAX_IDX) { -- TS0710_PRINTK("MUX set_count: invalid idx: %d!\n", idx); -+ TS0710_DEBUG("MUX set_count: invalid idx: %d!\n", idx); - return -1; - } - if (count < 0) { -- TS0710_PRINTK("MUX set_count: invalid count: %d!\n", count); -+ TS0710_DEBUG("MUX set_count: invalid count: %d!\n", count); - return -1; - } - -@@ -3792,11 +3797,11 @@ - static int add_count(__u8 idx, int count) - { - if (idx > TS0710MUX_COUNT_MAX_IDX) { -- TS0710_PRINTK("MUX add_count: invalid idx: %d!\n", idx); -+ TS0710_DEBUG("MUX add_count: invalid idx: %d!\n", idx); - return -1; - } - if (count <= 0) { -- TS0710_PRINTK("MUX add_count: invalid count: %d!\n", count); -+ TS0710_DEBUG("MUX add_count: invalid count: %d!\n", count); - return -1; - } - -Index: linux-2.6.20.7/drivers/char/ts0710_mux_usb.c -=================================================================== ---- linux-2.6.20.7.orig/drivers/char/ts0710_mux_usb.c 2007-04-22 12:26:47.000000000 +0200 -+++ linux-2.6.20.7/drivers/char/ts0710_mux_usb.c 2007-04-22 12:26:47.000000000 +0200 -@@ -72,7 +72,8 @@ - #define IPC_USB_PROBE_NOT_READY 4 - #define DBG_MAX_BUF_SIZE 1024 - #define ICL_EVENT_INTERVAL (HZ) --#undef BVD_DEBUG -+ -+#define BVD_DEBUG - - #define IS_EP_BULK(ep) ((ep).bmAttributes == USB_ENDPOINT_XFER_BULK ? 1 : 0) - #define IS_EP_BULK_IN(ep) (IS_EP_BULK(ep) && ((ep).bEndpointAddress & USB_ENDPOINT_DIR_MASK) == USB_DIR_IN) diff --git a/packages/linux/linux-ezx-2.6.20.7/usb_add_epalloc-r3.patch b/packages/linux/linux-ezx-2.6.20.7/usb_add_epalloc-r3.patch deleted file mode 100644 index fc9daf5297..0000000000 --- a/packages/linux/linux-ezx-2.6.20.7/usb_add_epalloc-r3.patch +++ /dev/null @@ -1,282 +0,0 @@ -Index: linux-2.6.20.7/drivers/usb/gadget/epautoconf.c -=================================================================== ---- linux-2.6.20.7.orig/drivers/usb/gadget/epautoconf.c 2007-04-21 11:24:21.000000000 -0300 -+++ linux-2.6.20.7/drivers/usb/gadget/epautoconf.c 2007-04-21 11:27:53.000000000 -0300 -@@ -228,14 +228,19 @@ - * - * On failure, this returns a null endpoint descriptor. - */ --struct usb_ep * __devinit usb_ep_autoconfig ( -+struct usb_ep * usb_ep_autoconfig ( - struct usb_gadget *gadget, -- struct usb_endpoint_descriptor *desc -+ struct usb_endpoint_descriptor *desc, -+ struct usb_endpoint_config *epconfig, int numconfigs - ) - { - struct usb_ep *ep; - u8 type; - -+ /* Use device specific ep allocation code if provided */ -+ if (gadget->ops->ep_alloc) -+ return gadget->ops->ep_alloc(gadget, desc, epconfig, numconfigs); -+ - type = desc->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK; - - /* First, apply chip-specific "best usage" knowledge. -Index: linux-2.6.20.7/drivers/usb/gadget/ether.c -=================================================================== ---- linux-2.6.20.7.orig/drivers/usb/gadget/ether.c 2007-04-21 11:27:52.000000000 -0300 -+++ linux-2.6.20.7/drivers/usb/gadget/ether.c 2007-04-21 11:27:53.000000000 -0300 -@@ -2219,7 +2219,8 @@ - struct eth_dev *dev; - struct net_device *net; - u8 cdc = 1, zlp = 1, rndis = 1; -- struct usb_ep *in_ep, *out_ep, *status_ep = NULL; -+ struct usb_ep *in_ep = NULL , *out_ep = NULL, *status_ep = NULL; -+ struct usb_endpoint_config ep_config[2]; - int status = -ENOMEM; - int gcnum; - -@@ -2318,7 +2319,26 @@ - - /* all we really need is bulk IN/OUT */ - usb_ep_autoconfig_reset (gadget); -- in_ep = usb_ep_autoconfig (gadget, &fs_source_desc); -+ -+ ep_config[0].config = DEV_CONFIG_VALUE; -+#if defined(DEV_CONFIG_CDC) -+ ep_config[0].interface = data_intf.bInterfaceNumber; -+ ep_config[0].altinterface = data_intf.bAlternateSetting; -+#else /* DEV_CONFIG_SUBSET */ -+ ep_config[0].interface = subset_data_intf.bInterfaceNumber; -+ ep_config[0].altinterface = subset_data_intf.bAlternateSetting; -+#endif -+ -+#ifdef CONFIG_USB_ETH_RNDIS -+ ep_config[1].config = DEV_RNDIS_CONFIG_VALUE; -+ ep_config[1].interface = rndis_data_intf.bInterfaceNumber; -+ ep_config[1].altinterface = rndis_data_intf.bAlternateSetting; -+ -+ in_ep = usb_ep_autoconfig(gadget, &fs_source_desc, &ep_config[0], 2); -+#else -+ in_ep = usb_ep_autoconfig(gadget, &fs_source_desc, &ep_config[0], 1); -+#endif -+ - if (!in_ep) { - autoconf_fail: - dev_err (&gadget->dev, -@@ -2328,7 +2348,12 @@ - } - in_ep->driver_data = in_ep; /* claim */ - -- out_ep = usb_ep_autoconfig (gadget, &fs_sink_desc); -+#ifdef CONFIG_USB_ETH_RNDIS -+ out_ep = usb_ep_autoconfig(gadget, &fs_sink_desc, &ep_config[0], 2); -+#else -+ out_ep = usb_ep_autoconfig(gadget, &fs_sink_desc, &ep_config[0], 1); -+#endif -+ - if (!out_ep) - goto autoconf_fail; - out_ep->driver_data = out_ep; /* claim */ -@@ -2338,7 +2363,25 @@ - * Since some hosts expect one, try to allocate one anyway. - */ - if (cdc || rndis) { -- status_ep = usb_ep_autoconfig (gadget, &fs_status_desc); -+#ifdef DEV_CONFIG_CDC -+ ep_config[0].config = DEV_CONFIG_VALUE; -+ ep_config[0].interface = control_intf.bInterfaceNumber; -+ ep_config[0].altinterface = control_intf.bAlternateSetting; -+#endif -+#ifdef CONFIG_USB_ETH_RNDIS -+ ep_config[1].config = DEV_RNDIS_CONFIG_VALUE; -+ ep_config[1].interface = rndis_control_intf.bInterfaceNumber; -+ ep_config[1].altinterface = rndis_control_intf.bAlternateSetting; -+#endif -+ -+#if defined(DEV_CONFIG_CDC) && defined(CONFIG_USB_ETH_RNDIS) -+ status_ep = usb_ep_autoconfig(gadget, &fs_status_desc, &ep_config[0], 2); -+#elif defined(CONFIG_USB_ETH_RNDIS) -+ status_ep = usb_ep_autoconfig(gadget, &fs_status_desc, &ep_config[1], 1); -+#else -+ status_ep = usb_ep_autoconfig(gadget, &fs_status_desc, &ep_config[0], 1); -+#endif -+ - if (status_ep) { - status_ep->driver_data = status_ep; /* claim */ - } else if (rndis) { -Index: linux-2.6.20.7/drivers/usb/gadget/file_storage.c -=================================================================== ---- linux-2.6.20.7.orig/drivers/usb/gadget/file_storage.c 2007-04-21 11:24:21.000000000 -0300 -+++ linux-2.6.20.7/drivers/usb/gadget/file_storage.c 2007-04-21 11:27:53.000000000 -0300 -@@ -3850,6 +3850,7 @@ - struct usb_ep *ep; - struct usb_request *req; - char *pathbuf, *p; -+ struct usb_endpoint_config ep_config; - - fsg->gadget = gadget; - set_gadget_data(gadget, fsg); -@@ -3920,21 +3921,25 @@ - } - - /* Find all the endpoints we will use */ -+ ep_config.config = CONFIG_VALUE; -+ ep_config.interface = intf_desc.bInterfaceNumber; -+ ep_config.altinterface = intf_desc.bAlternateSetting; -+ - usb_ep_autoconfig_reset(gadget); -- ep = usb_ep_autoconfig(gadget, &fs_bulk_in_desc); -+ ep = usb_ep_autoconfig(gadget, &fs_bulk_in_desc, &ep_config, 1); - if (!ep) - goto autoconf_fail; - ep->driver_data = fsg; // claim the endpoint - fsg->bulk_in = ep; - -- ep = usb_ep_autoconfig(gadget, &fs_bulk_out_desc); -+ ep = usb_ep_autoconfig(gadget, &fs_bulk_out_desc, &ep_config, 1); - if (!ep) - goto autoconf_fail; - ep->driver_data = fsg; // claim the endpoint - fsg->bulk_out = ep; - - if (transport_is_cbi()) { -- ep = usb_ep_autoconfig(gadget, &fs_intr_in_desc); -+ ep = usb_ep_autoconfig(gadget, &fs_intr_in_desc, &ep_config, 1); - if (!ep) - goto autoconf_fail; - ep->driver_data = fsg; // claim the endpoint -Index: linux-2.6.20.7/drivers/usb/gadget/serial.c -=================================================================== ---- linux-2.6.20.7.orig/drivers/usb/gadget/serial.c 2007-04-21 11:24:21.000000000 -0300 -+++ linux-2.6.20.7/drivers/usb/gadget/serial.c 2007-04-21 11:27:53.000000000 -0300 -@@ -1357,6 +1357,7 @@ - struct usb_ep *ep; - struct gs_dev *dev; - int gcnum; -+ struct usb_endpoint_config ep_config[2]; - - /* Some controllers can't support CDC ACM: - * - sh doesn't support multiple interfaces or configs; -@@ -1377,22 +1378,33 @@ - __constant_cpu_to_le16(GS_VERSION_NUM|0x0099); - } - -+ ep_config[0].config = GS_BULK_CONFIG_ID; -+ ep_config[0].interface = gs_bulk_interface_desc.bInterfaceNumber; -+ ep_config[0].altinterface = gs_bulk_interface_desc.bAlternateSetting; -+ ep_config[1].config = GS_ACM_CONFIG_ID; -+ ep_config[1].interface = gs_data_interface_desc.bInterfaceNumber; -+ ep_config[1].altinterface = gs_data_interface_desc.bAlternateSetting; -+ - usb_ep_autoconfig_reset(gadget); - -- ep = usb_ep_autoconfig(gadget, &gs_fullspeed_in_desc); -+ ep = usb_ep_autoconfig(gadget, &gs_fullspeed_in_desc, &ep_config[0], 2); - if (!ep) - goto autoconf_fail; - EP_IN_NAME = ep->name; - ep->driver_data = ep; /* claim the endpoint */ - -- ep = usb_ep_autoconfig(gadget, &gs_fullspeed_out_desc); -+ ep = usb_ep_autoconfig(gadget, &gs_fullspeed_out_desc, &ep_config[0], 2); - if (!ep) - goto autoconf_fail; - EP_OUT_NAME = ep->name; - ep->driver_data = ep; /* claim the endpoint */ - - if (use_acm) { -- ep = usb_ep_autoconfig(gadget, &gs_fullspeed_notify_desc); -+ ep_config[0].config = GS_ACM_CONFIG_ID; -+ ep_config[0].interface = gs_control_interface_desc.bInterfaceNumber; -+ ep_config[0].altinterface = gs_control_interface_desc.bAlternateSetting; -+ -+ ep = usb_ep_autoconfig(gadget, &gs_fullspeed_notify_desc, &ep_config[0], 1); - if (!ep) { - printk(KERN_ERR "gs_bind: cannot run ACM on %s\n", gadget->name); - goto autoconf_fail; -Index: linux-2.6.20.7/drivers/usb/gadget/zero.c -=================================================================== ---- linux-2.6.20.7.orig/drivers/usb/gadget/zero.c 2007-04-21 11:24:21.000000000 -0300 -+++ linux-2.6.20.7/drivers/usb/gadget/zero.c 2007-04-21 11:27:53.000000000 -0300 -@@ -1144,6 +1144,7 @@ - struct zero_dev *dev; - struct usb_ep *ep; - int gcnum; -+ struct usb_endpoint_config ep_config[2]; - - /* FIXME this can't yet work right with SH ... it has only - * one configuration, numbered one. -@@ -1156,7 +1157,15 @@ - * but there may also be important quirks to address. - */ - usb_ep_autoconfig_reset (gadget); -- ep = usb_ep_autoconfig (gadget, &fs_source_desc); -+ -+ ep_config[0].config = CONFIG_SOURCE_SINK; -+ ep_config[0].interface = source_sink_intf.bInterfaceNumber; -+ ep_config[0].altinterface = source_sink_intf.bAlternateSetting; -+ ep_config[1].config = CONFIG_LOOPBACK; -+ ep_config[1].interface = loopback_intf.bInterfaceNumber; -+ ep_config[1].altinterface = loopback_intf.bAlternateSetting; -+ -+ ep = usb_ep_autoconfig(gadget, &fs_source_desc, &ep_config[0], 2); - if (!ep) { - autoconf_fail: - printk (KERN_ERR "%s: can't autoconfigure on %s\n", -@@ -1166,7 +1175,7 @@ - EP_IN_NAME = ep->name; - ep->driver_data = ep; /* claim */ - -- ep = usb_ep_autoconfig (gadget, &fs_sink_desc); -+ ep = usb_ep_autoconfig(gadget, &fs_sink_desc, &ep_config[0], 2); - if (!ep) - goto autoconf_fail; - EP_OUT_NAME = ep->name; -Index: linux-2.6.20.7/include/linux/usb_gadget.h -=================================================================== ---- linux-2.6.20.7.orig/include/linux/usb_gadget.h 2007-04-21 11:24:21.000000000 -0300 -+++ linux-2.6.20.7/include/linux/usb_gadget.h 2007-04-21 11:27:53.000000000 -0300 -@@ -445,10 +445,28 @@ - - struct usb_gadget; - -+/** -+ * struct usb_endpoint_config - possible configurations of a given endpoint -+ * @config: the configuration number -+ * @interface: the interface number -+ * @altinterface: the altinterface number -+ * -+ * Used as an array to pass information about the possible configurations -+ * of a given endpoint to the bus controller. -+ */ -+struct usb_endpoint_config { -+ u8 config; -+ u8 interface; -+ u8 altinterface; -+}; -+ - /* the rest of the api to the controller hardware: device operations, - * which don't involve endpoints (or i/o). - */ - struct usb_gadget_ops { -+ struct usb_ep* (*ep_alloc)(struct usb_gadget *, -+ struct usb_endpoint_descriptor *, -+ struct usb_endpoint_config *, int); - int (*get_frame)(struct usb_gadget *); - int (*wakeup)(struct usb_gadget *); - int (*set_selfpowered) (struct usb_gadget *, int is_selfpowered); -@@ -872,7 +890,10 @@ - /* utility wrapping a simple endpoint selection policy */ - - extern struct usb_ep *usb_ep_autoconfig (struct usb_gadget *, -- struct usb_endpoint_descriptor *) __devinit; -+ struct usb_endpoint_descriptor *, -+ struct usb_endpoint_config *, -+ int numconfigs -+); - - extern void usb_ep_autoconfig_reset (struct usb_gadget *) __devinit; - diff --git a/packages/linux/linux-ezx-2.6.20.7/usb_pxa27x_udc-r3.patch b/packages/linux/linux-ezx-2.6.20.7/usb_pxa27x_udc-r3.patch deleted file mode 100644 index 2e60d5b9ce..0000000000 --- a/packages/linux/linux-ezx-2.6.20.7/usb_pxa27x_udc-r3.patch +++ /dev/null @@ -1,2868 +0,0 @@ - arch/arm/mach-pxa/spitz.c | 27 - drivers/usb/gadget/Kconfig | 20 - drivers/usb/gadget/Makefile | 1 - drivers/usb/gadget/ether.c | 12 - drivers/usb/gadget/pxa27x_udc.c | 2412 ++++++++++++++++++++++++++++++++++++++++ - drivers/usb/gadget/pxa27x_udc.h | 298 ++++ - drivers/usb/gadget/pxa2xx_udc.h | 7 - 7 files changed, 2774 insertions(+), 3 deletions(-) - -Index: linux-2.6.20.7/arch/arm/mach-pxa/spitz.c -=================================================================== ---- linux-2.6.20.7.orig/arch/arm/mach-pxa/spitz.c 2007-04-21 12:21:53.000000000 -0300 -+++ linux-2.6.20.7/arch/arm/mach-pxa/spitz.c 2007-04-21 12:22:00.000000000 -0300 -@@ -348,6 +348,32 @@ - - - /* -+ * USB Client (Gadget/UDC) -+ */ -+static void spitz_udc_command(int cmd) -+{ -+ switch(cmd) { -+ case PXA2XX_UDC_CMD_CONNECT: -+ UP2OCR = UP2OCR_HXOE | UP2OCR_DMPUE | UP2OCR_DMPUBE; -+ break; -+ case PXA2XX_UDC_CMD_DISCONNECT: -+ //UP2OCR = UP2OCR_HXOE | UP2OCR_DMPUE | UP2OCR_DMPUBE; -+ break; -+ } -+} -+ -+static int spitz_udc_detect(void) -+{ -+ return 1; -+} -+ -+static struct pxa2xx_udc_mach_info spitz_udc_info __initdata = { -+ .udc_is_connected = spitz_udc_detect, -+ .udc_command = spitz_udc_command, -+}; -+ -+ -+/* - * USB Host (OHCI) - */ - static int spitz_ohci_init(struct device *dev) -@@ -498,6 +524,7 @@ - pxa_gpio_mode(SPITZ_GPIO_HSYNC | GPIO_IN); - - platform_add_devices(devices, ARRAY_SIZE(devices)); -+ pxa_set_udc_info(&spitz_udc_info); - pxa_set_mci_info(&spitz_mci_platform_data); - pxa_set_ohci_info(&spitz_ohci_platform_data); - pxa_set_ficp_info(&spitz_ficp_platform_data); -Index: linux-2.6.20.7/drivers/usb/gadget/Kconfig -=================================================================== ---- linux-2.6.20.7.orig/drivers/usb/gadget/Kconfig 2007-04-21 12:21:53.000000000 -0300 -+++ linux-2.6.20.7/drivers/usb/gadget/Kconfig 2007-04-21 12:22:00.000000000 -0300 -@@ -121,6 +121,26 @@ - default y if USB_ETH - default y if USB_G_SERIAL - -+config USB_GADGET_PXA27X -+ boolean "PXA 27x" -+ depends on ARCH_PXA && PXA27x -+ help -+ Intel's PXA 27x series XScale ARM-5TE processors include -+ an integrated full speed USB 1.1 device controller. -+ -+ It has 23 endpoints, as well as endpoint zero (for control -+ transfers). -+ -+ Say "y" to link the driver statically, or "m" to build a -+ dynamically linked module called "pxa27x_udc" and force all -+ gadget drivers to also be dynamically linked. -+ -+config USB_PXA27X -+ tristate -+ depends on USB_GADGET_PXA27X -+ default USB_GADGET -+ select USB_GADGET_SELECTED -+ - config USB_GADGET_GOKU - boolean "Toshiba TC86C001 'Goku-S'" - depends on PCI -Index: linux-2.6.20.7/drivers/usb/gadget/Makefile -=================================================================== ---- linux-2.6.20.7.orig/drivers/usb/gadget/Makefile 2007-04-21 12:21:53.000000000 -0300 -+++ linux-2.6.20.7/drivers/usb/gadget/Makefile 2007-04-21 12:22:00.000000000 -0300 -@@ -4,6 +4,7 @@ - obj-$(CONFIG_USB_DUMMY_HCD) += dummy_hcd.o - obj-$(CONFIG_USB_NET2280) += net2280.o - obj-$(CONFIG_USB_PXA2XX) += pxa2xx_udc.o -+obj-$(CONFIG_USB_PXA27X) += pxa27x_udc.o - obj-$(CONFIG_USB_GOKU) += goku_udc.o - obj-$(CONFIG_USB_OMAP) += omap_udc.o - obj-$(CONFIG_USB_LH7A40X) += lh7a40x_udc.o -Index: linux-2.6.20.7/drivers/usb/gadget/pxa27x_udc.c -=================================================================== ---- /dev/null 1970-01-01 00:00:00.000000000 +0000 -+++ linux-2.6.20.7/drivers/usb/gadget/pxa27x_udc.c 2007-04-21 12:29:05.000000000 -0300 -@@ -0,0 +1,2412 @@ -+/* -+ * Handles the Intel 27x USB Device Controller (UDC) -+ * -+ * Copyright (C) 2002 Intrinsyc, Inc. (Frank Becker) -+ * Copyright (C) 2003 Robert Schwebel, Pengutronix -+ * Copyright (C) 2003 Benedikt Spranger, Pengutronix -+ * Copyright (C) 2003 David Brownell -+ * Copyright (C) 2003 Joshua Wise -+ * Copyright (C) 2004 Intel Corporation -+ * Copyright (C) 2005 SDG Systems, LLC (Aric Blumer) -+ * Copyright (C) 2005-2006 Openedhand Ltd. (Richard Purdie) -+ * -+ * 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 -+ * -+ */ -+ -+#undef DEBUG -+//#define DEBUG 1 -+//#define VERBOSE DBG_VERBOSE -+ -+#include <linux/module.h> -+#include <linux/kernel.h> -+#include <linux/ioport.h> -+#include <linux/types.h> -+#include <linux/version.h> -+#include <linux/errno.h> -+#include <linux/platform_device.h> -+#include <linux/delay.h> -+#include <linux/sched.h> -+#include <linux/slab.h> -+#include <linux/init.h> -+#include <linux/timer.h> -+#include <linux/list.h> -+#include <linux/interrupt.h> -+#include <linux/proc_fs.h> -+#include <linux/mm.h> -+#include <linux/device.h> -+#include <linux/dma-mapping.h> -+ -+#include <asm/byteorder.h> -+#include <asm/dma.h> -+#include <asm/io.h> -+#include <asm/irq.h> -+#include <asm/system.h> -+#include <asm/mach-types.h> -+#include <asm/unaligned.h> -+#include <asm/hardware.h> -+#include <asm/arch/pxa-regs.h> -+ -+#include <linux/usb_ch9.h> -+#include <linux/usb_gadget.h> -+ -+#include <asm/arch/udc.h> -+ -+/* -+ * This driver handles the USB Device Controller (UDC) in Intel's PXA 27x -+ * series processors. -+ * -+ * Such controller drivers work with a gadget driver. The gadget driver -+ * returns descriptors, implements configuration and data protocols used -+ * by the host to interact with this device, and allocates endpoints to -+ * the different protocol interfaces. The controller driver virtualizes -+ * usb hardware so that the gadget drivers will be more portable. -+ * -+ * This UDC hardware wants to implement a bit too much USB protocol. The -+ * biggest issue is that the endpoints have to be setup before the controller -+ * can be enabled and each endpoint can only have one configuration, interface -+ * and alternative interface number. Once enabled, these cannot be changed -+ * without a controller reset. -+ * -+ * Intel Errata #22 mentions issues when changing alternate interface. -+ * The exact meaning of this remains uncertain as gadget drivers using alternate -+ * interfaces such as CDC-Ethernet appear to work... -+ */ -+ -+#define DRIVER_VERSION "01-01-2006" -+#define DRIVER_DESC "PXA 27x USB Device Controller driver" -+ -+static const char driver_name [] = "pxa27x_udc"; -+ -+static const char ep0name [] = "ep0"; -+ -+ -+#define USE_DMA -+//#undef USE_DMA -+ -+#ifdef CONFIG_PROC_FS -+#define UDC_PROC_FILE -+#endif -+ -+#include "pxa27x_udc.h" -+ -+#ifdef USE_DMA -+static int use_dma = 1; -+module_param(use_dma, bool, 0); -+MODULE_PARM_DESC(use_dma, "true to use dma"); -+ -+static void dma_nodesc_handler(int dmach, void *_ep); -+static void kick_dma(struct pxa27x_ep *ep, struct pxa27x_request *req); -+ -+#define DMASTR " (dma support)" -+ -+#else /* !USE_DMA */ -+#define DMASTR " (pio only)" -+#endif -+ -+#define UDCISR0_IR0 0x3 -+#define UDCISR_INT_MASK (UDC_INT_FIFOERROR | UDC_INT_PACKETCMP) -+#define UDCICR_INT_MASK UDCISR_INT_MASK -+ -+#define UDCCSR_MASK (UDCCSR_FST | UDCCSR_DME) -+ -+static void pxa27x_ep_fifo_flush(struct usb_ep *ep); -+static void nuke(struct pxa27x_ep *, int status); -+static void udc_init_ep(struct pxa27x_udc *dev); -+ -+ -+/* -+ * Endpoint Functions -+ */ -+static void pio_irq_enable(int ep_num) -+{ -+ if (ep_num < 16) -+ UDCICR0 |= 3 << (ep_num * 2); -+ else { -+ ep_num -= 16; -+ UDCICR1 |= 3 << (ep_num * 2); -+ } -+} -+ -+static void pio_irq_disable(int ep_num) -+{ -+ ep_num &= 0xf; -+ if (ep_num < 16) -+ UDCICR0 &= ~(3 << (ep_num * 2)); -+ else { -+ ep_num -= 16; -+ UDCICR1 &= ~(3 << (ep_num * 2)); -+ } -+} -+ -+/* The UDCCR reg contains mask and interrupt status bits, -+ * so using '|=' isn't safe as it may ack an interrupt. -+ */ -+#define UDCCR_MASK_BITS (UDCCR_OEN | UDCCR_UDE) -+ -+static inline void udc_set_mask_UDCCR(int mask) -+{ -+ UDCCR = (UDCCR & UDCCR_MASK_BITS) | (mask & UDCCR_MASK_BITS); -+} -+ -+static inline void udc_clear_mask_UDCCR(int mask) -+{ -+ UDCCR = (UDCCR & UDCCR_MASK_BITS) & ~(mask & UDCCR_MASK_BITS); -+} -+ -+static inline void udc_ack_int_UDCCR(int mask) -+{ -+ /* udccr contains the bits we dont want to change */ -+ __u32 udccr = UDCCR & UDCCR_MASK_BITS; -+ -+ UDCCR = udccr | (mask & ~UDCCR_MASK_BITS); -+} -+ -+/* -+ * Endpoint enable/disable -+ * -+ * Not much to do here as the ep_alloc function sets up most things. Once -+ * enabled, not much of the pxa27x configuration can be changed. -+ * -+ */ -+static int pxa27x_ep_enable(struct usb_ep *_ep, const struct usb_endpoint_descriptor *desc) -+{ -+ struct pxa27x_virt_ep *virt_ep = container_of(_ep, struct pxa27x_virt_ep, usb_ep); -+ struct pxa27x_ep *ep = virt_ep->pxa_ep; -+ struct pxa27x_udc *dev; -+ -+ if (!_ep || !desc || _ep->name == ep0name -+ || desc->bDescriptorType != USB_DT_ENDPOINT -+ || ep->fifo_size < le16_to_cpu(desc->wMaxPacketSize)) { -+ dev_err(ep->dev->dev, "%s, bad ep or descriptor\n", __FUNCTION__); -+ return -EINVAL; -+ } -+ -+ /* xfer types must match, except that interrupt ~= bulk */ -+ if( ep->ep_type != USB_ENDPOINT_XFER_BULK -+ && desc->bmAttributes != USB_ENDPOINT_XFER_INT) { -+ dev_err(ep->dev->dev, "%s, %s type mismatch\n", __FUNCTION__, _ep->name); -+ return -EINVAL; -+ } -+ -+ /* hardware _could_ do smaller, but driver doesn't */ -+ if ((desc->bmAttributes == USB_ENDPOINT_XFER_BULK -+ && le16_to_cpu (desc->wMaxPacketSize) -+ != BULK_FIFO_SIZE) -+ || !desc->wMaxPacketSize) { -+ dev_err(ep->dev->dev, "%s, bad %s maxpacket\n", __FUNCTION__, _ep->name); -+ return -ERANGE; -+ } -+ -+ dev = ep->dev; -+ if (!dev->driver || dev->gadget.speed == USB_SPEED_UNKNOWN) { -+ dev_err(ep->dev->dev, "%s, bogus device state\n", __FUNCTION__); -+ return -ESHUTDOWN; -+ } -+ -+ ep->desc = desc; -+ ep->dma = -1; -+ ep->stopped = 0; -+ ep->pio_irqs = ep->dma_irqs = 0; -+ ep->usb_ep->maxpacket = le16_to_cpu(desc->wMaxPacketSize); -+ -+ /* flush fifo (mostly for OUT buffers) */ -+ pxa27x_ep_fifo_flush(_ep); -+ -+ /* ... reset halt state too, if we could ... */ -+ -+#ifdef USE_DMA -+ /* for (some) bulk and ISO endpoints, try to get a DMA channel and -+ * bind it to the endpoint. otherwise use PIO. -+ */ -+ dev_dbg(ep->dev->dev, "%s: called attributes=%d\n", __FUNCTION__, ep->ep_type); -+ switch (ep->ep_type) { -+ case USB_ENDPOINT_XFER_ISOC: -+ if (le16_to_cpu(desc->wMaxPacketSize) % 32) -+ break; -+ // fall through -+ case USB_ENDPOINT_XFER_BULK: -+ if (!use_dma || !ep->reg_drcmr) -+ break; -+ ep->dma = pxa_request_dma((char *)_ep->name, (le16_to_cpu(desc->wMaxPacketSize) > 64) -+ ? DMA_PRIO_MEDIUM : DMA_PRIO_LOW, dma_nodesc_handler, ep); -+ if (ep->dma >= 0) { -+ *ep->reg_drcmr = DRCMR_MAPVLD | ep->dma; -+ dev_dbg(ep->dev->dev, "%s using dma%d\n", _ep->name, ep->dma); -+ } -+ default: -+ break; -+ } -+#endif -+ DBG(DBG_VERBOSE, "enabled %s\n", _ep->name); -+ return 0; -+} -+ -+static int pxa27x_ep_disable(struct usb_ep *_ep) -+{ -+ struct pxa27x_virt_ep *virt_ep = container_of(_ep, struct pxa27x_virt_ep, usb_ep); -+ struct pxa27x_ep *ep = virt_ep->pxa_ep; -+ unsigned long flags; -+ -+ if (!_ep || !ep->desc) { -+ dev_err(ep->dev->dev, "%s, %s not enabled\n", __FUNCTION__, -+ _ep ? _ep->name : NULL); -+ return -EINVAL; -+ } -+ local_irq_save(flags); -+ nuke(ep, -ESHUTDOWN); -+ -+#ifdef USE_DMA -+ if (ep->dma >= 0) { -+ *ep->reg_drcmr = 0; -+ pxa_free_dma(ep->dma); -+ ep->dma = -1; -+ } -+#endif -+ -+ /* flush fifo (mostly for IN buffers) */ -+ pxa27x_ep_fifo_flush(_ep); -+ -+ ep->desc = 0; -+ ep->stopped = 1; -+ -+ local_irq_restore(flags); -+ DBG(DBG_VERBOSE, "%s disabled\n", _ep->name); -+ return 0; -+} -+ -+ -+ -+/* for the pxa27x, these can just wrap kmalloc/kfree. gadget drivers -+ * must still pass correctly initialized endpoints, since other controller -+ * drivers may care about how it's currently set up (dma issues etc). -+ */ -+ -+/* -+ * pxa27x_ep_alloc_request - allocate a request data structure -+ */ -+static struct usb_request * -+pxa27x_ep_alloc_request(struct usb_ep *_ep, unsigned gfp_flags) -+{ -+ struct pxa27x_request *req; -+ -+ req = kzalloc(sizeof *req, gfp_flags); -+ if (!req) -+ return 0; -+ -+ INIT_LIST_HEAD(&req->queue); -+ return &req->req; -+} -+ -+ -+/* -+ * pxa27x_ep_free_request - deallocate a request data structure -+ */ -+static void -+pxa27x_ep_free_request(struct usb_ep *_ep, struct usb_request *_req) -+{ -+ struct pxa27x_request *req; -+ -+ req = container_of(_req, struct pxa27x_request, req); -+ WARN_ON(!list_empty(&req->queue)); -+ kfree(req); -+} -+ -+ -+/* PXA cache needs flushing with DMA I/O (it's dma-incoherent), but there's -+ * no device-affinity and the heap works perfectly well for i/o buffers. -+ * It wastes much less memory than dma_alloc_coherent() would, and even -+ * prevents cacheline (32 bytes wide) sharing problems. -+ */ -+static void * -+pxa27x_ep_alloc_buffer(struct usb_ep *_ep, unsigned bytes, dma_addr_t *dma, unsigned gfp_flags) -+{ -+ char *retval; -+ -+ retval = kmalloc(bytes, gfp_flags & ~(__GFP_DMA|__GFP_HIGHMEM)); -+ if (retval) -+ *dma = virt_to_bus(retval); -+ return retval; -+} -+ -+static void -+pxa27x_ep_free_buffer(struct usb_ep *_ep, void *buf, dma_addr_t dma, unsigned bytes) -+{ -+ kfree(buf); -+} -+ -+/*-------------------------------------------------------------------------*/ -+ -+/* -+ * done - retire a request; caller blocked irqs -+ */ -+static void done(struct pxa27x_ep *ep, struct pxa27x_request *req, int status) -+{ -+ list_del_init(&req->queue); -+ if (likely (req->req.status == -EINPROGRESS)) -+ req->req.status = status; -+ else -+ status = req->req.status; -+ -+ if (status && status != -ESHUTDOWN) -+ DBG(DBG_VERBOSE, "complete %s req %p stat %d len %u/%u\n", -+ ep->usb_ep->name, &req->req, status, -+ req->req.actual, req->req.length); -+ -+ /* don't modify queue heads during completion callback */ -+ req->req.complete(ep->usb_ep, &req->req); -+} -+ -+ -+static inline void ep0_idle(struct pxa27x_udc *dev) -+{ -+ dev->ep0state = EP0_IDLE; -+} -+ -+static int write_packet(volatile u32 *uddr, struct pxa27x_request *req, unsigned max) -+{ -+ u32 *buf; -+ int length, count, remain; -+ -+ buf = (u32*)(req->req.buf + req->req.actual); -+ prefetch(buf); -+ -+ /* how big will this packet be? */ -+ length = min(req->req.length - req->req.actual, max); -+ req->req.actual += length; -+ -+ remain = length & 0x3; -+ count = length & ~(0x3); -+ -+ //dev_dbg(ep->dev->dev, "Length %d, Remain %d, Count %d\n",length, remain, count); -+ -+ while (likely(count)) { -+ //dev_dbg(ep->dev->dev, "Sending:0x%x\n", *buf); -+ *uddr = *buf++; -+ count -= 4; -+ } -+ -+ if (remain) { -+ volatile u8* reg=(u8*)uddr; -+ char *rd =(u8*)buf; -+ -+ while (remain--) { -+ *reg=*rd++; -+ } -+ } -+ -+ return length; -+} -+ -+/* -+ * write to an IN endpoint fifo, as many packets as possible. -+ * irqs will use this to write the rest later. -+ * caller guarantees at least one packet buffer is ready (or a zlp). -+ */ -+static int -+write_fifo(struct pxa27x_ep *ep, struct pxa27x_request *req) -+{ -+ unsigned max; -+ -+ max = le16_to_cpu(ep->desc->wMaxPacketSize); -+ do { -+ int count, is_last, is_short; -+ -+ //dev_dbg(ep->dev->dev, "write_fifo7 %x\n", *ep->reg_udccsr); -+ -+ if (*ep->reg_udccsr & UDCCSR_PC) { -+ //dev_dbg(ep->dev->dev, "Transmit Complete\n"); -+ *ep->reg_udccsr = UDCCSR_PC | (*ep->reg_udccsr & UDCCSR_MASK); -+ } -+ -+ if (*ep->reg_udccsr & UDCCSR_TRN) { -+ //dev_dbg(ep->dev->dev, "Clearing Underrun\n"); -+ *ep->reg_udccsr = UDCCSR_TRN | (*ep->reg_udccsr & UDCCSR_MASK); -+ } -+ //dev_dbg(ep->dev->dev, "write_fifo8 %x\n", *ep->reg_udccsr); -+ -+ count = write_packet(ep->reg_udcdr, req, max); -+ -+ /* last packet is usually short (or a zlp) */ -+ if (unlikely (count != max)) -+ is_last = is_short = 1; -+ else { -+ if (likely(req->req.length != req->req.actual) -+ || req->req.zero) -+ is_last = 0; -+ else -+ is_last = 1; -+ /* interrupt/iso maxpacket may not fill the fifo */ -+ is_short = unlikely (max < ep->fifo_size); -+ } -+ -+ //dev_dbg(ep->dev->dev, "write_fifo0 %x\n", *ep->reg_udccsr); -+ -+ dev_dbg(ep->dev->dev, "wrote %s count:%d bytes%s%s %d left %p\n", -+ ep->usb_ep->name, count, -+ is_last ? "/L" : "", is_short ? "/S" : "", -+ req->req.length - req->req.actual, &req->req); -+ -+ /* let loose that packet. maybe try writing another one, -+ * double buffering might work. -+ */ -+ -+ if (is_short) -+ *ep->reg_udccsr = UDCCSR_SP | (*ep->reg_udccsr & UDCCSR_MASK); -+ -+ dev_dbg(ep->dev->dev, "write_fifo0.5 %x\n", *ep->reg_udccsr); -+ -+ /* requests complete when all IN data is in the FIFO */ -+ if (is_last) { -+ done(ep, req, 0); -+ if (list_empty(&ep->queue) || unlikely(ep->dma >= 0)) { -+ pio_irq_disable(ep->pxa_ep_num); -+ //dev_dbg(ep->dev->dev, "write_fifo1 %x\n", *ep->reg_udccsr); -+#ifdef USE_DMA -+ /* unaligned data and zlps couldn't use dma */ -+ if (unlikely(!list_empty(&ep->queue))) { -+ req = list_entry(ep->queue.next, -+ struct pxa27x_request, queue); -+ kick_dma(ep,req); -+ return 0; -+ } -+#endif -+ } -+ //dev_dbg(ep->dev->dev, "write_fifo2 %x\n", *ep->reg_udccsr); -+ return 1; -+ } -+ -+ // TODO experiment: how robust can fifo mode tweaking be? -+ // double buffering is off in the default fifo mode, which -+ // prevents TFS from being set here. -+ -+ } while (*ep->reg_udccsr & UDCCSR_FS); -+ //dev_dbg(ep->dev->dev, "write_fifo2 %x\n", *ep->reg_udccsr); -+ return 0; -+} -+ -+/* caller asserts req->pending (ep0 irq status nyet cleared); starts -+ * ep0 data stage. these chips want very simple state transitions. -+ */ -+static inline -+void ep0start(struct pxa27x_udc *dev, u32 flags, const char *tag) -+{ -+ UDCCSR0 = flags|UDCCSR0_SA|UDCCSR0_OPC; -+ UDCISR0 = UDCICR_INT(0, UDC_INT_FIFOERROR | UDC_INT_PACKETCMP); -+ dev->req_pending = 0; -+ DBG(DBG_VERY_NOISY, "%s %s, %02x/%02x\n", -+ __FUNCTION__, tag, UDCCSR0, flags); -+} -+ -+static int -+write_ep0_fifo(struct pxa27x_ep *ep, struct pxa27x_request *req) -+{ -+ unsigned count; -+ int is_short; -+ -+ count = write_packet(&UDCDR0, req, EP0_FIFO_SIZE); -+ ep->dev->stats.write.bytes += count; -+ -+ /* last packet "must be" short (or a zlp) */ -+ is_short = (count != EP0_FIFO_SIZE); -+ -+ DBG(DBG_VERY_NOISY, "ep0in %d bytes %d left %p\n", count, -+ req->req.length - req->req.actual, &req->req); -+ -+ if (unlikely (is_short)) { -+ if (ep->dev->req_pending) -+ ep0start(ep->dev, UDCCSR0_IPR, "short IN"); -+ else -+ UDCCSR0 = UDCCSR0_IPR; -+ -+ count = req->req.length; -+ done(ep, req, 0); -+ ep0_idle(ep->dev); -+#if 0 -+ /* This seems to get rid of lost status irqs in some cases: -+ * host responds quickly, or next request involves config -+ * change automagic, or should have been hidden, or ... -+ * -+ * FIXME get rid of all udelays possible... -+ */ -+ if (count >= EP0_FIFO_SIZE) { -+ count = 100; -+ do { -+ if ((UDCCSR0 & UDCCSR0_OPC) != 0) { -+ /* clear OPC, generate ack */ -+ UDCCSR0 = UDCCSR0_OPC; -+ break; -+ } -+ count--; -+ udelay(1); -+ } while (count); -+ } -+#endif -+ } else if (ep->dev->req_pending) -+ ep0start(ep->dev, 0, "IN"); -+ return is_short; -+} -+ -+ -+/* -+ * read_fifo - unload packet(s) from the fifo we use for usb OUT -+ * transfers and put them into the request. caller should have made -+ * sure there's at least one packet ready. -+ * -+ * returns true if the request completed because of short packet or the -+ * request buffer having filled (and maybe overran till end-of-packet). -+ */ -+static int read_fifo(struct pxa27x_ep *ep, struct pxa27x_request *req) -+{ -+ for (;;) { -+ u32 *buf; -+ int bufferspace, count, is_short; -+ -+ /* make sure there's a packet in the FIFO.*/ -+ if (unlikely ((*ep->reg_udccsr & UDCCSR_PC) == 0)) -+ break; -+ buf =(u32*) (req->req.buf + req->req.actual); -+ prefetchw(buf); -+ bufferspace = req->req.length - req->req.actual; -+ -+ /* read all bytes from this packet */ -+ if (likely (*ep->reg_udccsr & UDCCSR_BNE)) { -+ count = 0x3ff & *ep->reg_udcbcr; -+ req->req.actual += min(count, bufferspace); -+ } else /* zlp */ -+ count = 0; -+ -+ is_short = (count < ep->usb_ep->maxpacket); -+ dev_dbg(ep->dev->dev, "read %s udccsr:%02x, count:%d bytes%s req %p %d/%d\n", -+ ep->usb_ep->name, *ep->reg_udccsr, count, -+ is_short ? "/S" : "", -+ &req->req, req->req.actual, req->req.length); -+ -+ count = min(count, bufferspace); -+ while (likely (count > 0)) { -+ *buf++ = *ep->reg_udcdr; -+ count -= 4; -+ } -+ dev_dbg(ep->dev->dev, "Buf:0x%p\n", req->req.buf); -+ -+ *ep->reg_udccsr = UDCCSR_PC; -+ /* RPC/RSP/RNE could now reflect the other packet buffer */ -+ -+ /* completion */ -+ if (is_short || req->req.actual == req->req.length) { -+ done(ep, req, 0); -+ if (list_empty(&ep->queue)) -+ pio_irq_disable(ep->pxa_ep_num); -+ return 1; -+ } -+ -+ /* finished that packet. the next one may be waiting... */ -+ } -+ return 0; -+} -+ -+/* -+ * special ep0 version of the above. no UBCR0 or double buffering; status -+ * handshaking is magic. most device protocols don't need control-OUT. -+ * CDC vendor commands (and RNDIS), mass storage CB/CBI, and some other -+ * protocols do use them. -+ */ -+static int read_ep0_fifo(struct pxa27x_ep *ep, struct pxa27x_request *req) -+{ -+ u32 *buf, word; -+ unsigned bufferspace; -+ -+ buf = (u32*) (req->req.buf + req->req.actual); -+ bufferspace = req->req.length - req->req.actual; -+ -+ while (UDCCSR0 & UDCCSR0_RNE) { -+ word = UDCDR0; -+ -+ if (unlikely (bufferspace == 0)) { -+ /* this happens when the driver's buffer -+ * is smaller than what the host sent. -+ * discard the extra data. -+ */ -+ if (req->req.status != -EOVERFLOW) -+ dev_info(ep->dev->dev, "%s overflow\n", ep->usb_ep->name); -+ req->req.status = -EOVERFLOW; -+ } else { -+ *buf++ = word; -+ req->req.actual += 4; -+ bufferspace -= 4; -+ } -+ } -+ -+ UDCCSR0 = UDCCSR0_OPC ; -+ -+ /* completion */ -+ if (req->req.actual >= req->req.length) -+ return 1; -+ -+ /* finished that packet. the next one may be waiting... */ -+ return 0; -+} -+ -+#ifdef USE_DMA -+ -+#define MAX_IN_DMA ((DCMD_LENGTH + 1) - BULK_FIFO_SIZE) -+static void kick_dma(struct pxa27x_ep *ep, struct pxa27x_request *req) -+{ -+ u32 dcmd = 0; -+ u32 len = req->req.length; -+ u32 buf = req->req.dma; -+ u32 fifo = io_v2p((u32)ep->reg_udcdr); -+ -+ buf += req->req.actual; -+ len -= req->req.actual; -+ ep->dma_con = 0; -+ -+ DMSG("%s: req:0x%p length:%d, actual:%d dma:%d\n", -+ __FUNCTION__, &req->req, req->req.length, -+ req->req.actual,ep->dma); -+ -+ /* no-descriptor mode can be simple for bulk-in, iso-in, iso-out */ -+ DCSR(ep->dma) = DCSR_NODESC; -+ if (buf & 0x3) -+ DALGN |= 1 << ep->dma; -+ else -+ DALGN &= ~(1 << ep->dma); -+ -+ if (ep->dir_in) { -+ DSADR(ep->dma) = buf; -+ DTADR(ep->dma) = fifo; -+ if (len > MAX_IN_DMA) { -+ len= MAX_IN_DMA; -+ ep->dma_con =1 ; -+ } else if (len >= ep->usb_ep->maxpacket) { -+ if ((ep->dma_con = (len % ep->usb_ep->maxpacket) != 0)) -+ len = ep->usb_ep->maxpacket; -+ } -+ dcmd = len | DCMD_BURST32 | DCMD_WIDTH4 | DCMD_ENDIRQEN -+ | DCMD_FLOWTRG | DCMD_INCSRCADDR; -+ } else { -+ DSADR(ep->dma) = fifo; -+ DTADR(ep->dma) = buf; -+ dcmd = len | DCMD_BURST32 | DCMD_WIDTH4 | DCMD_ENDIRQEN -+ | DCMD_FLOWSRC | DCMD_INCTRGADDR; -+ } -+ *ep->reg_udccsr = UDCCSR_DME; -+ DCMD(ep->dma) = dcmd; -+ DCSR(ep->dma) = DCSR_NODESC | DCSR_EORIRQEN \ -+ | ((ep->dir_in) ? DCSR_STOPIRQEN : 0); -+ *ep->reg_drcmr = ep->dma | DRCMR_MAPVLD; -+ DCSR(ep->dma) |= DCSR_RUN; -+} -+ -+static void cancel_dma(struct pxa27x_ep *ep) -+{ -+ struct pxa27x_request *req; -+ u32 tmp; -+ -+ if (DCSR(ep->dma) == 0 || list_empty(&ep->queue)) -+ return; -+ -+ DMSG("hehe dma:%d,dcsr:0x%x\n", ep->dma, DCSR(ep->dma)); -+ DCSR(ep->dma) = 0; -+ while ((DCSR(ep->dma) & DCSR_STOPSTATE) == 0) -+ cpu_relax(); -+ -+ req = list_entry(ep->queue.next, struct pxa27x_request, queue); -+ tmp = DCMD(ep->dma) & DCMD_LENGTH; -+ req->req.actual = req->req.length - tmp; -+ -+ /* the last tx packet may be incomplete, so flush the fifo. -+ * FIXME correct req.actual if we can -+ */ -+ *ep->reg_udccsr = UDCCSR_FEF; -+} -+ -+static void dma_nodesc_handler(int dmach, void *_ep) -+{ -+ struct pxa27x_ep *ep = _ep; -+ struct pxa27x_request *req, *req_next; -+ u32 dcsr, tmp, completed; -+ -+ local_irq_disable(); -+ -+ req = list_entry(ep->queue.next, struct pxa27x_request, queue); -+ -+ DMSG("%s, buf:0x%p\n",__FUNCTION__, req->req.buf); -+ -+ ep->dma_irqs++; -+ ep->dev->stats.irqs++; -+ -+ completed = 0; -+ -+ dcsr = DCSR(dmach); -+ DCSR(ep->dma) &= ~DCSR_RUN; -+ -+ if (dcsr & DCSR_BUSERR) { -+ DCSR(dmach) = DCSR_BUSERR; -+ dev_err(ep->dev->dev, "DMA Bus Error\n"); -+ req->req.status = -EIO; -+ completed = 1; -+ } else if (dcsr & DCSR_ENDINTR) { -+ DCSR(dmach) = DCSR_ENDINTR; -+ if (ep->dir_in) { -+ tmp = req->req.length - req->req.actual; -+ /* Last packet is a short one*/ -+ if (tmp < ep->usb_ep->maxpacket) { -+ int count = 0; -+ -+ *ep->reg_udccsr = UDCCSR_SP | \ -+ (*ep->reg_udccsr & UDCCSR_MASK); -+ /*Wait for packet out */ -+ while( (count++ < 10000) && \ -+ !(*ep->reg_udccsr & UDCCSR_FS)); -+ if (count >= 10000) -+ DMSG("Failed to send packet\n"); -+ else -+ DMSG("%s: short packet sent len:%d," -+ "length:%d,actual:%d\n", __FUNCTION__, -+ tmp, req->req.length, req->req.actual); -+ req->req.actual = req->req.length; -+ completed = 1; -+ /* There are still packets to transfer */ -+ } else if ( ep->dma_con) { -+ DMSG("%s: more packets,length:%d,actual:%d\n", -+ __FUNCTION__,req->req.length, -+ req->req.actual); -+ req->req.actual += ep->usb_ep->maxpacket; -+ completed = 0; -+ } else { -+ DMSG("%s: no more packets,length:%d," -+ "actual:%d\n", __FUNCTION__, -+ req->req.length, req->req.actual); -+ req->req.actual = req->req.length; -+ completed = 1; -+ } -+ } else { -+ req->req.actual = req->req.length; -+ completed = 1; -+ } -+ } else if (dcsr & DCSR_EORINTR) { //Only happened in OUT DMA -+ int remain,udccsr ; -+ -+ DCSR(dmach) = DCSR_EORINTR; -+ remain = DCMD(dmach) & DCMD_LENGTH; -+ req->req.actual = req->req.length - remain; -+ -+ udccsr = *ep->reg_udccsr; -+ if (udccsr & UDCCSR_SP) { -+ *ep->reg_udccsr = UDCCSR_PC | (udccsr & UDCCSR_MASK); -+ completed = 1; -+ } -+ DMSG("%s: length:%d actual:%d\n", -+ __FUNCTION__, req->req.length, req->req.actual); -+ } else -+ DMSG("%s: Others dma:%d DCSR:0x%x DCMD:0x%x\n", -+ __FUNCTION__, dmach, DCSR(dmach), DCMD(dmach)); -+ -+ if (likely(completed)) { -+ if (req->queue.next != &ep->queue) { -+ req_next = list_entry(req->queue.next, -+ struct pxa27x_request, queue); -+ kick_dma(ep, req_next); -+ } -+ done(ep, req, 0); -+ } else { -+ kick_dma(ep, req); -+ } -+ -+ local_irq_enable(); -+} -+ -+#endif -+/*-------------------------------------------------------------------------*/ -+ -+static int -+pxa27x_ep_queue(struct usb_ep *_ep, struct usb_request *_req, unsigned gfp_flags) -+{ -+ struct pxa27x_virt_ep *virt_ep; -+ struct pxa27x_ep *ep; -+ struct pxa27x_request *req; -+ struct pxa27x_udc *dev; -+ unsigned long flags; -+ -+ virt_ep = container_of(_ep, struct pxa27x_virt_ep, usb_ep); -+ ep = virt_ep->pxa_ep; -+ -+ req = container_of(_req, struct pxa27x_request, req); -+ if (unlikely (!_req || !_req->complete || !_req->buf|| -+ !list_empty(&req->queue))) { -+ DMSG("%s, bad params\n", __FUNCTION__); -+ return -EINVAL; -+ } -+ -+ if (unlikely (!_ep || (!ep->desc && _ep->name != ep0name))) { -+ DMSG("%s, bad ep\n", __FUNCTION__); -+ return -EINVAL; -+ } -+ -+ DMSG("%s, ep point %d is queue\n", __FUNCTION__, ep->ep_num); -+ -+ dev = ep->dev; -+ if (unlikely (!dev->driver -+ || dev->gadget.speed == USB_SPEED_UNKNOWN)) { -+ DMSG("%s, bogus device state\n", __FUNCTION__); -+ return -ESHUTDOWN; -+ } -+ -+ /* iso is always one packet per request, that's the only way -+ * we can report per-packet status. that also helps with dma. -+ */ -+ if (unlikely (ep->ep_type == USB_ENDPOINT_XFER_ISOC -+ && req->req.length > le16_to_cpu -+ (ep->desc->wMaxPacketSize))) -+ return -EMSGSIZE; -+ -+#ifdef USE_DMA -+ // FIXME caller may already have done the dma mapping -+ if (ep->dma >= 0) { -+ _req->dma = dma_map_single(dev->dev, _req->buf, _req->length, -+ (ep->dir_in) ? DMA_TO_DEVICE : DMA_FROM_DEVICE); -+ } -+#endif -+ -+ DBG(DBG_NOISY, "%s queue req %p, len %d buf %p\n", -+ _ep->name, _req, _req->length, _req->buf); -+ -+ local_irq_save(flags); -+ -+ _req->status = -EINPROGRESS; -+ _req->actual = 0; -+ -+ /* kickstart this i/o queue? */ -+ if (list_empty(&ep->queue) && !ep->stopped) { -+ if (ep->desc == 0 /* ep0 */) { -+ unsigned length = _req->length; -+ -+ switch (dev->ep0state) { -+ case EP0_IN_DATA_PHASE: -+ dev->stats.write.ops++; -+ if (write_ep0_fifo(ep, req)) -+ req = 0; -+ break; -+ -+ case EP0_OUT_DATA_PHASE: -+ dev->stats.read.ops++; -+ if (dev->req_pending) -+ ep0start(dev, UDCCSR0_IPR, "OUT"); -+ if (length == 0 || ((UDCCSR0 & UDCCSR0_RNE) != 0 -+ && read_ep0_fifo(ep, req))) { -+ ep0_idle(dev); -+ done(ep, req, 0); -+ req = 0; -+ } -+ break; -+ case EP0_NO_ACTION: -+ ep0_idle(dev); -+ req=0; -+ break; -+ default: -+ DMSG("ep0 i/o, odd state %d\n", dev->ep0state); -+ local_irq_restore (flags); -+ return -EL2HLT; -+ } -+#ifdef USE_DMA -+ /* either start dma or prime pio pump */ -+ } else if (ep->dma >= 0) { -+ kick_dma(ep, req); -+#endif -+ /* can the FIFO can satisfy the request immediately? */ -+ } else if (ep->dir_in && (*ep->reg_udccsr & UDCCSR_FS) != 0 -+ && write_fifo(ep, req)) { -+ req = 0; -+ } else if ((*ep->reg_udccsr & UDCCSR_FS) != 0 -+ && read_fifo(ep, req)) { -+ req = 0; -+ } -+ DMSG("req:%p,ep->desc:%p,ep->dma:%d\n", req, ep->desc, ep->dma); -+ if (likely (req && ep->desc) && ep->dma < 0) -+ pio_irq_enable(ep->pxa_ep_num); -+ } -+ -+ /* pio or dma irq handler advances the queue. */ -+ if (likely (req != 0)) -+ list_add_tail(&req->queue, &ep->queue); -+ local_irq_restore(flags); -+ -+ return 0; -+} -+ -+ -+/* -+ * nuke - dequeue ALL requests -+ */ -+static void nuke(struct pxa27x_ep *ep, int status) -+{ -+ struct pxa27x_request *req; -+ -+ /* called with irqs blocked */ -+#ifdef USE_DMA -+ if (ep->dma >= 0 && !ep->stopped) -+ cancel_dma(ep); -+#endif -+ while (!list_empty(&ep->queue)) { -+ req = list_entry(ep->queue.next, struct pxa27x_request, queue); -+ done(ep, req, status); -+ } -+ if (ep->desc) -+ pio_irq_disable(ep->pxa_ep_num); -+} -+ -+ -+/* dequeue JUST ONE request */ -+static int pxa27x_ep_dequeue(struct usb_ep *_ep, struct usb_request *_req) -+{ -+ struct pxa27x_virt_ep *virt_ep = container_of(_ep, struct pxa27x_virt_ep, usb_ep); -+ struct pxa27x_ep *ep = virt_ep->pxa_ep; -+ struct pxa27x_request *req; -+ unsigned long flags; -+ -+ if (!_ep || _ep->name == ep0name) -+ return -EINVAL; -+ -+ local_irq_save(flags); -+ -+ /* make sure it's actually queued on this endpoint */ -+ list_for_each_entry(req, &ep->queue, queue) { -+ if (&req->req == _req) -+ break; -+ } -+ if (&req->req != _req) { -+ local_irq_restore(flags); -+ return -EINVAL; -+ } -+ -+#ifdef USE_DMA -+ if (ep->dma >= 0 && ep->queue.next == &req->queue && !ep->stopped) { -+ cancel_dma(ep); -+ done(ep, req, -ECONNRESET); -+ /* restart i/o */ -+ if (!list_empty(&ep->queue)) { -+ req = list_entry(ep->queue.next, -+ struct pxa27x_request, queue); -+ kick_dma(ep, req); -+ } -+ } else -+#endif -+ done(ep, req, -ECONNRESET); -+ -+ local_irq_restore(flags); -+ return 0; -+} -+ -+/*-------------------------------------------------------------------------*/ -+ -+static int pxa27x_ep_set_halt(struct usb_ep *_ep, int value) -+{ -+ struct pxa27x_virt_ep *virt_ep = container_of(_ep, struct pxa27x_virt_ep, usb_ep); -+ struct pxa27x_ep *ep = virt_ep->pxa_ep; -+ unsigned long flags; -+ -+ DMSG("%s is called\n", __FUNCTION__); -+ if (unlikely (!_ep || (!ep->desc && _ep->name != ep0name)) -+ || ep->ep_type == USB_ENDPOINT_XFER_ISOC) { -+ DMSG("%s, bad ep\n", __FUNCTION__); -+ return -EINVAL; -+ } -+ if (value == 0) { -+ /* this path (reset toggle+halt) is needed to implement -+ * SET_INTERFACE on normal hardware. but it can't be -+ * done from software on the PXA UDC, and the hardware -+ * forgets to do it as part of SET_INTERFACE automagic. -+ */ -+ DMSG("only host can clear %s halt\n", _ep->name); -+ return -EROFS; -+ } -+ -+ local_irq_save(flags); -+ -+ if (ep->dir_in && ((*ep->reg_udccsr & UDCCSR_FS) == 0 -+ || !list_empty(&ep->queue))) { -+ local_irq_restore(flags); -+ return -EAGAIN; -+ } -+ -+ /* FST bit is the same for control, bulk in, bulk out, interrupt in */ -+ *ep->reg_udccsr = UDCCSR_FST|UDCCSR_FEF; -+ -+ /* ep0 needs special care */ -+ if (!ep->desc) { -+ start_watchdog(ep->dev); -+ ep->dev->req_pending = 0; -+ ep->dev->ep0state = EP0_STALL; -+ -+ /* and bulk/intr endpoints like dropping stalls too */ -+ } else { -+ unsigned i; -+ for (i = 0; i < 1000; i += 20) { -+ if (*ep->reg_udccsr & UDCCSR_SST) -+ break; -+ udelay(20); -+ } -+ } -+ local_irq_restore(flags); -+ -+ DBG(DBG_VERBOSE, "%s halt\n", _ep->name); -+ return 0; -+} -+ -+static int pxa27x_ep_fifo_status(struct usb_ep *_ep) -+{ -+ struct pxa27x_virt_ep *virt_ep = container_of(_ep, struct pxa27x_virt_ep, usb_ep); -+ struct pxa27x_ep *ep = virt_ep->pxa_ep; -+ -+ if (!_ep) { -+ DMSG("%s, bad ep\n", __FUNCTION__); -+ return -ENODEV; -+ } -+ /* pxa can't report unclaimed bytes from IN fifos */ -+ if (ep->dir_in) -+ return -EOPNOTSUPP; -+ if (ep->dev->gadget.speed == USB_SPEED_UNKNOWN -+ || (*ep->reg_udccsr & UDCCSR_FS) == 0) -+ return 0; -+ else -+ return (*ep->reg_udcbcr & 0xfff) + 1; -+} -+ -+static void pxa27x_ep_fifo_flush(struct usb_ep *_ep) -+{ -+ struct pxa27x_virt_ep *virt_ep = container_of(_ep, struct pxa27x_virt_ep, usb_ep); -+ struct pxa27x_ep *ep = virt_ep->pxa_ep; -+ -+ DMSG("pxa27x_ep_fifo_flush\n"); -+ -+ if (!_ep || _ep->name == ep0name || !list_empty(&ep->queue)) { -+ DMSG("%s, bad ep\n", __FUNCTION__); -+ return; -+ } -+ -+ /* toggle and halt bits stay unchanged */ -+ -+ /* for OUT, just read and discard the FIFO contents. */ -+ if (!ep->dir_in) { -+ while (((*ep->reg_udccsr) & UDCCSR_BNE) != 0) -+ (void) *ep->reg_udcdr; -+ return; -+ } -+ -+ /* most IN status is the same, but ISO can't stall */ -+ *ep->reg_udccsr = UDCCSR_PC|UDCCSR_FST|UDCCSR_TRN -+ | (ep->ep_type == USB_ENDPOINT_XFER_ISOC) -+ ? 0 : UDCCSR_SST; -+} -+ -+ -+static struct usb_ep_ops pxa27x_ep_ops = { -+ .enable = pxa27x_ep_enable, -+ .disable = pxa27x_ep_disable, -+ -+ .alloc_request = pxa27x_ep_alloc_request, -+ .free_request = pxa27x_ep_free_request, -+ -+ .alloc_buffer = pxa27x_ep_alloc_buffer, -+ .free_buffer = pxa27x_ep_free_buffer, -+ -+ .queue = pxa27x_ep_queue, -+ .dequeue = pxa27x_ep_dequeue, -+ -+ .set_halt = pxa27x_ep_set_halt, -+ .fifo_status = pxa27x_ep_fifo_status, -+ .fifo_flush = pxa27x_ep_fifo_flush, -+}; -+ -+ -+/* --------------------------------------------------------------------------- -+ * device-scoped parts of the api to the usb controller hardware -+ * --------------------------------------------------------------------------- -+ */ -+ -+static inline unsigned int validate_fifo_size(u8 bmAttributes) -+{ -+ switch (bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) { -+ case USB_ENDPOINT_XFER_CONTROL: -+ return EP0_FIFO_SIZE; -+ break; -+ case USB_ENDPOINT_XFER_ISOC: -+ return ISO_FIFO_SIZE; -+ break; -+ case USB_ENDPOINT_XFER_BULK: -+ return BULK_FIFO_SIZE; -+ break; -+ case USB_ENDPOINT_XFER_INT: -+ return INT_FIFO_SIZE; -+ break; -+ default: -+ break; -+ } -+} -+ -+static void pxa27x_ep_free(struct usb_gadget *gadget, struct usb_ep *_ep) -+{ -+ struct pxa27x_udc *dev = the_controller; -+ struct pxa27x_virt_ep *virt_ep; -+ int i; -+ -+ virt_ep = container_of(_ep, struct pxa27x_virt_ep, usb_ep); -+ -+ for (i = 1; i < UDC_EP_NUM; i++) { -+ if (dev->ep[i].usb_ep == &virt_ep->usb_ep) { -+ if (dev->ep[i].desc) { -+ virt_ep->pxa_ep = &dev->ep[i]; -+ pxa27x_ep_disable(&virt_ep->usb_ep); -+ } -+ dev->ep[i].usb_ep = NULL; -+ } -+ } -+ -+ if (!list_empty(&virt_ep->usb_ep.ep_list)) -+ list_del_init(&virt_ep->usb_ep.ep_list); -+ -+ kfree(virt_ep->usb_ep.name); -+ kfree(virt_ep); -+} -+ -+static void pxa27x_ep_freeall(struct usb_gadget *gadget) -+{ -+ struct pxa27x_udc *dev = the_controller; -+ int i; -+ -+ for (i = 1; i < UDC_EP_NUM; i++) { -+ if(dev->ep[i].usb_ep) -+ pxa27x_ep_free(gadget, dev->ep[i].usb_ep); -+ } -+} -+ -+#define NAME_SIZE 18 -+ -+static int pxa27x_find_free_ep(struct pxa27x_udc *dev) -+{ -+ int i; -+ for (i = 1; i < UDC_EP_NUM; i++) { -+ if(!dev->ep[i].assigned) -+ return i; -+ } -+ return -1; -+} -+ -+/* -+ * Endpoint Allocation/Configuration -+ * -+ * pxa27x endpoint configuration is fixed when the device is enabled. Any pxa -+ * endpoint is only active in one configuration, interface and alternate -+ * interface combination so to support gadget drivers, we map one usb_ep to -+ * one of several pxa ep's. One pxa endpoint is assigned per configuration -+ * combination. -+ */ -+static struct usb_ep* pxa27x_ep_alloc(struct usb_gadget *gadget, struct usb_endpoint_descriptor *desc, -+ struct usb_endpoint_config *epconfig, int configs) -+{ -+ struct pxa27x_udc *dev = the_controller; -+ struct pxa27x_virt_ep *virt_ep; -+ unsigned int i, fifo_size; -+ char *name; -+ -+ if (unlikely(configs < 1)) { -+ dev_err(dev->dev, "%s: Error in config data\n", __FUNCTION__); -+ return NULL; -+ } -+ -+ virt_ep = kmalloc(sizeof(struct pxa27x_virt_ep), GFP_KERNEL); -+ name = kmalloc(NAME_SIZE, GFP_KERNEL); -+ if (!virt_ep || !name) { -+ dev_err(dev->dev, "%s: -ENOMEM\n", __FUNCTION__); -+ kfree(name); -+ kfree(virt_ep); -+ return NULL; -+ } -+ -+ if (!(desc->wMaxPacketSize)) { -+ fifo_size = validate_fifo_size(desc->bmAttributes); -+ desc->wMaxPacketSize = fifo_size; -+ } else { -+ fifo_size = desc->wMaxPacketSize; -+ } -+ -+ DMSG("pxa27x_ep_alloc: bLength: %d, bDescriptorType: %x, bEndpointAddress: %x,\n" -+ " bmAttributes: %x, wMaxPacketSize: %d\n", desc->bLength, -+ desc->bDescriptorType, desc->bEndpointAddress, desc->bmAttributes, -+ desc->wMaxPacketSize); -+ -+ if (!(desc->bEndpointAddress & 0xF)) -+ desc->bEndpointAddress |= dev->ep_num; -+ -+ for (i = 0; i < configs; i++) -+ { -+ struct pxa27x_ep *pxa_ep; -+ int j; -+ -+ DMSG("pxa27x_ep_alloc: config: %d, interface: %d, altinterface: %x,\n", -+ epconfig->config, epconfig->interface, epconfig->altinterface); -+ -+ j = pxa27x_find_free_ep(dev); -+ -+ if (unlikely(j < 0)) { -+ dev_err(dev->dev, "pxa27x_ep_alloc: Failed to find a spare endpoint\n"); -+ pxa27x_ep_free(gadget, &virt_ep->usb_ep); -+ return NULL; -+ } -+ -+ pxa_ep = &dev->ep[j]; -+ -+ if (i == 0) -+ virt_ep->pxa_ep = pxa_ep; -+ -+ pxa_ep->assigned = 1; -+ pxa_ep->ep_num = dev->ep_num; -+ pxa_ep->pxa_ep_num = j; -+ pxa_ep->usb_ep = &virt_ep->usb_ep; -+ pxa_ep->dev = dev; -+ pxa_ep->desc = desc; -+ pxa_ep->pio_irqs = pxa_ep->dma_irqs = 0; -+ pxa_ep->dma = -1; -+ -+ pxa_ep->fifo_size = fifo_size; -+ pxa_ep->dir_in = (desc->bEndpointAddress & USB_DIR_IN) ? 1 : 0; -+ pxa_ep->ep_type = desc->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK; -+ pxa_ep->stopped = 1; -+ pxa_ep->dma_con = 0; -+ pxa_ep->config = epconfig->config; -+ pxa_ep->interface = epconfig->interface; -+ pxa_ep->aisn = epconfig->altinterface; -+ -+ pxa_ep->reg_udccsr = &UDCCSR0 + j; -+ pxa_ep->reg_udcbcr = &UDCBCR0 + j; -+ pxa_ep->reg_udcdr = &UDCDR0 + j ; -+ pxa_ep->reg_udccr = &UDCCRA - 1 + j; -+#ifdef USE_DMA -+ pxa_ep->reg_drcmr = &DRCMR24 + j; -+#endif -+ -+ /* Configure UDCCR */ -+ *pxa_ep->reg_udccr = ((pxa_ep->config << UDCCONR_CN_S) & UDCCONR_CN) -+ | ((pxa_ep->interface << UDCCONR_IN_S) & UDCCONR_IN) -+ | ((pxa_ep->aisn << UDCCONR_AISN_S) & UDCCONR_AISN) -+ | ((dev->ep_num << UDCCONR_EN_S) & UDCCONR_EN) -+ | ((pxa_ep->ep_type << UDCCONR_ET_S) & UDCCONR_ET) -+ | ((pxa_ep->dir_in) ? UDCCONR_ED : 0) -+ | ((min(pxa_ep->fifo_size, (unsigned)desc->wMaxPacketSize) << UDCCONR_MPS_S ) & UDCCONR_MPS) -+ | UDCCONR_EE; -+// | UDCCONR_DE | UDCCONR_EE; -+ -+ -+ -+#ifdef USE_DMA -+ /* Only BULK use DMA */ -+ if ((pxa_ep->ep_type & USB_ENDPOINT_XFERTYPE_MASK)\ -+ == USB_ENDPOINT_XFER_BULK) -+ *pxa_ep->reg_udccsr = UDCCSR_DME; -+#endif -+ -+ DMSG("UDCCR: 0x%p is 0x%x\n", pxa_ep->reg_udccr,*pxa_ep->reg_udccr); -+ -+ epconfig++; -+ } -+ -+ /* Fill ep name*/ -+ switch (desc->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) { -+ case USB_ENDPOINT_XFER_BULK: -+ sprintf(name, "ep%d%s-bulk", dev->ep_num, -+ ((desc->bEndpointAddress & USB_DIR_IN) ? "in":"out")); -+ break; -+ case USB_ENDPOINT_XFER_INT: -+ sprintf(name, "ep%d%s-intr", dev->ep_num, -+ ((desc->bEndpointAddress & USB_DIR_IN) ? "in":"out")); -+ break; -+ default: -+ sprintf(name, "ep%d%s", dev->ep_num, -+ ((desc->bEndpointAddress & USB_DIR_IN) ? "in":"out")); -+ break; -+ } -+ -+ virt_ep->desc = desc; -+ virt_ep->usb_ep.name = name; -+ virt_ep->usb_ep.ops = &pxa27x_ep_ops; -+ virt_ep->usb_ep.maxpacket = min((ushort)fifo_size, desc->wMaxPacketSize); -+ -+ list_add_tail(&virt_ep->usb_ep.ep_list, &gadget->ep_list); -+ -+ dev->ep_num++; -+ return &virt_ep->usb_ep; -+} -+ -+static int pxa27x_udc_get_frame(struct usb_gadget *_gadget) -+{ -+ return (UDCFNR & 0x7FF); -+} -+ -+static int pxa27x_udc_wakeup(struct usb_gadget *_gadget) -+{ -+ /* host may not have enabled remote wakeup */ -+ if ((UDCCR & UDCCR_DWRE) == 0) -+ return -EHOSTUNREACH; -+ udc_set_mask_UDCCR(UDCCR_UDR); -+ return 0; -+} -+ -+static const struct usb_gadget_ops pxa27x_udc_ops = { -+ .ep_alloc = pxa27x_ep_alloc, -+ .get_frame = pxa27x_udc_get_frame, -+ .wakeup = pxa27x_udc_wakeup, -+ // current versions must always be self-powered -+}; -+ -+ -+/*-------------------------------------------------------------------------*/ -+ -+#ifdef UDC_PROC_FILE -+ -+static const char proc_node_name [] = "driver/udc"; -+ -+static int -+udc_proc_read(char *page, char **start, off_t off, int count, -+ int *eof, void *_dev) -+{ -+ char *buf = page; -+ struct pxa27x_udc *dev = _dev; -+ char *next = buf; -+ unsigned size = count; -+ unsigned long flags; -+ int i, t; -+ u32 tmp; -+ -+ if (off != 0) -+ return 0; -+ -+ local_irq_save(flags); -+ -+ /* basic device status */ -+ t = scnprintf(next, size, DRIVER_DESC "\n" -+ "%s version: %s\nGadget driver: %s\n", -+ driver_name, DRIVER_VERSION DMASTR, -+ dev->driver ? dev->driver->driver.name : "(none)"); -+ size -= t; -+ next += t; -+ -+ /* registers for device and ep0 */ -+ t = scnprintf(next, size, -+ "uicr %02X.%02X, usir %02X.%02x, ufnr %02X\n", -+ UDCICR1, UDCICR0, UDCISR1, UDCISR0, UDCFNR); -+ size -= t; -+ next += t; -+ -+ tmp = UDCCR; -+ t = scnprintf(next, size,"udccr %02X =%s%s%s%s%s%s%s%s%s%s, con=%d,inter=%d,altinter=%d\n", tmp, -+ (tmp & UDCCR_OEN) ? " oen":"", -+ (tmp & UDCCR_AALTHNP) ? " aalthnp":"", -+ (tmp & UDCCR_AHNP) ? " rem" : "", -+ (tmp & UDCCR_BHNP) ? " rstir" : "", -+ (tmp & UDCCR_DWRE) ? " dwre" : "", -+ (tmp & UDCCR_SMAC) ? " smac" : "", -+ (tmp & UDCCR_EMCE) ? " emce" : "", -+ (tmp & UDCCR_UDR) ? " udr" : "", -+ (tmp & UDCCR_UDA) ? " uda" : "", -+ (tmp & UDCCR_UDE) ? " ude" : "", -+ (tmp & UDCCR_ACN) >> UDCCR_ACN_S, -+ (tmp & UDCCR_AIN) >> UDCCR_AIN_S, -+ (tmp & UDCCR_AAISN)>> UDCCR_AAISN_S ); -+ -+ size -= t; -+ next += t; -+ -+ tmp = UDCCSR0; -+ t = scnprintf(next, size, -+ "udccsr0 %02X =%s%s%s%s%s%s%s\n", tmp, -+ (tmp & UDCCSR0_SA) ? " sa" : "", -+ (tmp & UDCCSR0_RNE) ? " rne" : "", -+ (tmp & UDCCSR0_FST) ? " fst" : "", -+ (tmp & UDCCSR0_SST) ? " sst" : "", -+ (tmp & UDCCSR0_DME) ? " dme" : "", -+ (tmp & UDCCSR0_IPR) ? " ipr" : "", -+ (tmp & UDCCSR0_OPC) ? " opc" : ""); -+ size -= t; -+ next += t; -+ -+ if (!dev->driver) -+ goto done; -+ -+ t = scnprintf(next, size, "ep0 IN %lu/%lu, OUT %lu/%lu\nirqs %lu\n\n", -+ dev->stats.write.bytes, dev->stats.write.ops, -+ dev->stats.read.bytes, dev->stats.read.ops, -+ dev->stats.irqs); -+ size -= t; -+ next += t; -+ -+ /* dump endpoint queues */ -+ for (i = 0; i < UDC_EP_NUM; i++) { -+ struct pxa27x_ep *ep = &dev->ep [i]; -+ struct pxa27x_request *req; -+ int t; -+ -+ if (i != 0) { -+ const struct usb_endpoint_descriptor *d; -+ -+ d = ep->desc; -+ if (!d) -+ continue; -+ tmp = *dev->ep [i].reg_udccsr; -+ t = scnprintf(next, size, -+ "%d max %d %s udccs %02x udccr:0x%x\n", -+ i, le16_to_cpu (d->wMaxPacketSize), -+ (ep->dma >= 0) ? "dma" : "pio", tmp, -+ *dev->ep[i].reg_udccr); -+ /* TODO translate all five groups of udccs bits! */ -+ -+ } else /* ep0 should only have one transfer queued */ -+ t = scnprintf(next, size, "ep0 max 16 pio irqs %lu\n", -+ ep->pio_irqs); -+ if (t <= 0 || t > size) -+ goto done; -+ size -= t; -+ next += t; -+ -+ if (list_empty(&ep->queue)) { -+ t = scnprintf(next, size, "\t(nothing queued)\n"); -+ if (t <= 0 || t > size) -+ goto done; -+ size -= t; -+ next += t; -+ continue; -+ } -+ list_for_each_entry(req, &ep->queue, queue) { -+#ifdef USE_DMA -+ if (ep->dma >= 0 && req->queue.prev == &ep->queue) -+ t = scnprintf(next, size, "\treq %p len %d/%d " -+ "buf %p (dma%d dcmd %08x)\n", -+ &req->req, req->req.actual, -+ req->req.length, req->req.buf, -+ ep->dma, DCMD(ep->dma) -+ /* low 13 bits == bytes-to-go */); -+ else -+#endif -+ t = scnprintf(next, size, -+ "\treq %p len %d/%d buf %p\n", -+ &req->req, req->req.actual, -+ req->req.length, req->req.buf); -+ if (t <= 0 || t > size) -+ goto done; -+ size -= t; -+ next += t; -+ } -+ } -+ -+done: -+ local_irq_restore(flags); -+ *eof = 1; -+ return count - size; -+} -+ -+#define create_proc_files() \ -+ create_proc_read_entry(proc_node_name, 0, NULL, udc_proc_read, dev) -+#define remove_proc_files() \ -+ remove_proc_entry(proc_node_name, NULL) -+ -+#else /* !UDC_PROC_FILE */ -+#define create_proc_files() do {} while (0) -+#define remove_proc_files() do {} while (0) -+ -+#endif /* UDC_PROC_FILE */ -+ -+/* "function" sysfs attribute */ -+static ssize_t show_function(struct device *_dev, struct device_attribute *attr, char *buf) -+{ -+ struct pxa27x_udc *dev = dev_get_drvdata(_dev); -+ -+ if (!dev->driver || !dev->driver->function -+ || strlen(dev->driver->function) > PAGE_SIZE) -+ return 0; -+ return scnprintf(buf, PAGE_SIZE, "%s\n", dev->driver->function); -+} -+static DEVICE_ATTR(function, S_IRUGO, show_function, NULL); -+ -+/*-------------------------------------------------------------------------*/ -+ -+/* -+ * udc_disable - disable USB device controller -+ */ -+static void udc_disable(struct pxa27x_udc *dev) -+{ -+ UDCICR0 = UDCICR1 = 0x00000000; -+ -+ udc_clear_mask_UDCCR(UDCCR_UDE); -+ -+ /* Disable clock for USB device */ -+ pxa_set_cken(CKEN11_USB, 0); -+ -+ ep0_idle(dev); -+ dev->gadget.speed = USB_SPEED_UNKNOWN; -+ dev->mach->udc_command(PXA2XX_UDC_CMD_DISCONNECT); -+} -+ -+ -+/* -+ * udc_reinit - initialize software state -+ */ -+static void udc_reinit(struct pxa27x_udc *dev) -+{ -+ u32 i; -+ -+ dev->ep0state = EP0_IDLE; -+ -+ /* basic endpoint records init */ -+ for (i = 0; i < UDC_EP_NUM; i++) { -+ struct pxa27x_ep *ep = &dev->ep[i]; -+ -+ ep->stopped = 0; -+ ep->pio_irqs = ep->dma_irqs = 0; -+ } -+ dev->configuration = 0; -+ dev->interface = 0; -+ dev->alternate = 0; -+ /* the rest was statically initialized, and is read-only */ -+} -+ -+/* until it's enabled, this UDC should be completely invisible -+ * to any USB host. -+ */ -+static void udc_enable(struct pxa27x_udc *dev) -+{ -+ udc_clear_mask_UDCCR(UDCCR_UDE); -+ -+ /* Enable clock for USB device */ -+ pxa_set_cken(CKEN11_USB, 1); -+ -+ UDCICR0 = UDCICR1 = 0; -+ -+ ep0_idle(dev); -+ dev->gadget.speed = USB_SPEED_FULL; -+ dev->stats.irqs = 0; -+ -+ udc_set_mask_UDCCR(UDCCR_UDE); -+ udelay(2); -+ if (UDCCR & UDCCR_EMCE) -+ dev_err(dev->dev, "There are error in configuration, udc disabled\n"); -+ -+ /* caller must be able to sleep in order to cope -+ * with startup transients. -+ */ -+ msleep(100); -+ -+ /* enable suspend/resume and reset irqs */ -+ UDCICR1 = UDCICR1_IECC | UDCICR1_IERU | UDCICR1_IESU | UDCICR1_IERS; -+ -+ /* enable ep0 irqs */ -+ UDCICR0 = UDCICR_INT(0,UDCICR_INT_MASK); -+ -+ DMSG("Connecting\n"); -+ /* RPFIXME */ -+ UP2OCR = UP2OCR_HXOE | UP2OCR_DPPUE | UP2OCR_DPPUBE; -+ //dev->mach->udc_command(PXA2XX_UDC_CMD_CONNECT); -+} -+ -+ -+/* when a driver is successfully registered, it will receive -+ * control requests including set_configuration(), which enables -+ * non-control requests. then usb traffic follows until a -+ * disconnect is reported. then a host may connect again, or -+ * the driver might get unbound. -+ */ -+int usb_gadget_register_driver(struct usb_gadget_driver *driver) -+{ -+ struct pxa27x_udc *dev = the_controller; -+ int retval; -+ -+ if (!driver || driver->speed != USB_SPEED_FULL || !driver->bind -+ || !driver->unbind || !driver->disconnect || !driver->setup) -+ return -EINVAL; -+ if (!dev) -+ return -ENODEV; -+ if (dev->driver) -+ return -EBUSY; -+ -+ udc_disable(dev); -+ udc_init_ep(dev); -+ udc_reinit(dev); -+ -+ /* first hook up the driver ... */ -+ dev->driver = driver; -+ dev->gadget.dev.driver = &driver->driver; -+ dev->ep_num = 1; -+ -+ retval = device_add(&dev->gadget.dev); -+ if (retval) { -+ DMSG("device_add error %d\n", retval); -+ goto add_fail; -+ } -+ retval = driver->bind(&dev->gadget); -+ if (retval) { -+ DMSG("bind to driver %s --> error %d\n", -+ driver->driver.name, retval); -+ goto bind_fail; -+ } -+ retval = device_create_file(dev->dev, &dev_attr_function); -+ if (retval) { -+ DMSG("device_create_file failed: %d\n", retval); -+ goto create_file_fail; -+ } -+ -+ /* ... then enable host detection and ep0; and we're ready -+ * for set_configuration as well as eventual disconnect. -+ * NOTE: this shouldn't power up until later. -+ */ -+ DMSG("registered gadget driver '%s'\n", driver->driver.name); -+ udc_enable(dev); -+ dump_state(dev); -+ return 0; -+ -+create_file_fail: -+ driver->unbind(&dev->gadget); -+bind_fail: -+ device_del(&dev->gadget.dev); -+add_fail: -+ dev->driver = 0; -+ dev->gadget.dev.driver = 0; -+ return retval; -+} -+EXPORT_SYMBOL(usb_gadget_register_driver); -+ -+static void -+stop_activity(struct pxa27x_udc *dev, struct usb_gadget_driver *driver) -+{ -+ int i; -+ -+ DMSG("Trace path 1\n"); -+ /* don't disconnect drivers more than once */ -+ if (dev->gadget.speed == USB_SPEED_UNKNOWN) -+ driver = 0; -+ dev->gadget.speed = USB_SPEED_UNKNOWN; -+ -+ /* prevent new request submissions, kill any outstanding requests */ -+ for (i = 0; i < UDC_EP_NUM; i++) { -+ struct pxa27x_ep *ep = &dev->ep[i]; -+ -+ ep->stopped = 1; -+ nuke(ep, -ESHUTDOWN); -+ } -+ del_timer_sync(&dev->timer); -+ -+ /* report disconnect; the driver is already quiesced */ -+ if (driver) -+ driver->disconnect(&dev->gadget); -+ -+ /* re-init driver-visible data structures */ -+ udc_reinit(dev); -+} -+ -+int usb_gadget_unregister_driver(struct usb_gadget_driver *driver) -+{ -+ struct pxa27x_udc *dev = the_controller; -+ -+ if (!dev) -+ return -ENODEV; -+ if (!driver || driver != dev->driver) -+ return -EINVAL; -+ -+ local_irq_disable(); -+ udc_disable(dev); -+ stop_activity(dev, driver); -+ local_irq_enable(); -+ -+ driver->unbind(&dev->gadget); -+ pxa27x_ep_freeall(&dev->gadget); -+ dev->driver = 0; -+ -+ device_del(&dev->gadget.dev); -+ device_remove_file(dev->dev, &dev_attr_function); -+ -+ DMSG("unregistered gadget driver '%s'\n", driver->driver.name); -+ dump_state(dev); -+ return 0; -+} -+EXPORT_SYMBOL(usb_gadget_unregister_driver); -+ -+ -+/*-------------------------------------------------------------------------*/ -+ -+static inline void clear_ep_state(struct pxa27x_udc *dev) -+{ -+ unsigned i; -+ -+ /* hardware SET_{CONFIGURATION,INTERFACE} automagic resets endpoint -+ * fifos, and pending transactions mustn't be continued in any case. -+ */ -+ for (i = 1; i < UDC_EP_NUM; i++) -+ nuke(&dev->ep[i], -ECONNABORTED); -+} -+ -+static void udc_watchdog(unsigned long _dev) -+{ -+ struct pxa27x_udc *dev = (void *)_dev; -+ -+ local_irq_disable(); -+ if (dev->ep0state == EP0_STALL -+ && (UDCCSR0 & UDCCSR0_FST) == 0 -+ && (UDCCSR0 & UDCCSR0_SST) == 0) { -+ UDCCSR0 = UDCCSR0_FST|UDCCSR0_FTF; -+ DBG(DBG_VERBOSE, "ep0 re-stall\n"); -+ start_watchdog(dev); -+ } -+ local_irq_enable(); -+} -+ -+static void handle_ep0(struct pxa27x_udc *dev) -+{ -+ u32 udccsr0 = UDCCSR0; -+ struct pxa27x_ep *ep = &dev->ep[0]; -+ struct pxa27x_request *req; -+ union { -+ struct usb_ctrlrequest r; -+ u8 raw[8]; -+ u32 word[2]; -+ } u; -+ -+ if (list_empty(&ep->queue)) -+ req = 0; -+ else -+ req = list_entry(ep->queue.next, struct pxa27x_request, queue); -+ -+ /* clear stall status */ -+ if (udccsr0 & UDCCSR0_SST) { -+ nuke(ep, -EPIPE); -+ UDCCSR0 = UDCCSR0_SST; -+ del_timer(&dev->timer); -+ ep0_idle(dev); -+ } -+ -+ /* previous request unfinished? non-error iff back-to-back ... */ -+ if ((udccsr0 & UDCCSR0_SA) != 0 && dev->ep0state != EP0_IDLE) { -+ nuke(ep, 0); -+ del_timer(&dev->timer); -+ ep0_idle(dev); -+ } -+ -+ switch (dev->ep0state) { -+ case EP0_NO_ACTION: -+ dev_info(dev->dev, "%s: Busy\n", __FUNCTION__); -+ /*Fall through */ -+ case EP0_IDLE: -+ /* late-breaking status? */ -+ udccsr0 = UDCCSR0; -+ -+ /* start control request? */ -+ if (likely((udccsr0 & (UDCCSR0_OPC|UDCCSR0_SA|UDCCSR0_RNE)) -+ == (UDCCSR0_OPC|UDCCSR0_SA|UDCCSR0_RNE))) { -+ int i; -+ -+ nuke(ep, -EPROTO); -+ /* read SETUP packet */ -+ for (i = 0; i < 2; i++) { -+ if (unlikely(!(UDCCSR0 & UDCCSR0_RNE))) { -+bad_setup: -+ DMSG("SETUP %d!\n", i); -+ goto stall; -+ } -+ u.word [i] = UDCDR0; -+ } -+ if (unlikely((UDCCSR0 & UDCCSR0_RNE) != 0)) -+ goto bad_setup; -+ -+ le16_to_cpus(&u.r.wValue); -+ le16_to_cpus(&u.r.wIndex); -+ le16_to_cpus(&u.r.wLength); -+ -+ DBG(DBG_VERBOSE, "SETUP %02x.%02x v%04x i%04x l%04x\n", -+ u.r.bRequestType, u.r.bRequest, -+ u.r.wValue, u.r.wIndex, u.r.wLength); -+ /* cope with automagic for some standard requests. */ -+ dev->req_std = (u.r.bRequestType & USB_TYPE_MASK) -+ == USB_TYPE_STANDARD; -+ dev->req_config = 0; -+ dev->req_pending = 1; -+#if 0 -+ switch (u.r.bRequest) { -+ /* hardware was supposed to hide this */ -+ case USB_REQ_SET_CONFIGURATION: -+ case USB_REQ_SET_INTERFACE: -+ case USB_REQ_SET_ADDRESS: -+ dev_err(dev->dev, "Should not come here\n"); -+ break; -+ } -+ -+#endif -+ if (u.r.bRequestType & USB_DIR_IN) -+ dev->ep0state = EP0_IN_DATA_PHASE; -+ else -+ dev->ep0state = EP0_OUT_DATA_PHASE; -+ i = dev->driver->setup(&dev->gadget, &u.r); -+ -+ if (i < 0) { -+ /* hardware automagic preventing STALL... */ -+ if (dev->req_config) { -+ /* hardware sometimes neglects to tell -+ * tell us about config change events, -+ * so later ones may fail... -+ */ -+ WARN("config change %02x fail %d?\n", -+ u.r.bRequest, i); -+ return; -+ /* TODO experiment: if has_cfr, -+ * hardware didn't ACK; maybe we -+ * could actually STALL! -+ */ -+ } -+ DBG(DBG_VERBOSE, "protocol STALL, " -+ "%02x err %d\n", UDCCSR0, i); -+stall: -+ /* the watchdog timer helps deal with cases -+ * where udc seems to clear FST wrongly, and -+ * then NAKs instead of STALLing. -+ */ -+ ep0start(dev, UDCCSR0_FST|UDCCSR0_FTF, "stall"); -+ start_watchdog(dev); -+ dev->ep0state = EP0_STALL; -+ -+ /* deferred i/o == no response yet */ -+ } else if (dev->req_pending) { -+ if (likely(dev->ep0state == EP0_IN_DATA_PHASE -+ || dev->req_std || u.r.wLength)) -+ ep0start(dev, 0, "defer"); -+ else -+ ep0start(dev, UDCCSR0_IPR, "defer/IPR"); -+ } -+ -+ /* expect at least one data or status stage irq */ -+ return; -+ -+ } else { -+ /* some random early IRQ: -+ * - we acked FST -+ * - IPR cleared -+ * - OPC got set, without SA (likely status stage) -+ */ -+ UDCCSR0 = udccsr0 & (UDCCSR0_SA|UDCCSR0_OPC); -+ } -+ break; -+ case EP0_IN_DATA_PHASE: /* GET_DESCRIPTOR etc */ -+ if (udccsr0 & UDCCSR0_OPC) { -+ UDCCSR0 = UDCCSR0_OPC|UDCCSR0_FTF; -+ DBG(DBG_VERBOSE, "ep0in premature status\n"); -+ if (req) -+ done(ep, req, 0); -+ ep0_idle(dev); -+ } else /* irq was IPR clearing */ { -+ if (req) { -+ /* this IN packet might finish the request */ -+ (void) write_ep0_fifo(ep, req); -+ } /* else IN token before response was written */ -+ } -+ break; -+ case EP0_OUT_DATA_PHASE: /* SET_DESCRIPTOR etc */ -+ if (udccsr0 & UDCCSR0_OPC) { -+ if (req) { -+ /* this OUT packet might finish the request */ -+ if (read_ep0_fifo(ep, req)) -+ done(ep, req, 0); -+ /* else more OUT packets expected */ -+ } /* else OUT token before read was issued */ -+ } else /* irq was IPR clearing */ { -+ DBG(DBG_VERBOSE, "ep0out premature status\n"); -+ if (req) -+ done(ep, req, 0); -+ ep0_idle(dev); -+ } -+ break; -+ case EP0_STALL: -+ UDCCSR0 = UDCCSR0_FST; -+ break; -+ } -+ UDCISR0 = UDCISR_INT(0, UDCISR_INT_MASK); -+} -+ -+ -+static void handle_ep(struct pxa27x_ep *ep) -+{ -+ struct pxa27x_request *req; -+ int completed; -+ u32 udccsr=0; -+ -+ DMSG("%s is called\n", __FUNCTION__); -+ do { -+ completed = 0; -+ if (likely (!list_empty(&ep->queue))) { -+ req = list_entry(ep->queue.next, -+ struct pxa27x_request, queue); -+ } else -+ req = 0; -+ -+// udccsr = *ep->reg_udccsr; -+ DMSG("%s: req:%p, udcisr0:0x%x udccsr %p:0x%x\n", __FUNCTION__, -+ req, UDCISR0, ep->reg_udccsr, *ep->reg_udccsr); -+ if (unlikely(ep->dir_in)) { -+ udccsr = (UDCCSR_SST | UDCCSR_TRN) & *ep->reg_udccsr; -+ if (unlikely (udccsr)) -+ *ep->reg_udccsr = udccsr; -+ -+ if (req && likely ((*ep->reg_udccsr & UDCCSR_FS) != 0)) -+ completed = write_fifo(ep, req); -+ -+ } else { -+ udccsr = (UDCCSR_SST | UDCCSR_TRN) & *ep->reg_udccsr; -+ if (unlikely(udccsr)) -+ *ep->reg_udccsr = udccsr; -+ -+ /* fifos can hold packets, ready for reading... */ -+ if (likely(req)) { -+ completed = read_fifo(ep, req); -+ } else { -+ pio_irq_disable (ep->pxa_ep_num); -+ //*ep->reg_udccsr = UDCCSR_FEF; -+ DMSG("%s: no req for out data\n", -+ __FUNCTION__); -+ } -+ } -+ ep->pio_irqs++; -+ } while (completed); -+} -+ -+static void pxa27x_update_eps(struct pxa27x_udc *dev) -+{ -+ struct pxa27x_virt_ep *virt_ep; -+ int i; -+ -+ for (i = 1; i < UDC_EP_NUM; i++) { -+ if(!dev->ep[i].assigned || !dev->ep[i].usb_ep) -+ continue; -+ virt_ep = container_of(dev->ep[i].usb_ep, struct pxa27x_virt_ep, usb_ep); -+ -+ DMSG("%s, Updating eps %d:%d, %d:%d, %d:%d, %p,%p\n", __FUNCTION__, dev->ep[i].config, dev->configuration -+ ,dev->ep[i].interface, dev->interface, dev->ep[i].aisn, dev->alternate, virt_ep->pxa_ep, &dev->ep[i]); -+ -+ if(dev->ep[i].config == dev->configuration && virt_ep->pxa_ep != &dev->ep[i]) { -+ if ((dev->ep[i].interface == dev->interface && -+ dev->ep[i].aisn == dev->alternate) || virt_ep->pxa_ep->config != dev->configuration) { -+ -+ if (virt_ep->pxa_ep->desc) { -+ DMSG("%s, Changing end point to %d (en/dis)\n", __FUNCTION__, i); -+ pxa27x_ep_disable(&virt_ep->usb_ep); -+ virt_ep->pxa_ep = &dev->ep[i]; -+ pxa27x_ep_enable(&virt_ep->usb_ep, virt_ep->desc); -+ } else { -+ DMSG("%s, Changing end point to %d (no en/dis)\n", __FUNCTION__, i); -+ virt_ep->pxa_ep = &dev->ep[i]; -+ } -+ } -+ } -+ } -+} -+ -+static void pxa27x_change_configuration(struct pxa27x_udc *dev) -+{ -+ struct usb_ctrlrequest req ; -+ -+ pxa27x_update_eps(dev); -+ -+ req.bRequestType = 0; -+ req.bRequest = USB_REQ_SET_CONFIGURATION; -+ req.wValue = dev->configuration; -+ req.wIndex = 0; -+ req.wLength = 0; -+ -+ dev->ep0state = EP0_NO_ACTION; -+ dev->driver->setup(&dev->gadget, &req); -+} -+ -+static void pxa27x_change_interface(struct pxa27x_udc *dev) -+{ -+ struct usb_ctrlrequest req; -+ -+ pxa27x_update_eps(dev); -+ -+ req.bRequestType = USB_RECIP_INTERFACE; -+ req.bRequest = USB_REQ_SET_INTERFACE; -+ req.wValue = dev->alternate; -+ req.wIndex = dev->interface; -+ req.wLength = 0; -+ -+ dev->ep0state = EP0_NO_ACTION; -+ dev->driver->setup(&dev->gadget, &req); -+} -+ -+/* -+ * pxa27x_udc_irq - interrupt handler -+ * -+ * avoid delays in ep0 processing. the control handshaking isn't always -+ * under software control (pxa250c0 and the pxa255 are better), and delays -+ * could cause usb protocol errors. -+ */ -+static irqreturn_t pxa27x_udc_irq(int irq, void *_dev) -+{ -+ struct pxa27x_udc *dev = _dev; -+ int handled; -+ -+ dev->stats.irqs++; -+ -+ DBG(DBG_VERBOSE, "Interrupt, UDCISR0:0x%08x, UDCISR1:0x%08x, " -+ "UDCCR:0x%08x\n", UDCISR0, UDCISR1, UDCCR); -+ do { -+ u32 udcir = UDCISR1 & 0xF8000000; -+ -+ handled = 0; -+ -+ /* SUSpend Interrupt Request */ -+ if (unlikely(udcir & UDCISR1_IRSU)) { -+ UDCISR1 = UDCISR1_IRSU; -+ handled = 1; -+ DBG(DBG_VERBOSE, "USB suspend\n"); -+ if (dev->gadget.speed != USB_SPEED_UNKNOWN -+ && dev->driver -+ && dev->driver->suspend) -+ dev->driver->suspend(&dev->gadget); -+ ep0_idle(dev); -+ } -+ -+ /* RESume Interrupt Request */ -+ if (unlikely(udcir & UDCISR1_IRRU)) { -+ UDCISR1 = UDCISR1_IRRU; -+ handled = 1; -+ DBG(DBG_VERBOSE, "USB resume\n"); -+ -+ if (dev->gadget.speed != USB_SPEED_UNKNOWN -+ && dev->driver -+ && dev->driver->resume) -+ dev->driver->resume(&dev->gadget); -+ } -+ -+ if (unlikely(udcir & UDCISR1_IRCC)) { -+ unsigned config, interface, alternate; -+ -+ handled = 1; -+ DBG(DBG_VERBOSE, "USB SET_CONFIGURATION or " -+ "SET_INTERFACE command received\n"); -+ -+ config = (UDCCR & UDCCR_ACN) >> UDCCR_ACN_S; -+ -+ if (dev->configuration != config) { -+ dev->configuration = config; -+ pxa27x_change_configuration(dev) ; -+ } -+ -+ interface = (UDCCR & UDCCR_AIN) >> UDCCR_AIN_S; -+ alternate = (UDCCR & UDCCR_AAISN) >> UDCCR_AAISN_S; -+ -+ if ((dev->interface != interface) || (dev->alternate != alternate)) { -+ dev->interface = interface; -+ dev->alternate = alternate; -+ pxa27x_change_interface(dev); -+ } -+ -+ UDCCR |= UDCCR_SMAC; -+ -+ UDCISR1 = UDCISR1_IRCC; -+ DMSG("%s: con:%d,inter:%d,alt:%d\n", -+ __FUNCTION__, config,interface, alternate); -+ } -+ -+ /* ReSeT Interrupt Request - USB reset */ -+ if (unlikely(udcir & UDCISR1_IRRS)) { -+ UDCISR1 = UDCISR1_IRRS; -+ handled = 1; -+ -+ if ((UDCCR & UDCCR_UDA) == 0) { -+ DBG(DBG_VERBOSE, "USB reset start\n"); -+ -+ /* reset driver and endpoints, -+ * in case that's not yet done -+ */ -+ stop_activity(dev, dev->driver); -+ } -+ INFO("USB reset\n"); -+ dev->gadget.speed = USB_SPEED_FULL; -+ memset(&dev->stats, 0, sizeof dev->stats); -+ -+ } else { -+ u32 udcisr0 = UDCISR0 ; -+ u32 udcisr1 = UDCISR1 & 0xFFFF; -+ int i; -+ -+ if (unlikely (!udcisr0 && !udcisr1)) -+ continue; -+ -+ DBG(DBG_VERY_NOISY, "irq %02x.%02x\n", udcisr1,udcisr0); -+ -+ /* control traffic */ -+ if (udcisr0 & UDCISR0_IR0) { -+ dev->ep[0].pio_irqs++; -+ handle_ep0(dev); -+ handled = 1; -+ } -+ -+ udcisr0 >>= 2; -+ /* endpoint data transfers */ -+ for (i = 1; udcisr0!=0 && i < 16; udcisr0>>=2,i++) { -+ UDCISR0 = UDCISR_INT(i, UDCISR_INT_MASK); -+ -+ if (udcisr0 & UDC_INT_FIFOERROR) -+ dev_err(dev->dev, " Endpoint %d Fifo error\n", i); -+ if (udcisr0 & UDC_INT_PACKETCMP) { -+ handle_ep(&dev->ep[i]); -+ handled = 1; -+ } -+ -+ } -+ -+ for (i = 0; udcisr1!=0 && i < 8; udcisr1 >>= 2, i++) { -+ UDCISR1 = UDCISR_INT(i, UDCISR_INT_MASK); -+ -+ if (udcisr1 & UDC_INT_FIFOERROR) { -+ dev_err(dev->dev, "Endpoint %d fifo error\n", (i+16)); -+ } -+ -+ if (udcisr1 & UDC_INT_PACKETCMP) { -+ handle_ep(&dev->ep[i+16]); -+ handled = 1; -+ } -+ } -+ } -+ -+ /* we could also ask for 1 msec SOF (SIR) interrupts */ -+ -+ } while (handled); -+ return IRQ_HANDLED; -+} -+ -+int write_ep0_zlp(void) -+{ -+ UDCCSR0 = UDCCSR0_IPR; -+ return 0; -+} -+EXPORT_SYMBOL(write_ep0_zlp); -+ -+static void udc_init_ep(struct pxa27x_udc *dev) -+{ -+ int i; -+ -+ INIT_LIST_HEAD(&dev->gadget.ep_list); -+ INIT_LIST_HEAD(&dev->gadget.ep0->ep_list); -+ -+ for (i = 0; i < UDC_EP_NUM; i++) { -+ struct pxa27x_ep *ep = &dev->ep[i]; -+ -+ ep->dma = -1; -+ if (i != 0) { -+ memset(ep, 0, sizeof(*ep)); -+ } -+ INIT_LIST_HEAD(&ep->queue); -+ } -+} -+ -+/*-------------------------------------------------------------------------*/ -+ -+static void nop_release(struct device *dev) -+{ -+ DMSG("%s %s\n", __FUNCTION__, dev->bus_id); -+} -+ -+/* this uses load-time allocation and initialization (instead of -+ * doing it at run-time) to save code, eliminate fault paths, and -+ * be more obviously correct. -+ */ -+ -+static struct pxa27x_udc memory = { -+ .gadget = { -+ .ops = &pxa27x_udc_ops, -+ .ep0 = &memory.virt_ep0.usb_ep, -+ .name = driver_name, -+ .dev = { -+ .bus_id = "gadget", -+ .release = nop_release, -+ }, -+ }, -+ -+ /* control endpoint */ -+ .virt_ep0 = { -+ .pxa_ep = &memory.ep[0], -+ .usb_ep = { -+ .name = ep0name, -+ .ops = &pxa27x_ep_ops, -+ .maxpacket = EP0_FIFO_SIZE, -+ }, -+ }, -+ -+ .ep[0] = { -+ .usb_ep = &memory.virt_ep0.usb_ep, -+ .dev = &memory, -+ .reg_udccsr = &UDCCSR0, -+ .reg_udcdr = &UDCDR0, -+ }, -+}; -+ -+static int __init pxa27x_udc_probe(struct platform_device *_dev) -+{ -+ struct pxa27x_udc *dev = &memory; -+ int retval; -+ -+ /* other non-static parts of init */ -+ dev->dev = &_dev->dev; -+ dev->mach = _dev->dev.platform_data; -+ -+ /* RPFIXME */ -+ UP2OCR = UP2OCR_HXOE | UP2OCR_DPPUE | UP2OCR_DPPUBE; -+ -+ init_timer(&dev->timer); -+ dev->timer.function = udc_watchdog; -+ dev->timer.data = (unsigned long) dev; -+ -+ device_initialize(&dev->gadget.dev); -+ dev->gadget.dev.parent = &_dev->dev; -+ dev->gadget.dev.dma_mask = _dev->dev.dma_mask; -+ -+ the_controller = dev; -+ platform_set_drvdata(_dev, dev); -+ -+ udc_disable(dev); -+ udc_init_ep(dev); -+ udc_reinit(dev); -+ -+ /* irq setup after old hardware state is cleaned up */ -+ retval = request_irq(IRQ_USB, pxa27x_udc_irq, -+ SA_INTERRUPT, driver_name, dev); -+ if (retval != 0) { -+ dev_err(dev->dev, "%s: can't get irq %i, err %d\n", -+ driver_name, IRQ_USB, retval); -+ return -EBUSY; -+ } -+ dev->got_irq = 1; -+ -+ create_proc_files(); -+ -+ return 0; -+} -+ -+static int pxa27x_udc_remove(struct platform_device *_dev) -+{ -+ struct pxa27x_udc *dev = platform_get_drvdata(_dev); -+ -+ udc_disable(dev); -+ remove_proc_files(); -+ usb_gadget_unregister_driver(dev->driver); -+ -+ pxa27x_ep_freeall(&dev->gadget); -+ -+ if (dev->got_irq) { -+ free_irq(IRQ_USB, dev); -+ dev->got_irq = 0; -+ } -+ platform_set_drvdata(_dev, 0); -+ the_controller = 0; -+ return 0; -+} -+ -+#ifdef CONFIG_PM -+static void pxa27x_udc_shutdown(struct platform_device *_dev) -+{ -+ struct pxa27x_udc *dev = platform_get_drvdata(_dev); -+ -+ udc_disable(dev); -+} -+ -+static int pxa27x_udc_suspend(struct platform_device *_dev, pm_message_t state) -+{ -+ int i; -+ struct pxa27x_udc *dev = platform_get_drvdata(_dev); -+ -+ DMSG("%s is called\n", __FUNCTION__); -+ -+ dev->udccsr0 = UDCCSR0; -+ for(i=1; (i<UDC_EP_NUM); i++) { -+ if (dev->ep[i].assigned) { -+ struct pxa27x_ep *ep = &dev->ep[i]; -+ ep->udccsr_value = *ep->reg_udccsr; -+ ep->udccr_value = *ep->reg_udccr; -+ DMSG("EP%d, udccsr:0x%x, udccr:0x%x\n", -+ i, *ep->reg_udccsr, *ep->reg_udccr); -+ } -+ } -+ -+ udc_clear_mask_UDCCR(UDCCR_UDE); -+ pxa_set_cken(CKEN11_USB, 0); -+ -+ return 0; -+} -+ -+static int pxa27x_udc_resume(struct platform_device *_dev) -+{ -+ int i; -+ struct pxa27x_udc *dev = platform_get_drvdata(_dev); -+ -+ DMSG("%s is called\n", __FUNCTION__); -+ UDCCSR0 = dev->udccsr0 & (UDCCSR0_FST | UDCCSR0_DME); -+ for (i=1; i < UDC_EP_NUM; i++) { -+ if (dev->ep[i].assigned) { -+ struct pxa27x_ep *ep = &dev->ep[i]; -+ *ep->reg_udccsr = ep->udccsr_value; -+ *ep->reg_udccr = ep->udccr_value; -+ DMSG("EP%d, udccsr:0x%x, udccr:0x%x\n", -+ i, *ep->reg_udccsr, *ep->reg_udccr); -+ } -+ } -+ -+ udc_enable(dev); -+ -+ /* OTGPH bit is set when sleep mode is entered. -+ * it indicates that OTG pad is retaining its state. -+ * Upon exit from sleep mode and before clearing OTGPH, -+ * Software must configure the USB OTG pad, UDC, and UHC -+ * to the state they were in before entering sleep mode.*/ -+ PSSR |= PSSR_OTGPH; -+ -+ return 0; -+} -+#endif -+ -+/*-------------------------------------------------------------------------*/ -+ -+static struct platform_driver udc_driver = { -+ .driver = { -+ .name = "pxa2xx-udc", -+ }, -+ .probe = pxa27x_udc_probe, -+ .remove = pxa27x_udc_remove, -+#ifdef CONFIG_PM -+ .shutdown = pxa27x_udc_shutdown, -+ .suspend = pxa27x_udc_suspend, -+ .resume = pxa27x_udc_resume -+#endif -+}; -+ -+static int __init udc_init(void) -+{ -+ printk(KERN_INFO "%s: version %s\n", driver_name, DRIVER_VERSION); -+ return platform_driver_register(&udc_driver); -+} -+module_init(udc_init); -+ -+static void __exit udc_exit(void) -+{ -+ platform_driver_unregister(&udc_driver); -+} -+module_exit(udc_exit); -+ -+MODULE_DESCRIPTION(DRIVER_DESC); -+MODULE_AUTHOR("Frank Becker, Robert Schwebel, David Brownell"); -+MODULE_LICENSE("GPL"); -Index: linux-2.6.20.7/drivers/usb/gadget/pxa27x_udc.h -=================================================================== ---- /dev/null 1970-01-01 00:00:00.000000000 +0000 -+++ linux-2.6.20.7/drivers/usb/gadget/pxa27x_udc.h 2007-04-21 12:22:00.000000000 -0300 -@@ -0,0 +1,298 @@ -+/* -+ * linux/drivers/usb/gadget/pxa27x_udc.h -+ * Intel PXA27x on-chip full speed USB device controller -+ * -+ * Copyright (C) 2003 Robert Schwebel <r.schwebel@pengutronix.de>, Pengutronix -+ * Copyright (C) 2003 David Brownell -+ * Copyright (C) 2004 Intel 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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA -+ */ -+ -+#ifndef __LINUX_USB_GADGET_PXA27X_H -+#define __LINUX_USB_GADGET_PXA27X_H -+ -+#include <linux/types.h> -+ -+struct pxa27x_udc; -+ -+struct pxa27x_ep { -+ struct pxa27x_udc *dev; -+ struct usb_ep *usb_ep; -+ const struct usb_endpoint_descriptor *desc; -+ -+ struct list_head queue; -+ unsigned long pio_irqs; -+ unsigned long dma_irqs; -+ -+ unsigned pxa_ep_num; -+ int dma; -+ unsigned fifo_size; -+ unsigned ep_type; -+ -+ unsigned stopped : 1; -+ unsigned dma_con : 1; -+ unsigned dir_in : 1; -+ unsigned assigned : 1; -+ -+ unsigned ep_num; -+ unsigned config; -+ unsigned interface; -+ unsigned aisn; -+ /* UDCCSR = UDC Control/Status Register for this EP -+ * UBCR = UDC Byte Count Remaining (contents of OUT fifo) -+ * UDCDR = UDC Endpoint Data Register (the fifo) -+ * UDCCR = UDC Endpoint Configuration Registers -+ * DRCM = DMA Request Channel Map -+ */ -+ volatile u32 *reg_udccsr; -+ volatile u32 *reg_udcbcr; -+ volatile u32 *reg_udcdr; -+ volatile u32 *reg_udccr; -+#ifdef USE_DMA -+ volatile u32 *reg_drcmr; -+#define drcmr(n) .reg_drcmr = & DRCMR ## n , -+#else -+#define drcmr(n) -+#endif -+ -+#ifdef CONFIG_PM -+ unsigned udccsr_value; -+ unsigned udccr_value; -+#endif -+}; -+ -+struct pxa27x_virt_ep { -+ struct usb_ep usb_ep; -+ const struct usb_endpoint_descriptor *desc; -+ struct pxa27x_ep *pxa_ep; -+}; -+ -+struct pxa27x_request { -+ struct usb_request req; -+ struct list_head queue; -+}; -+ -+enum ep0_state { -+ EP0_IDLE, -+ EP0_IN_DATA_PHASE, -+ EP0_OUT_DATA_PHASE, -+// EP0_END_XFER, -+ EP0_STALL, -+ EP0_NO_ACTION -+}; -+ -+#define EP0_FIFO_SIZE ((unsigned)16) -+#define BULK_FIFO_SIZE ((unsigned)64) -+#define ISO_FIFO_SIZE ((unsigned)256) -+#define INT_FIFO_SIZE ((unsigned)8) -+ -+struct udc_stats { -+ struct ep0stats { -+ unsigned long ops; -+ unsigned long bytes; -+ } read, write; -+ unsigned long irqs; -+}; -+ -+#define UDC_EP_NUM 24 -+ -+ -+struct pxa27x_udc { -+ struct usb_gadget gadget; -+ struct usb_gadget_driver *driver; -+ -+ enum ep0_state ep0state; -+ struct udc_stats stats; -+ unsigned got_irq : 1, -+ has_cfr : 1, -+ req_pending : 1, -+ req_std : 1, -+ req_config : 1; -+ -+#define start_watchdog(dev) mod_timer(&dev->timer, jiffies + (HZ/200)) -+ struct timer_list timer; -+ -+ struct device *dev; -+ struct pxa2xx_udc_mach_info *mach; -+ u64 dma_mask; -+ struct pxa27x_virt_ep virt_ep0; -+ struct pxa27x_ep ep[UDC_EP_NUM]; -+ unsigned int ep_num; -+ -+ unsigned configuration, -+ interface, -+ alternate; -+#ifdef CONFIG_PM -+ unsigned udccsr0; -+#endif -+}; -+ -+static struct pxa27x_udc *the_controller; -+ -+#if 0 -+/*-------------------------------------------------------------------------*/ -+ -+ -+/* one GPIO should be used to detect host disconnect */ -+static inline int is_usb_connected(void) -+{ -+ if (!the_controller->mach->udc_is_connected) -+ return 1; -+ return the_controller->mach->udc_is_connected(); -+} -+ -+/* one GPIO should force the host to see this device (or not) */ -+static inline void make_usb_disappear(void) -+{ -+ if (!the_controller->mach->udc_command) -+ return; -+ the_controller->mach->udc_command(PXA27X_UDC_CMD_DISCONNECT); -+} -+ -+static inline void let_usb_appear(void) -+{ -+ if (!the_controller->mach->udc_command) -+ return; -+ the_controller->mach->udc_command(PXA2XX_UDC_CMD_CONNECT); -+} -+#endif -+ -+/*-------------------------------------------------------------------------*/ -+ -+/* -+ * Debugging support vanishes in non-debug builds. DBG_NORMAL should be -+ * mostly silent during normal use/testing, with no timing side-effects. -+ */ -+#define DBG_NORMAL 1 /* error paths, device state transitions */ -+#define DBG_VERBOSE 2 /* add some success path trace info */ -+#define DBG_NOISY 3 /* ... even more: request level */ -+#define DBG_VERY_NOISY 4 /* ... even more: packet level */ -+ -+#ifdef DEBUG -+static const char *state_name[] = { -+ "EP0_IDLE", -+ "EP0_IN_DATA_PHASE", "EP0_OUT_DATA_PHASE", -+ "EP0_END_XFER", "EP0_STALL" -+}; -+ -+#define DMSG(stuff...) printk(KERN_ERR "udc: " stuff) -+ -+#ifdef VERBOSE -+# define UDC_DEBUG DBG_VERBOSE -+#else -+# define UDC_DEBUG DBG_NORMAL -+#endif -+ -+static void __attribute__ ((__unused__)) -+dump_udccr(const char *label) -+{ -+ u32 udccr = UDCCR; -+ DMSG("%s 0x%08x =%s%s%s%s%s%s%s%s%s%s, con=%d,inter=%d,altinter=%d\n", -+ label, udccr, -+ (udccr & UDCCR_OEN) ? " oen":"", -+ (udccr & UDCCR_AALTHNP) ? " aalthnp":"", -+ (udccr & UDCCR_AHNP) ? " rem" : "", -+ (udccr & UDCCR_BHNP) ? " rstir" : "", -+ (udccr & UDCCR_DWRE) ? " dwre" : "", -+ (udccr & UDCCR_SMAC) ? " smac" : "", -+ (udccr & UDCCR_EMCE) ? " emce" : "", -+ (udccr & UDCCR_UDR) ? " udr" : "", -+ (udccr & UDCCR_UDA) ? " uda" : "", -+ (udccr & UDCCR_UDE) ? " ude" : "", -+ (udccr & UDCCR_ACN) >> UDCCR_ACN_S, -+ (udccr & UDCCR_AIN) >> UDCCR_AIN_S, -+ (udccr & UDCCR_AAISN)>> UDCCR_AAISN_S ); -+} -+ -+static void __attribute__ ((__unused__)) -+dump_udccsr0(const char *label) -+{ -+ u32 udccsr0 = UDCCSR0; -+ -+ DMSG("%s %s 0x%08x =%s%s%s%s%s%s%s\n", -+ label, state_name[the_controller->ep0state], udccsr0, -+ (udccsr0 & UDCCSR0_SA) ? " sa" : "", -+ (udccsr0 & UDCCSR0_RNE) ? " rne" : "", -+ (udccsr0 & UDCCSR0_FST) ? " fst" : "", -+ (udccsr0 & UDCCSR0_SST) ? " sst" : "", -+ (udccsr0 & UDCCSR0_DME) ? " dme" : "", -+ (udccsr0 & UDCCSR0_IPR) ? " ipr" : "", -+ (udccsr0 & UDCCSR0_OPC) ? " opr" : ""); -+} -+ -+static void __attribute__ ((__unused__)) -+dump_state(struct pxa27x_udc *dev) -+{ -+ unsigned i; -+ -+ DMSG("%s, udcicr %02X.%02X, udcsir %02X.%02x, udcfnr %02X\n", -+ state_name[dev->ep0state], -+ UDCICR1, UDCICR0, UDCISR1, UDCISR0, UDCFNR); -+ dump_udccr("udccr"); -+ -+ if (!dev->driver) { -+ DMSG("no gadget driver bound\n"); -+ return; -+ } else -+ DMSG("ep0 driver '%s'\n", dev->driver->driver.name); -+ -+ -+ dump_udccsr0 ("udccsr0"); -+ DMSG("ep0 IN %lu/%lu, OUT %lu/%lu\n", -+ dev->stats.write.bytes, dev->stats.write.ops, -+ dev->stats.read.bytes, dev->stats.read.ops); -+ -+ for (i = 1; i < UDC_EP_NUM; i++) { -+ if (dev->ep[i].assigned) -+ DMSG ("udccs%d = %02x\n", i, *dev->ep->reg_udccsr); -+ } -+} -+ -+#if 0 -+static void dump_regs(u8 ep) -+{ -+ DMSG("EP:%d UDCCSR:0x%08x UDCBCR:0x%08x\n UDCCR:0x%08x\n", -+ ep,UDCCSN(ep), UDCBCN(ep), UDCCN(ep)); -+} -+static void dump_req (struct pxa27x_request *req) -+{ -+ struct usb_request *r = &req->req; -+ -+ DMSG("%s: buf:0x%08x length:%d dma:0x%08x actual:%d\n", -+ __FUNCTION__, (unsigned)r->buf, r->length, -+ r->dma, r->actual); -+} -+#endif -+ -+#else -+ -+#define DMSG(stuff...) do{}while(0) -+ -+#define dump_udccr(x) do{}while(0) -+#define dump_udccsr0(x) do{}while(0) -+#define dump_state(x) do{}while(0) -+ -+#define UDC_DEBUG ((unsigned)4) -+ -+#endif -+ -+#define DBG(lvl, stuff...) do{if ((lvl) <= UDC_DEBUG) DMSG(stuff);}while(0) -+ -+#define WARN(stuff...) printk(KERN_WARNING "udc: " stuff) -+#define INFO(stuff...) printk(KERN_INFO "udc: " stuff) -+ -+ -+#endif /* __LINUX_USB_GADGET_PXA27X_H */ -Index: linux-2.6.20.7/drivers/usb/gadget/pxa2xx_udc.h -=================================================================== ---- linux-2.6.20.7.orig/drivers/usb/gadget/pxa2xx_udc.h 2007-04-21 12:21:53.000000000 -0300 -+++ linux-2.6.20.7/drivers/usb/gadget/pxa2xx_udc.h 2007-04-21 12:22:00.000000000 -0300 -@@ -259,7 +259,8 @@ - unsigned i; - - DMSG("%s %s, uicr %02X.%02X, usir %02X.%02x, ufnr %02X.%02X\n", -- is_usb_connected() ? "host " : "disconnected", -+ //is_usb_connected() ? "host " : "disconnected", -+ "host ", - state_name[dev->ep0state], - UICR1, UICR0, USIR1, USIR0, UFNRH, UFNRL); - dump_udccr("udccr"); -@@ -276,8 +277,8 @@ - } else - DMSG("ep0 driver '%s'\n", dev->driver->driver.name); - -- if (!is_usb_connected()) -- return; -+ //if (!is_usb_connected()) -+ // return; - - dump_udccs0 ("udccs0"); - DMSG("ep0 IN %lu/%lu, OUT %lu/%lu\n", -Index: linux-2.6.20.7/drivers/usb/gadget/ether.c -=================================================================== ---- linux-2.6.20.7.orig/drivers/usb/gadget/ether.c 2007-04-21 12:21:53.000000000 -0300 -+++ linux-2.6.20.7/drivers/usb/gadget/ether.c 2007-04-21 12:29:18.000000000 -0300 -@@ -1275,6 +1275,10 @@ - /* done sending after USB_CDC_GET_ENCAPSULATED_RESPONSE */ - } - -+#ifdef CONFIG_USB_GADGET_PXA27X -+int write_ep0_zlp(void); -+#endif -+ - static void rndis_command_complete (struct usb_ep *ep, struct usb_request *req) - { - struct eth_dev *dev = ep->driver_data; -@@ -1285,6 +1289,10 @@ - status = rndis_msg_parser (dev->rndis_config, (u8 *) req->buf); - if (status < 0) - ERROR(dev, "%s: rndis parse error %d\n", __FUNCTION__, status); -+ -+#ifdef CONFIG_USB_GADGET_PXA27X -+ write_ep0_zlp(); -+#endif - spin_unlock(&dev->lock); - } - |