Merge branches 'tracing/ftrace', 'tracing/kprobes', 'tracing/tasks' and 'linus' into...
Ingo Molnar [Fri, 20 Mar 2009 09:14:53 +0000 (10:14 +0100)]
98 files changed:
Makefile
arch/powerpc/configs/ps3_defconfig
arch/powerpc/include/asm/cputable.h
arch/powerpc/kernel/head_32.S
arch/powerpc/platforms/ps3/Kconfig
arch/s390/include/asm/mman.h
arch/s390/include/asm/processor.h
arch/s390/include/asm/topology.h
arch/s390/kernel/mcount.S
arch/s390/lib/div64.c
arch/s390/lib/uaccess_pt.c
arch/s390/mm/mmap.c
arch/s390/mm/pgtable.c
drivers/block/Makefile
drivers/block/ps3vram.c [new file with mode: 0644]
drivers/hid/usbhid/hiddev.c
drivers/mtd/devices/Kconfig
drivers/mtd/devices/Makefile
drivers/mtd/devices/ps3vram.c [deleted file]
drivers/staging/Kconfig
drivers/staging/Makefile
drivers/staging/benet/Kconfig [deleted file]
drivers/staging/benet/MAINTAINERS [deleted file]
drivers/staging/benet/Makefile [deleted file]
drivers/staging/benet/TODO [deleted file]
drivers/staging/benet/asyncmesg.h [deleted file]
drivers/staging/benet/be_cm.h [deleted file]
drivers/staging/benet/be_common.h [deleted file]
drivers/staging/benet/be_ethtool.c [deleted file]
drivers/staging/benet/be_init.c [deleted file]
drivers/staging/benet/be_int.c [deleted file]
drivers/staging/benet/be_netif.c [deleted file]
drivers/staging/benet/benet.h [deleted file]
drivers/staging/benet/bestatus.h [deleted file]
drivers/staging/benet/cev.h [deleted file]
drivers/staging/benet/cq.c [deleted file]
drivers/staging/benet/descriptors.h [deleted file]
drivers/staging/benet/doorbells.h [deleted file]
drivers/staging/benet/ep.h [deleted file]
drivers/staging/benet/eq.c [deleted file]
drivers/staging/benet/eth.c [deleted file]
drivers/staging/benet/etx_context.h [deleted file]
drivers/staging/benet/funcobj.c [deleted file]
drivers/staging/benet/fwcmd_common.h [deleted file]
drivers/staging/benet/fwcmd_common_bmap.h [deleted file]
drivers/staging/benet/fwcmd_eth_bmap.h [deleted file]
drivers/staging/benet/fwcmd_hdr_bmap.h [deleted file]
drivers/staging/benet/fwcmd_mcc.h [deleted file]
drivers/staging/benet/fwcmd_opcodes.h [deleted file]
drivers/staging/benet/fwcmd_types_bmap.h [deleted file]
drivers/staging/benet/host_struct.h [deleted file]
drivers/staging/benet/hwlib.h [deleted file]
drivers/staging/benet/mpu.c [deleted file]
drivers/staging/benet/mpu.h [deleted file]
drivers/staging/benet/mpu_context.h [deleted file]
drivers/staging/benet/pcicfg.h [deleted file]
drivers/staging/benet/post_codes.h [deleted file]
drivers/staging/benet/regmap.h [deleted file]
drivers/usb/atm/cxacru.c
drivers/usb/class/usbtmc.c
drivers/usb/core/devio.c
drivers/usb/host/ehci-q.c
drivers/usb/host/ehci-sched.c
drivers/usb/image/mdc800.c
drivers/usb/misc/adutux.c
drivers/usb/misc/vstusb.c
drivers/usb/serial/cp2101.c
drivers/usb/serial/ftdi_sio.c
drivers/usb/serial/ftdi_sio.h
drivers/usb/serial/option.c
drivers/usb/storage/unusual_devs.h
drivers/usb/wusbcore/wa-xfer.c
fs/aio.c
fs/btrfs/ctree.h
fs/btrfs/extent-tree.c
fs/btrfs/volumes.c
fs/buffer.c
fs/ext4/extents.c
fs/ext4/ialloc.c
fs/ext4/mballoc.c
fs/nfsd/nfs4xdr.c
include/linux/capability.h
include/linux/compiler.h
include/linux/ring_buffer.h
kernel/module.c
kernel/trace/ring_buffer.c
kernel/trace/trace.c
kernel/trace/trace.h
kernel/trace/trace_power.c
kernel/trace/trace_sched_switch.c
kernel/trace/trace_selftest.c
kernel/tracepoint.c
sound/core/oss/mixer_oss.c
sound/core/oss/pcm_oss.c
sound/core/sgbuf.c
sound/isa/opl3sa2.c
sound/pci/hda/hda_intel.c
sound/pci/mixart/mixart.c

index 46c04c5..828028d 100644 (file)
--- a/Makefile
+++ b/Makefile
@@ -567,6 +567,9 @@ KBUILD_CFLAGS += $(call cc-option,-Wdeclaration-after-statement,)
 # disable pointer signed / unsigned warnings in gcc 4.0
 KBUILD_CFLAGS += $(call cc-option,-Wno-pointer-sign,)
 
+# disable invalid "can't wrap" optimzations for signed / pointers
+KBUILD_CFLAGS  += $(call cc-option,-fwrapv)
+
 # Add user supplied CPPFLAGS, AFLAGS and CFLAGS as the last assignments
 # But warn user when we do so
 warn-assign = \
index b6eee7c..ac14f52 100644 (file)
@@ -1,7 +1,7 @@
 #
 # Automatically generated make config: don't edit
-# Linux kernel version: 2.6.27-rc3
-# Wed Aug 20 08:16:53 2008
+# Linux kernel version: 2.6.29-rc8
+# Fri Mar 13 09:28:45 2009
 #
 CONFIG_PPC64=y
 
@@ -16,13 +16,14 @@ CONFIG_PPC_FPU=y
 CONFIG_ALTIVEC=y
 # CONFIG_VSX is not set
 CONFIG_PPC_STD_MMU=y
+CONFIG_PPC_STD_MMU_64=y
 CONFIG_PPC_MM_SLICES=y
 CONFIG_VIRT_CPU_ACCOUNTING=y
 CONFIG_SMP=y
 CONFIG_NR_CPUS=2
 CONFIG_64BIT=y
 CONFIG_WORD_SIZE=64
-CONFIG_PPC_MERGE=y
+CONFIG_ARCH_PHYS_ADDR_T_64BIT=y
 CONFIG_MMU=y
 CONFIG_GENERIC_CMOS_UPDATE=y
 CONFIG_GENERIC_TIME=y
@@ -46,7 +47,7 @@ CONFIG_PPC=y
 CONFIG_EARLY_PRINTK=y
 CONFIG_COMPAT=y
 CONFIG_SYSVIPC_COMPAT=y
-CONFIG_SCHED_NO_NO_OMIT_FRAME_POINTER=y
+CONFIG_SCHED_OMIT_FRAME_POINTER=y
 CONFIG_ARCH_MAY_HAVE_PC_FDC=y
 CONFIG_PPC_OF=y
 CONFIG_OF=y
@@ -74,10 +75,19 @@ CONFIG_POSIX_MQUEUE=y
 # CONFIG_BSD_PROCESS_ACCT is not set
 # CONFIG_TASKSTATS is not set
 # CONFIG_AUDIT is not set
+
+#
+# RCU Subsystem
+#
+CONFIG_CLASSIC_RCU=y
+# CONFIG_TREE_RCU is not set
+# CONFIG_PREEMPT_RCU is not set
+# CONFIG_TREE_RCU_TRACE is not set
+# CONFIG_PREEMPT_RCU_TRACE is not set
 # CONFIG_IKCONFIG is not set
 CONFIG_LOG_BUF_SHIFT=17
-# CONFIG_CGROUPS is not set
 # CONFIG_GROUP_SCHED is not set
+# CONFIG_CGROUPS is not set
 CONFIG_SYSFS_DEPRECATED=y
 CONFIG_SYSFS_DEPRECATED_V2=y
 # CONFIG_RELAY is not set
@@ -86,11 +96,13 @@ CONFIG_NAMESPACES=y
 # CONFIG_IPC_NS is not set
 # CONFIG_USER_NS is not set
 # CONFIG_PID_NS is not set
+# CONFIG_NET_NS is not set
 CONFIG_BLK_DEV_INITRD=y
 CONFIG_INITRAMFS_SOURCE=""
 CONFIG_CC_OPTIMIZE_FOR_SIZE=y
 CONFIG_SYSCTL=y
-# CONFIG_EMBEDDED is not set
+CONFIG_ANON_INODES=y
+CONFIG_EMBEDDED=y
 CONFIG_SYSCTL_SYSCALL=y
 CONFIG_KALLSYMS=y
 CONFIG_KALLSYMS_ALL=y
@@ -99,37 +111,36 @@ CONFIG_HOTPLUG=y
 CONFIG_PRINTK=y
 CONFIG_BUG=y
 CONFIG_ELF_CORE=y
-# CONFIG_COMPAT_BRK is not set
 CONFIG_BASE_FULL=y
 CONFIG_FUTEX=y
-CONFIG_ANON_INODES=y
 CONFIG_EPOLL=y
 CONFIG_SIGNALFD=y
 CONFIG_TIMERFD=y
 CONFIG_EVENTFD=y
 CONFIG_SHMEM=y
+CONFIG_AIO=y
 CONFIG_VM_EVENT_COUNTERS=y
+# CONFIG_COMPAT_BRK is not set
 CONFIG_SLAB=y
 # CONFIG_SLUB is not set
 # CONFIG_SLOB is not set
 CONFIG_PROFILING=y
-# CONFIG_MARKERS is not set
+CONFIG_TRACEPOINTS=y
+CONFIG_MARKERS=y
 CONFIG_OPROFILE=m
 CONFIG_HAVE_OPROFILE=y
 # CONFIG_KPROBES is not set
 CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS=y
+CONFIG_HAVE_SYSCALL_WRAPPERS=y
 CONFIG_HAVE_IOREMAP_PROT=y
 CONFIG_HAVE_KPROBES=y
 CONFIG_HAVE_KRETPROBES=y
 CONFIG_HAVE_ARCH_TRACEHOOK=y
 CONFIG_HAVE_DMA_ATTRS=y
 CONFIG_USE_GENERIC_SMP_HELPERS=y
-# CONFIG_HAVE_CLK is not set
-CONFIG_PROC_PAGE_MONITOR=y
 # CONFIG_HAVE_GENERIC_DMA_COHERENT is not set
 CONFIG_SLABINFO=y
 CONFIG_RT_MUTEXES=y
-# CONFIG_TINY_SHMEM is not set
 CONFIG_BASE_SMALL=0
 CONFIG_MODULES=y
 # CONFIG_MODULE_FORCE_LOAD is not set
@@ -137,7 +148,6 @@ CONFIG_MODULE_UNLOAD=y
 # CONFIG_MODULE_FORCE_UNLOAD is not set
 # CONFIG_MODVERSIONS is not set
 # CONFIG_MODULE_SRCVERSION_ALL is not set
-CONFIG_KMOD=y
 CONFIG_STOP_MACHINE=y
 CONFIG_BLOCK=y
 # CONFIG_BLK_DEV_IO_TRACE is not set
@@ -157,7 +167,7 @@ CONFIG_DEFAULT_AS=y
 # CONFIG_DEFAULT_CFQ is not set
 # CONFIG_DEFAULT_NOOP is not set
 CONFIG_DEFAULT_IOSCHED="anticipatory"
-CONFIG_CLASSIC_RCU=y
+# CONFIG_FREEZER is not set
 
 #
 # Platform support
@@ -183,18 +193,20 @@ CONFIG_PS3_STORAGE=y
 CONFIG_PS3_DISK=y
 CONFIG_PS3_ROM=y
 CONFIG_PS3_FLASH=y
-CONFIG_OPROFILE_PS3=y
+CONFIG_PS3_VRAM=m
 CONFIG_PS3_LPM=m
 CONFIG_PPC_CELL=y
 # CONFIG_PPC_CELL_NATIVE is not set
 # CONFIG_PPC_IBM_CELL_BLADE is not set
 # CONFIG_PPC_CELLEB is not set
+# CONFIG_PPC_CELL_QPACE is not set
 
 #
 # Cell Broadband Engine options
 #
 CONFIG_SPU_FS=y
 CONFIG_SPU_FS_64K_LS=y
+# CONFIG_SPU_TRACE is not set
 CONFIG_SPU_BASE=y
 # CONFIG_PQ2ADS is not set
 # CONFIG_IPIC is not set
@@ -210,6 +222,7 @@ CONFIG_SPU_BASE=y
 # CONFIG_GENERIC_IOMAP is not set
 # CONFIG_CPU_FREQ is not set
 # CONFIG_FSL_ULI1575 is not set
+# CONFIG_SIMPLE_GPIO is not set
 
 #
 # Kernel options
@@ -229,6 +242,8 @@ CONFIG_PREEMPT_NONE=y
 # CONFIG_PREEMPT is not set
 CONFIG_BINFMT_ELF=y
 CONFIG_COMPAT_BINFMT_ELF=y
+# CONFIG_CORE_DUMP_DEFAULT_ELF_HEADERS is not set
+# CONFIG_HAVE_AOUT is not set
 CONFIG_BINFMT_MISC=y
 CONFIG_HUGETLB_PAGE_SIZE_VARIABLE=y
 # CONFIG_IOMMU_VMERGE is not set
@@ -251,7 +266,6 @@ CONFIG_SELECT_MEMORY_MODEL=y
 CONFIG_SPARSEMEM_MANUAL=y
 CONFIG_SPARSEMEM=y
 CONFIG_HAVE_MEMORY_PRESENT=y
-# CONFIG_SPARSEMEM_STATIC is not set
 CONFIG_SPARSEMEM_EXTREME=y
 CONFIG_SPARSEMEM_VMEMMAP_ENABLE=y
 # CONFIG_SPARSEMEM_VMEMMAP is not set
@@ -261,11 +275,14 @@ CONFIG_MEMORY_HOTPLUG_SPARSE=y
 CONFIG_PAGEFLAGS_EXTENDED=y
 CONFIG_SPLIT_PTLOCK_CPUS=4
 CONFIG_MIGRATION=y
-CONFIG_RESOURCES_64BIT=y
+CONFIG_PHYS_ADDR_T_64BIT=y
 CONFIG_ZONE_DMA_FLAG=1
 CONFIG_BOUNCE=y
+CONFIG_UNEVICTABLE_LRU=y
 CONFIG_ARCH_MEMORY_PROBE=y
 CONFIG_PPC_HAS_HASH_64K=y
+CONFIG_PPC_4K_PAGES=y
+# CONFIG_PPC_16K_PAGES is not set
 # CONFIG_PPC_64K_PAGES is not set
 CONFIG_FORCE_MAX_ZONEORDER=13
 CONFIG_SCHED_SMT=y
@@ -299,6 +316,7 @@ CONFIG_NET=y
 #
 # Networking options
 #
+CONFIG_COMPAT_NET_DEV_OPS=y
 CONFIG_PACKET=y
 CONFIG_PACKET_MMAP=y
 CONFIG_UNIX=y
@@ -361,6 +379,7 @@ CONFIG_IPV6_NDISC_NODETYPE=y
 # CONFIG_TIPC is not set
 # CONFIG_ATM is not set
 # CONFIG_BRIDGE is not set
+# CONFIG_NET_DSA is not set
 # CONFIG_VLAN_8021Q is not set
 # CONFIG_DECNET is not set
 # CONFIG_LLC2 is not set
@@ -371,6 +390,7 @@ CONFIG_IPV6_NDISC_NODETYPE=y
 # CONFIG_ECONET is not set
 # CONFIG_WAN_ROUTER is not set
 # CONFIG_NET_SCHED is not set
+# CONFIG_DCB is not set
 
 #
 # Network testing
@@ -392,39 +412,37 @@ CONFIG_BT_HIDP=m
 #
 # Bluetooth device drivers
 #
-CONFIG_BT_HCIUSB=m
-CONFIG_BT_HCIUSB_SCO=y
+CONFIG_BT_HCIBTUSB=m
 # CONFIG_BT_HCIUART 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_AF_RXRPC is not set
-
-#
-# Wireless
-#
+# CONFIG_PHONET is not set
+CONFIG_WIRELESS=y
 CONFIG_CFG80211=m
+# CONFIG_CFG80211_REG_DEBUG is not set
 CONFIG_NL80211=y
+# CONFIG_WIRELESS_OLD_REGULATORY is not set
 CONFIG_WIRELESS_EXT=y
 # CONFIG_WIRELESS_EXT_SYSFS is not set
+# CONFIG_LIB80211 is not set
 CONFIG_MAC80211=m
 
 #
 # Rate control algorithm selection
 #
 CONFIG_MAC80211_RC_PID=y
+# CONFIG_MAC80211_RC_MINSTREL is not set
 CONFIG_MAC80211_RC_DEFAULT_PID=y
+# CONFIG_MAC80211_RC_DEFAULT_MINSTREL is not set
 CONFIG_MAC80211_RC_DEFAULT="pid"
 # CONFIG_MAC80211_MESH is not set
 # CONFIG_MAC80211_LEDS is not set
 # CONFIG_MAC80211_DEBUGFS is not set
 # CONFIG_MAC80211_DEBUG_MENU is not set
-CONFIG_IEEE80211=m
-# CONFIG_IEEE80211_DEBUG is not set
-CONFIG_IEEE80211_CRYPT_WEP=m
-CONFIG_IEEE80211_CRYPT_CCMP=m
-CONFIG_IEEE80211_CRYPT_TKIP=m
+# CONFIG_WIMAX is not set
 # CONFIG_RFKILL is not set
 # CONFIG_NET_9P is not set
 
@@ -450,6 +468,7 @@ CONFIG_MTD_DEBUG=y
 CONFIG_MTD_DEBUG_VERBOSE=0
 # CONFIG_MTD_CONCAT is not set
 # CONFIG_MTD_PARTITIONS is not set
+# CONFIG_MTD_TESTS is not set
 
 #
 # User Modules And Translation Layers
@@ -494,7 +513,6 @@ CONFIG_MTD_CFI_I2=y
 #
 # CONFIG_MTD_SLRAM is not set
 # CONFIG_MTD_PHRAM is not set
-CONFIG_MTD_PS3VRAM=y
 # CONFIG_MTD_MTDRAM is not set
 # CONFIG_MTD_BLOCK2MTD is not set
 
@@ -508,6 +526,11 @@ CONFIG_MTD_PS3VRAM=y
 # CONFIG_MTD_ONENAND is not set
 
 #
+# LPDDR flash memory drivers
+#
+# CONFIG_MTD_LPDDR is not set
+
+#
 # UBI - Unsorted block images
 #
 # CONFIG_MTD_UBI is not set
@@ -528,8 +551,13 @@ CONFIG_BLK_DEV_RAM_SIZE=65535
 # CONFIG_ATA_OVER_ETH is not set
 # CONFIG_BLK_DEV_HD is not set
 CONFIG_MISC_DEVICES=y
-# CONFIG_EEPROM_93CX6 is not set
 # CONFIG_ENCLOSURE_SERVICES is not set
+# CONFIG_C2PORT is not set
+
+#
+# EEPROM support
+#
+# CONFIG_EEPROM_93CX6 is not set
 CONFIG_HAVE_IDE=y
 # CONFIG_IDE is not set
 
@@ -575,7 +603,17 @@ CONFIG_SCSI_WAIT_SCAN=m
 # CONFIG_SCSI_LOWLEVEL is not set
 # CONFIG_SCSI_DH is not set
 # CONFIG_ATA is not set
-# CONFIG_MD is not set
+CONFIG_MD=y
+# CONFIG_BLK_DEV_MD is not set
+CONFIG_BLK_DEV_DM=m
+# CONFIG_DM_DEBUG is not set
+# CONFIG_DM_CRYPT is not set
+# CONFIG_DM_SNAPSHOT is not set
+# CONFIG_DM_MIRROR is not set
+# CONFIG_DM_ZERO is not set
+# CONFIG_DM_MULTIPATH is not set
+# CONFIG_DM_DELAY is not set
+# CONFIG_DM_UEVENT is not set
 # CONFIG_MACINTOSH_DRIVERS is not set
 CONFIG_NETDEVICES=y
 # CONFIG_DUMMY is not set
@@ -591,6 +629,9 @@ CONFIG_MII=m
 # CONFIG_IBM_NEW_EMAC_RGMII is not set
 # CONFIG_IBM_NEW_EMAC_TAH is not set
 # CONFIG_IBM_NEW_EMAC_EMAC4 is not set
+# CONFIG_IBM_NEW_EMAC_NO_FLOW_CTRL is not set
+# CONFIG_IBM_NEW_EMAC_MAL_CLR_ICINTSTAT is not set
+# CONFIG_IBM_NEW_EMAC_MAL_COMMON_ERR is not set
 # CONFIG_B44 is not set
 CONFIG_NETDEV_1000=y
 CONFIG_GELIC_NET=y
@@ -604,6 +645,7 @@ CONFIG_GELIC_WIRELESS_OLD_PSK_INTERFACE=y
 # CONFIG_WLAN_PRE80211 is not set
 CONFIG_WLAN_80211=y
 # CONFIG_LIBERTAS is not set
+# CONFIG_LIBERTAS_THINFIRM is not set
 # CONFIG_USB_ZD1201 is not set
 # CONFIG_USB_NET_RNDIS_WLAN is not set
 # CONFIG_RTL8187 is not set
@@ -615,13 +657,11 @@ CONFIG_WLAN_80211=y
 # CONFIG_B43LEGACY is not set
 CONFIG_ZD1211RW=m
 # CONFIG_ZD1211RW_DEBUG is not set
-CONFIG_RT2X00=m
-CONFIG_RT2X00_LIB=m
-CONFIG_RT2X00_LIB_USB=m
-CONFIG_RT2X00_LIB_FIRMWARE=y
-# CONFIG_RT2500USB is not set
-CONFIG_RT73USB=m
-# CONFIG_RT2X00_DEBUG is not set
+# CONFIG_RT2X00 is not set
+
+#
+# Enable WiMAX (Networking options) to see the WiMAX drivers
+#
 
 #
 # USB Network Adapters
@@ -634,6 +674,7 @@ CONFIG_USB_USBNET=m
 CONFIG_USB_NET_AX8817X=m
 # CONFIG_USB_NET_CDCETHER is not set
 # CONFIG_USB_NET_DM9601 is not set
+# CONFIG_USB_NET_SMSC95XX is not set
 # CONFIG_USB_NET_GL620A is not set
 # CONFIG_USB_NET_NET1080 is not set
 # CONFIG_USB_NET_PLUSB is not set
@@ -664,7 +705,7 @@ CONFIG_SLHC=m
 # Input device support
 #
 CONFIG_INPUT=y
-# CONFIG_INPUT_FF_MEMLESS is not set
+CONFIG_INPUT_FF_MEMLESS=m
 # CONFIG_INPUT_POLLDEV is not set
 
 #
@@ -735,8 +776,10 @@ CONFIG_DEVKMEM=y
 # Non-8250 serial port support
 #
 CONFIG_UNIX98_PTYS=y
+# CONFIG_DEVPTS_MULTIPLE_INSTANCES is not set
 CONFIG_LEGACY_PTYS=y
 CONFIG_LEGACY_PTY_COUNT=16
+# CONFIG_HVC_UDBG is not set
 # CONFIG_IPMI_HANDLER is not set
 # CONFIG_HW_RANDOM is not set
 # CONFIG_R3964 is not set
@@ -753,11 +796,11 @@ CONFIG_ARCH_WANT_OPTIONAL_GPIOLIB=y
 # CONFIG_THERMAL is not set
 # CONFIG_THERMAL_HWMON is not set
 # CONFIG_WATCHDOG is not set
+CONFIG_SSB_POSSIBLE=y
 
 #
 # Sonics Silicon Backplane
 #
-CONFIG_SSB_POSSIBLE=y
 # CONFIG_SSB is not set
 
 #
@@ -767,6 +810,7 @@ CONFIG_SSB_POSSIBLE=y
 # CONFIG_MFD_SM501 is not set
 # CONFIG_HTC_PASIC3 is not set
 # CONFIG_MFD_TMIO is not set
+# CONFIG_REGULATOR is not set
 
 #
 # Multimedia devices
@@ -792,6 +836,7 @@ CONFIG_VIDEO_OUTPUT_CONTROL=m
 CONFIG_FB=y
 # CONFIG_FIRMWARE_EDID is not set
 # CONFIG_FB_DDC is not set
+# CONFIG_FB_BOOT_VESA_SUPPORT is not set
 # CONFIG_FB_CFB_FILLRECT is not set
 # CONFIG_FB_CFB_COPYAREA is not set
 # CONFIG_FB_CFB_IMAGEBLIT is not set
@@ -817,6 +862,8 @@ CONFIG_FB_SYS_FOPS=y
 CONFIG_FB_PS3=y
 CONFIG_FB_PS3_DEFAULT_SIZE_M=9
 # CONFIG_FB_VIRTUAL is not set
+# CONFIG_FB_METRONOME is not set
+# CONFIG_FB_MB862XX is not set
 # CONFIG_BACKLIGHT_LCD_SUPPORT is not set
 
 #
@@ -841,6 +888,7 @@ CONFIG_FB_LOGO_EXTRA=y
 # CONFIG_LOGO_LINUX_VGA16 is not set
 CONFIG_LOGO_LINUX_CLUT224=y
 CONFIG_SOUND=m
+# CONFIG_SOUND_OSS_CORE is not set
 CONFIG_SND=m
 CONFIG_SND_TIMER=m
 CONFIG_SND_PCM=m
@@ -849,6 +897,7 @@ CONFIG_SND_RAWMIDI=m
 # CONFIG_SND_SEQUENCER is not set
 # CONFIG_SND_MIXER_OSS is not set
 # CONFIG_SND_PCM_OSS is not set
+# CONFIG_SND_HRTIMER is not set
 # CONFIG_SND_DYNAMIC_MINORS is not set
 CONFIG_SND_SUPPORT_OLD_API=y
 CONFIG_SND_VERBOSE_PROCFS=y
@@ -873,15 +922,40 @@ CONFIG_HIDRAW=y
 # USB Input Devices
 #
 CONFIG_USB_HID=m
-# CONFIG_USB_HIDINPUT_POWERBOOK is not set
-# CONFIG_HID_FF is not set
-# CONFIG_USB_HIDDEV is not set
+# CONFIG_HID_PID is not set
+CONFIG_USB_HIDDEV=y
 
 #
 # USB HID Boot Protocol drivers
 #
 # CONFIG_USB_KBD is not set
 # CONFIG_USB_MOUSE is not set
+
+#
+# Special HID drivers
+#
+# CONFIG_HID_COMPAT is not set
+# CONFIG_HID_A4TECH is not set
+# CONFIG_HID_APPLE is not set
+# CONFIG_HID_BELKIN is not set
+# CONFIG_HID_CHERRY is not set
+# CONFIG_HID_CHICONY is not set
+# CONFIG_HID_CYPRESS is not set
+# CONFIG_HID_EZKEY is not set
+# CONFIG_HID_GYRATION is not set
+# CONFIG_HID_LOGITECH is not set
+# CONFIG_HID_MICROSOFT is not set
+# CONFIG_HID_MONTEREY is not set
+# CONFIG_HID_NTRIG is not set
+# CONFIG_HID_PANTHERLORD is not set
+# CONFIG_HID_PETALYNX is not set
+# CONFIG_HID_SAMSUNG is not set
+# CONFIG_HID_SONY is not set
+# CONFIG_HID_SUNPLUS is not set
+# CONFIG_GREENASIA_FF is not set
+# CONFIG_HID_TOPSEED is not set
+# CONFIG_THRUSTMASTER_FF is not set
+# CONFIG_ZEROPLUS_FF is not set
 CONFIG_USB_SUPPORT=y
 CONFIG_USB_ARCH_HAS_HCD=y
 CONFIG_USB_ARCH_HAS_OHCI=y
@@ -898,7 +972,11 @@ CONFIG_USB_DEVICEFS=y
 # CONFIG_USB_DYNAMIC_MINORS is not set
 CONFIG_USB_SUSPEND=y
 # CONFIG_USB_OTG is not set
-CONFIG_USB_MON=y
+# CONFIG_USB_OTG_WHITELIST is not set
+# CONFIG_USB_OTG_BLACKLIST_HUB is not set
+CONFIG_USB_MON=m
+# CONFIG_USB_WUSB is not set
+# CONFIG_USB_WUSB_CBAF is not set
 
 #
 # USB Host Controller Drivers
@@ -909,6 +987,7 @@ CONFIG_USB_EHCI_HCD=m
 # CONFIG_USB_EHCI_TT_NEWSCHED is not set
 CONFIG_USB_EHCI_BIG_ENDIAN_MMIO=y
 # CONFIG_USB_EHCI_HCD_PPC_OF is not set
+# CONFIG_USB_OXU210HP_HCD is not set
 # CONFIG_USB_ISP116X_HCD is not set
 # CONFIG_USB_ISP1760_HCD is not set
 CONFIG_USB_OHCI_HCD=m
@@ -918,6 +997,7 @@ CONFIG_USB_OHCI_BIG_ENDIAN_MMIO=y
 CONFIG_USB_OHCI_LITTLE_ENDIAN=y
 # CONFIG_USB_SL811_HCD is not set
 # CONFIG_USB_R8A66597_HCD is not set
+# CONFIG_USB_HWA_HCD is not set
 
 #
 # Enable Host or Gadget support to see Inventra options
@@ -929,20 +1009,20 @@ CONFIG_USB_OHCI_LITTLE_ENDIAN=y
 # CONFIG_USB_ACM is not set
 # CONFIG_USB_PRINTER is not set
 # CONFIG_USB_WDM is not set
+# CONFIG_USB_TMC is not set
 
 #
-# NOTE: USB_STORAGE enables SCSI, and 'SCSI disk support'
+# NOTE: USB_STORAGE depends on SCSI but BLK_DEV_SD may also be needed;
 #
 
 #
-# may also be needed; see USB_STORAGE Help for more information
+# see USB_STORAGE Help for more information
 #
 CONFIG_USB_STORAGE=m
 # CONFIG_USB_STORAGE_DEBUG is not set
 # CONFIG_USB_STORAGE_DATAFAB is not set
 # CONFIG_USB_STORAGE_FREECOM is not set
 # CONFIG_USB_STORAGE_ISD200 is not set
-# CONFIG_USB_STORAGE_DPCM is not set
 # CONFIG_USB_STORAGE_USBAT is not set
 # CONFIG_USB_STORAGE_SDDR09 is not set
 # CONFIG_USB_STORAGE_SDDR55 is not set
@@ -950,7 +1030,6 @@ CONFIG_USB_STORAGE=m
 # CONFIG_USB_STORAGE_ALAUDA is not set
 # CONFIG_USB_STORAGE_ONETOUCH is not set
 # CONFIG_USB_STORAGE_KARMA is not set
-# CONFIG_USB_STORAGE_SIERRA is not set
 # CONFIG_USB_STORAGE_CYPRESS_ATACB is not set
 # CONFIG_USB_LIBUSUAL is not set
 
@@ -971,6 +1050,7 @@ CONFIG_USB_STORAGE=m
 # CONFIG_USB_EMI62 is not set
 # CONFIG_USB_EMI26 is not set
 # CONFIG_USB_ADUTUX is not set
+# CONFIG_USB_SEVSEG is not set
 # CONFIG_USB_RIO500 is not set
 # CONFIG_USB_LEGOTOWER is not set
 # CONFIG_USB_LCD is not set
@@ -988,7 +1068,12 @@ CONFIG_USB_STORAGE=m
 # CONFIG_USB_IOWARRIOR is not set
 # CONFIG_USB_TEST is not set
 # CONFIG_USB_ISIGHTFW is not set
+# CONFIG_USB_VST is not set
 # CONFIG_USB_GADGET is not set
+
+#
+# OTG and related infrastructure
+#
 # CONFIG_MMC is not set
 # CONFIG_MEMSTICK is not set
 # CONFIG_NEW_LEDS is not set
@@ -1014,12 +1099,15 @@ CONFIG_RTC_INTF_DEV=y
 # Platform RTC drivers
 #
 # CONFIG_RTC_DRV_CMOS is not set
+# CONFIG_RTC_DRV_DS1286 is not set
 # CONFIG_RTC_DRV_DS1511 is not set
 # CONFIG_RTC_DRV_DS1553 is not set
 # CONFIG_RTC_DRV_DS1742 is not set
 # CONFIG_RTC_DRV_STK17TA8 is not set
 # CONFIG_RTC_DRV_M48T86 is not set
+# CONFIG_RTC_DRV_M48T35 is not set
 # CONFIG_RTC_DRV_M48T59 is not set
+# CONFIG_RTC_DRV_BQ4802 is not set
 # CONFIG_RTC_DRV_V3020 is not set
 
 #
@@ -1028,6 +1116,7 @@ CONFIG_RTC_INTF_DEV=y
 CONFIG_RTC_DRV_PPC=m
 # CONFIG_DMADEVICES is not set
 # CONFIG_UIO is not set
+# CONFIG_STAGING is not set
 
 #
 # File systems
@@ -1035,26 +1124,35 @@ CONFIG_RTC_DRV_PPC=m
 CONFIG_EXT2_FS=m
 # CONFIG_EXT2_FS_XATTR is not set
 # CONFIG_EXT2_FS_XIP is not set
-CONFIG_EXT3_FS=y
+CONFIG_EXT3_FS=m
 CONFIG_EXT3_FS_XATTR=y
 # CONFIG_EXT3_FS_POSIX_ACL is not set
 # CONFIG_EXT3_FS_SECURITY is not set
-# CONFIG_EXT4DEV_FS is not set
-CONFIG_JBD=y
+CONFIG_EXT4_FS=y
+# CONFIG_EXT4DEV_COMPAT is not set
+CONFIG_EXT4_FS_XATTR=y
+# CONFIG_EXT4_FS_POSIX_ACL is not set
+# CONFIG_EXT4_FS_SECURITY is not set
+CONFIG_JBD=m
 # CONFIG_JBD_DEBUG is not set
+CONFIG_JBD2=y
+# CONFIG_JBD2_DEBUG is not set
 CONFIG_FS_MBCACHE=y
 # CONFIG_REISERFS_FS is not set
 # CONFIG_JFS_FS is not set
 # CONFIG_FS_POSIX_ACL is not set
+CONFIG_FILE_LOCKING=y
 # CONFIG_XFS_FS is not set
 # CONFIG_GFS2_FS is not set
 # CONFIG_OCFS2_FS is not set
+# CONFIG_BTRFS_FS is not set
 CONFIG_DNOTIFY=y
 CONFIG_INOTIFY=y
 CONFIG_INOTIFY_USER=y
 CONFIG_QUOTA=y
 # CONFIG_QUOTA_NETLINK_INTERFACE is not set
 CONFIG_PRINT_QUOTA_WARNING=y
+CONFIG_QUOTA_TREE=y
 # CONFIG_QFMT_V1 is not set
 CONFIG_QFMT_V2=y
 CONFIG_QUOTACTL=y
@@ -1087,16 +1185,14 @@ CONFIG_FAT_DEFAULT_IOCHARSET="iso8859-1"
 CONFIG_PROC_FS=y
 CONFIG_PROC_KCORE=y
 CONFIG_PROC_SYSCTL=y
+CONFIG_PROC_PAGE_MONITOR=y
 CONFIG_SYSFS=y
 CONFIG_TMPFS=y
 # CONFIG_TMPFS_POSIX_ACL is not set
 CONFIG_HUGETLBFS=y
 CONFIG_HUGETLB_PAGE=y
 # CONFIG_CONFIGFS_FS is not set
-
-#
-# Miscellaneous filesystems
-#
+CONFIG_MISC_FILESYSTEMS=y
 # CONFIG_ADFS_FS is not set
 # CONFIG_AFFS_FS is not set
 # CONFIG_HFS_FS is not set
@@ -1106,6 +1202,7 @@ CONFIG_HUGETLB_PAGE=y
 # CONFIG_EFS_FS is not set
 # CONFIG_JFFS2_FS is not set
 # CONFIG_CRAMFS is not set
+# CONFIG_SQUASHFS is not set
 # CONFIG_VXFS_FS is not set
 # CONFIG_MINIX_FS is not set
 # CONFIG_OMFS_FS is not set
@@ -1126,6 +1223,7 @@ CONFIG_LOCKD_V4=y
 CONFIG_NFS_COMMON=y
 CONFIG_SUNRPC=y
 CONFIG_SUNRPC_GSS=y
+# CONFIG_SUNRPC_REGISTER_V4 is not set
 CONFIG_RPCSEC_GSS_KRB5=y
 # CONFIG_RPCSEC_GSS_SPKM3 is not set
 # CONFIG_SMB_FS is not set
@@ -1190,9 +1288,9 @@ CONFIG_NLS_ISO8859_1=y
 # Library routines
 #
 CONFIG_BITREVERSE=y
-# CONFIG_GENERIC_FIND_FIRST_BIT is not set
+CONFIG_GENERIC_FIND_LAST_BIT=y
 CONFIG_CRC_CCITT=m
-# CONFIG_CRC16 is not set
+CONFIG_CRC16=y
 CONFIG_CRC_T10DIF=y
 CONFIG_CRC_ITU_T=m
 CONFIG_CRC32=y
@@ -1250,27 +1348,44 @@ CONFIG_DEBUG_WRITECOUNT=y
 CONFIG_DEBUG_MEMORY_INIT=y
 CONFIG_DEBUG_LIST=y
 # CONFIG_DEBUG_SG is not set
-CONFIG_FRAME_POINTER=y
+# CONFIG_DEBUG_NOTIFIERS is not set
 # CONFIG_BOOT_PRINTK_DELAY is not set
 # CONFIG_RCU_TORTURE_TEST is not set
+# CONFIG_RCU_CPU_STALL_DETECTOR is not set
 # CONFIG_BACKTRACE_SELF_TEST is not set
+# CONFIG_DEBUG_BLOCK_EXT_DEVT is not set
 # CONFIG_FAULT_INJECTION is not set
 # CONFIG_LATENCYTOP is not set
 CONFIG_SYSCTL_SYSCALL_CHECK=y
-CONFIG_HAVE_FTRACE=y
+CONFIG_NOP_TRACER=y
+CONFIG_HAVE_FUNCTION_TRACER=y
 CONFIG_HAVE_DYNAMIC_FTRACE=y
-# CONFIG_FTRACE is not set
+CONFIG_HAVE_FTRACE_MCOUNT_RECORD=y
+CONFIG_RING_BUFFER=y
+CONFIG_TRACING=y
+
+#
+# Tracers
+#
+# CONFIG_FUNCTION_TRACER is not set
 # CONFIG_IRQSOFF_TRACER is not set
 # CONFIG_SCHED_TRACER is not set
 # CONFIG_CONTEXT_SWITCH_TRACER is not set
+# CONFIG_BOOT_TRACER is not set
+# CONFIG_TRACE_BRANCH_PROFILING is not set
+# CONFIG_STACK_TRACER is not set
+# CONFIG_FTRACE_STARTUP_TEST is not set
+# CONFIG_DYNAMIC_PRINTK_DEBUG is not set
 # CONFIG_SAMPLES is not set
 CONFIG_HAVE_ARCH_KGDB=y
 # CONFIG_KGDB is not set
+CONFIG_PRINT_STACK_DEPTH=64
 CONFIG_DEBUG_STACKOVERFLOW=y
 # CONFIG_DEBUG_STACK_USAGE is not set
 # CONFIG_DEBUG_PAGEALLOC is not set
 # CONFIG_CODE_PATCHING_SELFTEST is not set
 # CONFIG_FTR_FIXUP_SELFTEST is not set
+# CONFIG_MSI_BITMAP_SELFTEST is not set
 # CONFIG_XMON is not set
 CONFIG_IRQSTACKS=y
 # CONFIG_VIRQ_DEBUG is not set
@@ -1282,16 +1397,26 @@ CONFIG_IRQSTACKS=y
 #
 # CONFIG_KEYS is not set
 # CONFIG_SECURITY is not set
+# CONFIG_SECURITYFS is not set
 # CONFIG_SECURITY_FILE_CAPABILITIES is not set
 CONFIG_CRYPTO=y
 
 #
 # Crypto core or helper
 #
+# CONFIG_CRYPTO_FIPS is not set
 CONFIG_CRYPTO_ALGAPI=y
+CONFIG_CRYPTO_ALGAPI2=y
 CONFIG_CRYPTO_AEAD=m
+CONFIG_CRYPTO_AEAD2=y
 CONFIG_CRYPTO_BLKCIPHER=y
+CONFIG_CRYPTO_BLKCIPHER2=y
+CONFIG_CRYPTO_HASH=y
+CONFIG_CRYPTO_HASH2=y
+CONFIG_CRYPTO_RNG=m
+CONFIG_CRYPTO_RNG2=y
 CONFIG_CRYPTO_MANAGER=y
+CONFIG_CRYPTO_MANAGER2=y
 CONFIG_CRYPTO_GF128MUL=m
 # CONFIG_CRYPTO_NULL is not set
 # CONFIG_CRYPTO_CRYPTD is not set
@@ -1363,6 +1488,11 @@ CONFIG_CRYPTO_SALSA20=m
 #
 # CONFIG_CRYPTO_DEFLATE is not set
 CONFIG_CRYPTO_LZO=m
+
+#
+# Random Number Generation
+#
+# CONFIG_CRYPTO_ANSI_CPRNG is not set
 CONFIG_CRYPTO_HW=y
 # CONFIG_PPC_CLOCK is not set
 # CONFIG_VIRTUALIZATION is not set
index 4911104..21172ba 100644 (file)
@@ -241,9 +241,11 @@ extern const char *powerpc_base_platform;
 /* We need to mark all pages as being coherent if we're SMP or we have a
  * 74[45]x and an MPC107 host bridge. Also 83xx and PowerQUICC II
  * require it for PCI "streaming/prefetch" to work properly.
+ * This is also required by 52xx family.
  */
 #if defined(CONFIG_SMP) || defined(CONFIG_MPC10X_BRIDGE) \
-       || defined(CONFIG_PPC_83xx) || defined(CONFIG_8260)
+       || defined(CONFIG_PPC_83xx) || defined(CONFIG_8260) \
+       || defined(CONFIG_PPC_MPC52xx)
 #define CPU_FTR_COMMON                  CPU_FTR_NEED_COHERENT
 #else
 #define CPU_FTR_COMMON                  0
index a1c4cfd..7db2e42 100644 (file)
@@ -511,7 +511,7 @@ InstructionTLBMiss:
        and     r1,r1,r2                /* writable if _RW and _DIRTY */
        rlwimi  r3,r3,32-1,30,30        /* _PAGE_USER -> PP msb */
        rlwimi  r3,r3,32-1,31,31        /* _PAGE_USER -> PP lsb */
-       ori     r1,r1,0xe14             /* clear out reserved bits and M */
+       ori     r1,r1,0xe04             /* clear out reserved bits */
        andc    r1,r3,r1                /* PP = user? (rw&dirty? 2: 3): 0 */
        mtspr   SPRN_RPA,r1
        mfspr   r3,SPRN_IMISS
@@ -585,7 +585,7 @@ DataLoadTLBMiss:
        and     r1,r1,r2                /* writable if _RW and _DIRTY */
        rlwimi  r3,r3,32-1,30,30        /* _PAGE_USER -> PP msb */
        rlwimi  r3,r3,32-1,31,31        /* _PAGE_USER -> PP lsb */
-       ori     r1,r1,0xe14             /* clear out reserved bits and M */
+       ori     r1,r1,0xe04             /* clear out reserved bits */
        andc    r1,r3,r1                /* PP = user? (rw&dirty? 2: 3): 0 */
        mtspr   SPRN_RPA,r1
        mfspr   r3,SPRN_DMISS
@@ -653,7 +653,7 @@ DataStoreTLBMiss:
        stw     r3,0(r2)                /* update PTE (accessed/dirty bits) */
        /* Convert linux-style PTE to low word of PPC-style PTE */
        rlwimi  r3,r3,32-1,30,30        /* _PAGE_USER -> PP msb */
-       li      r1,0xe15                /* clear out reserved bits and M */
+       li      r1,0xe05                /* clear out reserved bits & PP lsb */
        andc    r1,r3,r1                /* PP = user? 2: 0 */
        mtspr   SPRN_RPA,r1
        mfspr   r3,SPRN_DMISS
index 920cf7a..740ef56 100644 (file)
@@ -128,6 +128,13 @@ config PS3_FLASH
          be disabled on the kernel command line using "ps3flash=off", to
          not allocate this fixed buffer.
 
+config PS3_VRAM
+       tristate "PS3 Video RAM Storage Driver"
+       depends on FB_PS3=y && BLOCK && m
+       help
+         This driver allows you to use excess PS3 video RAM as volatile
+         storage or system swap.
+
 config PS3_LPM
        tristate "PS3 Logical Performance Monitor support"
        depends on PPC_PS3
index 7839767..da01432 100644 (file)
@@ -22,4 +22,9 @@
 #define MCL_CURRENT    1               /* lock all current mappings */
 #define MCL_FUTURE     2               /* lock all future mappings */
 
+#if defined(__KERNEL__) && !defined(__ASSEMBLY__) && defined(CONFIG_64BIT)
+int s390_mmap_check(unsigned long addr, unsigned long len);
+#define arch_mmap_check(addr,len,flags)        s390_mmap_check(addr,len)
+#endif
+
 #endif /* __S390_MMAN_H__ */
index 066b995..db4523f 100644 (file)
@@ -61,7 +61,7 @@ extern void print_cpu_info(struct cpuinfo_S390 *);
 extern int get_cpu_capability(unsigned int *);
 
 /*
- * User space process size: 2GB for 31 bit, 4TB for 64 bit.
+ * User space process size: 2GB for 31 bit, 4TB or 8PT for 64 bit.
  */
 #ifndef __s390x__
 
@@ -70,8 +70,7 @@ extern int get_cpu_capability(unsigned int *);
 
 #else /* __s390x__ */
 
-#define TASK_SIZE_OF(tsk)      (test_tsk_thread_flag(tsk,TIF_31BIT) ? \
-                                       (1UL << 31) : (1UL << 53))
+#define TASK_SIZE_OF(tsk)      ((tsk)->mm->context.asce_limit)
 #define TASK_UNMAPPED_BASE     (test_thread_flag(TIF_31BIT) ? \
                                        (1UL << 30) : (1UL << 41))
 #define TASK_SIZE              TASK_SIZE_OF(current)
index c93eb50..c979c3b 100644 (file)
@@ -30,6 +30,8 @@ static inline void s390_init_cpu_topology(void)
 };
 #endif
 
+#define SD_MC_INIT SD_CPU_INIT
+
 #include <asm-generic/topology.h>
 
 #endif /* _ASM_S390_TOPOLOGY_H */
index 397d131..8064122 100644 (file)
@@ -5,6 +5,8 @@
  *
  */
 
+#include <asm/asm-offsets.h>
+
 #ifndef CONFIG_64BIT
 .globl _mcount
 _mcount:
@@ -14,7 +16,7 @@ _mcount:
        ahi     %r15,-96
        l       %r3,100(%r15)
        la      %r2,0(%r14)
-       st      %r1,0(%r15)
+       st      %r1,__SF_BACKCHAIN(%r15)
        la      %r3,0(%r3)
        bras    %r14,0f
        .long   ftrace_trace_function
@@ -38,7 +40,7 @@ _mcount:
        stg     %r14,112(%r15)
        lgr     %r1,%r15
        aghi    %r15,-160
-       stg     %r1,0(%r15)
+       stg     %r1,__SF_BACKCHAIN(%r15)
        lgr     %r2,%r14
        lg      %r3,168(%r15)
        larl    %r14,ftrace_trace_function
index a5f8300..d9e62c0 100644 (file)
@@ -61,7 +61,7 @@ static uint32_t __div64_31(uint64_t *n, uint32_t base)
                "       clr     %0,%3\n"
                "       jl      0f\n"
                "       slr     %0,%3\n"
-               "       alr     %1,%2\n"
+               "       ahi     %1,1\n"
                "0:\n"
                : "+d" (reg2), "+d" (reg3), "=d" (tmp)
                : "d" (base), "2" (1UL) : "cc" );
index d66215b..b0b84c3 100644 (file)
@@ -119,8 +119,6 @@ retry:
                        goto fault;
 
                pfn = pte_pfn(*pte);
-               if (!pfn_valid(pfn))
-                       goto out;
 
                offset = uaddr & (PAGE_SIZE - 1);
                size = min(n - done, PAGE_SIZE - offset);
@@ -135,7 +133,6 @@ retry:
                done += size;
                uaddr += size;
        } while (done < n);
-out:
        spin_unlock(&mm->page_table_lock);
        return n - done;
 fault:
@@ -163,9 +160,6 @@ retry:
                goto fault;
 
        pfn = pte_pfn(*pte);
-       if (!pfn_valid(pfn))
-               goto out;
-
        ret = (pfn << PAGE_SHIFT) + (uaddr & (PAGE_SIZE - 1));
 out:
        return ret;
@@ -244,11 +238,6 @@ retry:
                        goto fault;
 
                pfn = pte_pfn(*pte);
-               if (!pfn_valid(pfn)) {
-                       done = -1;
-                       goto out;
-               }
-
                offset = uaddr & (PAGE_SIZE-1);
                addr = (char *)(pfn << PAGE_SHIFT) + offset;
                len = min(count - done, PAGE_SIZE - offset);
@@ -256,7 +245,6 @@ retry:
                done += len_str;
                uaddr += len_str;
        } while ((len_str == len) && (done < count));
-out:
        spin_unlock(&mm->page_table_lock);
        return done + 1;
 fault:
@@ -325,12 +313,7 @@ retry:
                }
 
                pfn_from = pte_pfn(*pte_from);
-               if (!pfn_valid(pfn_from))
-                       goto out;
                pfn_to = pte_pfn(*pte_to);
-               if (!pfn_valid(pfn_to))
-                       goto out;
-
                offset_from = uaddr_from & (PAGE_SIZE-1);
                offset_to = uaddr_from & (PAGE_SIZE-1);
                offset_max = max(offset_from, offset_to);
@@ -342,7 +325,6 @@ retry:
                uaddr_from += size;
                uaddr_to += size;
        } while (done < n);
-out:
        spin_unlock(&mm->page_table_lock);
        return n - done;
 fault:
index 5932a82..e008d23 100644 (file)
@@ -35,7 +35,7 @@
  * Leave an at least ~128 MB hole.
  */
 #define MIN_GAP (128*1024*1024)
-#define MAX_GAP (TASK_SIZE/6*5)
+#define MAX_GAP (STACK_TOP/6*5)
 
 static inline unsigned long mmap_base(void)
 {
@@ -46,7 +46,7 @@ static inline unsigned long mmap_base(void)
        else if (gap > MAX_GAP)
                gap = MAX_GAP;
 
-       return TASK_SIZE - (gap & PAGE_MASK);
+       return STACK_TOP - (gap & PAGE_MASK);
 }
 
 static inline int mmap_is_legacy(void)
@@ -89,42 +89,58 @@ EXPORT_SYMBOL_GPL(arch_pick_mmap_layout);
 
 #else
 
+int s390_mmap_check(unsigned long addr, unsigned long len)
+{
+       if (!test_thread_flag(TIF_31BIT) &&
+           len >= TASK_SIZE && TASK_SIZE < (1UL << 53))
+               return crst_table_upgrade(current->mm, 1UL << 53);
+       return 0;
+}
+
 static unsigned long
 s390_get_unmapped_area(struct file *filp, unsigned long addr,
                unsigned long len, unsigned long pgoff, unsigned long flags)
 {
        struct mm_struct *mm = current->mm;
+       unsigned long area;
        int rc;
 
-       addr = arch_get_unmapped_area(filp, addr, len, pgoff, flags);
-       if (addr & ~PAGE_MASK)
-               return addr;
-       if (unlikely(mm->context.asce_limit < addr + len)) {
-               rc = crst_table_upgrade(mm, addr + len);
+       area = arch_get_unmapped_area(filp, addr, len, pgoff, flags);
+       if (!(area & ~PAGE_MASK))
+               return area;
+       if (area == -ENOMEM &&
+           !test_thread_flag(TIF_31BIT) && TASK_SIZE < (1UL << 53)) {
+               /* Upgrade the page table to 4 levels and retry. */
+               rc = crst_table_upgrade(mm, 1UL << 53);
                if (rc)
                        return (unsigned long) rc;
+               area = arch_get_unmapped_area(filp, addr, len, pgoff, flags);
        }
-       return addr;
+       return area;
 }
 
 static unsigned long
-s390_get_unmapped_area_topdown(struct file *filp, const unsigned long addr0,
+s390_get_unmapped_area_topdown(struct file *filp, const unsigned long addr,
                          const unsigned long len, const unsigned long pgoff,
                          const unsigned long flags)
 {
        struct mm_struct *mm = current->mm;
-       unsigned long addr = addr0;
+       unsigned long area;
        int rc;
 
-       addr = arch_get_unmapped_area_topdown(filp, addr, len, pgoff, flags);
-       if (addr & ~PAGE_MASK)
-               return addr;
-       if (unlikely(mm->context.asce_limit < addr + len)) {
-               rc = crst_table_upgrade(mm, addr + len);
+       area = arch_get_unmapped_area_topdown(filp, addr, len, pgoff, flags);
+       if (!(area & ~PAGE_MASK))
+               return area;
+       if (area == -ENOMEM &&
+           !test_thread_flag(TIF_31BIT) && TASK_SIZE < (1UL << 53)) {
+               /* Upgrade the page table to 4 levels and retry. */
+               rc = crst_table_upgrade(mm, 1UL << 53);
                if (rc)
                        return (unsigned long) rc;
+               area = arch_get_unmapped_area_topdown(filp, addr, len,
+                                                     pgoff, flags);
        }
-       return addr;
+       return area;
 }
 /*
  * This function, called very early during the creation of a new
index 0767827..6b6ddc4 100644 (file)
@@ -117,6 +117,7 @@ repeat:
                crst_table_init(table, entry);
                pgd_populate(mm, (pgd_t *) table, (pud_t *) pgd);
                mm->pgd = (pgd_t *) table;
+               mm->task_size = mm->context.asce_limit;
                table = NULL;
        }
        spin_unlock(&mm->page_table_lock);
@@ -154,6 +155,7 @@ void crst_table_downgrade(struct mm_struct *mm, unsigned long limit)
                        BUG();
                }
                mm->pgd = (pgd_t *) (pgd_val(*pgd) & _REGION_ENTRY_ORIGIN);
+               mm->task_size = mm->context.asce_limit;
                crst_table_free(mm, (unsigned long *) pgd);
        }
        update_mm(mm, current);
index 204332b..87e120e 100644 (file)
@@ -9,6 +9,7 @@ obj-$(CONFIG_MAC_FLOPPY)        += swim3.o
 obj-$(CONFIG_BLK_DEV_FD)       += floppy.o
 obj-$(CONFIG_AMIGA_FLOPPY)     += amiflop.o
 obj-$(CONFIG_PS3_DISK)         += ps3disk.o
+obj-$(CONFIG_PS3_VRAM)         += ps3vram.o
 obj-$(CONFIG_ATARI_FLOPPY)     += ataflop.o
 obj-$(CONFIG_AMIGA_Z2RAM)      += z2ram.o
 obj-$(CONFIG_BLK_DEV_RAM)      += brd.o
diff --git a/drivers/block/ps3vram.c b/drivers/block/ps3vram.c
new file mode 100644 (file)
index 0000000..393ed67
--- /dev/null
@@ -0,0 +1,865 @@
+/*
+ * ps3vram - Use extra PS3 video ram as MTD block device.
+ *
+ * Copyright 2009 Sony Corporation
+ *
+ * Based on the MTD ps3vram driver, which is
+ * Copyright (c) 2007-2008 Jim Paris <jim@jtan.com>
+ * Added support RSX DMA Vivien Chappelier <vivien.chappelier@free.fr>
+ */
+
+#include <linux/blkdev.h>
+#include <linux/delay.h>
+#include <linux/proc_fs.h>
+#include <linux/seq_file.h>
+
+#include <asm/firmware.h>
+#include <asm/lv1call.h>
+#include <asm/ps3.h>
+
+
+#define DEVICE_NAME            "ps3vram"
+
+
+#define XDR_BUF_SIZE (2 * 1024 * 1024) /* XDR buffer (must be 1MiB aligned) */
+#define XDR_IOIF 0x0c000000
+
+#define FIFO_BASE XDR_IOIF
+#define FIFO_SIZE (64 * 1024)
+
+#define DMA_PAGE_SIZE (4 * 1024)
+
+#define CACHE_PAGE_SIZE (256 * 1024)
+#define CACHE_PAGE_COUNT ((XDR_BUF_SIZE - FIFO_SIZE) / CACHE_PAGE_SIZE)
+
+#define CACHE_OFFSET CACHE_PAGE_SIZE
+#define FIFO_OFFSET 0
+
+#define CTRL_PUT 0x10
+#define CTRL_GET 0x11
+#define CTRL_TOP 0x15
+
+#define UPLOAD_SUBCH   1
+#define DOWNLOAD_SUBCH 2
+
+#define NV_MEMORY_TO_MEMORY_FORMAT_OFFSET_IN   0x0000030c
+#define NV_MEMORY_TO_MEMORY_FORMAT_NOTIFY      0x00000104
+
+#define L1GPU_CONTEXT_ATTRIBUTE_FB_BLIT 0x601
+
+#define CACHE_PAGE_PRESENT 1
+#define CACHE_PAGE_DIRTY   2
+
+struct ps3vram_tag {
+       unsigned int address;
+       unsigned int flags;
+};
+
+struct ps3vram_cache {
+       unsigned int page_count;
+       unsigned int page_size;
+       struct ps3vram_tag *tags;
+       unsigned int hit;
+       unsigned int miss;
+};
+
+struct ps3vram_priv {
+       struct request_queue *queue;
+       struct gendisk *gendisk;
+
+       u64 size;
+
+       u64 memory_handle;
+       u64 context_handle;
+       u32 *ctrl;
+       u32 *reports;
+       u8 __iomem *ddr_base;
+       u8 *xdr_buf;
+
+       u32 *fifo_base;
+       u32 *fifo_ptr;
+
+       struct ps3vram_cache cache;
+
+       /* Used to serialize cache/DMA operations */
+       struct mutex lock;
+};
+
+
+static int ps3vram_major;
+
+
+static struct block_device_operations ps3vram_fops = {
+       .owner          = THIS_MODULE,
+};
+
+
+#define DMA_NOTIFIER_HANDLE_BASE 0x66604200 /* first DMA notifier handle */
+#define DMA_NOTIFIER_OFFSET_BASE 0x1000     /* first DMA notifier offset */
+#define DMA_NOTIFIER_SIZE        0x40
+#define NOTIFIER 7     /* notifier used for completion report */
+
+static char *size = "256M";
+module_param(size, charp, 0);
+MODULE_PARM_DESC(size, "memory size");
+
+static u32 *ps3vram_get_notifier(u32 *reports, int notifier)
+{
+       return (void *)reports + DMA_NOTIFIER_OFFSET_BASE +
+              DMA_NOTIFIER_SIZE * notifier;
+}
+
+static void ps3vram_notifier_reset(struct ps3_system_bus_device *dev)
+{
+       struct ps3vram_priv *priv = dev->core.driver_data;
+       u32 *notify = ps3vram_get_notifier(priv->reports, NOTIFIER);
+       int i;
+
+       for (i = 0; i < 4; i++)
+               notify[i] = 0xffffffff;
+}
+
+static int ps3vram_notifier_wait(struct ps3_system_bus_device *dev,
+                                unsigned int timeout_ms)
+{
+       struct ps3vram_priv *priv = dev->core.driver_data;
+       u32 *notify = ps3vram_get_notifier(priv->reports, NOTIFIER);
+       unsigned long timeout = jiffies + msecs_to_jiffies(timeout_ms);
+
+       do {
+               if (!notify[3])
+                       return 0;
+               msleep(1);
+       } while (time_before(jiffies, timeout));
+
+       return -ETIMEDOUT;
+}
+
+static void ps3vram_init_ring(struct ps3_system_bus_device *dev)
+{
+       struct ps3vram_priv *priv = dev->core.driver_data;
+
+       priv->ctrl[CTRL_PUT] = FIFO_BASE + FIFO_OFFSET;
+       priv->ctrl[CTRL_GET] = FIFO_BASE + FIFO_OFFSET;
+}
+
+static int ps3vram_wait_ring(struct ps3_system_bus_device *dev,
+                            unsigned int timeout_ms)
+{
+       struct ps3vram_priv *priv = dev->core.driver_data;
+       unsigned long timeout = jiffies + msecs_to_jiffies(timeout_ms);
+
+       do {
+               if (priv->ctrl[CTRL_PUT] == priv->ctrl[CTRL_GET])
+                       return 0;
+               msleep(1);
+       } while (time_before(jiffies, timeout));
+
+       dev_warn(&dev->core, "FIFO timeout (%08x/%08x/%08x)\n",
+                priv->ctrl[CTRL_PUT], priv->ctrl[CTRL_GET],
+                priv->ctrl[CTRL_TOP]);
+
+       return -ETIMEDOUT;
+}
+
+static void ps3vram_out_ring(struct ps3vram_priv *priv, u32 data)
+{
+       *(priv->fifo_ptr)++ = data;
+}
+
+static void ps3vram_begin_ring(struct ps3vram_priv *priv, u32 chan, u32 tag,
+                              u32 size)
+{
+       ps3vram_out_ring(priv, (size << 18) | (chan << 13) | tag);
+}
+
+static void ps3vram_rewind_ring(struct ps3_system_bus_device *dev)
+{
+       struct ps3vram_priv *priv = dev->core.driver_data;
+       int status;
+
+       ps3vram_out_ring(priv, 0x20000000 | (FIFO_BASE + FIFO_OFFSET));
+
+       priv->ctrl[CTRL_PUT] = FIFO_BASE + FIFO_OFFSET;
+
+       /* asking the HV for a blit will kick the FIFO */
+       status = lv1_gpu_context_attribute(priv->context_handle,
+                                          L1GPU_CONTEXT_ATTRIBUTE_FB_BLIT, 0,
+                                          0, 0, 0);
+       if (status)
+               dev_err(&dev->core,
+                       "%s: lv1_gpu_context_attribute failed %d\n", __func__,
+                       status);
+
+       priv->fifo_ptr = priv->fifo_base;
+}
+
+static void ps3vram_fire_ring(struct ps3_system_bus_device *dev)
+{
+       struct ps3vram_priv *priv = dev->core.driver_data;
+       int status;
+
+       mutex_lock(&ps3_gpu_mutex);
+
+       priv->ctrl[CTRL_PUT] = FIFO_BASE + FIFO_OFFSET +
+                              (priv->fifo_ptr - priv->fifo_base) * sizeof(u32);
+
+       /* asking the HV for a blit will kick the FIFO */
+       status = lv1_gpu_context_attribute(priv->context_handle,
+                                          L1GPU_CONTEXT_ATTRIBUTE_FB_BLIT, 0,
+                                          0, 0, 0);
+       if (status)
+               dev_err(&dev->core,
+                       "%s: lv1_gpu_context_attribute failed %d\n", __func__,
+                       status);
+
+       if ((priv->fifo_ptr - priv->fifo_base) * sizeof(u32) >
+           FIFO_SIZE - 1024) {
+               dev_dbg(&dev->core, "FIFO full, rewinding\n");
+               ps3vram_wait_ring(dev, 200);
+               ps3vram_rewind_ring(dev);
+       }
+
+       mutex_unlock(&ps3_gpu_mutex);
+}
+
+static void ps3vram_bind(struct ps3_system_bus_device *dev)
+{
+       struct ps3vram_priv *priv = dev->core.driver_data;
+
+       ps3vram_begin_ring(priv, UPLOAD_SUBCH, 0, 1);
+       ps3vram_out_ring(priv, 0x31337303);
+       ps3vram_begin_ring(priv, UPLOAD_SUBCH, 0x180, 3);
+       ps3vram_out_ring(priv, DMA_NOTIFIER_HANDLE_BASE + NOTIFIER);
+       ps3vram_out_ring(priv, 0xfeed0001);     /* DMA system RAM instance */
+       ps3vram_out_ring(priv, 0xfeed0000);     /* DMA video RAM instance */
+
+       ps3vram_begin_ring(priv, DOWNLOAD_SUBCH, 0, 1);
+       ps3vram_out_ring(priv, 0x3137c0de);
+       ps3vram_begin_ring(priv, DOWNLOAD_SUBCH, 0x180, 3);
+       ps3vram_out_ring(priv, DMA_NOTIFIER_HANDLE_BASE + NOTIFIER);
+       ps3vram_out_ring(priv, 0xfeed0000);     /* DMA video RAM instance */
+       ps3vram_out_ring(priv, 0xfeed0001);     /* DMA system RAM instance */
+
+       ps3vram_fire_ring(dev);
+}
+
+static int ps3vram_upload(struct ps3_system_bus_device *dev,
+                         unsigned int src_offset, unsigned int dst_offset,
+                         int len, int count)
+{
+       struct ps3vram_priv *priv = dev->core.driver_data;
+
+       ps3vram_begin_ring(priv, UPLOAD_SUBCH,
+                          NV_MEMORY_TO_MEMORY_FORMAT_OFFSET_IN, 8);
+       ps3vram_out_ring(priv, XDR_IOIF + src_offset);
+       ps3vram_out_ring(priv, dst_offset);
+       ps3vram_out_ring(priv, len);
+       ps3vram_out_ring(priv, len);
+       ps3vram_out_ring(priv, len);
+       ps3vram_out_ring(priv, count);
+       ps3vram_out_ring(priv, (1 << 8) | 1);
+       ps3vram_out_ring(priv, 0);
+
+       ps3vram_notifier_reset(dev);
+       ps3vram_begin_ring(priv, UPLOAD_SUBCH,
+                          NV_MEMORY_TO_MEMORY_FORMAT_NOTIFY, 1);
+       ps3vram_out_ring(priv, 0);
+       ps3vram_begin_ring(priv, UPLOAD_SUBCH, 0x100, 1);
+       ps3vram_out_ring(priv, 0);
+       ps3vram_fire_ring(dev);
+       if (ps3vram_notifier_wait(dev, 200) < 0) {
+               dev_warn(&dev->core, "%s: Notifier timeout\n", __func__);
+               return -1;
+       }
+
+       return 0;
+}
+
+static int ps3vram_download(struct ps3_system_bus_device *dev,
+                           unsigned int src_offset, unsigned int dst_offset,
+                           int len, int count)
+{
+       struct ps3vram_priv *priv = dev->core.driver_data;
+
+       ps3vram_begin_ring(priv, DOWNLOAD_SUBCH,
+                          NV_MEMORY_TO_MEMORY_FORMAT_OFFSET_IN, 8);
+       ps3vram_out_ring(priv, src_offset);
+       ps3vram_out_ring(priv, XDR_IOIF + dst_offset);
+       ps3vram_out_ring(priv, len);
+       ps3vram_out_ring(priv, len);
+       ps3vram_out_ring(priv, len);
+       ps3vram_out_ring(priv, count);
+       ps3vram_out_ring(priv, (1 << 8) | 1);
+       ps3vram_out_ring(priv, 0);
+
+       ps3vram_notifier_reset(dev);
+       ps3vram_begin_ring(priv, DOWNLOAD_SUBCH,
+                          NV_MEMORY_TO_MEMORY_FORMAT_NOTIFY, 1);
+       ps3vram_out_ring(priv, 0);
+       ps3vram_begin_ring(priv, DOWNLOAD_SUBCH, 0x100, 1);
+       ps3vram_out_ring(priv, 0);
+       ps3vram_fire_ring(dev);
+       if (ps3vram_notifier_wait(dev, 200) < 0) {
+               dev_warn(&dev->core, "%s: Notifier timeout\n", __func__);
+               return -1;
+       }
+
+       return 0;
+}
+
+static void ps3vram_cache_evict(struct ps3_system_bus_device *dev, int entry)
+{
+       struct ps3vram_priv *priv = dev->core.driver_data;
+       struct ps3vram_cache *cache = &priv->cache;
+
+       if (!(cache->tags[entry].flags & CACHE_PAGE_DIRTY))
+               return;
+
+       dev_dbg(&dev->core, "Flushing %d: 0x%08x\n", entry,
+               cache->tags[entry].address);
+       if (ps3vram_upload(dev, CACHE_OFFSET + entry * cache->page_size,
+                          cache->tags[entry].address, DMA_PAGE_SIZE,
+                          cache->page_size / DMA_PAGE_SIZE) < 0) {
+               dev_err(&dev->core,
+                       "Failed to upload from 0x%x to " "0x%x size 0x%x\n",
+                       entry * cache->page_size, cache->tags[entry].address,
+                       cache->page_size);
+       }
+       cache->tags[entry].flags &= ~CACHE_PAGE_DIRTY;
+}
+
+static void ps3vram_cache_load(struct ps3_system_bus_device *dev, int entry,
+                              unsigned int address)
+{
+       struct ps3vram_priv *priv = dev->core.driver_data;
+       struct ps3vram_cache *cache = &priv->cache;
+
+       dev_dbg(&dev->core, "Fetching %d: 0x%08x\n", entry, address);
+       if (ps3vram_download(dev, address,
+                            CACHE_OFFSET + entry * cache->page_size,
+                            DMA_PAGE_SIZE,
+                            cache->page_size / DMA_PAGE_SIZE) < 0) {
+               dev_err(&dev->core,
+                       "Failed to download from 0x%x to 0x%x size 0x%x\n",
+                       address, entry * cache->page_size, cache->page_size);
+       }
+
+       cache->tags[entry].address = address;
+       cache->tags[entry].flags |= CACHE_PAGE_PRESENT;
+}
+
+
+static void ps3vram_cache_flush(struct ps3_system_bus_device *dev)
+{
+       struct ps3vram_priv *priv = dev->core.driver_data;
+       struct ps3vram_cache *cache = &priv->cache;
+       int i;
+
+       dev_dbg(&dev->core, "FLUSH\n");
+       for (i = 0; i < cache->page_count; i++) {
+               ps3vram_cache_evict(dev, i);
+               cache->tags[i].flags = 0;
+       }
+}
+
+static unsigned int ps3vram_cache_match(struct ps3_system_bus_device *dev,
+                                       loff_t address)
+{
+       struct ps3vram_priv *priv = dev->core.driver_data;
+       struct ps3vram_cache *cache = &priv->cache;
+       unsigned int base;
+       unsigned int offset;
+       int i;
+       static int counter;
+
+       offset = (unsigned int) (address & (cache->page_size - 1));
+       base = (unsigned int) (address - offset);
+
+       /* fully associative check */
+       for (i = 0; i < cache->page_count; i++) {
+               if ((cache->tags[i].flags & CACHE_PAGE_PRESENT) &&
+                   cache->tags[i].address == base) {
+                       cache->hit++;
+                       dev_dbg(&dev->core, "Found entry %d: 0x%08x\n", i,
+                               cache->tags[i].address);
+                       return i;
+               }
+       }
+
+       /* choose a random entry */
+       i = (jiffies + (counter++)) % cache->page_count;
+       dev_dbg(&dev->core, "Using entry %d\n", i);
+
+       ps3vram_cache_evict(dev, i);
+       ps3vram_cache_load(dev, i, base);
+
+       cache->miss++;
+       return i;
+}
+
+static int ps3vram_cache_init(struct ps3_system_bus_device *dev)
+{
+       struct ps3vram_priv *priv = dev->core.driver_data;
+
+       priv->cache.page_count = CACHE_PAGE_COUNT;
+       priv->cache.page_size = CACHE_PAGE_SIZE;
+       priv->cache.tags = kzalloc(sizeof(struct ps3vram_tag) *
+                                  CACHE_PAGE_COUNT, GFP_KERNEL);
+       if (priv->cache.tags == NULL) {
+               dev_err(&dev->core, "Could not allocate cache tags\n");
+               return -ENOMEM;
+       }
+
+       dev_info(&dev->core, "Created ram cache: %d entries, %d KiB each\n",
+               CACHE_PAGE_COUNT, CACHE_PAGE_SIZE / 1024);
+
+       return 0;
+}
+
+static void ps3vram_cache_cleanup(struct ps3_system_bus_device *dev)
+{
+       struct ps3vram_priv *priv = dev->core.driver_data;
+
+       ps3vram_cache_flush(dev);
+       kfree(priv->cache.tags);
+}
+
+static int ps3vram_read(struct ps3_system_bus_device *dev, loff_t from,
+                       size_t len, size_t *retlen, u_char *buf)
+{
+       struct ps3vram_priv *priv = dev->core.driver_data;
+       unsigned int cached, count;
+
+       dev_dbg(&dev->core, "%s: from=0x%08x len=0x%zx\n", __func__,
+               (unsigned int)from, len);
+
+       if (from >= priv->size)
+               return -EIO;
+
+       if (len > priv->size - from)
+               len = priv->size - from;
+
+       /* Copy from vram to buf */
+       count = len;
+       while (count) {
+               unsigned int offset, avail;
+               unsigned int entry;
+
+               offset = (unsigned int) (from & (priv->cache.page_size - 1));
+               avail  = priv->cache.page_size - offset;
+
+               mutex_lock(&priv->lock);
+
+               entry = ps3vram_cache_match(dev, from);
+               cached = CACHE_OFFSET + entry * priv->cache.page_size + offset;
+
+               dev_dbg(&dev->core, "%s: from=%08x cached=%08x offset=%08x "
+                       "avail=%08x count=%08x\n", __func__,
+                       (unsigned int)from, cached, offset, avail, count);
+
+               if (avail > count)
+                       avail = count;
+               memcpy(buf, priv->xdr_buf + cached, avail);
+
+               mutex_unlock(&priv->lock);
+
+               buf += avail;
+               count -= avail;
+               from += avail;
+       }
+
+       *retlen = len;
+       return 0;
+}
+
+static int ps3vram_write(struct ps3_system_bus_device *dev, loff_t to,
+                        size_t len, size_t *retlen, const u_char *buf)
+{
+       struct ps3vram_priv *priv = dev->core.driver_data;
+       unsigned int cached, count;
+
+       if (to >= priv->size)
+               return -EIO;
+
+       if (len > priv->size - to)
+               len = priv->size - to;
+
+       /* Copy from buf to vram */
+       count = len;
+       while (count) {
+               unsigned int offset, avail;
+               unsigned int entry;
+
+               offset = (unsigned int) (to & (priv->cache.page_size - 1));
+               avail  = priv->cache.page_size - offset;
+
+               mutex_lock(&priv->lock);
+
+               entry = ps3vram_cache_match(dev, to);
+               cached = CACHE_OFFSET + entry * priv->cache.page_size + offset;
+
+               dev_dbg(&dev->core, "%s: to=%08x cached=%08x offset=%08x "
+                       "avail=%08x count=%08x\n", __func__, (unsigned int)to,
+                       cached, offset, avail, count);
+
+               if (avail > count)
+                       avail = count;
+               memcpy(priv->xdr_buf + cached, buf, avail);
+
+               priv->cache.tags[entry].flags |= CACHE_PAGE_DIRTY;
+
+               mutex_unlock(&priv->lock);
+
+               buf += avail;
+               count -= avail;
+               to += avail;
+       }
+
+       *retlen = len;
+       return 0;
+}
+
+static int ps3vram_proc_show(struct seq_file *m, void *v)
+{
+       struct ps3vram_priv *priv = m->private;
+
+       seq_printf(m, "hit:%u\nmiss:%u\n", priv->cache.hit, priv->cache.miss);
+       return 0;
+}
+
+static int ps3vram_proc_open(struct inode *inode, struct file *file)
+{
+       return single_open(file, ps3vram_proc_show, PDE(inode)->data);
+}
+
+static const struct file_operations ps3vram_proc_fops = {
+       .owner          = THIS_MODULE,
+       .open           = ps3vram_proc_open,
+       .read           = seq_read,
+       .llseek         = seq_lseek,
+       .release        = single_release,
+};
+
+static void __devinit ps3vram_proc_init(struct ps3_system_bus_device *dev)
+{
+       struct ps3vram_priv *priv = dev->core.driver_data;
+       struct proc_dir_entry *pde;
+
+       pde = proc_create(DEVICE_NAME, 0444, NULL, &ps3vram_proc_fops);
+       if (!pde) {
+               dev_warn(&dev->core, "failed to create /proc entry\n");
+               return;
+       }
+
+       pde->owner = THIS_MODULE;
+       pde->data = priv;
+}
+
+static int ps3vram_make_request(struct request_queue *q, struct bio *bio)
+{
+       struct ps3_system_bus_device *dev = q->queuedata;
+       int write = bio_data_dir(bio) == WRITE;
+       const char *op = write ? "write" : "read";
+       loff_t offset = bio->bi_sector << 9;
+       int error = 0;
+       struct bio_vec *bvec;
+       unsigned int i;
+
+       dev_dbg(&dev->core, "%s\n", __func__);
+
+       bio_for_each_segment(bvec, bio, i) {
+               /* PS3 is ppc64, so we don't handle highmem */
+               char *ptr = page_address(bvec->bv_page) + bvec->bv_offset;
+               size_t len = bvec->bv_len, retlen;
+
+               dev_dbg(&dev->core, "    %s %zu bytes at offset %llu\n", op,
+                       len, offset);
+               if (write)
+                       error = ps3vram_write(dev, offset, len, &retlen, ptr);
+               else
+                       error = ps3vram_read(dev, offset, len, &retlen, ptr);
+
+               if (error) {
+                       dev_err(&dev->core, "%s failed\n", op);
+                       goto out;
+               }
+
+               if (retlen != len) {
+                       dev_err(&dev->core, "Short %s\n", op);
+                       goto out;
+               }
+
+               offset += len;
+       }
+
+       dev_dbg(&dev->core, "%s completed\n", op);
+
+out:
+       bio_endio(bio, error);
+       return 0;
+}
+
+static int __devinit ps3vram_probe(struct ps3_system_bus_device *dev)
+{
+       struct ps3vram_priv *priv;
+       int error, status;
+       struct request_queue *queue;
+       struct gendisk *gendisk;
+       u64 ddr_lpar, ctrl_lpar, info_lpar, reports_lpar, ddr_size,
+           reports_size;
+       char *rest;
+
+       priv = kzalloc(sizeof(*priv), GFP_KERNEL);
+       if (!priv) {
+               error = -ENOMEM;
+               goto fail;
+       }
+
+       mutex_init(&priv->lock);
+       dev->core.driver_data = priv;
+
+       priv = dev->core.driver_data;
+
+       /* Allocate XDR buffer (1MiB aligned) */
+       priv->xdr_buf = (void *)__get_free_pages(GFP_KERNEL,
+               get_order(XDR_BUF_SIZE));
+       if (priv->xdr_buf == NULL) {
+               dev_err(&dev->core, "Could not allocate XDR buffer\n");
+               error = -ENOMEM;
+               goto fail_free_priv;
+       }
+
+       /* Put FIFO at begginning of XDR buffer */
+       priv->fifo_base = (u32 *) (priv->xdr_buf + FIFO_OFFSET);
+       priv->fifo_ptr = priv->fifo_base;
+
+       /* XXX: Need to open GPU, in case ps3fb or snd_ps3 aren't loaded */
+       if (ps3_open_hv_device(dev)) {
+               dev_err(&dev->core, "ps3_open_hv_device failed\n");
+               error = -EAGAIN;
+               goto out_close_gpu;
+       }
+
+       /* Request memory */
+       status = -1;
+       ddr_size = ALIGN(memparse(size, &rest), 1024*1024);
+       if (!ddr_size) {
+               dev_err(&dev->core, "Specified size is too small\n");
+               error = -EINVAL;
+               goto out_close_gpu;
+       }
+
+       while (ddr_size > 0) {
+               status = lv1_gpu_memory_allocate(ddr_size, 0, 0, 0, 0,
+                                                &priv->memory_handle,
+                                                &ddr_lpar);
+               if (!status)
+                       break;
+               ddr_size -= 1024*1024;
+       }
+       if (status) {
+               dev_err(&dev->core, "lv1_gpu_memory_allocate failed %d\n",
+                       status);
+               error = -ENOMEM;
+               goto out_free_xdr_buf;
+       }
+
+       /* Request context */
+       status = lv1_gpu_context_allocate(priv->memory_handle, 0,
+                                         &priv->context_handle, &ctrl_lpar,
+                                         &info_lpar, &reports_lpar,
+                                         &reports_size);
+       if (status) {
+               dev_err(&dev->core, "lv1_gpu_context_allocate failed %d\n",
+                       status);
+               error = -ENOMEM;
+               goto out_free_memory;
+       }
+
+       /* Map XDR buffer to RSX */
+       status = lv1_gpu_context_iomap(priv->context_handle, XDR_IOIF,
+                                      ps3_mm_phys_to_lpar(__pa(priv->xdr_buf)),
+                                      XDR_BUF_SIZE, 0);
+       if (status) {
+               dev_err(&dev->core, "lv1_gpu_context_iomap failed %d\n",
+                       status);
+               error = -ENOMEM;
+               goto out_free_context;
+       }
+
+       priv->ddr_base = ioremap_flags(ddr_lpar, ddr_size, _PAGE_NO_CACHE);
+
+       if (!priv->ddr_base) {
+               dev_err(&dev->core, "ioremap DDR failed\n");
+               error = -ENOMEM;
+               goto out_free_context;
+       }
+
+       priv->ctrl = ioremap(ctrl_lpar, 64 * 1024);
+       if (!priv->ctrl) {
+               dev_err(&dev->core, "ioremap CTRL failed\n");
+               error = -ENOMEM;
+               goto out_unmap_vram;
+       }
+
+       priv->reports = ioremap(reports_lpar, reports_size);
+       if (!priv->reports) {
+               dev_err(&dev->core, "ioremap REPORTS failed\n");
+               error = -ENOMEM;
+               goto out_unmap_ctrl;
+       }
+
+       mutex_lock(&ps3_gpu_mutex);
+       ps3vram_init_ring(dev);
+       mutex_unlock(&ps3_gpu_mutex);
+
+       priv->size = ddr_size;
+
+       ps3vram_bind(dev);
+
+       mutex_lock(&ps3_gpu_mutex);
+       error = ps3vram_wait_ring(dev, 100);
+       mutex_unlock(&ps3_gpu_mutex);
+       if (error < 0) {
+               dev_err(&dev->core, "Failed to initialize channels\n");
+               error = -ETIMEDOUT;
+               goto out_unmap_reports;
+       }
+
+       ps3vram_cache_init(dev);
+       ps3vram_proc_init(dev);
+
+       queue = blk_alloc_queue(GFP_KERNEL);
+       if (!queue) {
+               dev_err(&dev->core, "blk_alloc_queue failed\n");
+               error = -ENOMEM;
+               goto out_cache_cleanup;
+       }
+
+       priv->queue = queue;
+       queue->queuedata = dev;
+       blk_queue_make_request(queue, ps3vram_make_request);
+       blk_queue_max_phys_segments(queue, MAX_PHYS_SEGMENTS);
+       blk_queue_max_hw_segments(queue, MAX_HW_SEGMENTS);
+       blk_queue_max_segment_size(queue, MAX_SEGMENT_SIZE);
+       blk_queue_max_sectors(queue, SAFE_MAX_SECTORS);
+
+       gendisk = alloc_disk(1);
+       if (!gendisk) {
+               dev_err(&dev->core, "alloc_disk failed\n");
+               error = -ENOMEM;
+               goto fail_cleanup_queue;
+       }
+
+       priv->gendisk = gendisk;
+       gendisk->major = ps3vram_major;
+       gendisk->first_minor = 0;
+       gendisk->fops = &ps3vram_fops;
+       gendisk->queue = queue;
+       gendisk->private_data = dev;
+       gendisk->driverfs_dev = &dev->core;
+       strlcpy(gendisk->disk_name, DEVICE_NAME, sizeof(gendisk->disk_name));
+       set_capacity(gendisk, priv->size >> 9);
+
+       dev_info(&dev->core, "%s: Using %lu MiB of GPU memory\n",
+                gendisk->disk_name, get_capacity(gendisk) >> 11);
+
+       add_disk(gendisk);
+       return 0;
+
+fail_cleanup_queue:
+       blk_cleanup_queue(queue);
+out_cache_cleanup:
+       remove_proc_entry(DEVICE_NAME, NULL);
+       ps3vram_cache_cleanup(dev);
+out_unmap_reports:
+       iounmap(priv->reports);
+out_unmap_ctrl:
+       iounmap(priv->ctrl);
+out_unmap_vram:
+       iounmap(priv->ddr_base);
+out_free_context:
+       lv1_gpu_context_free(priv->context_handle);
+out_free_memory:
+       lv1_gpu_memory_free(priv->memory_handle);
+out_close_gpu:
+       ps3_close_hv_device(dev);
+out_free_xdr_buf:
+       free_pages((unsigned long) priv->xdr_buf, get_order(XDR_BUF_SIZE));
+fail_free_priv:
+       kfree(priv);
+       dev->core.driver_data = NULL;
+fail:
+       return error;
+}
+
+static int ps3vram_remove(struct ps3_system_bus_device *dev)
+{
+       struct ps3vram_priv *priv = dev->core.driver_data;
+
+       del_gendisk(priv->gendisk);
+       put_disk(priv->gendisk);
+       blk_cleanup_queue(priv->queue);
+       remove_proc_entry(DEVICE_NAME, NULL);
+       ps3vram_cache_cleanup(dev);
+       iounmap(priv->reports);
+       iounmap(priv->ctrl);
+       iounmap(priv->ddr_base);
+       lv1_gpu_context_free(priv->context_handle);
+       lv1_gpu_memory_free(priv->memory_handle);
+       ps3_close_hv_device(dev);
+       free_pages((unsigned long) priv->xdr_buf, get_order(XDR_BUF_SIZE));
+       kfree(priv);
+       dev->core.driver_data = NULL;
+       return 0;
+}
+
+static struct ps3_system_bus_driver ps3vram = {
+       .match_id       = PS3_MATCH_ID_GPU,
+       .match_sub_id   = PS3_MATCH_SUB_ID_GPU_RAMDISK,
+       .core.name      = DEVICE_NAME,
+       .core.owner     = THIS_MODULE,
+       .probe          = ps3vram_probe,
+       .remove         = ps3vram_remove,
+       .shutdown       = ps3vram_remove,
+};
+
+
+static int __init ps3vram_init(void)
+{
+       int error;
+
+       if (!firmware_has_feature(FW_FEATURE_PS3_LV1))
+               return -ENODEV;
+
+       error = register_blkdev(0, DEVICE_NAME);
+       if (error <= 0) {
+               pr_err("%s: register_blkdev failed %d\n", DEVICE_NAME, error);
+               return error;
+       }
+       ps3vram_major = error;
+
+       pr_info("%s: registered block device major %d\n", DEVICE_NAME,
+               ps3vram_major);
+
+       error = ps3_system_bus_driver_register(&ps3vram);
+       if (error)
+               unregister_blkdev(ps3vram_major, DEVICE_NAME);
+
+       return error;
+}
+
+static void __exit ps3vram_exit(void)
+{
+       ps3_system_bus_driver_unregister(&ps3vram);
+       unregister_blkdev(ps3vram_major, DEVICE_NAME);
+}
+
+module_init(ps3vram_init);
+module_exit(ps3vram_exit);
+
+MODULE_LICENSE("GPL");
+MODULE_DESCRIPTION("PS3 Video RAM Storage Driver");
+MODULE_AUTHOR("Sony Corporation");
+MODULE_ALIAS(PS3_MODULE_ALIAS_GPU_RAMDISK);
index 4940e4d..1f5b5d4 100644 (file)
@@ -306,7 +306,7 @@ static int hiddev_open(struct inode *inode, struct file *file)
        return 0;
 bail:
        file->private_data = NULL;
-       kfree(list->hiddev);
+       kfree(list);
        return res;
 }
 
@@ -323,7 +323,7 @@ static ssize_t hiddev_write(struct file * file, const char __user * buffer, size
  */
 static ssize_t hiddev_read(struct file * file, char __user * buffer, size_t count, loff_t *ppos)
 {
-       DECLARE_WAITQUEUE(wait, current);
+       DEFINE_WAIT(wait);
        struct hiddev_list *list = file->private_data;
        int event_size;
        int retval;
index bc33200..6fde0a2 100644 (file)
@@ -120,13 +120,6 @@ config MTD_PHRAM
          doesn't have access to, memory beyond the mem=xxx limit, nvram,
          memory on the video card, etc...
 
-config MTD_PS3VRAM
-       tristate "PS3 video RAM"
-       depends on FB_PS3
-       help
-         This driver allows you to use excess PS3 video RAM as volatile
-         storage or system swap.
-
 config MTD_LART
        tristate "28F160xx flash driver for LART"
        depends on SA1100_LART
index e51521d..0993d5c 100644 (file)
@@ -16,4 +16,3 @@ obj-$(CONFIG_MTD_LART)                += lart.o
 obj-$(CONFIG_MTD_BLOCK2MTD)    += block2mtd.o
 obj-$(CONFIG_MTD_DATAFLASH)    += mtd_dataflash.o
 obj-$(CONFIG_MTD_M25P80)       += m25p80.o
-obj-$(CONFIG_MTD_PS3VRAM)      += ps3vram.o
diff --git a/drivers/mtd/devices/ps3vram.c b/drivers/mtd/devices/ps3vram.c
deleted file mode 100644 (file)
index d21e9be..0000000
+++ /dev/null
@@ -1,768 +0,0 @@
-/**
- * ps3vram - Use extra PS3 video ram as MTD block device.
- *
- * Copyright (c) 2007-2008 Jim Paris <jim@jtan.com>
- * Added support RSX DMA Vivien Chappelier <vivien.chappelier@free.fr>
- */
-
-#include <linux/io.h>
-#include <linux/mm.h>
-#include <linux/init.h>
-#include <linux/kernel.h>
-#include <linux/list.h>
-#include <linux/module.h>
-#include <linux/moduleparam.h>
-#include <linux/slab.h>
-#include <linux/version.h>
-#include <linux/gfp.h>
-#include <linux/delay.h>
-#include <linux/mtd/mtd.h>
-
-#include <asm/lv1call.h>
-#include <asm/ps3.h>
-
-#define DEVICE_NAME            "ps3vram"
-
-#define XDR_BUF_SIZE (2 * 1024 * 1024) /* XDR buffer (must be 1MiB aligned) */
-#define XDR_IOIF 0x0c000000
-
-#define FIFO_BASE XDR_IOIF
-#define FIFO_SIZE (64 * 1024)
-
-#define DMA_PAGE_SIZE (4 * 1024)
-
-#define CACHE_PAGE_SIZE (256 * 1024)
-#define CACHE_PAGE_COUNT ((XDR_BUF_SIZE - FIFO_SIZE) / CACHE_PAGE_SIZE)
-
-#define CACHE_OFFSET CACHE_PAGE_SIZE
-#define FIFO_OFFSET 0
-
-#define CTRL_PUT 0x10
-#define CTRL_GET 0x11
-#define CTRL_TOP 0x15
-
-#define UPLOAD_SUBCH   1
-#define DOWNLOAD_SUBCH 2
-
-#define NV_MEMORY_TO_MEMORY_FORMAT_OFFSET_IN   0x0000030c
-#define NV_MEMORY_TO_MEMORY_FORMAT_NOTIFY      0x00000104
-
-#define L1GPU_CONTEXT_ATTRIBUTE_FB_BLIT 0x601
-
-struct mtd_info ps3vram_mtd;
-
-#define CACHE_PAGE_PRESENT 1
-#define CACHE_PAGE_DIRTY   2
-
-struct ps3vram_tag {
-       unsigned int address;
-       unsigned int flags;
-};
-
-struct ps3vram_cache {
-       unsigned int page_count;
-       unsigned int page_size;
-       struct ps3vram_tag *tags;
-};
-
-struct ps3vram_priv {
-       u64 memory_handle;
-       u64 context_handle;
-       u32 *ctrl;
-       u32 *reports;
-       u8 __iomem *ddr_base;
-       u8 *xdr_buf;
-
-       u32 *fifo_base;
-       u32 *fifo_ptr;
-
-       struct device *dev;
-       struct ps3vram_cache cache;
-
-       /* Used to serialize cache/DMA operations */
-       struct mutex lock;
-};
-
-#define DMA_NOTIFIER_HANDLE_BASE 0x66604200 /* first DMA notifier handle */
-#define DMA_NOTIFIER_OFFSET_BASE 0x1000     /* first DMA notifier offset */
-#define DMA_NOTIFIER_SIZE        0x40
-#define NOTIFIER 7     /* notifier used for completion report */
-
-/* A trailing '-' means to subtract off ps3fb_videomemory.size */
-char *size = "256M-";
-module_param(size, charp, 0);
-MODULE_PARM_DESC(size, "memory size");
-
-static u32 *ps3vram_get_notifier(u32 *reports, int notifier)
-{
-       return (void *) reports +
-               DMA_NOTIFIER_OFFSET_BASE +
-               DMA_NOTIFIER_SIZE * notifier;
-}
-
-static void ps3vram_notifier_reset(struct mtd_info *mtd)
-{
-       int i;
-
-       struct ps3vram_priv *priv = mtd->priv;
-       u32 *notify = ps3vram_get_notifier(priv->reports, NOTIFIER);
-       for (i = 0; i < 4; i++)
-               notify[i] = 0xffffffff;
-}
-
-static int ps3vram_notifier_wait(struct mtd_info *mtd, unsigned int timeout_ms)
-{
-       struct ps3vram_priv *priv = mtd->priv;
-       u32 *notify = ps3vram_get_notifier(priv->reports, NOTIFIER);
-       unsigned long timeout = jiffies + msecs_to_jiffies(timeout_ms);
-
-       do {
-               if (!notify[3])
-                       return 0;
-               msleep(1);
-       } while (time_before(jiffies, timeout));
-
-       return -ETIMEDOUT;
-}
-
-static void ps3vram_init_ring(struct mtd_info *mtd)
-{
-       struct ps3vram_priv *priv = mtd->priv;
-
-       priv->ctrl[CTRL_PUT] = FIFO_BASE + FIFO_OFFSET;
-       priv->ctrl[CTRL_GET] = FIFO_BASE + FIFO_OFFSET;
-}
-
-static int ps3vram_wait_ring(struct mtd_info *mtd, unsigned int timeout_ms)
-{
-       struct ps3vram_priv *priv = mtd->priv;
-       unsigned long timeout = jiffies + msecs_to_jiffies(timeout_ms);
-
-       do {
-               if (priv->ctrl[CTRL_PUT] == priv->ctrl[CTRL_GET])
-                       return 0;
-               msleep(1);
-       } while (time_before(jiffies, timeout));
-
-       dev_dbg(priv->dev, "%s:%d: FIFO timeout (%08x/%08x/%08x)\n", __func__,
-               __LINE__, priv->ctrl[CTRL_PUT], priv->ctrl[CTRL_GET],
-               priv->ctrl[CTRL_TOP]);
-
-       return -ETIMEDOUT;
-}
-
-static void ps3vram_out_ring(struct ps3vram_priv *priv, u32 data)
-{
-       *(priv->fifo_ptr)++ = data;
-}
-
-static void ps3vram_begin_ring(struct ps3vram_priv *priv, u32 chan,
-                                     u32 tag, u32 size)
-{
-       ps3vram_out_ring(priv, (size << 18) | (chan << 13) | tag);
-}
-
-static void ps3vram_rewind_ring(struct mtd_info *mtd)
-{
-       struct ps3vram_priv *priv = mtd->priv;
-       u64 status;
-
-       ps3vram_out_ring(priv, 0x20000000 | (FIFO_BASE + FIFO_OFFSET));
-
-       priv->ctrl[CTRL_PUT] = FIFO_BASE + FIFO_OFFSET;
-
-       /* asking the HV for a blit will kick the fifo */
-       status = lv1_gpu_context_attribute(priv->context_handle,
-                                          L1GPU_CONTEXT_ATTRIBUTE_FB_BLIT,
-                                          0, 0, 0, 0);
-       if (status)
-               dev_err(priv->dev, "%s:%d: lv1_gpu_context_attribute failed\n",
-                       __func__, __LINE__);
-
-       priv->fifo_ptr = priv->fifo_base;
-}
-
-static void ps3vram_fire_ring(struct mtd_info *mtd)
-{
-       struct ps3vram_priv *priv = mtd->priv;
-       u64 status;
-
-       mutex_lock(&ps3_gpu_mutex);
-
-       priv->ctrl[CTRL_PUT] = FIFO_BASE + FIFO_OFFSET +
-               (priv->fifo_ptr - priv->fifo_base) * sizeof(u32);
-
-       /* asking the HV for a blit will kick the fifo */
-       status = lv1_gpu_context_attribute(priv->context_handle,
-                                          L1GPU_CONTEXT_ATTRIBUTE_FB_BLIT,
-                                          0, 0, 0, 0);
-       if (status)
-               dev_err(priv->dev, "%s:%d: lv1_gpu_context_attribute failed\n",
-                       __func__, __LINE__);
-
-       if ((priv->fifo_ptr - priv->fifo_base) * sizeof(u32) >
-               FIFO_SIZE - 1024) {
-               dev_dbg(priv->dev, "%s:%d: fifo full, rewinding\n", __func__,
-                       __LINE__);
-               ps3vram_wait_ring(mtd, 200);
-               ps3vram_rewind_ring(mtd);
-       }
-
-       mutex_unlock(&ps3_gpu_mutex);
-}
-
-static void ps3vram_bind(struct mtd_info *mtd)
-{
-       struct ps3vram_priv *priv = mtd->priv;
-
-       ps3vram_begin_ring(priv, UPLOAD_SUBCH, 0, 1);
-       ps3vram_out_ring(priv, 0x31337303);
-       ps3vram_begin_ring(priv, UPLOAD_SUBCH, 0x180, 3);
-       ps3vram_out_ring(priv, DMA_NOTIFIER_HANDLE_BASE + NOTIFIER);
-       ps3vram_out_ring(priv, 0xfeed0001);     /* DMA system RAM instance */
-       ps3vram_out_ring(priv, 0xfeed0000);     /* DMA video RAM instance */
-
-       ps3vram_begin_ring(priv, DOWNLOAD_SUBCH, 0, 1);
-       ps3vram_out_ring(priv, 0x3137c0de);
-       ps3vram_begin_ring(priv, DOWNLOAD_SUBCH, 0x180, 3);
-       ps3vram_out_ring(priv, DMA_NOTIFIER_HANDLE_BASE + NOTIFIER);
-       ps3vram_out_ring(priv, 0xfeed0000);     /* DMA video RAM instance */
-       ps3vram_out_ring(priv, 0xfeed0001);     /* DMA system RAM instance */
-
-       ps3vram_fire_ring(mtd);
-}
-
-static int ps3vram_upload(struct mtd_info *mtd, unsigned int src_offset,
-                         unsigned int dst_offset, int len, int count)
-{
-       struct ps3vram_priv *priv = mtd->priv;
-
-       ps3vram_begin_ring(priv, UPLOAD_SUBCH,
-                          NV_MEMORY_TO_MEMORY_FORMAT_OFFSET_IN, 8);
-       ps3vram_out_ring(priv, XDR_IOIF + src_offset);
-       ps3vram_out_ring(priv, dst_offset);
-       ps3vram_out_ring(priv, len);
-       ps3vram_out_ring(priv, len);
-       ps3vram_out_ring(priv, len);
-       ps3vram_out_ring(priv, count);
-       ps3vram_out_ring(priv, (1 << 8) | 1);
-       ps3vram_out_ring(priv, 0);
-
-       ps3vram_notifier_reset(mtd);
-       ps3vram_begin_ring(priv, UPLOAD_SUBCH,
-                          NV_MEMORY_TO_MEMORY_FORMAT_NOTIFY, 1);
-       ps3vram_out_ring(priv, 0);
-       ps3vram_begin_ring(priv, UPLOAD_SUBCH, 0x100, 1);
-       ps3vram_out_ring(priv, 0);
-       ps3vram_fire_ring(mtd);
-       if (ps3vram_notifier_wait(mtd, 200) < 0) {
-               dev_dbg(priv->dev, "%s:%d: notifier timeout\n", __func__,
-                       __LINE__);
-               return -1;
-       }
-
-       return 0;
-}
-
-static int ps3vram_download(struct mtd_info *mtd, unsigned int src_offset,
-                           unsigned int dst_offset, int len, int count)
-{
-       struct ps3vram_priv *priv = mtd->priv;
-
-       ps3vram_begin_ring(priv, DOWNLOAD_SUBCH,
-                          NV_MEMORY_TO_MEMORY_FORMAT_OFFSET_IN, 8);
-       ps3vram_out_ring(priv, src_offset);
-       ps3vram_out_ring(priv, XDR_IOIF + dst_offset);
-       ps3vram_out_ring(priv, len);
-       ps3vram_out_ring(priv, len);
-       ps3vram_out_ring(priv, len);
-       ps3vram_out_ring(priv, count);
-       ps3vram_out_ring(priv, (1 << 8) | 1);
-       ps3vram_out_ring(priv, 0);
-
-       ps3vram_notifier_reset(mtd);
-       ps3vram_begin_ring(priv, DOWNLOAD_SUBCH,
-                          NV_MEMORY_TO_MEMORY_FORMAT_NOTIFY, 1);
-       ps3vram_out_ring(priv, 0);
-       ps3vram_begin_ring(priv, DOWNLOAD_SUBCH, 0x100, 1);
-       ps3vram_out_ring(priv, 0);
-       ps3vram_fire_ring(mtd);
-       if (ps3vram_notifier_wait(mtd, 200) < 0) {
-               dev_dbg(priv->dev, "%s:%d: notifier timeout\n", __func__,
-                       __LINE__);
-               return -1;
-       }
-
-       return 0;
-}
-
-static void ps3vram_cache_evict(struct mtd_info *mtd, int entry)
-{
-       struct ps3vram_priv *priv = mtd->priv;
-       struct ps3vram_cache *cache = &priv->cache;
-
-       if (cache->tags[entry].flags & CACHE_PAGE_DIRTY) {
-               dev_dbg(priv->dev, "%s:%d: flushing %d : 0x%08x\n", __func__,
-                       __LINE__, entry, cache->tags[entry].address);
-               if (ps3vram_upload(mtd,
-                                  CACHE_OFFSET + entry * cache->page_size,
-                                  cache->tags[entry].address,
-                                  DMA_PAGE_SIZE,
-                                  cache->page_size / DMA_PAGE_SIZE) < 0) {
-                       dev_dbg(priv->dev, "%s:%d: failed to upload from "
-                               "0x%x to 0x%x size 0x%x\n", __func__, __LINE__,
-                               entry * cache->page_size,
-                               cache->tags[entry].address, cache->page_size);
-               }
-               cache->tags[entry].flags &= ~CACHE_PAGE_DIRTY;
-       }
-}
-
-static void ps3vram_cache_load(struct mtd_info *mtd, int entry,
-                              unsigned int address)
-{
-       struct ps3vram_priv *priv = mtd->priv;
-       struct ps3vram_cache *cache = &priv->cache;
-
-       dev_dbg(priv->dev, "%s:%d: fetching %d : 0x%08x\n", __func__, __LINE__,
-               entry, address);
-       if (ps3vram_download(mtd,
-                            address,
-                            CACHE_OFFSET + entry * cache->page_size,
-                            DMA_PAGE_SIZE,
-                            cache->page_size / DMA_PAGE_SIZE) < 0) {
-               dev_err(priv->dev, "%s:%d: failed to download from "
-                       "0x%x to 0x%x size 0x%x\n", __func__, __LINE__, address,
-                       entry * cache->page_size, cache->page_size);
-       }
-
-       cache->tags[entry].address = address;
-       cache->tags[entry].flags |= CACHE_PAGE_PRESENT;
-}
-
-
-static void ps3vram_cache_flush(struct mtd_info *mtd)
-{
-       struct ps3vram_priv *priv = mtd->priv;
-       struct ps3vram_cache *cache = &priv->cache;
-       int i;
-
-       dev_dbg(priv->dev, "%s:%d: FLUSH\n", __func__, __LINE__);
-       for (i = 0; i < cache->page_count; i++) {
-               ps3vram_cache_evict(mtd, i);
-               cache->tags[i].flags = 0;
-       }
-}
-
-static unsigned int ps3vram_cache_match(struct mtd_info *mtd, loff_t address)
-{
-       struct ps3vram_priv *priv = mtd->priv;
-       struct ps3vram_cache *cache = &priv->cache;
-       unsigned int base;
-       unsigned int offset;
-       int i;
-       static int counter;
-
-       offset = (unsigned int) (address & (cache->page_size - 1));
-       base = (unsigned int) (address - offset);
-
-       /* fully associative check */
-       for (i = 0; i < cache->page_count; i++) {
-               if ((cache->tags[i].flags & CACHE_PAGE_PRESENT) &&
-                   cache->tags[i].address == base) {
-                       dev_dbg(priv->dev, "%s:%d: found entry %d : 0x%08x\n",
-                               __func__, __LINE__, i, cache->tags[i].address);
-                       return i;
-               }
-       }
-
-       /* choose a random entry */
-       i = (jiffies + (counter++)) % cache->page_count;
-       dev_dbg(priv->dev, "%s:%d: using entry %d\n", __func__, __LINE__, i);
-
-       ps3vram_cache_evict(mtd, i);
-       ps3vram_cache_load(mtd, i, base);
-
-       return i;
-}
-
-static int ps3vram_cache_init(struct mtd_info *mtd)
-{
-       struct ps3vram_priv *priv = mtd->priv;
-
-       priv->cache.page_count = CACHE_PAGE_COUNT;
-       priv->cache.page_size = CACHE_PAGE_SIZE;
-       priv->cache.tags = kzalloc(sizeof(struct ps3vram_tag) *
-                                  CACHE_PAGE_COUNT, GFP_KERNEL);
-       if (priv->cache.tags == NULL) {
-               dev_err(priv->dev, "%s:%d: could not allocate cache tags\n",
-                       __func__, __LINE__);
-               return -ENOMEM;
-       }
-
-       dev_info(priv->dev, "created ram cache: %d entries, %d KiB each\n",
-               CACHE_PAGE_COUNT, CACHE_PAGE_SIZE / 1024);
-
-       return 0;
-}
-
-static void ps3vram_cache_cleanup(struct mtd_info *mtd)
-{
-       struct ps3vram_priv *priv = mtd->priv;
-
-       ps3vram_cache_flush(mtd);
-       kfree(priv->cache.tags);
-}
-
-static int ps3vram_erase(struct mtd_info *mtd, struct erase_info *instr)
-{
-       struct ps3vram_priv *priv = mtd->priv;
-
-       if (instr->addr + instr->len > mtd->size)
-               return -EINVAL;
-
-       mutex_lock(&priv->lock);
-
-       ps3vram_cache_flush(mtd);
-
-       /* Set bytes to 0xFF */
-       memset_io(priv->ddr_base + instr->addr, 0xFF, instr->len);
-
-       mutex_unlock(&priv->lock);
-
-       instr->state = MTD_ERASE_DONE;
-       mtd_erase_callback(instr);
-
-       return 0;
-}
-
-static int ps3vram_read(struct mtd_info *mtd, loff_t from, size_t len,
-                       size_t *retlen, u_char *buf)
-{
-       struct ps3vram_priv *priv = mtd->priv;
-       unsigned int cached, count;
-
-       dev_dbg(priv->dev, "%s:%d: from=0x%08x len=0x%zx\n", __func__, __LINE__,
-               (unsigned int)from, len);
-
-       if (from >= mtd->size)
-               return -EINVAL;
-
-       if (len > mtd->size - from)
-               len = mtd->size - from;
-
-       /* Copy from vram to buf */
-       count = len;
-       while (count) {
-               unsigned int offset, avail;
-               unsigned int entry;
-
-               offset = (unsigned int) (from & (priv->cache.page_size - 1));
-               avail  = priv->cache.page_size - offset;
-
-               mutex_lock(&priv->lock);
-
-               entry = ps3vram_cache_match(mtd, from);
-               cached = CACHE_OFFSET + entry * priv->cache.page_size + offset;
-
-               dev_dbg(priv->dev, "%s:%d: from=%08x cached=%08x offset=%08x "
-                       "avail=%08x count=%08x\n", __func__, __LINE__,
-                       (unsigned int)from, cached, offset, avail, count);
-
-               if (avail > count)
-                       avail = count;
-               memcpy(buf, priv->xdr_buf + cached, avail);
-
-               mutex_unlock(&priv->lock);
-
-               buf += avail;
-               count -= avail;
-               from += avail;
-       }
-
-       *retlen = len;
-       return 0;
-}
-
-static int ps3vram_write(struct mtd_info *mtd, loff_t to, size_t len,
-                        size_t *retlen, const u_char *buf)
-{
-       struct ps3vram_priv *priv = mtd->priv;
-       unsigned int cached, count;
-
-       if (to >= mtd->size)
-               return -EINVAL;
-
-       if (len > mtd->size - to)
-               len = mtd->size - to;
-
-       /* Copy from buf to vram */
-       count = len;
-       while (count) {
-               unsigned int offset, avail;
-               unsigned int entry;
-
-               offset = (unsigned int) (to & (priv->cache.page_size - 1));
-               avail  = priv->cache.page_size - offset;
-
-               mutex_lock(&priv->lock);
-
-               entry = ps3vram_cache_match(mtd, to);
-               cached = CACHE_OFFSET + entry * priv->cache.page_size + offset;
-
-               dev_dbg(priv->dev, "%s:%d: to=%08x cached=%08x offset=%08x "
-                       "avail=%08x count=%08x\n", __func__, __LINE__,
-                       (unsigned int)to, cached, offset, avail, count);
-
-               if (avail > count)
-                       avail = count;
-               memcpy(priv->xdr_buf + cached, buf, avail);
-
-               priv->cache.tags[entry].flags |= CACHE_PAGE_DIRTY;
-
-               mutex_unlock(&priv->lock);
-
-               buf += avail;
-               count -= avail;
-               to += avail;
-       }
-
-       *retlen = len;
-       return 0;
-}
-
-static int __devinit ps3vram_probe(struct ps3_system_bus_device *dev)
-{
-       struct ps3vram_priv *priv;
-       int status;
-       u64 ddr_lpar;
-       u64 ctrl_lpar;
-       u64 info_lpar;
-       u64 reports_lpar;
-       u64 ddr_size;
-       u64 reports_size;
-       int ret = -ENOMEM;
-       char *rest;
-
-       ret = -EIO;
-       ps3vram_mtd.priv = kzalloc(sizeof(struct ps3vram_priv), GFP_KERNEL);
-       if (!ps3vram_mtd.priv)
-               goto out;
-       priv = ps3vram_mtd.priv;
-
-       mutex_init(&priv->lock);
-       priv->dev = &dev->core;
-
-       /* Allocate XDR buffer (1MiB aligned) */
-       priv->xdr_buf = (void *)__get_free_pages(GFP_KERNEL,
-               get_order(XDR_BUF_SIZE));
-       if (priv->xdr_buf == NULL) {
-               dev_dbg(&dev->core, "%s:%d: could not allocate XDR buffer\n",
-                       __func__, __LINE__);
-               ret = -ENOMEM;
-               goto out_free_priv;
-       }
-
-       /* Put FIFO at begginning of XDR buffer */
-       priv->fifo_base = (u32 *) (priv->xdr_buf + FIFO_OFFSET);
-       priv->fifo_ptr = priv->fifo_base;
-
-       /* XXX: Need to open GPU, in case ps3fb or snd_ps3 aren't loaded */
-       if (ps3_open_hv_device(dev)) {
-               dev_err(&dev->core, "%s:%d: ps3_open_hv_device failed\n",
-                       __func__, __LINE__);
-               ret = -EAGAIN;
-               goto out_close_gpu;
-       }
-
-       /* Request memory */
-       status = -1;
-       ddr_size = memparse(size, &rest);
-       if (*rest == '-')
-               ddr_size -= ps3fb_videomemory.size;
-       ddr_size = ALIGN(ddr_size, 1024*1024);
-       if (ddr_size <= 0) {
-               dev_err(&dev->core, "%s:%d: specified size is too small\n",
-                       __func__, __LINE__);
-               ret = -EINVAL;
-               goto out_close_gpu;
-       }
-
-       while (ddr_size > 0) {
-               status = lv1_gpu_memory_allocate(ddr_size, 0, 0, 0, 0,
-                                                &priv->memory_handle,
-                                                &ddr_lpar);
-               if (!status)
-                       break;
-               ddr_size -= 1024*1024;
-       }
-       if (status || ddr_size <= 0) {
-               dev_err(&dev->core, "%s:%d: lv1_gpu_memory_allocate failed\n",
-                       __func__, __LINE__);
-               ret = -ENOMEM;
-               goto out_free_xdr_buf;
-       }
-
-       /* Request context */
-       status = lv1_gpu_context_allocate(priv->memory_handle,
-                                         0,
-                                         &priv->context_handle,
-                                         &ctrl_lpar,
-                                         &info_lpar,
-                                         &reports_lpar,
-                                         &reports_size);
-       if (status) {
-               dev_err(&dev->core, "%s:%d: lv1_gpu_context_allocate failed\n",
-                       __func__, __LINE__);
-               ret = -ENOMEM;
-               goto out_free_memory;
-       }
-
-       /* Map XDR buffer to RSX */
-       status = lv1_gpu_context_iomap(priv->context_handle, XDR_IOIF,
-                                      ps3_mm_phys_to_lpar(__pa(priv->xdr_buf)),
-                                      XDR_BUF_SIZE, 0);
-       if (status) {
-               dev_err(&dev->core, "%s:%d: lv1_gpu_context_iomap failed\n",
-                       __func__, __LINE__);
-               ret = -ENOMEM;
-               goto out_free_context;
-       }
-
-       priv->ddr_base = ioremap_flags(ddr_lpar, ddr_size, _PAGE_NO_CACHE);
-
-       if (!priv->ddr_base) {
-               dev_err(&dev->core, "%s:%d: ioremap failed\n", __func__,
-                       __LINE__);
-               ret = -ENOMEM;
-               goto out_free_context;
-       }
-
-       priv->ctrl = ioremap(ctrl_lpar, 64 * 1024);
-       if (!priv->ctrl) {
-               dev_err(&dev->core, "%s:%d: ioremap failed\n", __func__,
-                       __LINE__);
-               ret = -ENOMEM;
-               goto out_unmap_vram;
-       }
-
-       priv->reports = ioremap(reports_lpar, reports_size);
-       if (!priv->reports) {
-               dev_err(&dev->core, "%s:%d: ioremap failed\n", __func__,
-                       __LINE__);
-               ret = -ENOMEM;
-               goto out_unmap_ctrl;
-       }
-
-       mutex_lock(&ps3_gpu_mutex);
-       ps3vram_init_ring(&ps3vram_mtd);
-       mutex_unlock(&ps3_gpu_mutex);
-
-       ps3vram_mtd.name = "ps3vram";
-       ps3vram_mtd.size = ddr_size;
-       ps3vram_mtd.flags = MTD_CAP_RAM;
-       ps3vram_mtd.erase = ps3vram_erase;
-       ps3vram_mtd.point = NULL;
-       ps3vram_mtd.unpoint = NULL;
-       ps3vram_mtd.read = ps3vram_read;
-       ps3vram_mtd.write = ps3vram_write;
-       ps3vram_mtd.owner = THIS_MODULE;
-       ps3vram_mtd.type = MTD_RAM;
-       ps3vram_mtd.erasesize = CACHE_PAGE_SIZE;
-       ps3vram_mtd.writesize = 1;
-
-       ps3vram_bind(&ps3vram_mtd);
-
-       mutex_lock(&ps3_gpu_mutex);
-       ret = ps3vram_wait_ring(&ps3vram_mtd, 100);
-       mutex_unlock(&ps3_gpu_mutex);
-       if (ret < 0) {
-               dev_err(&dev->core, "%s:%d: failed to initialize channels\n",
-                       __func__, __LINE__);
-               ret = -ETIMEDOUT;
-               goto out_unmap_reports;
-       }
-
-       ps3vram_cache_init(&ps3vram_mtd);
-
-       if (add_mtd_device(&ps3vram_mtd)) {
-               dev_err(&dev->core, "%s:%d: add_mtd_device failed\n",
-                       __func__, __LINE__);
-               ret = -EAGAIN;
-               goto out_cache_cleanup;
-       }
-
-       dev_info(&dev->core, "reserved %u MiB of gpu memory\n",
-               (unsigned int)(ddr_size / 1024 / 1024));
-
-       return 0;
-
-out_cache_cleanup:
-       ps3vram_cache_cleanup(&ps3vram_mtd);
-out_unmap_reports:
-       iounmap(priv->reports);
-out_unmap_ctrl:
-       iounmap(priv->ctrl);
-out_unmap_vram:
-       iounmap(priv->ddr_base);
-out_free_context:
-       lv1_gpu_context_free(priv->context_handle);
-out_free_memory:
-       lv1_gpu_memory_free(priv->memory_handle);
-out_close_gpu:
-       ps3_close_hv_device(dev);
-out_free_xdr_buf:
-       free_pages((unsigned long) priv->xdr_buf, get_order(XDR_BUF_SIZE));
-out_free_priv:
-       kfree(ps3vram_mtd.priv);
-       ps3vram_mtd.priv = NULL;
-out:
-       return ret;
-}
-
-static int ps3vram_shutdown(struct ps3_system_bus_device *dev)
-{
-       struct ps3vram_priv *priv;
-
-       priv = ps3vram_mtd.priv;
-
-       del_mtd_device(&ps3vram_mtd);
-       ps3vram_cache_cleanup(&ps3vram_mtd);
-       iounmap(priv->reports);
-       iounmap(priv->ctrl);
-       iounmap(priv->ddr_base);
-       lv1_gpu_context_free(priv->context_handle);
-       lv1_gpu_memory_free(priv->memory_handle);
-       ps3_close_hv_device(dev);
-       free_pages((unsigned long) priv->xdr_buf, get_order(XDR_BUF_SIZE));
-       kfree(priv);
-       return 0;
-}
-
-static struct ps3_system_bus_driver ps3vram_driver = {
-       .match_id       = PS3_MATCH_ID_GPU,
-       .match_sub_id   = PS3_MATCH_SUB_ID_GPU_RAMDISK,
-       .core.name      = DEVICE_NAME,
-       .core.owner     = THIS_MODULE,
-       .probe          = ps3vram_probe,
-       .remove         = ps3vram_shutdown,
-       .shutdown       = ps3vram_shutdown,
-};
-
-static int __init ps3vram_init(void)
-{
-       return ps3_system_bus_driver_register(&ps3vram_driver);
-}
-
-static void __exit ps3vram_exit(void)
-{
-       ps3_system_bus_driver_unregister(&ps3vram_driver);
-}
-
-module_init(ps3vram_init);
-module_exit(ps3vram_exit);
-
-MODULE_LICENSE("GPL");
-MODULE_AUTHOR("Jim Paris <jim@jtan.com>");
-MODULE_DESCRIPTION("MTD driver for PS3 video RAM");
-MODULE_ALIAS(PS3_MODULE_ALIAS_GPU_RAMDISK);
index ce6badd..211af86 100644 (file)
@@ -73,8 +73,6 @@ source "drivers/staging/rt2860/Kconfig"
 
 source "drivers/staging/rt2870/Kconfig"
 
-source "drivers/staging/benet/Kconfig"
-
 source "drivers/staging/comedi/Kconfig"
 
 source "drivers/staging/asus_oled/Kconfig"
index 9ddcc2b..47a56f5 100644 (file)
@@ -19,7 +19,6 @@ obj-$(CONFIG_AGNX)            += agnx/
 obj-$(CONFIG_OTUS)             += otus/
 obj-$(CONFIG_RT2860)           += rt2860/
 obj-$(CONFIG_RT2870)           += rt2870/
-obj-$(CONFIG_BENET)            += benet/
 obj-$(CONFIG_COMEDI)           += comedi/
 obj-$(CONFIG_ASUS_OLED)                += asus_oled/
 obj-$(CONFIG_PANEL)            += panel/
diff --git a/drivers/staging/benet/Kconfig b/drivers/staging/benet/Kconfig
deleted file mode 100644 (file)
index f680607..0000000
+++ /dev/null
@@ -1,7 +0,0 @@
-config BENET
-       tristate "ServerEngines 10Gb NIC - BladeEngine"
-       depends on PCI && INET
-       select INET_LRO
-       help
-         This driver implements the NIC functionality for ServerEngines
-         10Gb network adapter BladeEngine (EC 3210).
diff --git a/drivers/staging/benet/MAINTAINERS b/drivers/staging/benet/MAINTAINERS
deleted file mode 100644 (file)
index d5ce340..0000000
+++ /dev/null
@@ -1,6 +0,0 @@
-SERVER ENGINES 10Gbe NIC - BLADE-ENGINE
-P:     Subbu Seetharaman
-M:     subbus@serverengines.com
-L:     netdev@vger.kernel.org
-W:     http://www.serverengines.com
-S:     Supported
diff --git a/drivers/staging/benet/Makefile b/drivers/staging/benet/Makefile
deleted file mode 100644 (file)
index 460b923..0000000
+++ /dev/null
@@ -1,14 +0,0 @@
-#
-# Makefile to build the network driver for ServerEngine's BladeEngine
-#
-obj-$(CONFIG_BENET) += benet.o
-
-benet-y :=  be_init.o \
-                       be_int.o \
-                       be_netif.o \
-                       be_ethtool.o \
-                       funcobj.o \
-                       cq.o \
-                       eq.o \
-                       mpu.o \
-                       eth.o
diff --git a/drivers/staging/benet/TODO b/drivers/staging/benet/TODO
deleted file mode 100644 (file)
index a51dfb5..0000000
+++ /dev/null
@@ -1,6 +0,0 @@
-TODO:
-       - remove wrappers around common iowrite functions
-       - full netdev audit of common problems/issues
-
-Please send all patches and questions to Subbu Seetharaman
-<subbus@serverengines.com> and Greg Kroah-Hartman <greg@kroah.com>
diff --git a/drivers/staging/benet/asyncmesg.h b/drivers/staging/benet/asyncmesg.h
deleted file mode 100644 (file)
index d1e779a..0000000
+++ /dev/null
@@ -1,82 +0,0 @@
-/*
- * Copyright (C) 2005 - 2008 ServerEngines
- * All rights reserved.
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License version 2
- * as published by the Free Software Foundation.  The full GNU General
- * Public License is included in this distribution in the file called COPYING.
- *
- * Contact Information:
- * linux-drivers@serverengines.com
- *
- * ServerEngines
- * 209 N. Fair Oaks Ave
- * Sunnyvale, CA 94085
- */
-/*
- * Autogenerated by srcgen version: 0127
- */
-#ifndef __asyncmesg_amap_h__
-#define __asyncmesg_amap_h__
-#include "fwcmd_common.h"
-
-/* --- ASYNC_EVENT_CODES --- */
-#define ASYNC_EVENT_CODE_LINK_STATE     (1)
-#define ASYNC_EVENT_CODE_ISCSI          (2)
-
-/* --- ASYNC_LINK_STATES --- */
-#define ASYNC_EVENT_LINK_DOWN           (0)    /* Link Down on a port */
-#define ASYNC_EVENT_LINK_UP             (1)    /* Link Up on a port */
-
-/*
- * The last 4 bytes of the async events have this common format.  It allows
- * the driver to distinguish [link]MCC_CQ_ENTRY[/link] structs from
- * asynchronous events.  Both arrive on the same completion queue.  This
- * structure also contains the common fields used to decode the async event.
- */
-struct BE_ASYNC_EVENT_TRAILER_AMAP {
-       u8 rsvd0[8];    /* DWORD 0 */
-       u8 event_code[8];       /* DWORD 0 */
-       u8 event_type[8];       /* DWORD 0 */
-       u8 rsvd1[6];    /* DWORD 0 */
-       u8 async_event; /* DWORD 0 */
-       u8 valid;               /* DWORD 0 */
-} __packed;
-struct ASYNC_EVENT_TRAILER_AMAP {
-       u32 dw[1];
-};
-
-/*
- * Applicable in Initiator, Target and NIC modes.
- * A link state async event is seen by all device drivers as soon they
- * create an MCC ring. Thereafter, anytime the link status changes the
- * drivers will receive a link state async event. Notifications continue to
- * be sent until a driver destroys its MCC ring. A link down event is
- * reported when either port loses link. A link up event is reported
- * when either port regains link. When BE's failover mechanism is enabled, a
- * link down on the active port causes traffic to be diverted to the standby
- * port by the BE's ARM firmware (assuming the standby port has link). In
- * this case, the standy port assumes the active status. Note: when link is
- * restored on the failed port, traffic continues on the currently active
- * port. The ARM firmware does not attempt to 'fail back' traffic to
- * the restored port.
- */
-struct BE_ASYNC_EVENT_LINK_STATE_AMAP {
-       u8 port0_link_status[8];
-       u8 port1_link_status[8];
-       u8 active_port[8];
-       u8 rsvd0[8];    /* DWORD 0 */
-       u8 port0_duplex[8];
-       u8 port0_speed[8];
-       u8 port1_duplex[8];
-       u8 port1_speed[8];
-       u8 port0_fault[8];
-       u8 port1_fault[8];
-       u8 rsvd1[2][8]; /* DWORD 2 */
-       struct BE_ASYNC_EVENT_TRAILER_AMAP trailer;
-} __packed;
-struct ASYNC_EVENT_LINK_STATE_AMAP {
-       u32 dw[4];
-};
-#endif /* __asyncmesg_amap_h__ */
diff --git a/drivers/staging/benet/be_cm.h b/drivers/staging/benet/be_cm.h
deleted file mode 100644 (file)
index b7a1dfd..0000000
+++ /dev/null
@@ -1,134 +0,0 @@
-/*
- * Copyright (C) 2005 - 2008 ServerEngines
- * All rights reserved.
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License version 2
- * as published by the Free Software Foundation.  The full GNU General
- * Public License is included in this distribution in the file called COPYING.
- *
- * Contact Information:
- * linux-drivers@serverengines.com
- *
- * ServerEngines
- * 209 N. Fair Oaks Ave
- * Sunnyvale, CA 94085
- */
-/*
- * Autogenerated by srcgen version: 0127
- */
-#ifndef __be_cm_amap_h__
-#define __be_cm_amap_h__
-#include "be_common.h"
-#include "etx_context.h"
-#include "mpu_context.h"
-
-/*
- * --- CEV_WATERMARK_ENUM ---
- * CQ/EQ Watermark Encodings. Encoded as number of free entries in
- * Queue when Watermark is reached.
- */
-#define CEV_WMARK_0        (0) /* Watermark when Queue full */
-#define CEV_WMARK_16       (1) /* Watermark at 16 free entries */
-#define CEV_WMARK_32       (2) /* Watermark at 32 free entries */
-#define CEV_WMARK_48       (3) /* Watermark at 48 free entries */
-#define CEV_WMARK_64       (4) /* Watermark at 64 free entries */
-#define CEV_WMARK_80       (5) /* Watermark at 80 free entries */
-#define CEV_WMARK_96       (6) /* Watermark at 96 free entries */
-#define CEV_WMARK_112      (7) /* Watermark at 112 free entries */
-#define CEV_WMARK_128      (8) /* Watermark at 128 free entries */
-#define CEV_WMARK_144      (9) /* Watermark at 144 free entries */
-#define CEV_WMARK_160      (10)        /* Watermark at 160 free entries */
-#define CEV_WMARK_176      (11)        /* Watermark at 176 free entries */
-#define CEV_WMARK_192      (12)        /* Watermark at 192 free entries */
-#define CEV_WMARK_208      (13)        /* Watermark at 208 free entries */
-#define CEV_WMARK_224      (14)        /* Watermark at 224 free entries */
-#define CEV_WMARK_240      (15)        /* Watermark at 240 free entries */
-
-/*
- * --- CQ_CNT_ENUM ---
- * Completion Queue Count Encodings.
- */
-#define CEV_CQ_CNT_256                  (0)    /* CQ has 256 entries */
-#define CEV_CQ_CNT_512                  (1)    /* CQ has 512 entries */
-#define CEV_CQ_CNT_1024                 (2)    /* CQ has 1024 entries */
-
-/*
- * --- EQ_CNT_ENUM ---
- * Event Queue Count Encodings.
- */
-#define CEV_EQ_CNT_256     (0) /* EQ has 256 entries (16-byte EQEs only) */
-#define CEV_EQ_CNT_512     (1) /* EQ has 512 entries (16-byte EQEs only) */
-#define CEV_EQ_CNT_1024    (2) /* EQ has 1024 entries (4-byte or */
-                               /* 16-byte EQEs only) */
-#define CEV_EQ_CNT_2048    (3) /* EQ has 2048 entries (4-byte or */
-                               /* 16-byte EQEs only) */
-#define CEV_EQ_CNT_4096    (4) /* EQ has 4096 entries (4-byte EQEs only) */
-
-/*
- * --- EQ_SIZE_ENUM ---
- * Event Queue Entry Size Encoding.
- */
-#define CEV_EQ_SIZE_4                   (0)    /* EQE is 4 bytes */
-#define CEV_EQ_SIZE_16                  (1)    /* EQE is 16 bytes */
-
-/*
- * Completion Queue Context Table Entry. Contains the state of a CQ.
- * Located in RAM within the CEV block.
- */
-struct BE_CQ_CONTEXT_AMAP {
-       u8 Cidx[11];    /* DWORD 0 */
-       u8 Watermark[4];        /* DWORD 0 */
-       u8 NoDelay;             /* DWORD 0 */
-       u8 EPIdx[11];   /* DWORD 0 */
-       u8 Count[2];    /* DWORD 0 */
-       u8 valid;               /* DWORD 0 */
-       u8 SolEvent;    /* DWORD 0 */
-       u8 Eventable;   /* DWORD 0 */
-       u8 Pidx[11];    /* DWORD 1 */
-       u8 PD[10];              /* DWORD 1 */
-       u8 EQID[7];             /* DWORD 1 */
-       u8 Func;                /* DWORD 1 */
-       u8 WME;         /* DWORD 1 */
-       u8 Stalled;             /* DWORD 1 */
-       u8 Armed;               /* DWORD 1 */
-} __packed;
-struct CQ_CONTEXT_AMAP {
-       u32 dw[2];
-};
-
-/*
- * Event Queue Context Table Entry. Contains the state of an EQ.
- * Located in RAM in the CEV block.
- */
-struct BE_EQ_CONTEXT_AMAP {
-       u8 Cidx[13];    /* DWORD 0 */
-       u8 rsvd0[2];    /* DWORD 0 */
-       u8 Func;                /* DWORD 0 */
-       u8 EPIdx[13];   /* DWORD 0 */
-       u8 valid;               /* DWORD 0 */
-       u8 rsvd1;               /* DWORD 0 */
-       u8 Size;                /* DWORD 0 */
-       u8 Pidx[13];    /* DWORD 1 */
-       u8 rsvd2[3];    /* DWORD 1 */
-       u8 PD[10];              /* DWORD 1 */
-       u8 Count[3];    /* DWORD 1 */
-       u8 SolEvent;    /* DWORD 1 */
-       u8 Stalled;             /* DWORD 1 */
-       u8 Armed;               /* DWORD 1 */
-       u8 Watermark[4];        /* DWORD 2 */
-       u8 WME;         /* DWORD 2 */
-       u8 rsvd3[3];    /* DWORD 2 */
-       u8 EventVect[6];        /* DWORD 2 */
-       u8 rsvd4[2];    /* DWORD 2 */
-       u8 Delay[8];    /* DWORD 2 */
-       u8 rsvd5[6];    /* DWORD 2 */
-       u8 TMR;         /* DWORD 2 */
-       u8 rsvd6;               /* DWORD 2 */
-       u8 rsvd7[32];   /* DWORD 3 */
-} __packed;
-struct EQ_CONTEXT_AMAP {
-       u32 dw[4];
-};
-
-#endif /* __be_cm_amap_h__ */
diff --git a/drivers/staging/benet/be_common.h b/drivers/staging/benet/be_common.h
deleted file mode 100644 (file)
index 7e63dc5..0000000
+++ /dev/null
@@ -1,53 +0,0 @@
-/*
- * Copyright (C) 2005 - 2008 ServerEngines
- * All rights reserved.
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License version 2
- * as published by the Free Software Foundation.  The full GNU General
- * Public License is included in this distribution in the file called COPYING.
- *
- * Contact Information:
- * linux-drivers@serverengines.com
- *
- * ServerEngines
- * 209 N. Fair Oaks Ave
- * Sunnyvale, CA 94085
- */
-/*
- * Autogenerated by srcgen version: 0127
- */
-#ifndef __be_common_amap_h__
-#define __be_common_amap_h__
-
-/* Physical Address. */
-struct BE_PHYS_ADDR_AMAP {
-       u8 lo[32];              /* DWORD 0 */
-       u8 hi[32];              /* DWORD 1 */
-} __packed;
-struct PHYS_ADDR_AMAP {
-       u32 dw[2];
-};
-
-/* Virtual Address. */
-struct BE_VIRT_ADDR_AMAP {
-       u8 lo[32];              /* DWORD 0 */
-       u8 hi[32];              /* DWORD 1 */
-} __packed;
-struct VIRT_ADDR_AMAP {
-       u32 dw[2];
-};
-
-/* Scatter gather element. */
-struct BE_SGE_AMAP {
-       u8 addr_hi[32]; /* DWORD 0 */
-       u8 addr_lo[32]; /* DWORD 1 */
-       u8 rsvd0[32];   /* DWORD 2 */
-       u8 len[16];             /* DWORD 3 */
-       u8 rsvd1[16];   /* DWORD 3 */
-} __packed;
-struct SGE_AMAP {
-       u32 dw[4];
-};
-
-#endif /* __be_common_amap_h__ */
diff --git a/drivers/staging/benet/be_ethtool.c b/drivers/staging/benet/be_ethtool.c
deleted file mode 100644 (file)
index 027af85..0000000
+++ /dev/null
@@ -1,348 +0,0 @@
-/*
- * Copyright (C) 2005 - 2008 ServerEngines
- * All rights reserved.
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License version 2
- * as published by the Free Software Foundation.  The full GNU General
- * Public License is included in this distribution in the file called COPYING.
- *
- * Contact Information:
- * linux-drivers@serverengines.com
- *
- * ServerEngines
- * 209 N. Fair Oaks Ave
- * Sunnyvale, CA 94085
- */
-/*
- * be_ethtool.c
- *
- *     This file contains various functions that ethtool can use
- *     to talk to the driver and the BE H/W.
- */
-
-#include "benet.h"
-
-#include <linux/ethtool.h>
-
-static const char benet_gstrings_stats[][ETH_GSTRING_LEN] = {
-/* net_device_stats */
-       "rx_packets",
-       "tx_packets",
-       "rx_bytes",
-       "tx_bytes",
-       "rx_errors",
-       "tx_errors",
-       "rx_dropped",
-       "tx_dropped",
-       "multicast",
-       "collisions",
-       "rx_length_errors",
-       "rx_over_errors",
-       "rx_crc_errors",
-       "rx_frame_errors",
-       "rx_fifo_errors",
-       "rx_missed_errors",
-       "tx_aborted_errors",
-       "tx_carrier_errors",
-       "tx_fifo_errors",
-       "tx_heartbeat_errors",
-       "tx_window_errors",
-       "rx_compressed",
-       "tc_compressed",
-/* BE driver Stats */
-       "bes_tx_reqs",
-       "bes_tx_fails",
-       "bes_fwd_reqs",
-       "bes_tx_wrbs",
-       "bes_interrupts",
-       "bes_events",
-       "bes_tx_events",
-       "bes_rx_events",
-       "bes_tx_compl",
-       "bes_rx_compl",
-       "bes_ethrx_post_fail",
-       "bes_802_3_dropped_frames",
-       "bes_802_3_malformed_frames",
-       "bes_rx_misc_pkts",
-       "bes_eth_tx_rate",
-       "bes_eth_rx_rate",
-       "Num Packets collected",
-       "Num Times Flushed",
-};
-
-#define NET_DEV_STATS_LEN \
-       (sizeof(struct net_device_stats)/sizeof(unsigned long))
-
-#define BENET_STATS_LEN  ARRAY_SIZE(benet_gstrings_stats)
-
-static void
-be_get_drvinfo(struct net_device *netdev, struct ethtool_drvinfo *drvinfo)
-{
-       struct be_net_object *pnob = netdev_priv(netdev);
-       struct be_adapter *adapter = pnob->adapter;
-
-       strncpy(drvinfo->driver, be_driver_name, 32);
-       strncpy(drvinfo->version, be_drvr_ver, 32);
-       strncpy(drvinfo->fw_version, be_fw_ver, 32);
-       strcpy(drvinfo->bus_info, pci_name(adapter->pdev));
-       drvinfo->testinfo_len = 0;
-       drvinfo->regdump_len = 0;
-       drvinfo->eedump_len = 0;
-}
-
-static int
-be_get_coalesce(struct net_device *netdev, struct ethtool_coalesce *coalesce)
-{
-       struct be_net_object *pnob = netdev_priv(netdev);
-       struct be_adapter *adapter = pnob->adapter;
-
-       coalesce->rx_max_coalesced_frames = adapter->max_rx_coal;
-
-       coalesce->rx_coalesce_usecs = adapter->cur_eqd;
-       coalesce->rx_coalesce_usecs_high = adapter->max_eqd;
-       coalesce->rx_coalesce_usecs_low = adapter->min_eqd;
-
-       coalesce->tx_coalesce_usecs = adapter->cur_eqd;
-       coalesce->tx_coalesce_usecs_high = adapter->max_eqd;
-       coalesce->tx_coalesce_usecs_low = adapter->min_eqd;
-
-       coalesce->use_adaptive_rx_coalesce = adapter->enable_aic;
-       coalesce->use_adaptive_tx_coalesce = adapter->enable_aic;
-
-       return 0;
-}
-
-/*
- * This routine is used to set interrup coalescing delay *as well as*
- * the number of pkts to coalesce for LRO.
- */
-static int
-be_set_coalesce(struct net_device *netdev, struct ethtool_coalesce *coalesce)
-{
-       struct be_net_object *pnob = netdev_priv(netdev);
-       struct be_adapter *adapter = pnob->adapter;
-       struct be_eq_object *eq_objectp;
-       u32 max, min, cur;
-       int status;
-
-       adapter->max_rx_coal = coalesce->rx_max_coalesced_frames;
-       if (adapter->max_rx_coal >= BE_LRO_MAX_PKTS)
-               adapter->max_rx_coal = BE_LRO_MAX_PKTS;
-
-       if (adapter->enable_aic == 0 &&
-               coalesce->use_adaptive_rx_coalesce == 1) {
-               /* if AIC is being turned on now, start with an EQD of 0 */
-               adapter->cur_eqd = 0;
-       }
-       adapter->enable_aic = coalesce->use_adaptive_rx_coalesce;
-
-       /* round off to nearest multiple of 8 */
-       max = (((coalesce->rx_coalesce_usecs_high + 4) >> 3) << 3);
-       min = (((coalesce->rx_coalesce_usecs_low + 4) >> 3) << 3);
-       cur = (((coalesce->rx_coalesce_usecs + 4) >> 3) << 3);
-
-       if (adapter->enable_aic) {
-               /* accept low and high if AIC is enabled */
-               if (max > MAX_EQD)
-                       max = MAX_EQD;
-               if (min > max)
-                       min = max;
-               adapter->max_eqd = max;
-               adapter->min_eqd = min;
-               if (adapter->cur_eqd > max)
-                       adapter->cur_eqd = max;
-               if (adapter->cur_eqd < min)
-                       adapter->cur_eqd = min;
-       } else {
-               /* accept specified coalesce_usecs only if AIC is disabled */
-               if (cur > MAX_EQD)
-                       cur = MAX_EQD;
-               eq_objectp = &pnob->event_q_obj;
-               status =
-                   be_eq_modify_delay(&pnob->fn_obj, 1, &eq_objectp, &cur,
-                                      NULL, NULL, NULL);
-               if (status == BE_SUCCESS)
-                       adapter->cur_eqd = cur;
-       }
-       return 0;
-}
-
-static u32 be_get_rx_csum(struct net_device *netdev)
-{
-       struct be_net_object *pnob = netdev_priv(netdev);
-       struct be_adapter *adapter = pnob->adapter;
-       return adapter->rx_csum;
-}
-
-static int be_set_rx_csum(struct net_device *netdev, uint32_t data)
-{
-       struct be_net_object *pnob = netdev_priv(netdev);
-       struct be_adapter *adapter = pnob->adapter;
-
-       if (data)
-               adapter->rx_csum = 1;
-       else
-               adapter->rx_csum = 0;
-
-       return 0;
-}
-
-static void
-be_get_strings(struct net_device *netdev, uint32_t stringset, uint8_t *data)
-{
-       switch (stringset) {
-       case ETH_SS_STATS:
-               memcpy(data, *benet_gstrings_stats,
-                      sizeof(benet_gstrings_stats));
-               break;
-       }
-}
-
-static int be_get_stats_count(struct net_device *netdev)
-{
-       return BENET_STATS_LEN;
-}
-
-static void
-be_get_ethtool_stats(struct net_device *netdev,
-                    struct ethtool_stats *stats, uint64_t *data)
-{
-       struct be_net_object *pnob = netdev_priv(netdev);
-       struct be_adapter *adapter = pnob->adapter;
-       int i;
-
-       benet_get_stats(netdev);
-
-       for (i = 0; i <= NET_DEV_STATS_LEN; i++)
-               data[i] = ((unsigned long *)&adapter->benet_stats)[i];
-
-       data[i] = adapter->be_stat.bes_tx_reqs;
-       data[i++] = adapter->be_stat.bes_tx_fails;
-       data[i++] = adapter->be_stat.bes_fwd_reqs;
-       data[i++] = adapter->be_stat.bes_tx_wrbs;
-
-       data[i++] = adapter->be_stat.bes_ints;
-       data[i++] = adapter->be_stat.bes_events;
-       data[i++] = adapter->be_stat.bes_tx_events;
-       data[i++] = adapter->be_stat.bes_rx_events;
-       data[i++] = adapter->be_stat.bes_tx_compl;
-       data[i++] = adapter->be_stat.bes_rx_compl;
-       data[i++] = adapter->be_stat.bes_ethrx_post_fail;
-       data[i++] = adapter->be_stat.bes_802_3_dropped_frames;
-       data[i++] = adapter->be_stat.bes_802_3_malformed_frames;
-       data[i++] = adapter->be_stat.bes_rx_misc_pkts;
-       data[i++] = adapter->be_stat.bes_eth_tx_rate;
-       data[i++] = adapter->be_stat.bes_eth_rx_rate;
-       data[i++] = adapter->be_stat.bes_rx_coal;
-       data[i++] = adapter->be_stat.bes_rx_flush;
-
-}
-
-static int be_get_settings(struct net_device *netdev, struct ethtool_cmd *ecmd)
-{
-       ecmd->speed = SPEED_10000;
-       ecmd->duplex = DUPLEX_FULL;
-       ecmd->autoneg = AUTONEG_DISABLE;
-       return 0;
-}
-
-/* Get the Ring parameters from the pnob */
-static void
-be_get_ringparam(struct net_device *netdev, struct ethtool_ringparam *ring)
-{
-       struct be_net_object *pnob = netdev_priv(netdev);
-
-       /* Pre Set Maxims */
-       ring->rx_max_pending = pnob->rx_q_len;
-       ring->rx_mini_max_pending = ring->rx_mini_max_pending;
-       ring->rx_jumbo_max_pending = ring->rx_jumbo_max_pending;
-       ring->tx_max_pending = pnob->tx_q_len;
-
-       /* Current hardware Settings                */
-       ring->rx_pending = atomic_read(&pnob->rx_q_posted);
-       ring->rx_mini_pending = ring->rx_mini_pending;
-       ring->rx_jumbo_pending = ring->rx_jumbo_pending;
-       ring->tx_pending = atomic_read(&pnob->tx_q_used);
-
-}
-
-static void
-be_get_pauseparam(struct net_device *netdev, struct ethtool_pauseparam *ecmd)
-{
-       struct be_net_object *pnob = netdev_priv(netdev);
-       bool rxfc, txfc;
-       int status;
-
-       status = be_eth_get_flow_control(&pnob->fn_obj, &txfc, &rxfc);
-       if (status != BE_SUCCESS) {
-               dev_info(&netdev->dev, "Unable to get pause frame settings\n");
-               /* return defaults */
-               ecmd->rx_pause = 1;
-               ecmd->tx_pause = 0;
-               ecmd->autoneg = AUTONEG_ENABLE;
-               return;
-       }
-
-       if (txfc == true)
-               ecmd->tx_pause = 1;
-       else
-               ecmd->tx_pause = 0;
-
-       if (rxfc == true)
-               ecmd->rx_pause = 1;
-       else
-               ecmd->rx_pause = 0;
-
-       ecmd->autoneg = AUTONEG_ENABLE;
-}
-
-static int
-be_set_pauseparam(struct net_device *netdev, struct ethtool_pauseparam *ecmd)
-{
-       struct be_net_object *pnob = netdev_priv(netdev);
-       bool txfc, rxfc;
-       int status;
-
-       if (ecmd->autoneg != AUTONEG_ENABLE)
-               return -EINVAL;
-
-       if (ecmd->tx_pause)
-               txfc = true;
-       else
-               txfc = false;
-
-       if (ecmd->rx_pause)
-               rxfc = true;
-       else
-               rxfc = false;
-
-       status = be_eth_set_flow_control(&pnob->fn_obj, txfc, rxfc);
-       if (status != BE_SUCCESS) {
-               dev_info(&netdev->dev, "Unable to set pause frame settings\n");
-               return -1;
-       }
-       return 0;
-}
-
-struct ethtool_ops be_ethtool_ops = {
-       .get_settings = be_get_settings,
-       .get_drvinfo = be_get_drvinfo,
-       .get_link = ethtool_op_get_link,
-       .get_coalesce = be_get_coalesce,
-       .set_coalesce = be_set_coalesce,
-       .get_ringparam = be_get_ringparam,
-       .get_pauseparam = be_get_pauseparam,
-       .set_pauseparam = be_set_pauseparam,
-       .get_rx_csum = be_get_rx_csum,
-       .set_rx_csum = be_set_rx_csum,
-       .get_tx_csum = ethtool_op_get_tx_csum,
-       .set_tx_csum = ethtool_op_set_tx_csum,
-       .get_sg = ethtool_op_get_sg,
-       .set_sg = ethtool_op_set_sg,
-       .get_tso = ethtool_op_get_tso,
-       .set_tso = ethtool_op_set_tso,
-       .get_strings = be_get_strings,
-       .get_stats_count = be_get_stats_count,
-       .get_ethtool_stats = be_get_ethtool_stats,
-};
diff --git a/drivers/staging/benet/be_init.c b/drivers/staging/benet/be_init.c
deleted file mode 100644 (file)
index 12a026c..0000000
+++ /dev/null
@@ -1,1382 +0,0 @@
-/*
- * Copyright (C) 2005 - 2008 ServerEngines
- * All rights reserved.
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License version 2
- * as published by the Free Software Foundation.  The full GNU General
- * Public License is included in this distribution in the file called COPYING.
- *
- * Contact Information:
- * linux-drivers@serverengines.com
- *
- * ServerEngines
- * 209 N. Fair Oaks Ave
- * Sunnyvale, CA 94085
- */
-#include <linux/etherdevice.h>
-#include "benet.h"
-
-#define  DRVR_VERSION  "1.0.728"
-
-static const struct pci_device_id be_device_id_table[] = {
-       {PCI_DEVICE(0x19a2, 0x0201)},
-       {0}
-};
-
-MODULE_DEVICE_TABLE(pci, be_device_id_table);
-
-MODULE_VERSION(DRVR_VERSION);
-
-#define DRV_DESCRIPTION "ServerEngines BladeEngine Network Driver Version "
-
-MODULE_DESCRIPTION(DRV_DESCRIPTION DRVR_VERSION);
-MODULE_AUTHOR("ServerEngines");
-MODULE_LICENSE("GPL");
-
-static unsigned int msix = 1;
-module_param(msix, uint, S_IRUGO);
-MODULE_PARM_DESC(msix, "Use MSI-x interrupts");
-
-static unsigned int rxbuf_size = 2048; /* Default RX frag size */
-module_param(rxbuf_size, uint, S_IRUGO);
-MODULE_PARM_DESC(rxbuf_size, "Size of buffers to hold Rx data");
-
-const char be_drvr_ver[] = DRVR_VERSION;
-char be_fw_ver[32];            /* F/W version filled in by be_probe */
-char be_driver_name[] = "benet";
-
-/*
- * Number of entries in each queue.
- */
-#define EVENT_Q_LEN            1024
-#define ETH_TXQ_LEN            2048
-#define ETH_TXCQ_LEN           1024
-#define ETH_RXQ_LEN            1024    /* Does not support any other value */
-#define ETH_UC_RXCQ_LEN                1024
-#define ETH_BC_RXCQ_LEN                256
-#define MCC_Q_LEN               64     /* total size not to exceed 8 pages */
-#define MCC_CQ_LEN              256
-
-/* Bit mask describing events of interest to be traced */
-unsigned int trace_level;
-
-static int
-init_pci_be_function(struct be_adapter *adapter, struct pci_dev *pdev)
-{
-       u64 pa;
-
-       /* CSR */
-       pa = pci_resource_start(pdev, 2);
-       adapter->csr_va = ioremap_nocache(pa, pci_resource_len(pdev, 2));
-       if (adapter->csr_va == NULL)
-               return -ENOMEM;
-
-       /* Door Bell */
-       pa = pci_resource_start(pdev, 4);
-       adapter->db_va = ioremap_nocache(pa, (128 * 1024));
-       if (adapter->db_va == NULL) {
-               iounmap(adapter->csr_va);
-               return -ENOMEM;
-       }
-
-       /* PCI */
-       pa = pci_resource_start(pdev, 1);
-       adapter->pci_va = ioremap_nocache(pa, pci_resource_len(pdev, 1));
-       if (adapter->pci_va == NULL) {
-               iounmap(adapter->csr_va);
-               iounmap(adapter->db_va);
-               return -ENOMEM;
-       }
-       return 0;
-}
-
-/*
-   This function enables the interrupt corresponding to the Event
-   queue ID for the given NetObject
-*/
-void be_enable_eq_intr(struct be_net_object *pnob)
-{
-       struct CQ_DB_AMAP cqdb;
-       cqdb.dw[0] = 0;
-       AMAP_SET_BITS_PTR(CQ_DB, event, &cqdb, 1);
-       AMAP_SET_BITS_PTR(CQ_DB, rearm, &cqdb, 1);
-       AMAP_SET_BITS_PTR(CQ_DB, num_popped, &cqdb, 0);
-       AMAP_SET_BITS_PTR(CQ_DB, qid, &cqdb, pnob->event_q_id);
-       PD_WRITE(&pnob->fn_obj, cq_db, cqdb.dw[0]);
-}
-
-/*
-   This function disables the interrupt corresponding to the Event
-   queue ID for the given NetObject
-*/
-void be_disable_eq_intr(struct be_net_object *pnob)
-{
-       struct CQ_DB_AMAP cqdb;
-       cqdb.dw[0] = 0;
-       AMAP_SET_BITS_PTR(CQ_DB, event, &cqdb, 1);
-       AMAP_SET_BITS_PTR(CQ_DB, rearm, &cqdb, 0);
-       AMAP_SET_BITS_PTR(CQ_DB, num_popped, &cqdb, 0);
-       AMAP_SET_BITS_PTR(CQ_DB, qid, &cqdb, pnob->event_q_id);
-       PD_WRITE(&pnob->fn_obj, cq_db, cqdb.dw[0]);
-}
-
-/*
-    This function enables the interrupt from the  network function
-    of the BladeEngine. Use the function be_disable_eq_intr()
-    to enable the interrupt from the event queue of only one specific
-    NetObject
-*/
-void be_enable_intr(struct be_net_object *pnob)
-{
-       struct PCICFG_HOST_TIMER_INT_CTRL_CSR_AMAP ctrl;
-       u32 host_intr;
-
-       ctrl.dw[0] = PCICFG1_READ(&pnob->fn_obj, host_timer_int_ctrl);
-       host_intr = AMAP_GET_BITS_PTR(PCICFG_HOST_TIMER_INT_CTRL_CSR,
-                                                       hostintr, ctrl.dw);
-       if (!host_intr) {
-               AMAP_SET_BITS_PTR(PCICFG_HOST_TIMER_INT_CTRL_CSR,
-                       hostintr, ctrl.dw, 1);
-               PCICFG1_WRITE(&pnob->fn_obj, host_timer_int_ctrl,
-                       ctrl.dw[0]);
-       }
-}
-
-/*
-   This function disables the interrupt from the network function of
-   the BladeEngine.  Use the function be_disable_eq_intr() to
-   disable the interrupt from the event queue of only one specific NetObject
-*/
-void be_disable_intr(struct be_net_object *pnob)
-{
-
-       struct PCICFG_HOST_TIMER_INT_CTRL_CSR_AMAP ctrl;
-       u32 host_intr;
-       ctrl.dw[0] = PCICFG1_READ(&pnob->fn_obj, host_timer_int_ctrl);
-       host_intr = AMAP_GET_BITS_PTR(PCICFG_HOST_TIMER_INT_CTRL_CSR,
-                                                       hostintr, ctrl.dw);
-       if (host_intr) {
-               AMAP_SET_BITS_PTR(PCICFG_HOST_TIMER_INT_CTRL_CSR, hostintr,
-                       ctrl.dw, 0);
-               PCICFG1_WRITE(&pnob->fn_obj, host_timer_int_ctrl,
-                       ctrl.dw[0]);
-       }
-}
-
-static int be_enable_msix(struct be_adapter *adapter)
-{
-       int i, ret;
-
-       if (!msix)
-               return -1;
-
-       for (i = 0; i < BE_MAX_REQ_MSIX_VECTORS; i++)
-               adapter->msix_entries[i].entry = i;
-
-       ret = pci_enable_msix(adapter->pdev, adapter->msix_entries,
-               BE_MAX_REQ_MSIX_VECTORS);
-
-       if (ret == 0)
-               adapter->msix_enabled = 1;
-       return ret;
-}
-
-static int be_register_isr(struct be_adapter *adapter,
-               struct be_net_object *pnob)
-{
-       struct net_device *netdev = pnob->netdev;
-       int intx = 0, r;
-
-       netdev->irq = adapter->pdev->irq;
-       r = be_enable_msix(adapter);
-
-       if (r == 0) {
-               r = request_irq(adapter->msix_entries[0].vector,
-                               be_int, IRQF_SHARED, netdev->name, netdev);
-               if (r) {
-                       printk(KERN_WARNING
-                               "MSIX Request IRQ failed - Errno %d\n", r);
-                       intx = 1;
-                       pci_disable_msix(adapter->pdev);
-                       adapter->msix_enabled = 0;
-               }
-       } else {
-               intx = 1;
-       }
-
-       if (intx) {
-               r = request_irq(netdev->irq, be_int, IRQF_SHARED,
-                               netdev->name, netdev);
-               if (r) {
-                       printk(KERN_WARNING
-                               "INTx Request IRQ failed - Errno %d\n", r);
-                       return -1;
-               }
-       }
-       adapter->isr_registered = 1;
-       return 0;
-}
-
-static void be_unregister_isr(struct be_adapter *adapter)
-{
-       struct net_device *netdev = adapter->netdevp;
-       if (adapter->isr_registered) {
-               if (adapter->msix_enabled) {
-                       free_irq(adapter->msix_entries[0].vector, netdev);
-                       pci_disable_msix(adapter->pdev);
-                       adapter->msix_enabled = 0;
-               } else {
-                       free_irq(netdev->irq, netdev);
-               }
-               adapter->isr_registered = 0;
-       }
-}
-
-/*
-    This function processes the Flush Completions that are issued by the
-    ARM F/W, when a Recv Ring is destroyed.  A flush completion is
-    identified when a Rx COmpl descriptor has the tcpcksum and udpcksum
-    set and the pktsize is 32.  These completions are received on the
-    Rx Completion Queue.
-*/
-static u32 be_process_rx_flush_cmpl(struct be_net_object *pnob)
-{
-       struct ETH_RX_COMPL_AMAP *rxcp;
-       unsigned int i = 0;
-       while ((rxcp = be_get_rx_cmpl(pnob)) != NULL) {
-               be_notify_cmpl(pnob, 1, pnob->rx_cq_id, 1);
-               i++;
-       }
-       return i;
-}
-
-static void be_tx_q_clean(struct be_net_object *pnob)
-{
-       while (atomic_read(&pnob->tx_q_used))
-               process_one_tx_compl(pnob, tx_compl_lastwrb_idx_get(pnob));
-}
-
-static void be_rx_q_clean(struct be_net_object *pnob)
-{
-       if (pnob->rx_ctxt) {
-               int i;
-               struct be_rx_page_info *rx_page_info;
-               for (i = 0; i < pnob->rx_q_len; i++) {
-                       rx_page_info = &(pnob->rx_page_info[i]);
-                       if (!pnob->rx_pg_shared || rx_page_info->page_offset) {
-                               pci_unmap_page(pnob->adapter->pdev,
-                                      pci_unmap_addr(rx_page_info, bus),
-                                              pnob->rx_buf_size,
-                                              PCI_DMA_FROMDEVICE);
-                       }
-                       if (rx_page_info->page)
-                               put_page(rx_page_info->page);
-                       memset(rx_page_info, 0, sizeof(struct be_rx_page_info));
-               }
-               pnob->rx_pg_info_hd = 0;
-       }
-}
-
-static void be_destroy_netobj(struct be_net_object *pnob)
-{
-       int status;
-
-       if (pnob->tx_q_created) {
-               status = be_eth_sq_destroy(&pnob->tx_q_obj);
-               pnob->tx_q_created = 0;
-       }
-
-       if (pnob->rx_q_created) {
-               status = be_eth_rq_destroy(&pnob->rx_q_obj);
-               if (status != 0) {
-                       status = be_eth_rq_destroy_options(&pnob->rx_q_obj, 0,
-                                                     NULL, NULL);
-                       BUG_ON(status);
-               }
-               pnob->rx_q_created = 0;
-       }
-
-       be_process_rx_flush_cmpl(pnob);
-
-       if (pnob->tx_cq_created) {
-               status = be_cq_destroy(&pnob->tx_cq_obj);
-               pnob->tx_cq_created = 0;
-       }
-
-       if (pnob->rx_cq_created) {
-               status = be_cq_destroy(&pnob->rx_cq_obj);
-               pnob->rx_cq_created = 0;
-       }
-
-       if (pnob->mcc_q_created) {
-               status = be_mcc_ring_destroy(&pnob->mcc_q_obj);
-               pnob->mcc_q_created = 0;
-       }
-       if (pnob->mcc_cq_created) {
-               status = be_cq_destroy(&pnob->mcc_cq_obj);
-               pnob->mcc_cq_created = 0;
-       }
-
-       if (pnob->event_q_created) {
-               status = be_eq_destroy(&pnob->event_q_obj);
-               pnob->event_q_created = 0;
-       }
-       be_function_cleanup(&pnob->fn_obj);
-}
-
-/*
- * free all resources associated with a pnob
- * Called at the time of module cleanup as well a any error during
- * module init.  Some resources may be partially allocated in a NetObj.
- */
-static void netobject_cleanup(struct be_adapter *adapter,
-                       struct be_net_object *pnob)
-{
-       struct net_device *netdev = adapter->netdevp;
-
-       if (netif_running(netdev)) {
-               netif_stop_queue(netdev);
-               be_wait_nic_tx_cmplx_cmpl(pnob);
-               be_disable_eq_intr(pnob);
-       }
-
-       be_unregister_isr(adapter);
-
-       if (adapter->tasklet_started) {
-               tasklet_kill(&(adapter->sts_handler));
-               adapter->tasklet_started = 0;
-       }
-       if (pnob->fn_obj_created)
-               be_disable_intr(pnob);
-
-       if (adapter->dev_state != BE_DEV_STATE_NONE)
-               unregister_netdev(netdev);
-
-       if (pnob->fn_obj_created)
-               be_destroy_netobj(pnob);
-
-       adapter->net_obj = NULL;
-       adapter->netdevp = NULL;
-
-       be_rx_q_clean(pnob);
-       if (pnob->rx_ctxt) {
-               kfree(pnob->rx_page_info);
-               kfree(pnob->rx_ctxt);
-       }
-
-       be_tx_q_clean(pnob);
-       kfree(pnob->tx_ctxt);
-
-       if (pnob->mcc_q)
-               pci_free_consistent(adapter->pdev, pnob->mcc_q_size,
-                       pnob->mcc_q, pnob->mcc_q_bus);
-
-       if (pnob->mcc_wrb_ctxt)
-               free_pages((unsigned long)pnob->mcc_wrb_ctxt,
-                          get_order(pnob->mcc_wrb_ctxt_size));
-
-       if (pnob->mcc_cq)
-               pci_free_consistent(adapter->pdev, pnob->mcc_cq_size,
-                       pnob->mcc_cq, pnob->mcc_cq_bus);
-
-       if (pnob->event_q)
-               pci_free_consistent(adapter->pdev, pnob->event_q_size,
-                       pnob->event_q, pnob->event_q_bus);
-
-       if (pnob->tx_cq)
-               pci_free_consistent(adapter->pdev, pnob->tx_cq_size,
-                       pnob->tx_cq, pnob->tx_cq_bus);
-
-       if (pnob->tx_q)
-               pci_free_consistent(adapter->pdev, pnob->tx_q_size,
-                       pnob->tx_q, pnob->tx_q_bus);
-
-       if (pnob->rx_q)
-               pci_free_consistent(adapter->pdev, pnob->rx_q_size,
-                       pnob->rx_q, pnob->rx_q_bus);
-
-       if (pnob->rx_cq)
-               pci_free_consistent(adapter->pdev, pnob->rx_cq_size,
-                       pnob->rx_cq, pnob->rx_cq_bus);
-
-
-       if (pnob->mb_ptr)
-               pci_free_consistent(adapter->pdev, pnob->mb_size, pnob->mb_ptr,
-                       pnob->mb_bus);
-
-       free_netdev(netdev);
-}
-
-
-static int be_nob_ring_alloc(struct be_adapter *adapter,
-       struct be_net_object *pnob)
-{
-       u32 size;
-
-       /* Mail box rd; mailbox pointer needs to be 16 byte aligned */
-       pnob->mb_size = sizeof(struct MCC_MAILBOX_AMAP) + 16;
-       pnob->mb_ptr = pci_alloc_consistent(adapter->pdev, pnob->mb_size,
-                               &pnob->mb_bus);
-       if (!pnob->mb_bus)
-               return -1;
-       memset(pnob->mb_ptr, 0, pnob->mb_size);
-       pnob->mb_rd.va = PTR_ALIGN(pnob->mb_ptr, 16);
-       pnob->mb_rd.pa = PTR_ALIGN(pnob->mb_bus, 16);
-       pnob->mb_rd.length = sizeof(struct MCC_MAILBOX_AMAP);
-       /*
-        * Event queue
-        */
-       pnob->event_q_len = EVENT_Q_LEN;
-       pnob->event_q_size = pnob->event_q_len * sizeof(struct EQ_ENTRY_AMAP);
-       pnob->event_q = pci_alloc_consistent(adapter->pdev, pnob->event_q_size,
-                               &pnob->event_q_bus);
-       if (!pnob->event_q_bus)
-               return -1;
-       memset(pnob->event_q, 0, pnob->event_q_size);
-       /*
-        * Eth TX queue
-        */
-       pnob->tx_q_len = ETH_TXQ_LEN;
-       pnob->tx_q_port = 0;
-       pnob->tx_q_size =  pnob->tx_q_len * sizeof(struct ETH_WRB_AMAP);
-       pnob->tx_q = pci_alloc_consistent(adapter->pdev, pnob->tx_q_size,
-                               &pnob->tx_q_bus);
-       if (!pnob->tx_q_bus)
-               return -1;
-       memset(pnob->tx_q, 0, pnob->tx_q_size);
-       /*
-        * Eth TX Compl queue
-        */
-       pnob->txcq_len = ETH_TXCQ_LEN;
-       pnob->tx_cq_size = pnob->txcq_len * sizeof(struct ETH_TX_COMPL_AMAP);
-       pnob->tx_cq = pci_alloc_consistent(adapter->pdev, pnob->tx_cq_size,
-                               &pnob->tx_cq_bus);
-       if (!pnob->tx_cq_bus)
-               return -1;
-       memset(pnob->tx_cq, 0, pnob->tx_cq_size);
-       /*
-        * Eth RX queue
-        */
-       pnob->rx_q_len = ETH_RXQ_LEN;
-       pnob->rx_q_size =  pnob->rx_q_len * sizeof(struct ETH_RX_D_AMAP);
-       pnob->rx_q = pci_alloc_consistent(adapter->pdev, pnob->rx_q_size,
-                               &pnob->rx_q_bus);
-       if (!pnob->rx_q_bus)
-               return -1;
-       memset(pnob->rx_q, 0, pnob->rx_q_size);
-       /*
-        * Eth Unicast RX Compl queue
-        */
-       pnob->rx_cq_len = ETH_UC_RXCQ_LEN;
-       pnob->rx_cq_size =  pnob->rx_cq_len *
-                       sizeof(struct ETH_RX_COMPL_AMAP);
-       pnob->rx_cq = pci_alloc_consistent(adapter->pdev, pnob->rx_cq_size,
-                               &pnob->rx_cq_bus);
-       if (!pnob->rx_cq_bus)
-               return -1;
-       memset(pnob->rx_cq, 0, pnob->rx_cq_size);
-
-       /* TX resources */
-       size = pnob->tx_q_len * sizeof(void **);
-       pnob->tx_ctxt = kzalloc(size, GFP_KERNEL);
-       if (pnob->tx_ctxt == NULL)
-               return -1;
-
-       /* RX resources */
-       size = pnob->rx_q_len * sizeof(void *);
-       pnob->rx_ctxt = kzalloc(size, GFP_KERNEL);
-       if (pnob->rx_ctxt == NULL)
-               return -1;
-
-       size = (pnob->rx_q_len * sizeof(struct be_rx_page_info));
-       pnob->rx_page_info = kzalloc(size, GFP_KERNEL);
-       if (pnob->rx_page_info == NULL)
-               return -1;
-
-       adapter->eth_statsp = kzalloc(sizeof(struct FWCMD_ETH_GET_STATISTICS),
-                               GFP_KERNEL);
-       if (adapter->eth_statsp == NULL)
-               return -1;
-       pnob->rx_buf_size = rxbuf_size;
-       return 0;
-}
-
-/*
-    This function initializes the be_net_object for subsequent
-    network operations.
-
-    Before calling this function, the driver  must have allocated
-    space for the NetObject structure, initialized the structure,
-    allocated DMAable memory for all the network queues that form
-    part of the NetObject and populated the start address (virtual)
-    and number of entries allocated for each queue in the NetObject structure.
-
-    The driver must also have allocated memory to hold the
-    mailbox structure (MCC_MAILBOX) and post the physical address,
-    virtual addresses and the size of the mailbox memory in the
-    NetObj.mb_rd.  This structure is used by BECLIB for
-    initial communication with the embedded MCC processor. BECLIB
-    uses the mailbox until MCC rings are created for  more  efficient
-    communication with the MCC processor.
-
-    If the driver wants to create multiple network interface for more
-    than one protection domain, it can call be_create_netobj()
-    multiple times  once for each protection domain.  A Maximum of
-    32 protection domains are supported.
-
-*/
-static int
-be_create_netobj(struct be_net_object *pnob, u8 __iomem *csr_va,
-       u8 __iomem *db_va, u8 __iomem *pci_va)
-{
-       int status = 0;
-       bool  eventable = false, tx_no_delay = false, rx_no_delay = false;
-       struct be_eq_object *eq_objectp = NULL;
-       struct be_function_object *pfob = &pnob->fn_obj;
-       struct ring_desc rd;
-       u32 set_rxbuf_size;
-       u32 tx_cmpl_wm = CEV_WMARK_96;  /* 0xffffffff to disable */
-       u32 rx_cmpl_wm = CEV_WMARK_160; /* 0xffffffff to disable */
-       u32 eq_delay = 0; /* delay in 8usec units. 0xffffffff to disable */
-
-       memset(&rd, 0, sizeof(struct ring_desc));
-
-       status = be_function_object_create(csr_va, db_va, pci_va,
-                       BE_FUNCTION_TYPE_NETWORK, &pnob->mb_rd, pfob);
-       if (status != BE_SUCCESS)
-               return status;
-       pnob->fn_obj_created = true;
-
-       if (tx_cmpl_wm == 0xffffffff)
-               tx_no_delay = true;
-       if (rx_cmpl_wm == 0xffffffff)
-               rx_no_delay = true;
-       /*
-        * now create the necessary rings
-        * Event Queue first.
-        */
-       if (pnob->event_q_len) {
-               rd.va = pnob->event_q;
-               rd.pa = pnob->event_q_bus;
-               rd.length = pnob->event_q_size;
-
-               status = be_eq_create(pfob, &rd, 4, pnob->event_q_len,
-                               (u32) -1,       /* CEV_WMARK_* or -1 */
-                               eq_delay,       /* in 8us units, or -1 */
-                               &pnob->event_q_obj);
-               if (status != BE_SUCCESS)
-                       goto error_ret;
-               pnob->event_q_id = pnob->event_q_obj.eq_id;
-               pnob->event_q_created = 1;
-               eventable = true;
-               eq_objectp = &pnob->event_q_obj;
-       }
-       /*
-        * Now Eth Tx Compl. queue.
-        */
-       if (pnob->txcq_len) {
-               rd.va = pnob->tx_cq;
-               rd.pa = pnob->tx_cq_bus;
-               rd.length = pnob->tx_cq_size;
-
-               status = be_cq_create(pfob, &rd,
-                       pnob->txcq_len * sizeof(struct ETH_TX_COMPL_AMAP),
-                       false,  /* solicted events,  */
-                       tx_no_delay,    /* nodelay  */
-                       tx_cmpl_wm,     /* Watermark encodings */
-                       eq_objectp, &pnob->tx_cq_obj);
-               if (status != BE_SUCCESS)
-                       goto error_ret;
-
-               pnob->tx_cq_id = pnob->tx_cq_obj.cq_id;
-               pnob->tx_cq_created = 1;
-       }
-       /*
-        * Eth Tx queue
-        */
-       if (pnob->tx_q_len) {
-               struct be_eth_sq_parameters ex_params = { 0 };
-               u32 type;
-
-               if (pnob->tx_q_port) {
-                       /* TXQ to be bound to a specific port */
-                       type = BE_ETH_TX_RING_TYPE_BOUND;
-                       ex_params.port = pnob->tx_q_port - 1;
-               } else
-                       type = BE_ETH_TX_RING_TYPE_STANDARD;
-
-               rd.va = pnob->tx_q;
-               rd.pa = pnob->tx_q_bus;
-               rd.length = pnob->tx_q_size;
-
-               status = be_eth_sq_create_ex(pfob, &rd,
-                               pnob->tx_q_len * sizeof(struct ETH_WRB_AMAP),
-                               type, 2, &pnob->tx_cq_obj,
-                               &ex_params, &pnob->tx_q_obj);
-
-               if (status != BE_SUCCESS)
-                       goto error_ret;
-
-               pnob->tx_q_id = pnob->tx_q_obj.bid;
-               pnob->tx_q_created = 1;
-       }
-       /*
-        * Now Eth Rx compl. queue.  Always needed.
-        */
-       rd.va = pnob->rx_cq;
-       rd.pa = pnob->rx_cq_bus;
-       rd.length = pnob->rx_cq_size;
-
-       status = be_cq_create(pfob, &rd,
-                       pnob->rx_cq_len * sizeof(struct ETH_RX_COMPL_AMAP),
-                       false,  /* solicted events,  */
-                       rx_no_delay,    /* nodelay  */
-                       rx_cmpl_wm,     /* Watermark encodings */
-                       eq_objectp, &pnob->rx_cq_obj);
-       if (status != BE_SUCCESS)
-               goto error_ret;
-
-       pnob->rx_cq_id = pnob->rx_cq_obj.cq_id;
-       pnob->rx_cq_created = 1;
-
-       status = be_eth_rq_set_frag_size(pfob, pnob->rx_buf_size,
-                       (u32 *) &set_rxbuf_size);
-       if (status != BE_SUCCESS) {
-               be_eth_rq_get_frag_size(pfob, (u32 *) &pnob->rx_buf_size);
-               if ((pnob->rx_buf_size != 2048) && (pnob->rx_buf_size != 4096)
-                   && (pnob->rx_buf_size != 8192))
-                       goto error_ret;
-       } else {
-               if (pnob->rx_buf_size != set_rxbuf_size)
-                       pnob->rx_buf_size = set_rxbuf_size;
-       }
-       /*
-        * Eth RX queue. be_eth_rq_create() always assumes 2 pages size
-        */
-       rd.va = pnob->rx_q;
-       rd.pa = pnob->rx_q_bus;
-       rd.length = pnob->rx_q_size;
-
-       status = be_eth_rq_create(pfob, &rd, &pnob->rx_cq_obj,
-                            &pnob->rx_cq_obj, &pnob->rx_q_obj);
-
-       if (status != BE_SUCCESS)
-               goto error_ret;
-
-       pnob->rx_q_id = pnob->rx_q_obj.rid;
-       pnob->rx_q_created = 1;
-
-       return BE_SUCCESS;      /* All required queues created. */
-
-error_ret:
-       be_destroy_netobj(pnob);
-       return status;
-}
-
-static int be_nob_ring_init(struct be_adapter *adapter,
-                               struct be_net_object *pnob)
-{
-       int status;
-
-       pnob->event_q_tl = 0;
-
-       pnob->tx_q_hd = 0;
-       pnob->tx_q_tl = 0;
-
-       pnob->tx_cq_tl = 0;
-
-       pnob->rx_cq_tl = 0;
-
-       memset(pnob->event_q, 0, pnob->event_q_size);
-       memset(pnob->tx_cq, 0, pnob->tx_cq_size);
-       memset(pnob->tx_ctxt, 0, pnob->tx_q_len * sizeof(void **));
-       memset(pnob->rx_ctxt, 0, pnob->rx_q_len * sizeof(void *));
-       pnob->rx_pg_info_hd = 0;
-       pnob->rx_q_hd = 0;
-       atomic_set(&pnob->rx_q_posted, 0);
-
-       status = be_create_netobj(pnob, adapter->csr_va, adapter->db_va,
-                               adapter->pci_va);
-       if (status != BE_SUCCESS)
-               return -1;
-
-       be_post_eth_rx_buffs(pnob);
-       return 0;
-}
-
-/* This function handles async callback for link status */
-static void
-be_link_status_async_callback(void *context, u32 event_code, void *event)
-{
-       struct ASYNC_EVENT_LINK_STATE_AMAP *link_status = event;
-       struct be_adapter *adapter = context;
-       bool link_enable = false;
-       struct be_net_object *pnob;
-       struct ASYNC_EVENT_TRAILER_AMAP *async_trailer;
-       struct net_device *netdev;
-       u32 async_event_code, async_event_type, active_port;
-       u32 port0_link_status, port1_link_status, port0_duplex, port1_duplex;
-       u32 port0_speed, port1_speed;
-
-       if (event_code != ASYNC_EVENT_CODE_LINK_STATE) {
-               /* Not our event to handle */
-               return;
-       }
-       async_trailer = (struct ASYNC_EVENT_TRAILER_AMAP *)
-           ((u8 *) event + sizeof(struct MCC_CQ_ENTRY_AMAP) -
-            sizeof(struct ASYNC_EVENT_TRAILER_AMAP));
-
-       async_event_code = AMAP_GET_BITS_PTR(ASYNC_EVENT_TRAILER, event_code,
-                                            async_trailer);
-       BUG_ON(async_event_code != ASYNC_EVENT_CODE_LINK_STATE);
-
-       pnob = adapter->net_obj;
-       netdev = pnob->netdev;
-
-       /* Determine if this event is a switch VLD or a physical link event */
-       async_event_type = AMAP_GET_BITS_PTR(ASYNC_EVENT_TRAILER, event_type,
-                                            async_trailer);
-       active_port = AMAP_GET_BITS_PTR(ASYNC_EVENT_LINK_STATE,
-                                       active_port, link_status);
-       port0_link_status = AMAP_GET_BITS_PTR(ASYNC_EVENT_LINK_STATE,
-                                             port0_link_status, link_status);
-       port1_link_status = AMAP_GET_BITS_PTR(ASYNC_EVENT_LINK_STATE,
-                                             port1_link_status, link_status);
-       port0_duplex = AMAP_GET_BITS_PTR(ASYNC_EVENT_LINK_STATE,
-                                        port0_duplex, link_status);
-       port1_duplex = AMAP_GET_BITS_PTR(ASYNC_EVENT_LINK_STATE,
-                                        port1_duplex, link_status);
-       port0_speed = AMAP_GET_BITS_PTR(ASYNC_EVENT_LINK_STATE,
-                                       port0_speed, link_status);
-       port1_speed = AMAP_GET_BITS_PTR(ASYNC_EVENT_LINK_STATE,
-                                       port1_speed, link_status);
-       if (async_event_type == NTWK_LINK_TYPE_VIRTUAL) {
-               adapter->be_stat.bes_link_change_virtual++;
-               if (adapter->be_link_sts->active_port != active_port) {
-                       dev_notice(&netdev->dev,
-                              "Active port changed due to VLD on switch\n");
-               } else {
-                       dev_notice(&netdev->dev, "Link status update\n");
-               }
-
-       } else {
-               adapter->be_stat.bes_link_change_physical++;
-               if (adapter->be_link_sts->active_port != active_port) {
-                       dev_notice(&netdev->dev,
-                              "Active port changed due to port link"
-                              " status change\n");
-               } else {
-                       dev_notice(&netdev->dev, "Link status update\n");
-               }
-       }
-
-       memset(adapter->be_link_sts, 0, sizeof(adapter->be_link_sts));
-
-       if ((port0_link_status == ASYNC_EVENT_LINK_UP) ||
-           (port1_link_status == ASYNC_EVENT_LINK_UP)) {
-               if ((adapter->port0_link_sts == BE_PORT_LINK_DOWN) &&
-                   (adapter->port1_link_sts == BE_PORT_LINK_DOWN)) {
-                       /* Earlier both the ports are down So link is up */
-                       link_enable = true;
-               }
-
-               if (port0_link_status == ASYNC_EVENT_LINK_UP) {
-                       adapter->port0_link_sts = BE_PORT_LINK_UP;
-                       adapter->be_link_sts->mac0_duplex = port0_duplex;
-                       adapter->be_link_sts->mac0_speed = port0_speed;
-                       if (active_port == NTWK_PORT_A)
-                               adapter->be_link_sts->active_port = 0;
-               } else
-                       adapter->port0_link_sts = BE_PORT_LINK_DOWN;
-
-               if (port1_link_status == ASYNC_EVENT_LINK_UP) {
-                       adapter->port1_link_sts = BE_PORT_LINK_UP;
-                       adapter->be_link_sts->mac1_duplex = port1_duplex;
-                       adapter->be_link_sts->mac1_speed = port1_speed;
-                       if (active_port == NTWK_PORT_B)
-                               adapter->be_link_sts->active_port = 1;
-               } else
-                       adapter->port1_link_sts = BE_PORT_LINK_DOWN;
-
-               printk(KERN_INFO "Link Properties for %s:\n", netdev->name);
-               dev_info(&netdev->dev, "Link Properties:\n");
-               be_print_link_info(adapter->be_link_sts);
-
-               if (!link_enable)
-                       return;
-               /*
-                * Both ports were down previously, but atleast one of
-                * them has come up if this netdevice's carrier is not up,
-                * then indicate to stack
-                */
-               if (!netif_carrier_ok(netdev)) {
-                       netif_start_queue(netdev);
-                       netif_carrier_on(netdev);
-               }
-               return;
-       }
-
-       /* Now both the ports are down. Tell the stack about it */
-       dev_info(&netdev->dev, "Both ports are down\n");
-       adapter->port0_link_sts = BE_PORT_LINK_DOWN;
-       adapter->port1_link_sts = BE_PORT_LINK_DOWN;
-       if (netif_carrier_ok(netdev)) {
-               netif_carrier_off(netdev);
-               netif_stop_queue(netdev);
-       }
-       return;
-}
-
-static int be_mcc_create(struct be_adapter *adapter)
-{
-       struct be_net_object *pnob;
-
-       pnob = adapter->net_obj;
-       /*
-        * Create the MCC ring so that all further communication with
-        * MCC can go thru the ring. we do this at the end since
-        * we do not want to be dealing with interrupts until the
-        * initialization is complete.
-        */
-       pnob->mcc_q_len = MCC_Q_LEN;
-       pnob->mcc_q_size = pnob->mcc_q_len * sizeof(struct MCC_WRB_AMAP);
-       pnob->mcc_q =  pci_alloc_consistent(adapter->pdev, pnob->mcc_q_size,
-                               &pnob->mcc_q_bus);
-       if (!pnob->mcc_q_bus)
-               return -1;
-       /*
-        * space for MCC WRB context
-        */
-       pnob->mcc_wrb_ctxtLen = MCC_Q_LEN;
-       pnob->mcc_wrb_ctxt_size =  pnob->mcc_wrb_ctxtLen *
-               sizeof(struct be_mcc_wrb_context);
-       pnob->mcc_wrb_ctxt = (void *)__get_free_pages(GFP_KERNEL,
-               get_order(pnob->mcc_wrb_ctxt_size));
-       if (pnob->mcc_wrb_ctxt == NULL)
-               return -1;
-       /*
-        * Space for MCC compl. ring
-        */
-       pnob->mcc_cq_len = MCC_CQ_LEN;
-       pnob->mcc_cq_size = pnob->mcc_cq_len * sizeof(struct MCC_CQ_ENTRY_AMAP);
-       pnob->mcc_cq = pci_alloc_consistent(adapter->pdev, pnob->mcc_cq_size,
-                               &pnob->mcc_cq_bus);
-       if (!pnob->mcc_cq_bus)
-               return -1;
-       return 0;
-}
-
-/*
-    This function creates the MCC request and completion ring required
-    for communicating with the ARM processor.  The caller must have
-    allocated required amount of memory for the MCC ring and MCC
-    completion ring and posted the virtual address and number of
-    entries in the corresponding members (mcc_q and mcc_cq) in the
-    NetObject struture.
-
-    When this call is completed, all further communication with
-    ARM will switch from mailbox to this ring.
-
-    pnob       - Pointer to the NetObject structure. This NetObject should
-                 have been created using a previous call to be_create_netobj()
-*/
-int be_create_mcc_rings(struct be_net_object *pnob)
-{
-       int status = 0;
-       struct ring_desc rd;
-       struct be_function_object *pfob = &pnob->fn_obj;
-
-       memset(&rd, 0, sizeof(struct ring_desc));
-       if (pnob->mcc_cq_len) {
-               rd.va = pnob->mcc_cq;
-               rd.pa = pnob->mcc_cq_bus;
-               rd.length = pnob->mcc_cq_size;
-
-               status = be_cq_create(pfob, &rd,
-                       pnob->mcc_cq_len * sizeof(struct MCC_CQ_ENTRY_AMAP),
-                       false,  /* solicted events,  */
-                       true,   /* nodelay  */
-                       0,      /* 0 Watermark since Nodelay is true */
-                       &pnob->event_q_obj,
-                       &pnob->mcc_cq_obj);
-
-               if (status != BE_SUCCESS)
-                       return status;
-
-               pnob->mcc_cq_id = pnob->mcc_cq_obj.cq_id;
-               pnob->mcc_cq_created = 1;
-       }
-       if (pnob->mcc_q_len) {
-               rd.va = pnob->mcc_q;
-               rd.pa = pnob->mcc_q_bus;
-               rd.length = pnob->mcc_q_size;
-
-               status = be_mcc_ring_create(pfob, &rd,
-                               pnob->mcc_q_len * sizeof(struct MCC_WRB_AMAP),
-                               pnob->mcc_wrb_ctxt, pnob->mcc_wrb_ctxtLen,
-                               &pnob->mcc_cq_obj, &pnob->mcc_q_obj);
-
-               if (status != BE_SUCCESS)
-                       return status;
-
-               pnob->mcc_q_created = 1;
-       }
-       return BE_SUCCESS;
-}
-
-static int be_mcc_init(struct be_adapter *adapter)
-{
-       u32 r;
-       struct be_net_object *pnob;
-
-       pnob = adapter->net_obj;
-       memset(pnob->mcc_q, 0, pnob->mcc_q_size);
-       pnob->mcc_q_hd = 0;
-
-       memset(pnob->mcc_wrb_ctxt, 0, pnob->mcc_wrb_ctxt_size);
-
-       memset(pnob->mcc_cq, 0, pnob->mcc_cq_size);
-       pnob->mcc_cq_tl = 0;
-
-       r = be_create_mcc_rings(adapter->net_obj);
-       if (r != BE_SUCCESS)
-               return -1;
-
-       return 0;
-}
-
-static void be_remove(struct pci_dev *pdev)
-{
-       struct be_net_object *pnob;
-       struct be_adapter *adapter;
-
-       adapter = pci_get_drvdata(pdev);
-       if (!adapter)
-               return;
-
-       pci_set_drvdata(pdev, NULL);
-       pnob = (struct be_net_object *)adapter->net_obj;
-
-       flush_scheduled_work();
-
-       if (pnob) {
-               /* Unregister async callback function for link status updates */
-               if (pnob->mcc_q_created)
-                       be_mcc_add_async_event_callback(&pnob->mcc_q_obj,
-                                                               NULL, NULL);
-               netobject_cleanup(adapter, pnob);
-       }
-
-       if (adapter->csr_va)
-               iounmap(adapter->csr_va);
-       if (adapter->db_va)
-               iounmap(adapter->db_va);
-       if (adapter->pci_va)
-               iounmap(adapter->pci_va);
-
-       pci_release_regions(adapter->pdev);
-       pci_disable_device(adapter->pdev);
-
-       kfree(adapter->be_link_sts);
-       kfree(adapter->eth_statsp);
-
-       if (adapter->timer_ctxt.get_stats_timer.function)
-               del_timer_sync(&adapter->timer_ctxt.get_stats_timer);
-       kfree(adapter);
-}
-
-/*
- * This function is called by the PCI sub-system when it finds a PCI
- * device with dev/vendor IDs that match with one of our devices.
- * All of the driver initialization is done in this function.
- */
-static int be_probe(struct pci_dev *pdev, const struct pci_device_id *pdev_id)
-{
-       int status = 0;
-       struct be_adapter *adapter;
-       struct FWCMD_COMMON_GET_FW_VERSION_RESPONSE_PAYLOAD get_fwv;
-       struct be_net_object *pnob;
-       struct net_device *netdev;
-
-       status = pci_enable_device(pdev);
-       if (status)
-               goto error;
-
-       status = pci_request_regions(pdev, be_driver_name);
-       if (status)
-               goto error_pci_req;
-
-       pci_set_master(pdev);
-       adapter = kzalloc(sizeof(struct be_adapter), GFP_KERNEL);
-       if (adapter == NULL) {
-               status = -ENOMEM;
-               goto error_adapter;
-       }
-       adapter->dev_state = BE_DEV_STATE_NONE;
-       adapter->pdev = pdev;
-       pci_set_drvdata(pdev, adapter);
-
-       adapter->enable_aic = 1;
-       adapter->max_eqd = MAX_EQD;
-       adapter->min_eqd = 0;
-       adapter->cur_eqd = 0;
-
-       status = pci_set_dma_mask(pdev, DMA_64BIT_MASK);
-       if (!status) {
-               adapter->dma_64bit_cap = true;
-       } else {
-               adapter->dma_64bit_cap = false;
-               status = pci_set_dma_mask(pdev, DMA_32BIT_MASK);
-               if (status != 0) {
-                       printk(KERN_ERR "Could not set PCI DMA Mask\n");
-                       goto cleanup;
-               }
-       }
-
-       status = init_pci_be_function(adapter, pdev);
-       if (status != 0) {
-               printk(KERN_ERR "Failed to map PCI BARS\n");
-               status = -ENOMEM;
-               goto cleanup;
-       }
-
-       be_trace_set_level(DL_ALWAYS | DL_ERR);
-
-       adapter->be_link_sts = kmalloc(sizeof(struct BE_LINK_STATUS),
-                                       GFP_KERNEL);
-       if (adapter->be_link_sts == NULL) {
-               printk(KERN_ERR "Memory allocation for link status "
-                      "buffer failed\n");
-               goto cleanup;
-       }
-       spin_lock_init(&adapter->txq_lock);
-
-       netdev = alloc_etherdev(sizeof(struct be_net_object));
-       if (netdev == NULL) {
-               status = -ENOMEM;
-               goto cleanup;
-       }
-       pnob = netdev_priv(netdev);
-       adapter->net_obj = pnob;
-       adapter->netdevp = netdev;
-       pnob->adapter = adapter;
-       pnob->netdev = netdev;
-
-       status = be_nob_ring_alloc(adapter, pnob);
-       if (status != 0)
-               goto cleanup;
-
-       status = be_nob_ring_init(adapter, pnob);
-       if (status != 0)
-               goto cleanup;
-
-       be_rxf_mac_address_read_write(&pnob->fn_obj, false, false, false,
-               false, false, netdev->dev_addr, NULL, NULL);
-
-       netdev->init = &benet_init;
-       netif_carrier_off(netdev);
-       netif_stop_queue(netdev);
-
-       SET_NETDEV_DEV(netdev, &(adapter->pdev->dev));
-
-       netif_napi_add(netdev, &pnob->napi, be_poll, 64);
-
-       /* if the rx_frag size if 2K, one page is shared as two RX frags */
-       pnob->rx_pg_shared =
-               (pnob->rx_buf_size <= PAGE_SIZE / 2) ? true : false;
-       if (pnob->rx_buf_size != rxbuf_size) {
-               printk(KERN_WARNING
-                      "Could not set Rx buffer size to %d. Using %d\n",
-                                      rxbuf_size, pnob->rx_buf_size);
-               rxbuf_size = pnob->rx_buf_size;
-       }
-
-       tasklet_init(&(adapter->sts_handler), be_process_intr,
-                    (unsigned long)adapter);
-       adapter->tasklet_started = 1;
-       spin_lock_init(&(adapter->int_lock));
-
-       status = be_register_isr(adapter, pnob);
-       if (status != 0)
-               goto cleanup;
-
-       adapter->rx_csum = 1;
-       adapter->max_rx_coal = BE_LRO_MAX_PKTS;
-
-       memset(&get_fwv, 0,
-              sizeof(struct FWCMD_COMMON_GET_FW_VERSION_RESPONSE_PAYLOAD));
-       printk(KERN_INFO "BladeEngine Driver version:%s. "
-              "Copyright ServerEngines, Corporation 2005 - 2008\n",
-                              be_drvr_ver);
-       status = be_function_get_fw_version(&pnob->fn_obj, &get_fwv, NULL,
-                                           NULL);
-       if (status == BE_SUCCESS) {
-               strncpy(be_fw_ver, get_fwv.firmware_version_string, 32);
-               printk(KERN_INFO "BladeEngine Firmware Version:%s\n",
-                      get_fwv.firmware_version_string);
-       } else {
-               printk(KERN_WARNING "Unable to get BE Firmware Version\n");
-       }
-
-       sema_init(&adapter->get_eth_stat_sem, 0);
-       init_timer(&adapter->timer_ctxt.get_stats_timer);
-       atomic_set(&adapter->timer_ctxt.get_stat_flag, 0);
-       adapter->timer_ctxt.get_stats_timer.function =
-           &be_get_stats_timer_handler;
-
-       status = be_mcc_create(adapter);
-       if (status < 0)
-               goto cleanup;
-       status = be_mcc_init(adapter);
-       if (status < 0)
-               goto cleanup;
-
-
-       status = be_mcc_add_async_event_callback(&adapter->net_obj->mcc_q_obj,
-                        be_link_status_async_callback, (void *)adapter);
-       if (status != BE_SUCCESS) {
-               printk(KERN_WARNING "add_async_event_callback failed");
-               printk(KERN_WARNING
-                      "Link status changes may not be reflected\n");
-       }
-
-       status = register_netdev(netdev);
-       if (status != 0)
-               goto cleanup;
-       be_update_link_status(adapter);
-       adapter->dev_state = BE_DEV_STATE_INIT;
-       return 0;
-
-cleanup:
-       be_remove(pdev);
-       return status;
-error_adapter:
-       pci_release_regions(pdev);
-error_pci_req:
-       pci_disable_device(pdev);
-error:
-       printk(KERN_ERR "BladeEngine initalization failed\n");
-       return status;
-}
-
-/*
- * Get the current link status and print the status on console
- */
-void be_update_link_status(struct be_adapter *adapter)
-{
-       int status;
-       struct be_net_object *pnob = adapter->net_obj;
-
-       status = be_rxf_link_status(&pnob->fn_obj, adapter->be_link_sts, NULL,
-                       NULL, NULL);
-       if (status == BE_SUCCESS) {
-               if (adapter->be_link_sts->mac0_speed &&
-                   adapter->be_link_sts->mac0_duplex)
-                       adapter->port0_link_sts = BE_PORT_LINK_UP;
-               else
-                       adapter->port0_link_sts = BE_PORT_LINK_DOWN;
-
-               if (adapter->be_link_sts->mac1_speed &&
-                   adapter->be_link_sts->mac1_duplex)
-                       adapter->port1_link_sts = BE_PORT_LINK_UP;
-               else
-                       adapter->port1_link_sts = BE_PORT_LINK_DOWN;
-
-               dev_info(&pnob->netdev->dev, "Link Properties:\n");
-               be_print_link_info(adapter->be_link_sts);
-               return;
-       }
-       dev_info(&pnob->netdev->dev, "Could not get link status\n");
-       return;
-}
-
-
-#ifdef CONFIG_PM
-static void
-be_pm_cleanup(struct be_adapter *adapter,
-             struct be_net_object *pnob, struct net_device *netdev)
-{
-       netif_carrier_off(netdev);
-       netif_stop_queue(netdev);
-
-       be_wait_nic_tx_cmplx_cmpl(pnob);
-       be_disable_eq_intr(pnob);
-
-       if (adapter->tasklet_started) {
-               tasklet_kill(&adapter->sts_handler);
-               adapter->tasklet_started = 0;
-       }
-
-       be_unregister_isr(adapter);
-       be_disable_intr(pnob);
-
-       be_tx_q_clean(pnob);
-       be_rx_q_clean(pnob);
-
-       be_destroy_netobj(pnob);
-}
-
-static int be_suspend(struct pci_dev *pdev, pm_message_t state)
-{
-       struct be_adapter *adapter = pci_get_drvdata(pdev);
-       struct net_device *netdev =  adapter->netdevp;
-       struct be_net_object *pnob = netdev_priv(netdev);
-
-       adapter->dev_pm_state = adapter->dev_state;
-       adapter->dev_state = BE_DEV_STATE_SUSPEND;
-
-       netif_device_detach(netdev);
-       if (netif_running(netdev))
-               be_pm_cleanup(adapter, pnob, netdev);
-
-       pci_enable_wake(pdev, 3, 1);
-       pci_enable_wake(pdev, 4, 1);    /* D3 Cold = 4 */
-       pci_save_state(pdev);
-       pci_disable_device(pdev);
-       pci_set_power_state(pdev, pci_choose_state(pdev, state));
-       return 0;
-}
-
-static void be_up(struct be_adapter *adapter)
-{
-       struct be_net_object *pnob = adapter->net_obj;
-
-       if (pnob->num_vlans != 0)
-               be_rxf_vlan_config(&pnob->fn_obj, false, pnob->num_vlans,
-                       pnob->vlan_tag, NULL, NULL, NULL);
-
-}
-
-static int be_resume(struct pci_dev *pdev)
-{
-       int status = 0;
-       struct be_adapter *adapter = pci_get_drvdata(pdev);
-       struct net_device *netdev =  adapter->netdevp;
-       struct be_net_object *pnob = netdev_priv(netdev);
-
-       netif_device_detach(netdev);
-
-       status = pci_enable_device(pdev);
-       if (status)
-               return status;
-
-       pci_set_power_state(pdev, 0);
-       pci_restore_state(pdev);
-       pci_enable_wake(pdev, 3, 0);
-       pci_enable_wake(pdev, 4, 0);    /* 4 is D3 cold */
-
-       netif_carrier_on(netdev);
-       netif_start_queue(netdev);
-
-       if (netif_running(netdev)) {
-               be_rxf_mac_address_read_write(&pnob->fn_obj, false, false,
-                       false, true, false, netdev->dev_addr, NULL, NULL);
-
-               status = be_nob_ring_init(adapter, pnob);
-               if (status < 0)
-                       return status;
-
-               tasklet_init(&(adapter->sts_handler), be_process_intr,
-                            (unsigned long)adapter);
-               adapter->tasklet_started = 1;
-
-               if (be_register_isr(adapter, pnob) != 0) {
-                       printk(KERN_ERR "be_register_isr failed\n");
-                       return status;
-               }
-
-
-               status = be_mcc_init(adapter);
-               if (status < 0) {
-                       printk(KERN_ERR "be_mcc_init failed\n");
-                       return status;
-               }
-               be_update_link_status(adapter);
-               /*
-                * Register async call back function to handle link
-                * status updates
-                */
-               status = be_mcc_add_async_event_callback(
-                               &adapter->net_obj->mcc_q_obj,
-                               be_link_status_async_callback, (void *)adapter);
-               if (status != BE_SUCCESS) {
-                       printk(KERN_WARNING "add_async_event_callback failed");
-                       printk(KERN_WARNING
-                              "Link status changes may not be reflected\n");
-               }
-               be_enable_intr(pnob);
-               be_enable_eq_intr(pnob);
-               be_up(adapter);
-       }
-       netif_device_attach(netdev);
-       adapter->dev_state = adapter->dev_pm_state;
-       return 0;
-
-}
-
-#endif
-
-/* Wait until no more pending transmits  */
-void be_wait_nic_tx_cmplx_cmpl(struct be_net_object *pnob)
-{
-       int i;
-
-       /* Wait for 20us * 50000 (= 1s) and no more */
-       i = 0;
-       while ((pnob->tx_q_tl != pnob->tx_q_hd) && (i < 50000)) {
-               ++i;
-               udelay(20);
-       }
-
-       /* Check for no more pending transmits */
-       if (i >= 50000) {
-               printk(KERN_WARNING
-                      "Did not receive completions for all TX requests\n");
-       }
-}
-
-static struct pci_driver be_driver = {
-       .name = be_driver_name,
-       .id_table = be_device_id_table,
-       .probe = be_probe,
-#ifdef CONFIG_PM
-       .suspend = be_suspend,
-       .resume = be_resume,
-#endif
-       .remove = be_remove
-};
-
-/*
- * Module init entry point. Registers our our device and return.
- * Our probe will be called if the device is found.
- */
-static int __init be_init_module(void)
-{
-       int ret;
-
-       if (rxbuf_size != 8192 && rxbuf_size != 4096 && rxbuf_size != 2048) {
-               printk(KERN_WARNING
-                      "Unsupported receive buffer size (%d) requested\n",
-                      rxbuf_size);
-               printk(KERN_WARNING
-                      "Must be 2048, 4096 or 8192. Defaulting to 2048\n");
-               rxbuf_size = 2048;
-       }
-
-       ret = pci_register_driver(&be_driver);
-
-       return ret;
-}
-
-module_init(be_init_module);
-
-/*
- * be_exit_module - Driver Exit Cleanup Routine
- */
-static void __exit be_exit_module(void)
-{
-       pci_unregister_driver(&be_driver);
-}
-
-module_exit(be_exit_module);
diff --git a/drivers/staging/benet/be_int.c b/drivers/staging/benet/be_int.c
deleted file mode 100644 (file)
index cba95d0..0000000
+++ /dev/null
@@ -1,863 +0,0 @@
-/*
- * Copyright (C) 2005 - 2008 ServerEngines
- * All rights reserved.
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License version 2
- * as published by the Free Software Foundation.  The full GNU General
- * Public License is included in this distribution in the file called COPYING.
- *
- * Contact Information:
- * linux-drivers@serverengines.com
- *
- * ServerEngines
- * 209 N. Fair Oaks Ave
- * Sunnyvale, CA 94085
- */
-#include <linux/if_vlan.h>
-#include <linux/inet_lro.h>
-
-#include "benet.h"
-
-/* number of bytes of RX frame that are copied to skb->data */
-#define BE_HDR_LEN 64
-
-#define NETIF_RX(skb) netif_receive_skb(skb)
-#define VLAN_ACCEL_RX(skb, pnob, vt) \
-               vlan_hwaccel_rx(skb, pnob->vlan_grp, vt)
-
-/*
-    This function notifies BladeEngine of the number of completion
-    entries processed from the specified completion queue by writing
-    the number of popped entries to the door bell.
-
-    pnob       - Pointer to the NetObject structure
-    n          - Number of completion entries processed
-    cq_id      - Queue ID of the completion queue for which notification
-                       is being done.
-    re_arm     - 1  - rearm the completion ring to generate an event.
-               - 0  - dont rearm the completion ring to generate an event
-*/
-void be_notify_cmpl(struct be_net_object *pnob, int n, int cq_id, int re_arm)
-{
-       struct CQ_DB_AMAP cqdb;
-
-       cqdb.dw[0] = 0;
-       AMAP_SET_BITS_PTR(CQ_DB, qid, &cqdb, cq_id);
-       AMAP_SET_BITS_PTR(CQ_DB, rearm, &cqdb, re_arm);
-       AMAP_SET_BITS_PTR(CQ_DB, num_popped, &cqdb, n);
-       PD_WRITE(&pnob->fn_obj, cq_db, cqdb.dw[0]);
-}
-
-/*
- * adds additional receive frags indicated by BE starting from given
- * frag index (fi) to specified skb's frag list
- */
-static void
-add_skb_frags(struct be_net_object *pnob, struct sk_buff *skb,
-             u32 nresid, u32 fi)
-{
-       struct be_adapter *adapter = pnob->adapter;
-       u32 sk_frag_idx, n;
-       struct be_rx_page_info *rx_page_info;
-       u32 frag_sz = pnob->rx_buf_size;
-
-       sk_frag_idx = skb_shinfo(skb)->nr_frags;
-       while (nresid) {
-               index_inc(&fi, pnob->rx_q_len);
-
-               rx_page_info = (struct be_rx_page_info *)pnob->rx_ctxt[fi];
-               pnob->rx_ctxt[fi] = NULL;
-               if ((rx_page_info->page_offset) ||
-                   (pnob->rx_pg_shared == false)) {
-                       pci_unmap_page(adapter->pdev,
-                                      pci_unmap_addr(rx_page_info, bus),
-                                      frag_sz, PCI_DMA_FROMDEVICE);
-               }
-
-               n = min(nresid, frag_sz);
-               skb_shinfo(skb)->frags[sk_frag_idx].page = rx_page_info->page;
-               skb_shinfo(skb)->frags[sk_frag_idx].page_offset
-                   = rx_page_info->page_offset;
-               skb_shinfo(skb)->frags[sk_frag_idx].size = n;
-
-               sk_frag_idx++;
-               skb->len += n;
-               skb->data_len += n;
-               skb_shinfo(skb)->nr_frags++;
-               nresid -= n;
-
-               memset(rx_page_info, 0, sizeof(struct be_rx_page_info));
-               atomic_dec(&pnob->rx_q_posted);
-       }
-}
-
-/*
- * This function processes incoming nic packets over various Rx queues.
- * This function takes the adapter, the current Rx status descriptor
- * entry and the Rx completion queue ID as argument.
- */
-static inline int process_nic_rx_completion(struct be_net_object *pnob,
-                                           struct ETH_RX_COMPL_AMAP *rxcp)
-{
-       struct be_adapter *adapter = pnob->adapter;
-       struct sk_buff *skb;
-       int udpcksm, tcpcksm;
-       int n;
-       u32 nresid, fi;
-       u32 frag_sz = pnob->rx_buf_size;
-       u8 *va;
-       struct be_rx_page_info *rx_page_info;
-       u32 numfrags, vtp, vtm, vlan_tag, pktsize;
-
-       fi = AMAP_GET_BITS_PTR(ETH_RX_COMPL, fragndx, rxcp);
-       BUG_ON(fi >= (int)pnob->rx_q_len);
-       BUG_ON(fi < 0);
-
-       rx_page_info = (struct be_rx_page_info *)pnob->rx_ctxt[fi];
-       BUG_ON(!rx_page_info->page);
-       pnob->rx_ctxt[fi] = NULL;
-
-       /*
-        * If one page is used per fragment or if this is the second half of
-        *  of the page, unmap the page here
-        */
-       if ((rx_page_info->page_offset) || (pnob->rx_pg_shared == false)) {
-               pci_unmap_page(adapter->pdev,
-                              pci_unmap_addr(rx_page_info, bus), frag_sz,
-                              PCI_DMA_FROMDEVICE);
-       }
-
-       atomic_dec(&pnob->rx_q_posted);
-       udpcksm = AMAP_GET_BITS_PTR(ETH_RX_COMPL, udpcksm, rxcp);
-       tcpcksm = AMAP_GET_BITS_PTR(ETH_RX_COMPL, tcpcksm, rxcp);
-       pktsize = AMAP_GET_BITS_PTR(ETH_RX_COMPL, pktsize, rxcp);
-       /*
-        * get rid of RX flush completions first.
-        */
-       if ((tcpcksm) && (udpcksm) && (pktsize == 32)) {
-               put_page(rx_page_info->page);
-               memset(rx_page_info, 0, sizeof(struct be_rx_page_info));
-               return 0;
-       }
-       skb = netdev_alloc_skb(pnob->netdev, BE_HDR_LEN + NET_IP_ALIGN);
-       if (skb == NULL) {
-               dev_info(&pnob->netdev->dev, "alloc_skb() failed\n");
-               put_page(rx_page_info->page);
-               memset(rx_page_info, 0, sizeof(struct be_rx_page_info));
-               goto free_frags;
-       }
-       skb_reserve(skb, NET_IP_ALIGN);
-
-       skb->dev = pnob->netdev;
-
-       n = min(pktsize, frag_sz);
-
-       va = page_address(rx_page_info->page) + rx_page_info->page_offset;
-       prefetch(va);
-
-       skb->len = n;
-       skb->data_len = n;
-       if (n <= BE_HDR_LEN) {
-               memcpy(skb->data, va, n);
-               put_page(rx_page_info->page);
-               skb->data_len -= n;
-               skb->tail += n;
-       } else {
-
-               /* Setup the SKB with page buffer information */
-               skb_shinfo(skb)->frags[0].page = rx_page_info->page;
-               skb_shinfo(skb)->nr_frags++;
-
-               /* Copy the header into the skb_data */
-               memcpy(skb->data, va, BE_HDR_LEN);
-               skb_shinfo(skb)->frags[0].page_offset =
-                   rx_page_info->page_offset + BE_HDR_LEN;
-               skb_shinfo(skb)->frags[0].size = n - BE_HDR_LEN;
-               skb->data_len -= BE_HDR_LEN;
-               skb->tail += BE_HDR_LEN;
-       }
-       memset(rx_page_info, 0, sizeof(struct be_rx_page_info));
-       nresid = pktsize - n;
-
-       skb->protocol = eth_type_trans(skb, pnob->netdev);
-
-       if ((tcpcksm || udpcksm) && adapter->rx_csum)
-               skb->ip_summed = CHECKSUM_UNNECESSARY;
-       else
-               skb->ip_summed = CHECKSUM_NONE;
-       /*
-        * if we have more bytes left, the frame has been
-        * given to us in multiple fragments.  This happens
-        * with Jumbo frames. Add the remaining fragments to
-        * skb->frags[] array.
-        */
-       if (nresid)
-               add_skb_frags(pnob, skb, nresid, fi);
-
-       /* update the the true size of the skb. */
-       skb->truesize = skb->len + sizeof(struct sk_buff);
-
-       /*
-        * If a 802.3 frame or 802.2 LLC frame
-        * (i.e) contains length field in MAC Hdr
-        * and frame len is greater than 64 bytes
-        */
-       if (((skb->protocol == ntohs(ETH_P_802_2)) ||
-            (skb->protocol == ntohs(ETH_P_802_3)))
-           && (pktsize > BE_HDR_LEN)) {
-               /*
-                * If the length given in Mac Hdr is less than frame size
-                * Erraneous frame, Drop it
-                */
-               if ((ntohs(*(u16 *) (va + 12)) + ETH_HLEN) < pktsize) {
-                       /* Increment Non Ether type II frames dropped */
-                       adapter->be_stat.bes_802_3_dropped_frames++;
-
-                       kfree_skb(skb);
-                       return 0;
-               }
-               /*
-                * else if the length given in Mac Hdr is greater than
-                * frame size, should not be seeing this sort of frames
-                * dump the pkt and pass to stack
-                */
-               else if ((ntohs(*(u16 *) (va + 12)) + ETH_HLEN) > pktsize) {
-                       /* Increment Non Ether type II frames malformed */
-                       adapter->be_stat.bes_802_3_malformed_frames++;
-               }
-       }
-
-       vtp = AMAP_GET_BITS_PTR(ETH_RX_COMPL, vtp, rxcp);
-       vtm = AMAP_GET_BITS_PTR(ETH_RX_COMPL, vtm, rxcp);
-       if (vtp && vtm) {
-               /* Vlan tag present in pkt and BE found
-                * that the tag matched an entry in VLAN table
-                */
-               if (!pnob->vlan_grp || pnob->num_vlans == 0) {
-                       /* But we have no VLANs configured.
-                        * This should never happen.  Drop the packet.
-                        */
-                       dev_info(&pnob->netdev->dev,
-                              "BladeEngine: Unexpected vlan tagged packet\n");
-                       kfree_skb(skb);
-                       return 0;
-               }
-               /* pass the VLAN packet to stack */
-               vlan_tag = AMAP_GET_BITS_PTR(ETH_RX_COMPL, vlan_tag, rxcp);
-               VLAN_ACCEL_RX(skb, pnob, be16_to_cpu(vlan_tag));
-
-       } else {
-               NETIF_RX(skb);
-       }
-       return 0;
-
-free_frags:
-       /* free all frags associated with the current rxcp */
-       numfrags = AMAP_GET_BITS_PTR(ETH_RX_COMPL, numfrags, rxcp);
-       while (numfrags-- > 1) {
-               index_inc(&fi, pnob->rx_q_len);
-
-               rx_page_info = (struct be_rx_page_info *)
-                   pnob->rx_ctxt[fi];
-               pnob->rx_ctxt[fi] = (void *)NULL;
-               if (rx_page_info->page_offset || !pnob->rx_pg_shared) {
-                       pci_unmap_page(adapter->pdev,
-                                      pci_unmap_addr(rx_page_info, bus),
-                                      frag_sz, PCI_DMA_FROMDEVICE);
-               }
-
-               put_page(rx_page_info->page);
-               memset(rx_page_info, 0, sizeof(struct be_rx_page_info));
-               atomic_dec(&pnob->rx_q_posted);
-       }
-       return -ENOMEM;
-}
-
-static void process_nic_rx_completion_lro(struct be_net_object *pnob,
-                                         struct ETH_RX_COMPL_AMAP *rxcp)
-{
-       struct be_adapter *adapter = pnob->adapter;
-       struct skb_frag_struct rx_frags[BE_MAX_FRAGS_PER_FRAME];
-       unsigned int udpcksm, tcpcksm;
-       u32 numfrags, vlanf, vtm, vlan_tag, nresid;
-       u16 vlant;
-       unsigned int fi, idx, n;
-       struct be_rx_page_info *rx_page_info;
-       u32 frag_sz = pnob->rx_buf_size, pktsize;
-       bool rx_coal = (adapter->max_rx_coal <= 1) ? 0 : 1;
-       u8 err, *va;
-       __wsum csum = 0;
-
-       if (AMAP_GET_BITS_PTR(ETH_RX_COMPL, ipsec, rxcp)) {
-               /*  Drop the pkt and move to the next completion.  */
-               adapter->be_stat.bes_rx_misc_pkts++;
-               return;
-       }
-       err = AMAP_GET_BITS_PTR(ETH_RX_COMPL, err, rxcp);
-       if (err || !rx_coal) {
-               /* We won't coalesce Rx pkts if the err bit set.
-                * take the path of normal completion processing */
-               process_nic_rx_completion(pnob, rxcp);
-               return;
-       }
-
-       fi = AMAP_GET_BITS_PTR(ETH_RX_COMPL, fragndx, rxcp);
-       BUG_ON(fi >= (int)pnob->rx_q_len);
-       BUG_ON(fi < 0);
-       rx_page_info = (struct be_rx_page_info *)pnob->rx_ctxt[fi];
-       BUG_ON(!rx_page_info->page);
-       pnob->rx_ctxt[fi] = (void *)NULL;
-       /*  If one page is used per fragment or if this is the
-        * second half of the page, unmap the page here
-        */
-       if (rx_page_info->page_offset || !pnob->rx_pg_shared) {
-               pci_unmap_page(adapter->pdev,
-                              pci_unmap_addr(rx_page_info, bus),
-                              frag_sz, PCI_DMA_FROMDEVICE);
-       }
-
-       numfrags = AMAP_GET_BITS_PTR(ETH_RX_COMPL, numfrags, rxcp);
-       udpcksm = AMAP_GET_BITS_PTR(ETH_RX_COMPL, udpcksm, rxcp);
-       tcpcksm = AMAP_GET_BITS_PTR(ETH_RX_COMPL, tcpcksm, rxcp);
-       vlan_tag = AMAP_GET_BITS_PTR(ETH_RX_COMPL, vlan_tag, rxcp);
-       vlant = be16_to_cpu(vlan_tag);
-       vlanf = AMAP_GET_BITS_PTR(ETH_RX_COMPL, vtp, rxcp);
-       vtm = AMAP_GET_BITS_PTR(ETH_RX_COMPL, vtm, rxcp);
-       pktsize = AMAP_GET_BITS_PTR(ETH_RX_COMPL, pktsize, rxcp);
-
-       atomic_dec(&pnob->rx_q_posted);
-
-       if (tcpcksm && udpcksm && pktsize == 32) {
-               /* flush completion entries */
-               put_page(rx_page_info->page);
-               memset(rx_page_info, 0, sizeof(struct be_rx_page_info));
-               return;
-       }
-       /* Only one of udpcksum and tcpcksum can be set */
-       BUG_ON(udpcksm && tcpcksm);
-
-       /* jumbo frames could come in multiple fragments */
-       BUG_ON(numfrags != ((pktsize + (frag_sz - 1)) / frag_sz));
-       n = min(pktsize, frag_sz);
-       nresid = pktsize - n;   /* will be useful for jumbo pkts */
-       idx = 0;
-
-       va = page_address(rx_page_info->page) + rx_page_info->page_offset;
-       prefetch(va);
-       rx_frags[idx].page = rx_page_info->page;
-       rx_frags[idx].page_offset = (rx_page_info->page_offset);
-       rx_frags[idx].size = n;
-       memset(rx_page_info, 0, sizeof(struct be_rx_page_info));
-
-       /* If we got multiple fragments, we have more data. */
-       while (nresid) {
-               idx++;
-               index_inc(&fi, pnob->rx_q_len);
-
-               rx_page_info = (struct be_rx_page_info *)pnob->rx_ctxt[fi];
-               pnob->rx_ctxt[fi] = (void *)NULL;
-               if (rx_page_info->page_offset || !pnob->rx_pg_shared) {
-                       pci_unmap_page(adapter->pdev,
-                                      pci_unmap_addr(rx_page_info, bus),
-                                      frag_sz, PCI_DMA_FROMDEVICE);
-               }
-
-               n = min(nresid, frag_sz);
-               rx_frags[idx].page = rx_page_info->page;
-               rx_frags[idx].page_offset = (rx_page_info->page_offset);
-               rx_frags[idx].size = n;
-
-               nresid -= n;
-               memset(rx_page_info, 0, sizeof(struct be_rx_page_info));
-               atomic_dec(&pnob->rx_q_posted);
-       }
-
-       if (likely(!(vlanf && vtm))) {
-               lro_receive_frags(&pnob->lro_mgr, rx_frags,
-                                 pktsize, pktsize,
-                                 (void *)(unsigned long)csum, csum);
-       } else {
-               /* Vlan tag present in pkt and BE found
-                * that the tag matched an entry in VLAN table
-                */
-               if (unlikely(!pnob->vlan_grp || pnob->num_vlans == 0)) {
-                       /* But we have no VLANs configured.
-                        * This should never happen.  Drop the packet.
-                        */
-                       dev_info(&pnob->netdev->dev,
-                              "BladeEngine: Unexpected vlan tagged packet\n");
-                       return;
-               }
-               /* pass the VLAN packet to stack */
-               lro_vlan_hwaccel_receive_frags(&pnob->lro_mgr,
-                                              rx_frags, pktsize, pktsize,
-                                              pnob->vlan_grp, vlant,
-                                              (void *)(unsigned long)csum,
-                                              csum);
-       }
-
-       adapter->be_stat.bes_rx_coal++;
-}
-
-struct ETH_RX_COMPL_AMAP *be_get_rx_cmpl(struct be_net_object *pnob)
-{
-       struct ETH_RX_COMPL_AMAP *rxcp = &pnob->rx_cq[pnob->rx_cq_tl];
-       u32 valid, ct;
-
-       valid = AMAP_GET_BITS_PTR(ETH_RX_COMPL, valid, rxcp);
-       if (valid == 0)
-               return NULL;
-
-       ct = AMAP_GET_BITS_PTR(ETH_RX_COMPL, ct, rxcp);
-       if (ct != 0) {
-               /* Invalid chute #. treat as error */
-               AMAP_SET_BITS_PTR(ETH_RX_COMPL, err, rxcp, 1);
-       }
-
-       be_adv_rxcq_tl(pnob);
-       AMAP_SET_BITS_PTR(ETH_RX_COMPL, valid, rxcp, 0);
-       return rxcp;
-}
-
-static void update_rx_rate(struct be_adapter *adapter)
-{
-       /* update the rate once in two seconds */
-       if ((jiffies - adapter->eth_rx_jiffies) > 2 * (HZ)) {
-               u32 r;
-               r = adapter->eth_rx_bytes /
-                   ((jiffies - adapter->eth_rx_jiffies) / (HZ));
-               r = (r / 1000000);      /* MB/Sec */
-
-               /* Mega Bits/Sec */
-               adapter->be_stat.bes_eth_rx_rate = (r * 8);
-               adapter->eth_rx_jiffies = jiffies;
-               adapter->eth_rx_bytes = 0;
-       }
-}
-
-static int process_rx_completions(struct be_net_object *pnob, int max_work)
-{
-       struct be_adapter *adapter = pnob->adapter;
-       struct ETH_RX_COMPL_AMAP *rxcp;
-       u32 nc = 0;
-       unsigned int pktsize;
-
-       while (max_work && (rxcp = be_get_rx_cmpl(pnob))) {
-               prefetch(rxcp);
-               pktsize = AMAP_GET_BITS_PTR(ETH_RX_COMPL, pktsize, rxcp);
-               process_nic_rx_completion_lro(pnob, rxcp);
-               adapter->eth_rx_bytes += pktsize;
-               update_rx_rate(adapter);
-               nc++;
-               max_work--;
-               adapter->be_stat.bes_rx_compl++;
-       }
-       if (likely(adapter->max_rx_coal > 1)) {
-               adapter->be_stat.bes_rx_flush++;
-               lro_flush_all(&pnob->lro_mgr);
-       }
-
-       /* Refill the queue */
-       if (atomic_read(&pnob->rx_q_posted) < 900)
-               be_post_eth_rx_buffs(pnob);
-
-       return nc;
-}
-
-static struct ETH_TX_COMPL_AMAP *be_get_tx_cmpl(struct be_net_object *pnob)
-{
-       struct ETH_TX_COMPL_AMAP *txcp = &pnob->tx_cq[pnob->tx_cq_tl];
-       u32 valid;
-
-       valid = AMAP_GET_BITS_PTR(ETH_TX_COMPL, valid, txcp);
-       if (valid == 0)
-               return NULL;
-
-       AMAP_SET_BITS_PTR(ETH_TX_COMPL, valid, txcp, 0);
-       be_adv_txcq_tl(pnob);
-       return txcp;
-
-}
-
-void process_one_tx_compl(struct be_net_object *pnob, u32 end_idx)
-{
-       struct be_adapter *adapter = pnob->adapter;
-       int cur_index, tx_wrbs_completed = 0;
-       struct sk_buff *skb;
-       u64 busaddr, pa, pa_lo, pa_hi;
-       struct ETH_WRB_AMAP *wrb;
-       u32 frag_len, last_index, j;
-
-       last_index = tx_compl_lastwrb_idx_get(pnob);
-       BUG_ON(last_index != end_idx);
-       pnob->tx_ctxt[pnob->tx_q_tl] = NULL;
-       do {
-               cur_index = pnob->tx_q_tl;
-               wrb = &pnob->tx_q[cur_index];
-               pa_hi = AMAP_GET_BITS_PTR(ETH_WRB, frag_pa_hi, wrb);
-               pa_lo = AMAP_GET_BITS_PTR(ETH_WRB, frag_pa_lo, wrb);
-               frag_len = AMAP_GET_BITS_PTR(ETH_WRB, frag_len, wrb);
-               busaddr = (pa_hi << 32) | pa_lo;
-               if (busaddr != 0) {
-                       pa = le64_to_cpu(busaddr);
-                       pci_unmap_single(adapter->pdev, pa,
-                                        frag_len, PCI_DMA_TODEVICE);
-               }
-               if (cur_index == last_index) {
-                       skb = (struct sk_buff *)pnob->tx_ctxt[cur_index];
-                       BUG_ON(!skb);
-                       for (j = 0; j < skb_shinfo(skb)->nr_frags; j++) {
-                               struct skb_frag_struct *frag;
-                               frag = &skb_shinfo(skb)->frags[j];
-                               pci_unmap_page(adapter->pdev,
-                                              (ulong) frag->page, frag->size,
-                                              PCI_DMA_TODEVICE);
-                       }
-                       kfree_skb(skb);
-                       pnob->tx_ctxt[cur_index] = NULL;
-               } else {
-                       BUG_ON(pnob->tx_ctxt[cur_index]);
-               }
-               tx_wrbs_completed++;
-               be_adv_txq_tl(pnob);
-       } while (cur_index != last_index);
-       atomic_sub(tx_wrbs_completed, &pnob->tx_q_used);
-}
-
-/* there is no need to take an SMP lock here since currently
- * we have only one instance of the tasklet that does completion
- * processing.
- */
-static void process_nic_tx_completions(struct be_net_object *pnob)
-{
-       struct be_adapter *adapter = pnob->adapter;
-       struct ETH_TX_COMPL_AMAP *txcp;
-       struct net_device *netdev = pnob->netdev;
-       u32 end_idx, num_processed = 0;
-
-       adapter->be_stat.bes_tx_events++;
-
-       while ((txcp = be_get_tx_cmpl(pnob))) {
-               end_idx = AMAP_GET_BITS_PTR(ETH_TX_COMPL, wrb_index, txcp);
-               process_one_tx_compl(pnob, end_idx);
-               num_processed++;
-               adapter->be_stat.bes_tx_compl++;
-       }
-       be_notify_cmpl(pnob, num_processed, pnob->tx_cq_id, 1);
-       /*
-        * We got Tx completions and have usable WRBs.
-        * If the netdev's queue has been stopped
-        * because we had run out of WRBs, wake it now.
-        */
-       spin_lock(&adapter->txq_lock);
-       if (netif_queue_stopped(netdev)
-           && atomic_read(&pnob->tx_q_used) < pnob->tx_q_len / 2) {
-               netif_wake_queue(netdev);
-       }
-       spin_unlock(&adapter->txq_lock);
-}
-
-static u32 post_rx_buffs(struct be_net_object *pnob, struct list_head *rxbl)
-{
-       u32 nposted = 0;
-       struct ETH_RX_D_AMAP *rxd = NULL;
-       struct be_recv_buffer *rxbp;
-       void **rx_ctxp;
-       struct RQ_DB_AMAP rqdb;
-
-       rx_ctxp = pnob->rx_ctxt;
-
-       while (!list_empty(rxbl) &&
-              (rx_ctxp[pnob->rx_q_hd] == NULL) && nposted < 255) {
-
-               rxbp = list_first_entry(rxbl, struct be_recv_buffer, rxb_list);
-               list_del(&rxbp->rxb_list);
-               rxd = pnob->rx_q + pnob->rx_q_hd;
-               AMAP_SET_BITS_PTR(ETH_RX_D, fragpa_lo, rxd, rxbp->rxb_pa_lo);
-               AMAP_SET_BITS_PTR(ETH_RX_D, fragpa_hi, rxd, rxbp->rxb_pa_hi);
-
-               rx_ctxp[pnob->rx_q_hd] = rxbp->rxb_ctxt;
-               be_adv_rxq_hd(pnob);
-               nposted++;
-       }
-
-       if (nposted) {
-               /* Now press the door bell to notify BladeEngine. */
-               rqdb.dw[0] = 0;
-               AMAP_SET_BITS_PTR(RQ_DB, numPosted, &rqdb, nposted);
-               AMAP_SET_BITS_PTR(RQ_DB, rq, &rqdb, pnob->rx_q_id);
-               PD_WRITE(&pnob->fn_obj, erx_rq_db, rqdb.dw[0]);
-       }
-       atomic_add(nposted, &pnob->rx_q_posted);
-       return nposted;
-}
-
-void be_post_eth_rx_buffs(struct be_net_object *pnob)
-{
-       struct be_adapter *adapter = pnob->adapter;
-       u32 num_bufs, r;
-       u64 busaddr = 0, tmp_pa;
-       u32 max_bufs, pg_hd;
-       u32 frag_size;
-       struct be_recv_buffer *rxbp;
-       struct list_head rxbl;
-       struct be_rx_page_info *rx_page_info;
-       struct page *page = NULL;
-       u32 page_order = 0;
-       gfp_t alloc_flags = GFP_ATOMIC;
-
-       BUG_ON(!adapter);
-
-       max_bufs = 64;          /* should be even # <= 255. */
-
-       frag_size = pnob->rx_buf_size;
-       page_order = get_order(frag_size);
-
-       if (frag_size == 8192)
-               alloc_flags |= (gfp_t) __GFP_COMP;
-       /*
-        * Form a linked list of RECV_BUFFFER structure to be be posted.
-        * We will post even number of buffer so that pages can be
-        * shared.
-        */
-       INIT_LIST_HEAD(&rxbl);
-
-       for (num_bufs = 0; num_bufs < max_bufs &&
-               !pnob->rx_page_info[pnob->rx_pg_info_hd].page; ++num_bufs) {
-
-               rxbp = &pnob->eth_rx_bufs[num_bufs];
-               pg_hd = pnob->rx_pg_info_hd;
-               rx_page_info = &pnob->rx_page_info[pg_hd];
-
-               if (!page) {
-                       page = alloc_pages(alloc_flags, page_order);
-                       if (unlikely(page == NULL)) {
-                               adapter->be_stat.bes_ethrx_post_fail++;
-                               pnob->rxbuf_post_fail++;
-                               break;
-                       }
-                       pnob->rxbuf_post_fail = 0;
-                       busaddr = pci_map_page(adapter->pdev, page, 0,
-                                              frag_size, PCI_DMA_FROMDEVICE);
-                       rx_page_info->page_offset = 0;
-                       rx_page_info->page = page;
-                       /*
-                        * If we are sharing a page among two skbs,
-                        * alloc a new one on the next iteration
-                        */
-                       if (pnob->rx_pg_shared == false)
-                               page = NULL;
-               } else {
-                       get_page(page);
-                       rx_page_info->page_offset += frag_size;
-                       rx_page_info->page = page;
-                       /*
-                        * We are finished with the alloced page,
-                        * Alloc a new one on the next iteration
-                        */
-                       page = NULL;
-               }
-               rxbp->rxb_ctxt = (void *)rx_page_info;
-               index_inc(&pnob->rx_pg_info_hd, pnob->rx_q_len);
-
-               pci_unmap_addr_set(rx_page_info, bus, busaddr);
-               tmp_pa = busaddr + rx_page_info->page_offset;
-               rxbp->rxb_pa_lo = (tmp_pa & 0xFFFFFFFF);
-               rxbp->rxb_pa_hi = (tmp_pa >> 32);
-               rxbp->rxb_len = frag_size;
-               list_add_tail(&rxbp->rxb_list, &rxbl);
-       }                       /* End of for */
-
-       r = post_rx_buffs(pnob, &rxbl);
-       BUG_ON(r != num_bufs);
-       return;
-}
-
-/*
- * Interrupt service for network function.  We just schedule the
- * tasklet which does all completion processing.
- */
-irqreturn_t be_int(int irq, void *dev)
-{
-       struct net_device *netdev = dev;
-       struct be_net_object *pnob = netdev_priv(netdev);
-       struct be_adapter *adapter = pnob->adapter;
-       u32 isr;
-
-       isr = CSR_READ(&pnob->fn_obj, cev.isr1);
-       if (unlikely(!isr))
-               return IRQ_NONE;
-
-       spin_lock(&adapter->int_lock);
-       adapter->isr |= isr;
-       spin_unlock(&adapter->int_lock);
-
-       adapter->be_stat.bes_ints++;
-
-       tasklet_schedule(&adapter->sts_handler);
-       return IRQ_HANDLED;
-}
-
-/*
- * Poll function called by NAPI with a work budget.
- * We process as many UC. BC and MC receive completions
- * as the budget allows and return the actual number of
- * RX ststutses processed.
- */
-int be_poll(struct napi_struct *napi, int budget)
-{
-       struct be_net_object *pnob =
-                       container_of(napi, struct be_net_object, napi);
-       u32 work_done;
-
-       pnob->adapter->be_stat.bes_polls++;
-       work_done = process_rx_completions(pnob, budget);
-       BUG_ON(work_done > budget);
-
-       /* All consumed */
-       if (work_done < budget) {
-               netif_rx_complete(napi);
-               /* enable intr */
-               be_notify_cmpl(pnob, work_done, pnob->rx_cq_id, 1);
-       } else {
-               /* More to be consumed; continue with interrupts disabled */
-               be_notify_cmpl(pnob, work_done, pnob->rx_cq_id, 0);
-       }
-       return work_done;
-}
-
-static struct EQ_ENTRY_AMAP *get_event(struct be_net_object *pnob)
-{
-       struct EQ_ENTRY_AMAP *eqp = &(pnob->event_q[pnob->event_q_tl]);
-       if (!AMAP_GET_BITS_PTR(EQ_ENTRY, Valid, eqp))
-               return NULL;
-       be_adv_eq_tl(pnob);
-       return eqp;
-}
-
-/*
- * Processes all valid events in the event ring associated with given
- * NetObject.  Also, notifies BE the number of events processed.
- */
-static inline u32 process_events(struct be_net_object *pnob)
-{
-       struct be_adapter *adapter = pnob->adapter;
-       struct EQ_ENTRY_AMAP *eqp;
-       u32 rid, num_events = 0;
-       struct net_device *netdev = pnob->netdev;
-
-       while ((eqp = get_event(pnob)) != NULL) {
-               adapter->be_stat.bes_events++;
-               rid = AMAP_GET_BITS_PTR(EQ_ENTRY, ResourceID, eqp);
-               if (rid == pnob->rx_cq_id) {
-                       adapter->be_stat.bes_rx_events++;
-                       netif_rx_schedule(&pnob->napi);
-               } else if (rid == pnob->tx_cq_id) {
-                       process_nic_tx_completions(pnob);
-               } else if (rid == pnob->mcc_cq_id) {
-                       be_mcc_process_cq(&pnob->mcc_q_obj, 1);
-               } else {
-                       dev_info(&netdev->dev,
-                                       "Invalid EQ ResourceID %d\n", rid);
-               }
-               AMAP_SET_BITS_PTR(EQ_ENTRY, Valid, eqp, 0);
-               AMAP_SET_BITS_PTR(EQ_ENTRY, ResourceID, eqp, 0);
-               num_events++;
-       }
-       return num_events;
-}
-
-static void update_eqd(struct be_adapter *adapter, struct be_net_object *pnob)
-{
-       int status;
-       struct be_eq_object *eq_objectp;
-
-       /* update once a second */
-       if ((jiffies - adapter->ips_jiffies) > 1 * (HZ)) {
-               /* One second elapsed since last update  */
-               u32 r, new_eqd = -1;
-               r = adapter->be_stat.bes_ints - adapter->be_stat.bes_prev_ints;
-               r = r / ((jiffies - adapter->ips_jiffies) / (HZ));
-               adapter->be_stat.bes_ips = r;
-               adapter->ips_jiffies = jiffies;
-               adapter->be_stat.bes_prev_ints = adapter->be_stat.bes_ints;
-               if (r > IPS_HI_WM && adapter->cur_eqd < adapter->max_eqd)
-                       new_eqd = (adapter->cur_eqd + 8);
-               if (r < IPS_LO_WM && adapter->cur_eqd > adapter->min_eqd)
-                       new_eqd = (adapter->cur_eqd - 8);
-               if (adapter->enable_aic && new_eqd != -1) {
-                       eq_objectp = &pnob->event_q_obj;
-                       status = be_eq_modify_delay(&pnob->fn_obj, 1,
-                                                   &eq_objectp, &new_eqd, NULL,
-                                                   NULL, NULL);
-                       if (status == BE_SUCCESS)
-                               adapter->cur_eqd = new_eqd;
-               }
-       }
-}
-
-/*
-    This function notifies BladeEngine of how many events were processed
-    from the event queue by ringing the corresponding door bell and
-    optionally re-arms the event queue.
-    n          - number of events processed
-    re_arm     - 1 - re-arm the EQ, 0 - do not re-arm the EQ
-
-*/
-static void be_notify_event(struct be_net_object *pnob, int n, int re_arm)
-{
-       struct CQ_DB_AMAP eqdb;
-       eqdb.dw[0] = 0;
-
-       AMAP_SET_BITS_PTR(CQ_DB, qid, &eqdb, pnob->event_q_id);
-       AMAP_SET_BITS_PTR(CQ_DB, rearm, &eqdb, re_arm);
-       AMAP_SET_BITS_PTR(CQ_DB, event, &eqdb, 1);
-       AMAP_SET_BITS_PTR(CQ_DB, num_popped, &eqdb, n);
-       /*
-        * Under some situations we see an interrupt and no valid
-        * EQ entry.  To keep going, we need to ring the DB even if
-        * numPOsted is 0.
-        */
-       PD_WRITE(&pnob->fn_obj, cq_db, eqdb.dw[0]);
-       return;
-}
-
-/*
- * Called from the tasklet scheduled by ISR.  All real interrupt processing
- * is done here.
- */
-void be_process_intr(unsigned long context)
-{
-       struct be_adapter *adapter = (struct be_adapter *)context;
-       struct be_net_object *pnob = adapter->net_obj;
-       u32 isr, n;
-       ulong flags = 0;
-
-       isr = adapter->isr;
-
-       /*
-        * we create only one NIC event queue in Linux. Event is
-        * expected only in the first event queue
-        */
-       BUG_ON(isr & 0xfffffffe);
-       if ((isr & 1) == 0)
-               return;         /* not our interrupt */
-       n = process_events(pnob);
-       /*
-        * Clear the event bit. adapter->isr is  set by
-        * hard interrupt.  Prevent race with lock.
-        */
-       spin_lock_irqsave(&adapter->int_lock, flags);
-       adapter->isr &= ~1;
-       spin_unlock_irqrestore(&adapter->int_lock, flags);
-       be_notify_event(pnob, n, 1);
-       /*
-        * If previous allocation attempts had failed and
-        * BE has used up all posted buffers, post RX buffers here
-        */
-       if (pnob->rxbuf_post_fail && atomic_read(&pnob->rx_q_posted) == 0)
-               be_post_eth_rx_buffs(pnob);
-       update_eqd(adapter, pnob);
-       return;
-}
diff --git a/drivers/staging/benet/be_netif.c b/drivers/staging/benet/be_netif.c
deleted file mode 100644 (file)
index 2b8daf6..0000000
+++ /dev/null
@@ -1,705 +0,0 @@
-/*
- * Copyright (C) 2005 - 2008 ServerEngines
- * All rights reserved.
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License version 2
- * as published by the Free Software Foundation.  The full GNU General
- * Public License is included in this distribution in the file called COPYING.
- *
- * Contact Information:
- * linux-drivers@serverengines.com
- *
- * ServerEngines
- * 209 N. Fair Oaks Ave
- * Sunnyvale, CA 94085
- */
-/*
- * be_netif.c
- *
- * This file contains various entry points of drivers seen by tcp/ip stack.
- */
-
-#include <linux/if_vlan.h>
-#include <linux/in.h>
-#include "benet.h"
-#include <linux/ip.h>
-#include <linux/inet_lro.h>
-
-/* Strings to print Link properties */
-static const char *link_speed[] = {
-       "Invalid link Speed Value",
-       "10 Mbps",
-       "100 Mbps",
-       "1 Gbps",
-       "10 Gbps"
-};
-
-static const char *link_duplex[] = {
-       "Invalid Duplex Value",
-       "Half Duplex",
-       "Full Duplex"
-};
-
-static const char *link_state[] = {
-       "",
-       "(active)"
-};
-
-void be_print_link_info(struct BE_LINK_STATUS *lnk_status)
-{
-       u16 si, di, ai;
-
-       /* Port 0 */
-       if (lnk_status->mac0_speed && lnk_status->mac0_duplex) {
-               /* Port is up and running */
-               si = (lnk_status->mac0_speed < 5) ? lnk_status->mac0_speed : 0;
-               di = (lnk_status->mac0_duplex < 3) ?
-                   lnk_status->mac0_duplex : 0;
-               ai = (lnk_status->active_port == 0) ? 1 : 0;
-               printk(KERN_INFO "PortNo. 0: Speed - %s %s %s\n",
-                      link_speed[si], link_duplex[di], link_state[ai]);
-       } else
-               printk(KERN_INFO "PortNo. 0: Down\n");
-
-       /* Port 1 */
-       if (lnk_status->mac1_speed && lnk_status->mac1_duplex) {
-               /* Port is up and running */
-               si = (lnk_status->mac1_speed < 5) ? lnk_status->mac1_speed : 0;
-               di = (lnk_status->mac1_duplex < 3) ?
-                   lnk_status->mac1_duplex : 0;
-               ai = (lnk_status->active_port == 0) ? 1 : 0;
-               printk(KERN_INFO "PortNo. 1: Speed - %s %s %s\n",
-                      link_speed[si], link_duplex[di], link_state[ai]);
-       } else
-               printk(KERN_INFO "PortNo. 1: Down\n");
-
-       return;
-}
-
-static int
-be_get_frag_header(struct skb_frag_struct *frag, void **mac_hdr,
-                  void **ip_hdr, void **tcpudp_hdr,
-                  u64 *hdr_flags, void *priv)
-{
-       struct ethhdr *eh;
-       struct vlan_ethhdr *veh;
-       struct iphdr *iph;
-       u8 *va = page_address(frag->page) + frag->page_offset;
-       unsigned long ll_hlen;
-
-       /* find the mac header, abort if not IPv4 */
-
-       prefetch(va);
-       eh = (struct ethhdr *)va;
-       *mac_hdr = eh;
-       ll_hlen = ETH_HLEN;
-       if (eh->h_proto != htons(ETH_P_IP)) {
-               if (eh->h_proto == htons(ETH_P_8021Q)) {
-                       veh = (struct vlan_ethhdr *)va;
-                       if (veh->h_vlan_encapsulated_proto != htons(ETH_P_IP))
-                               return -1;
-
-                       ll_hlen += VLAN_HLEN;
-
-               } else {
-                       return -1;
-               }
-       }
-       *hdr_flags = LRO_IPV4;
-
-       iph = (struct iphdr *)(va + ll_hlen);
-       *ip_hdr = iph;
-       if (iph->protocol != IPPROTO_TCP)
-               return -1;
-       *hdr_flags |= LRO_TCP;
-       *tcpudp_hdr = (u8 *) (*ip_hdr) + (iph->ihl << 2);
-
-       return 0;
-}
-
-static int benet_open(struct net_device *netdev)
-{
-       struct be_net_object *pnob = netdev_priv(netdev);
-       struct be_adapter *adapter = pnob->adapter;
-       struct net_lro_mgr *lro_mgr;
-
-       if (adapter->dev_state < BE_DEV_STATE_INIT)
-               return -EAGAIN;
-
-       lro_mgr = &pnob->lro_mgr;
-       lro_mgr->dev = netdev;
-
-       lro_mgr->features = LRO_F_NAPI;
-       lro_mgr->ip_summed = CHECKSUM_UNNECESSARY;
-       lro_mgr->ip_summed_aggr = CHECKSUM_UNNECESSARY;
-       lro_mgr->max_desc = BE_MAX_LRO_DESCRIPTORS;
-       lro_mgr->lro_arr = pnob->lro_desc;
-       lro_mgr->get_frag_header = be_get_frag_header;
-       lro_mgr->max_aggr = adapter->max_rx_coal;
-       lro_mgr->frag_align_pad = 2;
-       if (lro_mgr->max_aggr > MAX_SKB_FRAGS)
-               lro_mgr->max_aggr = MAX_SKB_FRAGS;
-
-       adapter->max_rx_coal = BE_LRO_MAX_PKTS;
-
-       be_update_link_status(adapter);
-
-       /*
-        * Set carrier on only if Physical Link up
-        * Either of the port link status up signifies this
-        */
-       if ((adapter->port0_link_sts == BE_PORT_LINK_UP) ||
-           (adapter->port1_link_sts == BE_PORT_LINK_UP)) {
-               netif_start_queue(netdev);
-               netif_carrier_on(netdev);
-       }
-
-       adapter->dev_state = BE_DEV_STATE_OPEN;
-       napi_enable(&pnob->napi);
-       be_enable_intr(pnob);
-       be_enable_eq_intr(pnob);
-       /*
-        * RX completion queue may be in dis-armed state. Arm it.
-        */
-       be_notify_cmpl(pnob, 0, pnob->rx_cq_id, 1);
-
-       return 0;
-}
-
-static int benet_close(struct net_device *netdev)
-{
-       struct be_net_object *pnob = netdev_priv(netdev);
-       struct be_adapter *adapter = pnob->adapter;
-
-       netif_stop_queue(netdev);
-       synchronize_irq(netdev->irq);
-
-       be_wait_nic_tx_cmplx_cmpl(pnob);
-       adapter->dev_state = BE_DEV_STATE_INIT;
-       netif_carrier_off(netdev);
-
-       adapter->port0_link_sts = BE_PORT_LINK_DOWN;
-       adapter->port1_link_sts = BE_PORT_LINK_DOWN;
-       be_disable_intr(pnob);
-       be_disable_eq_intr(pnob);
-       napi_disable(&pnob->napi);
-
-       return 0;
-}
-
-/*
- * Setting a Mac Address for BE
- * Takes netdev and a void pointer as arguments.
- * The pointer holds the new addres to be used.
- */
-static int benet_set_mac_addr(struct net_device *netdev, void *p)
-{
-       struct sockaddr *addr = p;
-       struct be_net_object *pnob = netdev_priv(netdev);
-
-       memcpy(netdev->dev_addr, addr->sa_data, netdev->addr_len);
-       be_rxf_mac_address_read_write(&pnob->fn_obj, 0, 0, false, true, false,
-                               netdev->dev_addr, NULL, NULL);
-       /*
-        * Since we are doing Active-Passive failover, both
-        * ports should have matching MAC addresses everytime.
-        */
-       be_rxf_mac_address_read_write(&pnob->fn_obj, 1, 0, false, true, false,
-                                     netdev->dev_addr, NULL, NULL);
-
-       return 0;
-}
-
-void be_get_stats_timer_handler(unsigned long context)
-{
-       struct be_timer_ctxt *ctxt = (struct be_timer_ctxt *)context;
-
-       if (atomic_read(&ctxt->get_stat_flag)) {
-               atomic_dec(&ctxt->get_stat_flag);
-               up((void *)ctxt->get_stat_sem_addr);
-       }
-       del_timer(&ctxt->get_stats_timer);
-       return;
-}
-
-void be_get_stat_cb(void *context, int status,
-                   struct MCC_WRB_AMAP *optional_wrb)
-{
-       struct be_timer_ctxt *ctxt = (struct be_timer_ctxt *)context;
-       /*
-        * just up the semaphore if the get_stat_flag
-        * reads 1. so that the waiter can continue.
-        * If it is 0, then it was handled by the timer handler.
-        */
-       del_timer(&ctxt->get_stats_timer);
-       if (atomic_read(&ctxt->get_stat_flag)) {
-               atomic_dec(&ctxt->get_stat_flag);
-               up((void *)ctxt->get_stat_sem_addr);
-       }
-}
-
-struct net_device_stats *benet_get_stats(struct net_device *dev)
-{
-       struct be_net_object *pnob = netdev_priv(dev);
-       struct be_adapter *adapter = pnob->adapter;
-       u64 pa;
-       struct be_timer_ctxt *ctxt = &adapter->timer_ctxt;
-
-       if (adapter->dev_state != BE_DEV_STATE_OPEN) {
-               /* Return previously read stats */
-               return &(adapter->benet_stats);
-       }
-       /* Get Physical Addr */
-       pa = pci_map_single(adapter->pdev, adapter->eth_statsp,
-                           sizeof(struct FWCMD_ETH_GET_STATISTICS),
-                           PCI_DMA_FROMDEVICE);
-       ctxt->get_stat_sem_addr = (unsigned long)&adapter->get_eth_stat_sem;
-       atomic_inc(&ctxt->get_stat_flag);
-
-       be_rxf_query_eth_statistics(&pnob->fn_obj, adapter->eth_statsp,
-                                   cpu_to_le64(pa), be_get_stat_cb, ctxt,
-                                   NULL);
-
-       ctxt->get_stats_timer.data = (unsigned long)ctxt;
-       mod_timer(&ctxt->get_stats_timer, (jiffies + (HZ * 2)));
-       down((void *)ctxt->get_stat_sem_addr);  /* callback will unblock us */
-
-       /* Adding port0 and port1 stats. */
-       adapter->benet_stats.rx_packets =
-           adapter->eth_statsp->params.response.p0recvdtotalframes +
-           adapter->eth_statsp->params.response.p1recvdtotalframes;
-       adapter->benet_stats.tx_packets =
-           adapter->eth_statsp->params.response.p0xmitunicastframes +
-           adapter->eth_statsp->params.response.p1xmitunicastframes;
-       adapter->benet_stats.tx_bytes =
-           adapter->eth_statsp->params.response.p0xmitbyteslsd +
-           adapter->eth_statsp->params.response.p1xmitbyteslsd;
-       adapter->benet_stats.rx_errors =
-           adapter->eth_statsp->params.response.p0crcerrors +
-           adapter->eth_statsp->params.response.p1crcerrors;
-       adapter->benet_stats.rx_errors +=
-           adapter->eth_statsp->params.response.p0alignmentsymerrs +
-           adapter->eth_statsp->params.response.p1alignmentsymerrs;
-       adapter->benet_stats.rx_errors +=
-           adapter->eth_statsp->params.response.p0inrangelenerrors +
-           adapter->eth_statsp->params.response.p1inrangelenerrors;
-       adapter->benet_stats.rx_bytes =
-           adapter->eth_statsp->params.response.p0recvdtotalbytesLSD +
-           adapter->eth_statsp->params.response.p1recvdtotalbytesLSD;
-       adapter->benet_stats.rx_crc_errors =
-           adapter->eth_statsp->params.response.p0crcerrors +
-           adapter->eth_statsp->params.response.p1crcerrors;
-
-       adapter->benet_stats.tx_packets +=
-           adapter->eth_statsp->params.response.p0xmitmulticastframes +
-           adapter->eth_statsp->params.response.p1xmitmulticastframes;
-       adapter->benet_stats.tx_packets +=
-           adapter->eth_statsp->params.response.p0xmitbroadcastframes +
-           adapter->eth_statsp->params.response.p1xmitbroadcastframes;
-       adapter->benet_stats.tx_errors = 0;
-
-       adapter->benet_stats.multicast =
-           adapter->eth_statsp->params.response.p0xmitmulticastframes +
-           adapter->eth_statsp->params.response.p1xmitmulticastframes;
-
-       adapter->benet_stats.rx_fifo_errors =
-           adapter->eth_statsp->params.response.p0rxfifooverflowdropped +
-           adapter->eth_statsp->params.response.p1rxfifooverflowdropped;
-       adapter->benet_stats.rx_frame_errors =
-           adapter->eth_statsp->params.response.p0alignmentsymerrs +
-           adapter->eth_statsp->params.response.p1alignmentsymerrs;
-       adapter->benet_stats.rx_length_errors =
-           adapter->eth_statsp->params.response.p0inrangelenerrors +
-           adapter->eth_statsp->params.response.p1inrangelenerrors;
-       adapter->benet_stats.rx_length_errors +=
-           adapter->eth_statsp->params.response.p0outrangeerrors +
-           adapter->eth_statsp->params.response.p1outrangeerrors;
-       adapter->benet_stats.rx_length_errors +=
-           adapter->eth_statsp->params.response.p0frametoolongerrors +
-           adapter->eth_statsp->params.response.p1frametoolongerrors;
-
-       pci_unmap_single(adapter->pdev, (ulong) adapter->eth_statsp,
-                        sizeof(struct FWCMD_ETH_GET_STATISTICS),
-                        PCI_DMA_FROMDEVICE);
-       return &(adapter->benet_stats);
-
-}
-
-static void be_start_tx(struct be_net_object *pnob, u32 nposted)
-{
-#define CSR_ETH_MAX_SQPOSTS 255
-       struct SQ_DB_AMAP sqdb;
-
-       sqdb.dw[0] = 0;
-
-       AMAP_SET_BITS_PTR(SQ_DB, cid, &sqdb, pnob->tx_q_id);
-       while (nposted) {
-               if (nposted > CSR_ETH_MAX_SQPOSTS) {
-                       AMAP_SET_BITS_PTR(SQ_DB, numPosted, &sqdb,
-                                         CSR_ETH_MAX_SQPOSTS);
-                       nposted -= CSR_ETH_MAX_SQPOSTS;
-               } else {
-                       AMAP_SET_BITS_PTR(SQ_DB, numPosted, &sqdb, nposted);
-                       nposted = 0;
-               }
-               PD_WRITE(&pnob->fn_obj, etx_sq_db, sqdb.dw[0]);
-       }
-
-       return;
-}
-
-static void update_tx_rate(struct be_adapter *adapter)
-{
-       /* update the rate once in two seconds */
-       if ((jiffies - adapter->eth_tx_jiffies) > 2 * (HZ)) {
-               u32 r;
-               r = adapter->eth_tx_bytes /
-                   ((jiffies - adapter->eth_tx_jiffies) / (HZ));
-               r = (r / 1000000);      /* M bytes/s */
-               adapter->be_stat.bes_eth_tx_rate = (r * 8); /* M bits/s */
-               adapter->eth_tx_jiffies = jiffies;
-               adapter->eth_tx_bytes = 0;
-       }
-}
-
-static int wrb_cnt_in_skb(struct sk_buff *skb)
-{
-       int cnt = 0;
-       while (skb) {
-               if (skb->len > skb->data_len)
-                       cnt++;
-               cnt += skb_shinfo(skb)->nr_frags;
-               skb = skb_shinfo(skb)->frag_list;
-       }
-       BUG_ON(cnt > BE_MAX_TX_FRAG_COUNT);
-       return cnt;
-}
-
-static void wrb_fill(struct ETH_WRB_AMAP *wrb, u64 addr, int len)
-{
-       AMAP_SET_BITS_PTR(ETH_WRB, frag_pa_hi, wrb, addr >> 32);
-       AMAP_SET_BITS_PTR(ETH_WRB, frag_pa_lo, wrb, addr & 0xFFFFFFFF);
-       AMAP_SET_BITS_PTR(ETH_WRB, frag_len, wrb, len);
-}
-
-static void wrb_fill_extra(struct ETH_WRB_AMAP *wrb, struct sk_buff *skb,
-                          struct be_net_object *pnob)
-{
-       wrb->dw[2] = 0;
-       wrb->dw[3] = 0;
-       AMAP_SET_BITS_PTR(ETH_WRB, crc, wrb, 1);
-       if (skb_shinfo(skb)->gso_segs > 1 && skb_shinfo(skb)->gso_size) {
-               AMAP_SET_BITS_PTR(ETH_WRB, lso, wrb, 1);
-               AMAP_SET_BITS_PTR(ETH_WRB, lso_mss, wrb,
-                                 skb_shinfo(skb)->gso_size);
-       } else if (skb->ip_summed == CHECKSUM_PARTIAL) {
-               u8 proto = ((struct iphdr *)ip_hdr(skb))->protocol;
-               if (proto == IPPROTO_TCP)
-                       AMAP_SET_BITS_PTR(ETH_WRB, tcpcs, wrb, 1);
-               else if (proto == IPPROTO_UDP)
-                       AMAP_SET_BITS_PTR(ETH_WRB, udpcs, wrb, 1);
-       }
-       if (pnob->vlan_grp && vlan_tx_tag_present(skb)) {
-               AMAP_SET_BITS_PTR(ETH_WRB, vlan, wrb, 1);
-               AMAP_SET_BITS_PTR(ETH_WRB, vlan_tag, wrb, vlan_tx_tag_get(skb));
-       }
-}
-
-static inline void wrb_copy_extra(struct ETH_WRB_AMAP *to,
-                                 struct ETH_WRB_AMAP *from)
-{
-
-       to->dw[2] = from->dw[2];
-       to->dw[3] = from->dw[3];
-}
-
-/* Returns the actual count of wrbs used including a possible dummy */
-static int copy_skb_to_txq(struct be_net_object *pnob, struct sk_buff *skb,
-                          u32 wrb_cnt, u32 *copied)
-{
-       u64 busaddr;
-       struct ETH_WRB_AMAP *wrb = NULL, *first = NULL;
-       u32 i;
-       bool dummy = true;
-       struct pci_dev *pdev = pnob->adapter->pdev;
-
-       if (wrb_cnt & 1)
-               wrb_cnt++;
-       else
-               dummy = false;
-
-       atomic_add(wrb_cnt, &pnob->tx_q_used);
-
-       while (skb) {
-               if (skb->len > skb->data_len) {
-                       int len = skb->len - skb->data_len;
-                       busaddr = pci_map_single(pdev, skb->data, len,
-                                                PCI_DMA_TODEVICE);
-                       busaddr = cpu_to_le64(busaddr);
-                       wrb = &pnob->tx_q[pnob->tx_q_hd];
-                       if (first == NULL) {
-                               wrb_fill_extra(wrb, skb, pnob);
-                               first = wrb;
-                       } else {
-                               wrb_copy_extra(wrb, first);
-                       }
-                       wrb_fill(wrb, busaddr, len);
-                       be_adv_txq_hd(pnob);
-                       *copied += len;
-               }
-
-               for (i = 0; i < skb_shinfo(skb)->nr_frags; i++) {
-                       struct skb_frag_struct *frag =
-                           &skb_shinfo(skb)->frags[i];
-                       busaddr = pci_map_page(pdev, frag->page,
-                                              frag->page_offset, frag->size,
-                                              PCI_DMA_TODEVICE);
-                       busaddr = cpu_to_le64(busaddr);
-                       wrb = &pnob->tx_q[pnob->tx_q_hd];
-                       if (first == NULL) {
-                               wrb_fill_extra(wrb, skb, pnob);
-                               first = wrb;
-                       } else {
-                               wrb_copy_extra(wrb, first);
-                       }
-                       wrb_fill(wrb, busaddr, frag->size);
-                       be_adv_txq_hd(pnob);
-                       *copied += frag->size;
-               }
-               skb = skb_shinfo(skb)->frag_list;
-       }
-
-       if (dummy) {
-               wrb = &pnob->tx_q[pnob->tx_q_hd];
-               BUG_ON(first == NULL);
-               wrb_copy_extra(wrb, first);
-               wrb_fill(wrb, 0, 0);
-               be_adv_txq_hd(pnob);
-       }
-       AMAP_SET_BITS_PTR(ETH_WRB, complete, wrb, 1);
-       AMAP_SET_BITS_PTR(ETH_WRB, last, wrb, 1);
-       return wrb_cnt;
-}
-
-/* For each skb transmitted, tx_ctxt stores the num of wrbs in the
- * start index and skb pointer in the end index
- */
-static inline void be_tx_wrb_info_remember(struct be_net_object *pnob,
-                                          struct sk_buff *skb, int wrb_cnt,
-                                          u32 start)
-{
-       *(u32 *) (&pnob->tx_ctxt[start]) = wrb_cnt;
-       index_adv(&start, wrb_cnt - 1, pnob->tx_q_len);
-       pnob->tx_ctxt[start] = skb;
-}
-
-static int benet_xmit(struct sk_buff *skb, struct net_device *netdev)
-{
-       struct be_net_object *pnob = netdev_priv(netdev);
-       struct be_adapter *adapter = pnob->adapter;
-       u32 wrb_cnt, copied = 0;
-       u32 start = pnob->tx_q_hd;
-
-       adapter->be_stat.bes_tx_reqs++;
-
-       wrb_cnt = wrb_cnt_in_skb(skb);
-       spin_lock_bh(&adapter->txq_lock);
-       if ((pnob->tx_q_len - 2 - atomic_read(&pnob->tx_q_used)) <= wrb_cnt) {
-               netif_stop_queue(pnob->netdev);
-               spin_unlock_bh(&adapter->txq_lock);
-               adapter->be_stat.bes_tx_fails++;
-               return NETDEV_TX_BUSY;
-       }
-       spin_unlock_bh(&adapter->txq_lock);
-
-       wrb_cnt = copy_skb_to_txq(pnob, skb, wrb_cnt, &copied);
-       be_tx_wrb_info_remember(pnob, skb, wrb_cnt, start);
-
-       be_start_tx(pnob, wrb_cnt);
-
-       adapter->eth_tx_bytes += copied;
-       adapter->be_stat.bes_tx_wrbs += wrb_cnt;
-       update_tx_rate(adapter);
-       netdev->trans_start = jiffies;
-
-       return NETDEV_TX_OK;
-}
-
-/*
- * This is the driver entry point to change the mtu of the device
- * Returns 0 for success and errno for failure.
- */
-static int benet_change_mtu(struct net_device *netdev, int new_mtu)
-{
-       /*
-        * BE supports jumbo frame size upto 9000 bytes including the link layer
-        * header. Considering the different variants of frame formats possible
-        * like VLAN, SNAP/LLC, the maximum possible value for MTU is 8974 bytes
-        */
-
-       if (new_mtu < (ETH_ZLEN + ETH_FCS_LEN) || (new_mtu > BE_MAX_MTU)) {
-               dev_info(&netdev->dev, "Invalid MTU requested. "
-                              "Must be between %d and %d bytes\n",
-                                      (ETH_ZLEN + ETH_FCS_LEN), BE_MAX_MTU);
-               return -EINVAL;
-       }
-       dev_info(&netdev->dev, "MTU changed from %d to %d\n",
-                                               netdev->mtu, new_mtu);
-       netdev->mtu = new_mtu;
-       return 0;
-}
-
-/*
- * This is the driver entry point to register a vlan with the device
- */
-static void benet_vlan_register(struct net_device *netdev,
-                               struct vlan_group *grp)
-{
-       struct be_net_object *pnob = netdev_priv(netdev);
-
-       be_disable_eq_intr(pnob);
-       pnob->vlan_grp = grp;
-       pnob->num_vlans = 0;
-       be_enable_eq_intr(pnob);
-}
-
-/*
- * This is the driver entry point to add a vlan vlan_id
- * with the device netdev
- */
-static void benet_vlan_add_vid(struct net_device *netdev, u16 vlan_id)
-{
-       struct be_net_object *pnob = netdev_priv(netdev);
-
-       if (pnob->num_vlans == (BE_NUM_VLAN_SUPPORTED - 1)) {
-               /* no  way to return an error */
-               dev_info(&netdev->dev,
-                      "BladeEngine: Cannot configure more than %d Vlans\n",
-                              BE_NUM_VLAN_SUPPORTED);
-               return;
-       }
-       /* The new vlan tag will be in the slot indicated by num_vlans. */
-       pnob->vlan_tag[pnob->num_vlans++] = vlan_id;
-       be_rxf_vlan_config(&pnob->fn_obj, false, pnob->num_vlans,
-                          pnob->vlan_tag, NULL, NULL, NULL);
-}
-
-/*
- * This is the driver entry point to remove a vlan vlan_id
- * with the device netdev
- */
-static void benet_vlan_rem_vid(struct net_device *netdev, u16 vlan_id)
-{
-       struct be_net_object *pnob = netdev_priv(netdev);
-
-       u32 i, value;
-
-       /*
-        * In Blade Engine, we support 32 vlan tag filters across both ports.
-        * To program a vlan tag, the RXF_RTPR_CSR register is used.
-        * Each 32-bit value of RXF_RTDR_CSR can address 2 vlan tag entries.
-        * The Vlan table is of depth 16. thus we support 32 tags.
-        */
-
-       value = vlan_id | VLAN_VALID_BIT;
-       for (i = 0; i < BE_NUM_VLAN_SUPPORTED; i++) {
-               if (pnob->vlan_tag[i] == vlan_id)
-                       break;
-       }
-
-       if (i == BE_NUM_VLAN_SUPPORTED)
-               return;
-       /* Now compact the vlan tag array by removing hole created. */
-       while ((i + 1) < BE_NUM_VLAN_SUPPORTED) {
-               pnob->vlan_tag[i] = pnob->vlan_tag[i + 1];
-               i++;
-       }
-       if ((i + 1) == BE_NUM_VLAN_SUPPORTED)
-               pnob->vlan_tag[i] = (u16) 0x0;
-       pnob->num_vlans--;
-       be_rxf_vlan_config(&pnob->fn_obj, false, pnob->num_vlans,
-                          pnob->vlan_tag, NULL, NULL, NULL);
-}
-
-/*
- * This function is called to program multicast
- * address in the multicast filter of the ASIC.
- */
-static void be_set_multicast_filter(struct net_device *netdev)
-{
-       struct be_net_object *pnob = netdev_priv(netdev);
-       struct dev_mc_list *mc_ptr;
-       u8 mac_addr[32][ETH_ALEN];
-       int i;
-
-       if (netdev->flags & IFF_ALLMULTI) {
-               /* set BE in Multicast promiscuous */
-               be_rxf_multicast_config(&pnob->fn_obj, true, 0, NULL, NULL,
-                                       NULL, NULL);
-               return;
-       }
-
-       for (mc_ptr = netdev->mc_list, i = 0; mc_ptr;
-            mc_ptr = mc_ptr->next, i++) {
-               memcpy(&mac_addr[i][0], mc_ptr->dmi_addr, ETH_ALEN);
-       }
-
-       /* reset the promiscuous mode also. */
-       be_rxf_multicast_config(&pnob->fn_obj, false, i,
-                               &mac_addr[0][0], NULL, NULL, NULL);
-}
-
-/*
- * This is the driver entry point to set multicast list
- * with the device netdev. This function will be used to
- * set promiscuous mode or multicast promiscuous mode
- * or multicast mode....
- */
-static void benet_set_multicast_list(struct net_device *netdev)
-{
-       struct be_net_object *pnob = netdev_priv(netdev);
-
-       if (netdev->flags & IFF_PROMISC) {
-               be_rxf_promiscuous(&pnob->fn_obj, 1, 1, NULL, NULL, NULL);
-       } else {
-               be_rxf_promiscuous(&pnob->fn_obj, 0, 0, NULL, NULL, NULL);
-               be_set_multicast_filter(netdev);
-       }
-}
-
-int benet_init(struct net_device *netdev)
-{
-       struct be_net_object *pnob = netdev_priv(netdev);
-       struct be_adapter *adapter = pnob->adapter;
-
-       ether_setup(netdev);
-
-       netdev->open = &benet_open;
-       netdev->stop = &benet_close;
-       netdev->hard_start_xmit = &benet_xmit;
-
-       netdev->get_stats = &benet_get_stats;
-
-       netdev->set_multicast_list = &benet_set_multicast_list;
-
-       netdev->change_mtu = &benet_change_mtu;
-       netdev->set_mac_address = &benet_set_mac_addr;
-
-       netdev->vlan_rx_register = benet_vlan_register;
-       netdev->vlan_rx_add_vid = benet_vlan_add_vid;
-       netdev->vlan_rx_kill_vid = benet_vlan_rem_vid;
-
-       netdev->features =
-           NETIF_F_SG | NETIF_F_HIGHDMA | NETIF_F_HW_VLAN_RX | NETIF_F_TSO |
-           NETIF_F_HW_VLAN_TX | NETIF_F_HW_VLAN_FILTER | NETIF_F_IP_CSUM;
-
-       netdev->flags |= IFF_MULTICAST;
-
-       /* If device is DAC Capable, set the HIGHDMA flag for netdevice. */
-       if (adapter->dma_64bit_cap)
-               netdev->features |= NETIF_F_HIGHDMA;
-
-       SET_ETHTOOL_OPS(netdev, &be_ethtool_ops);
-       return 0;
-}
diff --git a/drivers/staging/benet/benet.h b/drivers/staging/benet/benet.h
deleted file mode 100644 (file)
index 09a1f08..0000000
+++ /dev/null
@@ -1,429 +0,0 @@
-/*
- * Copyright (C) 2005 - 2008 ServerEngines
- * All rights reserved.
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License version 2
- * as published by the Free Software Foundation.  The full GNU General
- * Public License is included in this distribution in the file called COPYING.
- *
- * Contact Information:
- * linux-drivers@serverengines.com
- *
- * ServerEngines
- * 209 N. Fair Oaks Ave
- * Sunnyvale, CA 94085
- */
-#ifndef _BENET_H_
-#define _BENET_H_
-
-#include <linux/pci.h>
-#include <linux/netdevice.h>
-#include <linux/inet_lro.h>
-#include "hwlib.h"
-
-#define _SA_MODULE_NAME "net-driver"
-
-#define VLAN_VALID_BIT         0x8000
-#define BE_NUM_VLAN_SUPPORTED  32
-#define BE_PORT_LINK_DOWN       0000
-#define BE_PORT_LINK_UP         0001
-#define        BE_MAX_TX_FRAG_COUNT            (30)
-
-/* Flag bits for send operation */
-#define IPCS            (1 << 0)       /* Enable IP checksum offload */
-#define UDPCS           (1 << 1)       /* Enable UDP checksum offload */
-#define TCPCS           (1 << 2)       /* Enable TCP checksum offload */
-#define LSO             (1 << 3)       /* Enable Large Segment  offload */
-#define ETHVLAN         (1 << 4)       /* Enable VLAN insert */
-#define ETHEVENT        (1 << 5)       /* Generate  event on completion */
-#define ETHCOMPLETE     (1 << 6)       /* Generate completion when done */
-#define IPSEC           (1 << 7)       /* Enable IPSEC */
-#define FORWARD         (1 << 8)       /* Send the packet in forwarding path */
-#define FIN             (1 << 9)       /* Issue FIN segment */
-
-#define BE_MAX_MTU     8974
-
-#define BE_MAX_LRO_DESCRIPTORS                 8
-#define BE_LRO_MAX_PKTS                                64
-#define BE_MAX_FRAGS_PER_FRAME                 6
-
-extern const char be_drvr_ver[];
-extern char be_fw_ver[];
-extern char be_driver_name[];
-
-extern struct ethtool_ops be_ethtool_ops;
-
-#define BE_DEV_STATE_NONE 0
-#define BE_DEV_STATE_INIT 1
-#define BE_DEV_STATE_OPEN 2
-#define BE_DEV_STATE_SUSPEND 3
-
-/* This structure is used to describe physical fragments to use
- * for DMAing data from NIC.
- */
-struct be_recv_buffer {
-       struct list_head rxb_list;      /* for maintaining a linked list */
-       void *rxb_va;           /* buffer virtual address */
-       u32 rxb_pa_lo;          /* low part of physical address */
-       u32 rxb_pa_hi;          /* high part of physical address */
-       u32 rxb_len;            /* length of recv buffer */
-       void *rxb_ctxt;         /* context for OSM driver to use */
-};
-
-/*
- * fragment list to describe scattered data.
- */
-struct be_tx_frag_list {
-       u32 txb_len;            /* Size of this fragment */
-       u32 txb_pa_lo;          /* Lower 32 bits of 64 bit physical addr */
-       u32 txb_pa_hi;          /* Higher 32 bits of 64 bit physical addr */
-};
-
-struct be_rx_page_info {
-       struct page *page;
-       dma_addr_t bus;
-       u16 page_offset;
-};
-
-/*
- *  This structure is the main tracking structure for a NIC interface.
- */
-struct be_net_object {
-       /* MCC Ring - used to send fwcmds to embedded ARM processor */
-       struct MCC_WRB_AMAP *mcc_q;     /* VA of the start of the ring */
-       u32 mcc_q_len;                  /* # of WRB entries in this ring */
-       u32 mcc_q_size;
-       u32 mcc_q_hd;                   /* MCC ring head */
-       u8 mcc_q_created;               /* flag to help cleanup */
-       struct be_mcc_object mcc_q_obj; /* BECLIB's MCC ring Object */
-       dma_addr_t mcc_q_bus;           /* DMA'ble bus address */
-
-       /* MCC Completion Ring - FW responses to fwcmds sent from MCC ring */
-       struct MCC_CQ_ENTRY_AMAP *mcc_cq; /* VA of the start of the ring */
-       u32 mcc_cq_len;                 /* # of compl. entries in this ring */
-       u32 mcc_cq_size;
-       u32 mcc_cq_tl;                  /* compl. ring tail */
-       u8 mcc_cq_created;              /* flag to help cleanup */
-       struct be_cq_object mcc_cq_obj; /* BECLIB's MCC compl. ring object */
-       u32 mcc_cq_id;                  /* MCC ring ID */
-       dma_addr_t mcc_cq_bus;          /* DMA'ble bus address */
-
-       struct ring_desc mb_rd;         /* RD for MCC_MAIL_BOX */
-       void *mb_ptr;                   /* mailbox ptr to be freed  */
-       dma_addr_t mb_bus;              /* DMA'ble bus address */
-       u32 mb_size;
-
-       /* BEClib uses an array of context objects to track outstanding
-        * requests to the MCC.  We need allocate the same number of
-        * conext entries as the number of entries in the MCC WRB ring
-        */
-       u32 mcc_wrb_ctxt_size;
-       void *mcc_wrb_ctxt;             /* pointer to the context area */
-       u32 mcc_wrb_ctxtLen;            /* Number of entries in the context */
-       /*
-        * NIC send request ring - used for xmitting raw ether frames.
-        */
-       struct ETH_WRB_AMAP *tx_q;      /* VA of the start of the ring */
-       u32 tx_q_len;                   /* # if entries in the send ring */
-       u32 tx_q_size;
-       u32 tx_q_hd;                    /* Head index. Next req. goes here */
-       u32 tx_q_tl;                    /* Tail indx. oldest outstanding req. */
-       u8 tx_q_created;                /* flag to help cleanup */
-       struct be_ethsq_object tx_q_obj;/* BECLIB's send Q handle */
-       dma_addr_t tx_q_bus;            /* DMA'ble bus address */
-       u32 tx_q_id;                    /* send queue ring ID */
-       u32 tx_q_port;                  /* 0 no binding, 1 port A,  2 port B */
-       atomic_t tx_q_used;             /* # of WRBs used */
-       /* ptr to an array in which we store context info for each send req. */
-       void **tx_ctxt;
-       /*
-        * NIC Send compl. ring - completion status for all NIC frames xmitted.
-        */
-       struct ETH_TX_COMPL_AMAP *tx_cq;/* VA of start of the ring */
-       u32 txcq_len;                   /* # of entries in the ring */
-       u32 tx_cq_size;
-       /*
-        * index into compl ring where the host expects next completion entry
-        */
-       u32 tx_cq_tl;
-       u32 tx_cq_id;                   /* completion queue id */
-       u8 tx_cq_created;               /* flag to help cleanup */
-       struct be_cq_object tx_cq_obj;
-       dma_addr_t tx_cq_bus;           /* DMA'ble bus address */
-       /*
-        * Event Queue - all completion entries post events here.
-        */
-       struct EQ_ENTRY_AMAP *event_q;  /* VA of start of event queue */
-       u32 event_q_len;                /* # of entries */
-       u32 event_q_size;
-       u32 event_q_tl;                 /* Tail of the event queue */
-       u32 event_q_id;                 /* Event queue ID */
-       u8 event_q_created;             /* flag to help cleanup */
-       struct be_eq_object event_q_obj; /* Queue handle */
-       dma_addr_t event_q_bus;         /* DMA'ble bus address */
-       /*
-        * NIC receive queue - Data buffers to be used for receiving unicast,
-        * broadcast and multi-cast frames  are posted here.
-        */
-       struct ETH_RX_D_AMAP *rx_q;     /* VA of start of the queue */
-       u32 rx_q_len;                   /* # of entries */
-       u32 rx_q_size;
-       u32 rx_q_hd;                    /* Head of the queue */
-       atomic_t rx_q_posted;           /* number of posted buffers */
-       u32 rx_q_id;                    /* queue ID */
-       u8 rx_q_created;                /* flag to help cleanup */
-       struct be_ethrq_object rx_q_obj;        /* NIC RX queue handle */
-       dma_addr_t rx_q_bus;            /* DMA'ble bus address */
-       /*
-        * Pointer to an array of opaque context object for use by OSM driver
-        */
-       void **rx_ctxt;
-       /*
-        * NIC unicast RX completion queue - all unicast ether frame completion
-        * statuses from BE come here.
-        */
-       struct ETH_RX_COMPL_AMAP *rx_cq;        /* VA of start of the queue */
-       u32 rx_cq_len;          /* # of entries */
-       u32 rx_cq_size;
-       u32 rx_cq_tl;                   /* Tail of the queue */
-       u32 rx_cq_id;                   /* queue ID */
-       u8 rx_cq_created;               /* flag to help cleanup */
-       struct be_cq_object rx_cq_obj;  /* queue handle */
-       dma_addr_t rx_cq_bus;           /* DMA'ble bus address */
-       struct be_function_object fn_obj;       /* function object   */
-       bool    fn_obj_created;
-       u32 rx_buf_size;                /* Size of the RX buffers */
-
-       struct net_device *netdev;
-       struct be_recv_buffer eth_rx_bufs[256]; /* to pass Rx buffer
-                                                          addresses */
-       struct be_adapter *adapter;     /* Pointer to OSM adapter */
-       u32 devno;              /* OSM, network dev no. */
-       u32 use_port;           /* Current active port */
-       struct be_rx_page_info *rx_page_info;   /* Array of Rx buf pages */
-       u32 rx_pg_info_hd;      /* Head of queue */
-       int rxbuf_post_fail;    /* RxBuff posting fail count */
-       bool rx_pg_shared;      /* Is an allocsted page shared as two frags ? */
-       struct vlan_group *vlan_grp;
-       u32 num_vlans;          /* Number of vlans in BE's filter */
-       u16 vlan_tag[BE_NUM_VLAN_SUPPORTED]; /* vlans currently configured */
-       struct napi_struct napi;
-       struct net_lro_mgr lro_mgr;
-       struct net_lro_desc lro_desc[BE_MAX_LRO_DESCRIPTORS];
-};
-
-#define NET_FH(np)       (&(np)->fn_obj)
-
-/*
- * BE driver statistics.
- */
-struct be_drvr_stat {
-       u32 bes_tx_reqs;        /* number of TX requests initiated */
-       u32 bes_tx_fails;       /* number of TX requests that failed */
-       u32 bes_fwd_reqs;       /* number of send reqs through forwarding i/f */
-       u32 bes_tx_wrbs;        /* number of tx WRBs used */
-
-       u32 bes_ints;           /* number of interrupts */
-       u32 bes_polls;          /* number of times NAPI called poll function */
-       u32 bes_events;         /* total evet entries processed */
-       u32 bes_tx_events;      /* number of tx completion events  */
-       u32 bes_rx_events;      /* number of ucast rx completion events  */
-       u32 bes_tx_compl;       /* number of tx completion entries processed */
-       u32 bes_rx_compl;       /* number of rx completion entries
-                                  processed */
-       u32 bes_ethrx_post_fail;        /* number of ethrx buffer alloc
-                                          failures */
-       /*
-        * number of non ether type II frames dropped where
-        * frame len > length field of Mac Hdr
-        */
-       u32 bes_802_3_dropped_frames;
-       /*
-        * number of non ether type II frames malformed where
-        * in frame len < length field of Mac Hdr
-        */
-       u32 bes_802_3_malformed_frames;
-       u32 bes_ips;            /*  interrupts / sec */
-       u32 bes_prev_ints;      /* bes_ints at last IPS calculation  */
-       u16 bes_eth_tx_rate;    /*  ETH TX rate - Mb/sec */
-       u16 bes_eth_rx_rate;    /*  ETH RX rate - Mb/sec */
-       u32 bes_rx_coal;        /* Num pkts coalasced */
-       u32 bes_rx_flush;       /* Num times coalasced */
-       u32 bes_link_change_physical;   /*Num of times physical link changed */
-       u32 bes_link_change_virtual;    /*Num of times virtual link changed */
-       u32 bes_rx_misc_pkts;   /* Misc pkts received */
-};
-
-/* Maximum interrupt delay (in microseconds) allowed */
-#define MAX_EQD                                120
-
-/*
- * timer to prevent system shutdown hang for ever if h/w stops responding
- */
-struct be_timer_ctxt {
-       atomic_t get_stat_flag;
-       struct timer_list get_stats_timer;
-       unsigned long get_stat_sem_addr;
-} ;
-
-/* This structure is the main BladeEngine driver context.  */
-struct be_adapter {
-       struct net_device *netdevp;
-       struct be_drvr_stat be_stat;
-       struct net_device_stats benet_stats;
-
-       /* PCI BAR mapped addresses */
-       u8 __iomem *csr_va;     /* CSR */
-       u8 __iomem *db_va;      /* Door  Bell  */
-       u8 __iomem *pci_va;     /* PCI Config */
-
-       struct tasklet_struct sts_handler;
-       struct timer_list cq_timer;
-       spinlock_t int_lock;    /* to protect the isr field in adapter */
-
-       struct FWCMD_ETH_GET_STATISTICS *eth_statsp;
-       /*
-        * This will enable the use of ethtool to enable or disable
-        * Checksum on Rx pkts to be obeyed or disobeyed.
-        * If this is true = 1, then whatever is the checksum on the
-        * Received pkt as per BE, it will be given to the stack.
-        * Else the stack will re calculate it.
-        */
-       bool rx_csum;
-       /*
-        * This will enable the use of ethtool to enable or disable
-        * Coalese on Rx pkts to be obeyed or disobeyed.
-        * If this is grater than 0 and less than 16 then coalascing
-        * is enabled else it is disabled
-        */
-       u32 max_rx_coal;
-       struct pci_dev *pdev;   /* Pointer to OS's PCI dvice */
-
-       spinlock_t txq_lock;    /* to stop/wake queue based on tx_q_used */
-
-       u32 isr;                /* copy of Intr status reg. */
-
-       u32 port0_link_sts;     /* Port 0 link status */
-       u32 port1_link_sts;     /* port 1 list status */
-       struct BE_LINK_STATUS *be_link_sts;
-
-       /* pointer to the first netobject of this adapter */
-       struct be_net_object *net_obj;
-
-       /*  Flags to indicate what to clean up */
-       bool tasklet_started;
-       bool isr_registered;
-       /*
-        * adaptive interrupt coalescing (AIC) related
-        */
-       bool enable_aic;        /* 1 if AIC is enabled */
-       u16 min_eqd;            /* minimum EQ delay in usec */
-       u16 max_eqd;            /* minimum EQ delay in usec */
-       u16 cur_eqd;            /* current EQ delay in usec */
-       /*
-        * book keeping for interrupt / sec and TX/RX rate calculation
-        */
-       ulong ips_jiffies;      /* jiffies at last IPS calc */
-       u32 eth_tx_bytes;
-       ulong eth_tx_jiffies;
-       u32 eth_rx_bytes;
-       ulong eth_rx_jiffies;
-
-       struct semaphore get_eth_stat_sem;
-
-       /* timer ctxt to prevent shutdown hanging due to un-responsive BE */
-       struct be_timer_ctxt timer_ctxt;
-
-#define BE_MAX_MSIX_VECTORS             32
-#define BE_MAX_REQ_MSIX_VECTORS         1 /* only one EQ in Linux driver */
-       struct msix_entry msix_entries[BE_MAX_MSIX_VECTORS];
-       bool msix_enabled;
-       bool dma_64bit_cap;     /* the Device DAC capable  or not */
-       u8 dev_state;   /* The current state of the device */
-       u8 dev_pm_state; /* The State of device before going to suspend */
-};
-
-/*
- * Every second we look at the ints/sec and adjust eq_delay
- * between adapter->min_eqd and adapter->max_eqd to keep the ints/sec between
- * IPS_HI_WM and IPS_LO_WM.
- */
-#define IPS_HI_WM      18000
-#define IPS_LO_WM      8000
-
-
-static inline void index_adv(u32 *index, u32 val,  u32 limit)
-{
-       BUG_ON(limit & (limit-1));
-       *index = (*index + val) & (limit - 1);
-}
-
-static inline void index_inc(u32 *index, u32 limit)
-{
-       BUG_ON(limit & (limit-1));
-       *index = (*index + 1) & (limit - 1);
-}
-
-static inline void be_adv_eq_tl(struct be_net_object *pnob)
-{
-       index_inc(&pnob->event_q_tl, pnob->event_q_len);
-}
-
-static inline void be_adv_txq_hd(struct be_net_object *pnob)
-{
-       index_inc(&pnob->tx_q_hd, pnob->tx_q_len);
-}
-
-static inline void be_adv_txq_tl(struct be_net_object *pnob)
-{
-       index_inc(&pnob->tx_q_tl, pnob->tx_q_len);
-}
-
-static inline void be_adv_txcq_tl(struct be_net_object *pnob)
-{
-       index_inc(&pnob->tx_cq_tl, pnob->txcq_len);
-}
-
-static inline void be_adv_rxq_hd(struct be_net_object *pnob)
-{
-       index_inc(&pnob->rx_q_hd, pnob->rx_q_len);
-}
-
-static inline void be_adv_rxcq_tl(struct be_net_object *pnob)
-{
-       index_inc(&pnob->rx_cq_tl, pnob->rx_cq_len);
-}
-
-static inline u32 tx_compl_lastwrb_idx_get(struct be_net_object *pnob)
-{
-       return (pnob->tx_q_tl + *(u32 *)&pnob->tx_ctxt[pnob->tx_q_tl] - 1)
-                   & (pnob->tx_q_len - 1);
-}
-
-int benet_init(struct net_device *);
-int be_ethtool_ioctl(struct net_device *, struct ifreq *);
-struct net_device_stats *benet_get_stats(struct net_device *);
-void be_process_intr(unsigned long context);
-irqreturn_t be_int(int irq, void *dev);
-void be_post_eth_rx_buffs(struct be_net_object *);
-void be_get_stat_cb(void *, int, struct MCC_WRB_AMAP *);
-void be_get_stats_timer_handler(unsigned long);
-void be_wait_nic_tx_cmplx_cmpl(struct be_net_object *);
-void be_print_link_info(struct BE_LINK_STATUS *);
-void be_update_link_status(struct be_adapter *);
-void be_init_procfs(struct be_adapter *);
-void be_cleanup_procfs(struct be_adapter *);
-int be_poll(struct napi_struct *, int);
-struct ETH_RX_COMPL_AMAP *be_get_rx_cmpl(struct be_net_object *);
-void be_notify_cmpl(struct be_net_object *, int, int, int);
-void be_enable_intr(struct be_net_object *);
-void be_enable_eq_intr(struct be_net_object *);
-void be_disable_intr(struct be_net_object *);
-void be_disable_eq_intr(struct be_net_object *);
-int be_set_uc_mac_adr(struct be_net_object *, u8, u8, u8,
-                   u8 *, mcc_wrb_cqe_callback, void *);
-int be_get_flow_ctl(struct be_function_object *pFnObj, bool *, bool *);
-void process_one_tx_compl(struct be_net_object *pnob, u32 end_idx);
-
-#endif /* _BENET_H_ */
diff --git a/drivers/staging/benet/bestatus.h b/drivers/staging/benet/bestatus.h
deleted file mode 100644 (file)
index 59c7a4b..0000000
+++ /dev/null
@@ -1,103 +0,0 @@
-/*
- * Copyright (C) 2005 - 2008 ServerEngines
- * All rights reserved.
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License version 2
- * as published by the Free Software Foundation.  The full GNU General
- * Public License is included in this distribution in the file called COPYING.
- *
- * Contact Information:
- * linux-drivers@serverengines.com
- *
- * ServerEngines
- * 209 N. Fair Oaks Ave
- * Sunnyvale, CA 94085
- */
-#ifndef _BESTATUS_H_
-#define _BESTATUS_H_
-
-#define BE_SUCCESS                      (0x00000000L)
-/*
- * MessageId: BE_PENDING
- *  The BladeEngine Driver call succeeded, and pended operation.
- */
-#define BE_PENDING                       (0x20070001L)
-#define BE_STATUS_PENDING                (BE_PENDING)
-/*
- * MessageId: BE_NOT_OK
- *  An error occurred.
- */
-#define BE_NOT_OK                        (0xE0070002L)
-/*
- * MessageId: BE_STATUS_SYSTEM_RESOURCES
- *  Insufficient host system resources exist to complete the API.
- */
-#define BE_STATUS_SYSTEM_RESOURCES       (0xE0070003L)
-/*
- * MessageId: BE_STATUS_CHIP_RESOURCES
- *  Insufficient chip resources exist to complete the API.
- */
-#define BE_STATUS_CHIP_RESOURCES         (0xE0070004L)
-/*
- * MessageId: BE_STATUS_NO_RESOURCE
- *  Insufficient resources to complete request.
- */
-#define BE_STATUS_NO_RESOURCE            (0xE0070005L)
-/*
- * MessageId: BE_STATUS_BUSY
- *  Resource is currently busy.
- */
-#define BE_STATUS_BUSY                   (0xE0070006L)
-/*
- * MessageId: BE_STATUS_INVALID_PARAMETER
- *  Invalid Parameter in request.
- */
-#define BE_STATUS_INVALID_PARAMETER      (0xE0000007L)
-/*
- * MessageId: BE_STATUS_NOT_SUPPORTED
- *  Requested operation is not supported.
- */
-#define BE_STATUS_NOT_SUPPORTED          (0xE000000DL)
-
-/*
- * ***************************************************************************
- *                     E T H E R N E T   S T A T U S
- * ***************************************************************************
- */
-
-/*
- * MessageId: BE_ETH_TX_ERROR
- *  The Ethernet device driver failed to transmit a packet.
- */
-#define BE_ETH_TX_ERROR                  (0xE0070101L)
-
-/*
- * ***************************************************************************
- *                     S H A R E D   S T A T U S
- * ***************************************************************************
- */
-
-/*
- * MessageId: BE_STATUS_VBD_INVALID_VERSION
- *  The device driver is not compatible with this version of the VBD.
- */
-#define BE_STATUS_INVALID_VERSION    (0xE0070402L)
-/*
- * MessageId: BE_STATUS_DOMAIN_DENIED
- *  The operation failed to complete due to insufficient access
- *  rights for the requesting domain.
- */
-#define BE_STATUS_DOMAIN_DENIED          (0xE0070403L)
-/*
- * MessageId: BE_STATUS_TCP_NOT_STARTED
- *  The embedded TCP/IP stack has not been started.
- */
-#define BE_STATUS_TCP_NOT_STARTED        (0xE0070409L)
-/*
- * MessageId: BE_STATUS_NO_MCC_WRB
- *  No free MCC WRB are available for posting the request.
- */
-#define BE_STATUS_NO_MCC_WRB                 (0xE0070414L)
-
-#endif /* _BESTATUS_ */
diff --git a/drivers/staging/benet/cev.h b/drivers/staging/benet/cev.h
deleted file mode 100644 (file)
index 3099692..0000000
+++ /dev/null
@@ -1,243 +0,0 @@
-/*
- * Copyright (C) 2005 - 2008 ServerEngines
- * All rights reserved.
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License version 2
- * as published by the Free Software Foundation.  The full GNU General
- * Public License is included in this distribution in the file called COPYING.
- *
- * Contact Information:
- * linux-drivers@serverengines.com
- *
- * ServerEngines
- * 209 N. Fair Oaks Ave
- * Sunnyvale, CA 94085
- */
-/*
- * Autogenerated by srcgen version: 0127
- */
-#ifndef __cev_amap_h__
-#define __cev_amap_h__
-#include "ep.h"
-
-/*
- * Host Interrupt Status Register 0. The first of four application
- * interrupt status registers. This register contains the interrupts
- * for Event Queues EQ0 through EQ31.
- */
-struct BE_CEV_ISR0_CSR_AMAP {
-       u8 interrupt0;  /* DWORD 0 */
-       u8 interrupt1;  /* DWORD 0 */
-       u8 interrupt2;  /* DWORD 0 */
-       u8 interrupt3;  /* DWORD 0 */
-       u8 interrupt4;  /* DWORD 0 */
-       u8 interrupt5;  /* DWORD 0 */
-       u8 interrupt6;  /* DWORD 0 */
-       u8 interrupt7;  /* DWORD 0 */
-       u8 interrupt8;  /* DWORD 0 */
-       u8 interrupt9;  /* DWORD 0 */
-       u8 interrupt10; /* DWORD 0 */
-       u8 interrupt11; /* DWORD 0 */
-       u8 interrupt12; /* DWORD 0 */
-       u8 interrupt13; /* DWORD 0 */
-       u8 interrupt14; /* DWORD 0 */
-       u8 interrupt15; /* DWORD 0 */
-       u8 interrupt16; /* DWORD 0 */
-       u8 interrupt17; /* DWORD 0 */
-       u8 interrupt18; /* DWORD 0 */
-       u8 interrupt19; /* DWORD 0 */
-       u8 interrupt20; /* DWORD 0 */
-       u8 interrupt21; /* DWORD 0 */
-       u8 interrupt22; /* DWORD 0 */
-       u8 interrupt23; /* DWORD 0 */
-       u8 interrupt24; /* DWORD 0 */
-       u8 interrupt25; /* DWORD 0 */
-       u8 interrupt26; /* DWORD 0 */
-       u8 interrupt27; /* DWORD 0 */
-       u8 interrupt28; /* DWORD 0 */
-       u8 interrupt29; /* DWORD 0 */
-       u8 interrupt30; /* DWORD 0 */
-       u8 interrupt31; /* DWORD 0 */
-} __packed;
-struct CEV_ISR0_CSR_AMAP {
-       u32 dw[1];
-};
-
-/*
- * Host Interrupt Status Register 1. The second of four application
- * interrupt status registers. This register contains the interrupts
- * for Event Queues EQ32 through EQ63.
- */
-struct BE_CEV_ISR1_CSR_AMAP {
-       u8 interrupt32; /* DWORD 0 */
-       u8 interrupt33; /* DWORD 0 */
-       u8 interrupt34; /* DWORD 0 */
-       u8 interrupt35; /* DWORD 0 */
-       u8 interrupt36; /* DWORD 0 */
-       u8 interrupt37; /* DWORD 0 */
-       u8 interrupt38; /* DWORD 0 */
-       u8 interrupt39; /* DWORD 0 */
-       u8 interrupt40; /* DWORD 0 */
-       u8 interrupt41; /* DWORD 0 */
-       u8 interrupt42; /* DWORD 0 */
-       u8 interrupt43; /* DWORD 0 */
-       u8 interrupt44; /* DWORD 0 */
-       u8 interrupt45; /* DWORD 0 */
-       u8 interrupt46; /* DWORD 0 */
-       u8 interrupt47; /* DWORD 0 */
-       u8 interrupt48; /* DWORD 0 */
-       u8 interrupt49; /* DWORD 0 */
-       u8 interrupt50; /* DWORD 0 */
-       u8 interrupt51; /* DWORD 0 */
-       u8 interrupt52; /* DWORD 0 */
-       u8 interrupt53; /* DWORD 0 */
-       u8 interrupt54; /* DWORD 0 */
-       u8 interrupt55; /* DWORD 0 */
-       u8 interrupt56; /* DWORD 0 */
-       u8 interrupt57; /* DWORD 0 */
-       u8 interrupt58; /* DWORD 0 */
-       u8 interrupt59; /* DWORD 0 */
-       u8 interrupt60; /* DWORD 0 */
-       u8 interrupt61; /* DWORD 0 */
-       u8 interrupt62; /* DWORD 0 */
-       u8 interrupt63; /* DWORD 0 */
-} __packed;
-struct CEV_ISR1_CSR_AMAP {
-       u32 dw[1];
-};
-/*
- * Host Interrupt Status Register 2. The third of four application
- * interrupt status registers. This register contains the interrupts
- * for Event Queues EQ64 through EQ95.
- */
-struct BE_CEV_ISR2_CSR_AMAP {
-       u8 interrupt64; /* DWORD 0 */
-       u8 interrupt65; /* DWORD 0 */
-       u8 interrupt66; /* DWORD 0 */
-       u8 interrupt67; /* DWORD 0 */
-       u8 interrupt68; /* DWORD 0 */
-       u8 interrupt69; /* DWORD 0 */
-       u8 interrupt70; /* DWORD 0 */
-       u8 interrupt71; /* DWORD 0 */
-       u8 interrupt72; /* DWORD 0 */
-       u8 interrupt73; /* DWORD 0 */
-       u8 interrupt74; /* DWORD 0 */
-       u8 interrupt75; /* DWORD 0 */
-       u8 interrupt76; /* DWORD 0 */
-       u8 interrupt77; /* DWORD 0 */
-       u8 interrupt78; /* DWORD 0 */
-       u8 interrupt79; /* DWORD 0 */
-       u8 interrupt80; /* DWORD 0 */
-       u8 interrupt81; /* DWORD 0 */
-       u8 interrupt82; /* DWORD 0 */
-       u8 interrupt83; /* DWORD 0 */
-       u8 interrupt84; /* DWORD 0 */
-       u8 interrupt85; /* DWORD 0 */
-       u8 interrupt86; /* DWORD 0 */
-       u8 interrupt87; /* DWORD 0 */
-       u8 interrupt88; /* DWORD 0 */
-       u8 interrupt89; /* DWORD 0 */
-       u8 interrupt90; /* DWORD 0 */
-       u8 interrupt91; /* DWORD 0 */
-       u8 interrupt92; /* DWORD 0 */
-       u8 interrupt93; /* DWORD 0 */
-       u8 interrupt94; /* DWORD 0 */
-       u8 interrupt95; /* DWORD 0 */
-} __packed;
-struct CEV_ISR2_CSR_AMAP {
-       u32 dw[1];
-};
-
-/*
- * Host Interrupt Status Register 3. The fourth of four application
- * interrupt status registers. This register contains the interrupts
- * for Event Queues EQ96 through EQ127.
- */
-struct BE_CEV_ISR3_CSR_AMAP {
-       u8 interrupt96; /* DWORD 0 */
-       u8 interrupt97; /* DWORD 0 */
-       u8 interrupt98; /* DWORD 0 */
-       u8 interrupt99; /* DWORD 0 */
-       u8 interrupt100;        /* DWORD 0 */
-       u8 interrupt101;        /* DWORD 0 */
-       u8 interrupt102;        /* DWORD 0 */
-       u8 interrupt103;        /* DWORD 0 */
-       u8 interrupt104;        /* DWORD 0 */
-       u8 interrupt105;        /* DWORD 0 */
-       u8 interrupt106;        /* DWORD 0 */
-       u8 interrupt107;        /* DWORD 0 */
-       u8 interrupt108;        /* DWORD 0 */
-       u8 interrupt109;        /* DWORD 0 */
-       u8 interrupt110;        /* DWORD 0 */
-       u8 interrupt111;        /* DWORD 0 */
-       u8 interrupt112;        /* DWORD 0 */
-       u8 interrupt113;        /* DWORD 0 */
-       u8 interrupt114;        /* DWORD 0 */
-       u8 interrupt115;        /* DWORD 0 */
-       u8 interrupt116;        /* DWORD 0 */
-       u8 interrupt117;        /* DWORD 0 */
-       u8 interrupt118;        /* DWORD 0 */
-       u8 interrupt119;        /* DWORD 0 */
-       u8 interrupt120;        /* DWORD 0 */
-       u8 interrupt121;        /* DWORD 0 */
-       u8 interrupt122;        /* DWORD 0 */
-       u8 interrupt123;        /* DWORD 0 */
-       u8 interrupt124;        /* DWORD 0 */
-       u8 interrupt125;        /* DWORD 0 */
-       u8 interrupt126;        /* DWORD 0 */
-       u8 interrupt127;        /* DWORD 0 */
-} __packed;
-struct CEV_ISR3_CSR_AMAP {
-       u32 dw[1];
-};
-
-/*  Completions and Events block Registers.  */
-struct BE_CEV_CSRMAP_AMAP {
-       u8 rsvd0[32];   /* DWORD 0 */
-       u8 rsvd1[32];   /* DWORD 1 */
-       u8 rsvd2[32];   /* DWORD 2 */
-       u8 rsvd3[32];   /* DWORD 3 */
-       struct BE_CEV_ISR0_CSR_AMAP isr0;
-       struct BE_CEV_ISR1_CSR_AMAP isr1;
-       struct BE_CEV_ISR2_CSR_AMAP isr2;
-       struct BE_CEV_ISR3_CSR_AMAP isr3;
-       u8 rsvd4[32];   /* DWORD 8 */
-       u8 rsvd5[32];   /* DWORD 9 */
-       u8 rsvd6[32];   /* DWORD 10 */
-       u8 rsvd7[32];   /* DWORD 11 */
-       u8 rsvd8[32];   /* DWORD 12 */
-       u8 rsvd9[32];   /* DWORD 13 */
-       u8 rsvd10[32];  /* DWORD 14 */
-       u8 rsvd11[32];  /* DWORD 15 */
-       u8 rsvd12[32];  /* DWORD 16 */
-       u8 rsvd13[32];  /* DWORD 17 */
-       u8 rsvd14[32];  /* DWORD 18 */
-       u8 rsvd15[32];  /* DWORD 19 */
-       u8 rsvd16[32];  /* DWORD 20 */
-       u8 rsvd17[32];  /* DWORD 21 */
-       u8 rsvd18[32];  /* DWORD 22 */
-       u8 rsvd19[32];  /* DWORD 23 */
-       u8 rsvd20[32];  /* DWORD 24 */
-       u8 rsvd21[32];  /* DWORD 25 */
-       u8 rsvd22[32];  /* DWORD 26 */
-       u8 rsvd23[32];  /* DWORD 27 */
-       u8 rsvd24[32];  /* DWORD 28 */
-       u8 rsvd25[32];  /* DWORD 29 */
-       u8 rsvd26[32];  /* DWORD 30 */
-       u8 rsvd27[32];  /* DWORD 31 */
-       u8 rsvd28[32];  /* DWORD 32 */
-       u8 rsvd29[32];  /* DWORD 33 */
-       u8 rsvd30[192]; /* DWORD 34 */
-       u8 rsvd31[192]; /* DWORD 40 */
-       u8 rsvd32[160]; /* DWORD 46 */
-       u8 rsvd33[160]; /* DWORD 51 */
-       u8 rsvd34[160]; /* DWORD 56 */
-       u8 rsvd35[96];  /* DWORD 61 */
-       u8 rsvd36[192][32];     /* DWORD 64 */
-} __packed;
-struct CEV_CSRMAP_AMAP {
-       u32 dw[256];
-};
-
-#endif /* __cev_amap_h__ */
diff --git a/drivers/staging/benet/cq.c b/drivers/staging/benet/cq.c
deleted file mode 100644 (file)
index 6504586..0000000
+++ /dev/null
@@ -1,211 +0,0 @@
-/*
- * Copyright (C) 2005 - 2008 ServerEngines
- * All rights reserved.
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License version 2
- * as published by the Free Software Foundation.  The full GNU General
- * Public License is included in this distribution in the file called COPYING.
- *
- * Contact Information:
- * linux-drivers@serverengines.com
- *
- * ServerEngines
- * 209 N. Fair Oaks Ave
- * Sunnyvale, CA 94085
- */
-#include "hwlib.h"
-#include "bestatus.h"
-
-/*
- * Completion Queue Objects
- */
-/*
- *============================================================================
- *                  P U B L I C  R O U T I N E S
- *============================================================================
- */
-
-/*
-    This routine creates a completion queue based on the client completion
-    queue configuration information.
-
-
-    FunctionObject      - Handle to a function object
-    CqBaseVa            - Base VA for a the CQ ring
-    NumEntries          - CEV_CQ_CNT_* values
-    solEventEnable      - 0 = All CQEs can generate Events if CQ is eventable
-                       1 = only CQEs with solicited bit set are eventable
-    eventable           - Eventable CQ, generates interrupts.
-    nodelay             - 1 = Force interrupt, relevent if CQ eventable.
-                       Interrupt is asserted immediately after EQE
-                       write is confirmed, regardless of EQ Timer
-                       or watermark settings.
-    wme                 - Enable watermark based coalescing
-    wmThresh            - High watermark(CQ fullness at which event
-                       or interrupt should be asserted).  These are the
-                       CEV_WATERMARK encoded values.
-    EqObject            - EQ Handle to assign to this CQ
-    ppCqObject          - Internal CQ Handle returned.
-
-    Returns BE_SUCCESS if successfull, otherwise a useful error code is
-       returned.
-
-    IRQL < DISPATCH_LEVEL
-
-*/
-int be_cq_create(struct be_function_object *pfob,
-       struct ring_desc *rd, u32 length, bool solicited_eventable,
-       bool no_delay, u32 wm_thresh,
-       struct be_eq_object *eq_object, struct be_cq_object *cq_object)
-{
-       int status = BE_SUCCESS;
-       u32 num_entries_encoding;
-       u32 num_entries = length / sizeof(struct MCC_CQ_ENTRY_AMAP);
-       struct FWCMD_COMMON_CQ_CREATE *fwcmd = NULL;
-       struct MCC_WRB_AMAP *wrb = NULL;
-       u32 n;
-       unsigned long irql;
-
-       ASSERT(rd);
-       ASSERT(cq_object);
-       ASSERT(length % sizeof(struct MCC_CQ_ENTRY_AMAP) == 0);
-
-       switch (num_entries) {
-       case 256:
-               num_entries_encoding = CEV_CQ_CNT_256;
-               break;
-       case 512:
-               num_entries_encoding = CEV_CQ_CNT_512;
-               break;
-       case 1024:
-               num_entries_encoding = CEV_CQ_CNT_1024;
-               break;
-       default:
-               ASSERT(0);
-               return BE_STATUS_INVALID_PARAMETER;
-       }
-
-       /*
-        * All cq entries all the same size.  Use iSCSI version
-        * as a test for the proper rd length.
-        */
-       memset(cq_object, 0, sizeof(*cq_object));
-
-       atomic_set(&cq_object->ref_count, 0);
-       cq_object->parent_function = pfob;
-       cq_object->eq_object = eq_object;
-       cq_object->num_entries = num_entries;
-       /* save for MCC cq processing */
-       cq_object->va = rd->va;
-
-       /* map into UT. */
-       length = num_entries * sizeof(struct MCC_CQ_ENTRY_AMAP);
-
-       spin_lock_irqsave(&pfob->post_lock, irql);
-
-       wrb = be_function_peek_mcc_wrb(pfob);
-       if (!wrb) {
-               ASSERT(wrb);
-               TRACE(DL_ERR, "No free MCC WRBs in create EQ.");
-               status = BE_STATUS_NO_MCC_WRB;
-               goto Error;
-       }
-       /* Prepares an embedded fwcmd, including request/response sizes. */
-       fwcmd = BE_PREPARE_EMBEDDED_FWCMD(pfob, wrb, COMMON_CQ_CREATE);
-
-       fwcmd->params.request.num_pages = PAGES_SPANNED(OFFSET_IN_PAGE(rd->va),
-                                                                       length);
-
-       AMAP_SET_BITS_PTR(CQ_CONTEXT, valid, &fwcmd->params.request.context, 1);
-       n = pfob->pci_function_number;
-       AMAP_SET_BITS_PTR(CQ_CONTEXT, Func, &fwcmd->params.request.context, n);
-
-       n = (eq_object != NULL);
-       AMAP_SET_BITS_PTR(CQ_CONTEXT, Eventable,
-                               &fwcmd->params.request.context, n);
-       AMAP_SET_BITS_PTR(CQ_CONTEXT, Armed, &fwcmd->params.request.context, 1);
-
-       n = eq_object ? eq_object->eq_id : 0;
-       AMAP_SET_BITS_PTR(CQ_CONTEXT, EQID, &fwcmd->params.request.context, n);
-       AMAP_SET_BITS_PTR(CQ_CONTEXT, Count,
-                       &fwcmd->params.request.context, num_entries_encoding);
-
-       n = 0; /* Protection Domain is always 0 in  Linux  driver */
-       AMAP_SET_BITS_PTR(CQ_CONTEXT, PD, &fwcmd->params.request.context, n);
-       AMAP_SET_BITS_PTR(CQ_CONTEXT, NoDelay,
-                               &fwcmd->params.request.context, no_delay);
-       AMAP_SET_BITS_PTR(CQ_CONTEXT, SolEvent,
-                       &fwcmd->params.request.context, solicited_eventable);
-
-       n = (wm_thresh != 0xFFFFFFFF);
-       AMAP_SET_BITS_PTR(CQ_CONTEXT, WME, &fwcmd->params.request.context, n);
-
-       n = (n ? wm_thresh : 0);
-       AMAP_SET_BITS_PTR(CQ_CONTEXT, Watermark,
-                               &fwcmd->params.request.context, n);
-       /* Create a page list for the FWCMD. */
-       be_rd_to_pa_list(rd, fwcmd->params.request.pages,
-                         ARRAY_SIZE(fwcmd->params.request.pages));
-
-       /* Post the f/w command */
-       status = be_function_post_mcc_wrb(pfob, wrb, NULL, NULL, NULL,
-                       NULL, NULL, fwcmd, NULL);
-       if (status != BE_SUCCESS) {
-               TRACE(DL_ERR, "MCC to create CQ failed.");
-               goto Error;
-       }
-       /* Remember the CQ id. */
-       cq_object->cq_id = fwcmd->params.response.cq_id;
-
-       /* insert this cq into eq_object reference */
-       if (eq_object) {
-               atomic_inc(&eq_object->ref_count);
-               list_add_tail(&cq_object->cqlist_for_eq,
-                                       &eq_object->cq_list_head);
-       }
-
-Error:
-       spin_unlock_irqrestore(&pfob->post_lock, irql);
-
-       if (pfob->pend_queue_driving && pfob->mcc) {
-               pfob->pend_queue_driving = 0;
-               be_drive_mcc_wrb_queue(pfob->mcc);
-       }
-       return status;
-}
-
-/*
-
-    Deferences the given object. Once the object's reference count drops to
-    zero, the object is destroyed and all resources that are held by this object
-    are released.  The on-chip context is also destroyed along with the queue
-    ID, and any mappings made into the UT.
-
-    cq_object            - CQ handle returned from cq_object_create.
-
-    returns the current reference count on the object
-
-    IRQL: IRQL < DISPATCH_LEVEL
-*/
-int be_cq_destroy(struct be_cq_object *cq_object)
-{
-       int status = 0;
-
-       /* Nothing should reference this CQ at this point. */
-       ASSERT(atomic_read(&cq_object->ref_count) == 0);
-
-       /* Send fwcmd to destroy the CQ. */
-       status = be_function_ring_destroy(cq_object->parent_function,
-                    cq_object->cq_id, FWCMD_RING_TYPE_CQ,
-                                       NULL, NULL, NULL, NULL);
-       ASSERT(status == 0);
-
-       /* Remove reference if this is an eventable CQ. */
-       if (cq_object->eq_object) {
-               atomic_dec(&cq_object->eq_object->ref_count);
-               list_del(&cq_object->cqlist_for_eq);
-       }
-       return BE_SUCCESS;
-}
-
diff --git a/drivers/staging/benet/descriptors.h b/drivers/staging/benet/descriptors.h
deleted file mode 100644 (file)
index 8da438c..0000000
+++ /dev/null
@@ -1,71 +0,0 @@
-/*
- * Copyright (C) 2005 - 2008 ServerEngines
- * All rights reserved.
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License version 2
- * as published by the Free Software Foundation.  The full GNU General
- * Public License is included in this distribution in the file called COPYING.
- *
- * Contact Information:
- * linux-drivers@serverengines.com
- *
- * ServerEngines
- * 209 N. Fair Oaks Ave
- * Sunnyvale, CA 94085
- */
-/*
- * Autogenerated by srcgen version: 0127
- */
-#ifndef __descriptors_amap_h__
-#define __descriptors_amap_h__
-
-/*
- * --- IPC_NODE_ID_ENUM ---
- * IPC processor id values
- */
-#define TPOST_NODE_ID                   (0)    /* TPOST ID */
-#define TPRE_NODE_ID                    (1)    /* TPRE ID */
-#define TXULP0_NODE_ID                  (2)    /* TXULP0 ID */
-#define TXULP1_NODE_ID                  (3)    /* TXULP1 ID */
-#define TXULP2_NODE_ID                  (4)    /* TXULP2 ID */
-#define RXULP0_NODE_ID                  (5)    /* RXULP0 ID */
-#define RXULP1_NODE_ID                  (6)    /* RXULP1 ID */
-#define RXULP2_NODE_ID                  (7)    /* RXULP2 ID */
-#define MPU_NODE_ID                     (15)   /* MPU ID */
-
-/*
- * --- MAC_ID_ENUM ---
- * Meaning of the mac_id field in rxpp_eth_d
- */
-#define PORT0_HOST_MAC0    (0)  /* PD 0, Port 0, host networking, MAC 0. */
-#define PORT0_HOST_MAC1    (1) /* PD 0, Port 0, host networking, MAC 1. */
-#define PORT0_STORAGE_MAC0 (2) /* PD 0, Port 0, host storage, MAC 0. */
-#define PORT0_STORAGE_MAC1 (3) /* PD 0, Port 0, host storage, MAC 1. */
-#define PORT1_HOST_MAC0    (4) /* PD 0, Port 1 host networking, MAC 0. */
-#define PORT1_HOST_MAC1    (5) /* PD 0, Port 1 host networking, MAC 1. */
-#define PORT1_STORAGE_MAC0 (6) /* PD 0, Port 1 host storage, MAC 0. */
-#define PORT1_STORAGE_MAC1 (7) /* PD 0, Port 1 host storage, MAC 1. */
-#define FIRST_VM_MAC       (8) /* PD 1 MAC. Protection domains have IDs */
-                               /* from 0x8-0x26, one per PD. */
-#define LAST_VM_MAC        (38)        /* PD 31 MAC. */
-#define MGMT_MAC           (39)        /* Management port MAC. */
-#define MARBLE_MAC0        (59)        /* Used for flushing function 0 receive */
-                                 /*
-                                  * queues before re-using a torn-down
-                                  * receive ring. the DA =
-                                  * 00-00-00-00-00-00, and the MSB of the
-                                  * SA = 00
-                                  */
-#define MARBLE_MAC1        (60)        /* Used for flushing function 1 receive */
-                                 /*
-                                  * queues before re-using a torn-down
-                                  * receive ring. the DA =
-                                  * 00-00-00-00-00-00, and the MSB of the
-                                  * SA != 00
-                                  */
-#define NULL_MAC           (61)        /* Promiscuous mode, indicates no match */
-#define MCAST_MAC          (62)        /* Multicast match. */
-#define BCAST_MATCH        (63)        /* Broadcast match. */
-
-#endif /* __descriptors_amap_h__ */
diff --git a/drivers/staging/benet/doorbells.h b/drivers/staging/benet/doorbells.h
deleted file mode 100644 (file)
index 550cc4d..0000000
+++ /dev/null
@@ -1,179 +0,0 @@
-/*
- * Copyright (C) 2005 - 2008 ServerEngines
- * All rights reserved.
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License version 2
- * as published by the Free Software Foundation.  The full GNU General
- * Public License is included in this distribution in the file called COPYING.
- *
- * Contact Information:
- * linux-drivers@serverengines.com
- *
- * ServerEngines
- * 209 N. Fair Oaks Ave
- * Sunnyvale, CA 94085
- */
-/*
- * Autogenerated by srcgen version: 0127
- */
-#ifndef __doorbells_amap_h__
-#define __doorbells_amap_h__
-
-/* The TX/RDMA send queue doorbell. */
-struct BE_SQ_DB_AMAP {
-       u8 cid[11];             /* DWORD 0 */
-       u8 rsvd0[5];    /* DWORD 0 */
-       u8 numPosted[14];       /* DWORD 0 */
-       u8 rsvd1[2];    /* DWORD 0 */
-} __packed;
-struct SQ_DB_AMAP {
-       u32 dw[1];
-};
-
-/* The receive queue doorbell. */
-struct BE_RQ_DB_AMAP {
-       u8 rq[10];              /* DWORD 0 */
-       u8 rsvd0[13];   /* DWORD 0 */
-       u8 Invalidate;  /* DWORD 0 */
-       u8 numPosted[8];        /* DWORD 0 */
-} __packed;
-struct RQ_DB_AMAP {
-       u32 dw[1];
-};
-
-/*
- * The CQ/EQ doorbell. Software MUST set reserved fields in this
- * descriptor to zero, otherwise (CEV) hardware will not execute the
- * doorbell (flagging a bad_db_qid error instead).
- */
-struct BE_CQ_DB_AMAP {
-       u8 qid[10];             /* DWORD 0 */
-       u8 rsvd0[4];    /* DWORD 0 */
-       u8 rearm;               /* DWORD 0 */
-       u8 event;               /* DWORD 0 */
-       u8 num_popped[13];      /* DWORD 0 */
-       u8 rsvd1[3];    /* DWORD 0 */
-} __packed;
-struct CQ_DB_AMAP {
-       u32 dw[1];
-};
-
-struct BE_TPM_RQ_DB_AMAP {
-       u8 qid[10];             /* DWORD 0 */
-       u8 rsvd0[6];    /* DWORD 0 */
-       u8 numPosted[11];       /* DWORD 0 */
-       u8 mss_cnt[5];  /* DWORD 0 */
-} __packed;
-struct TPM_RQ_DB_AMAP {
-       u32 dw[1];
-};
-
-/*
- * Post WRB Queue Doorbell Register used by the host Storage stack
- * to notify the controller of a posted Work Request Block
- */
-struct BE_WRB_POST_DB_AMAP {
-       u8 wrb_cid[10]; /* DWORD 0 */
-       u8 rsvd0[6];    /* DWORD 0 */
-       u8 wrb_index[8];        /* DWORD 0 */
-       u8 numberPosted[8];     /* DWORD 0 */
-} __packed;
-struct WRB_POST_DB_AMAP {
-       u32 dw[1];
-};
-
-/*
- * Update Default PDU Queue Doorbell Register used to communicate
- * to the controller that the driver has stopped processing the queue
- * and where in the queue it stopped, this is
- * a CQ Entry Type. Used by storage driver.
- */
-struct BE_DEFAULT_PDU_DB_AMAP {
-       u8 qid[10];             /* DWORD 0 */
-       u8 rsvd0[4];    /* DWORD 0 */
-       u8 rearm;               /* DWORD 0 */
-       u8 event;               /* DWORD 0 */
-       u8 cqproc[14];  /* DWORD 0 */
-       u8 rsvd1[2];    /* DWORD 0 */
-} __packed;
-struct DEFAULT_PDU_DB_AMAP {
-       u32 dw[1];
-};
-
-/* Management Command and Controller default fragment ring */
-struct BE_MCC_DB_AMAP {
-       u8 rid[11];             /* DWORD 0 */
-       u8 rsvd0[5];    /* DWORD 0 */
-       u8 numPosted[14];       /* DWORD 0 */
-       u8 rsvd1[2];    /* DWORD 0 */
-} __packed;
-struct MCC_DB_AMAP {
-       u32 dw[1];
-};
-
-/*
- * Used for bootstrapping the Host interface. This register is
- * used for driver communication with the MPU when no MCC Rings exist.
- * The software must write this register twice to post any MCC
- * command. First, it writes the register with hi=1 and the upper bits of
- * the  physical address for the MCC_MAILBOX structure.  Software must poll
- * the ready bit until this is acknowledged.  Then, sotware writes the
- * register with hi=0 with the lower bits in the address.  It must
- * poll the ready bit until the MCC command is complete.  Upon completion,
- * the MCC_MAILBOX will contain a valid completion queue  entry.
- */
-struct BE_MPU_MAILBOX_DB_AMAP {
-       u8 ready;               /* DWORD 0 */
-       u8 hi;          /* DWORD 0 */
-       u8 address[30]; /* DWORD 0 */
-} __packed;
-struct MPU_MAILBOX_DB_AMAP {
-       u32 dw[1];
-};
-
-/*
- *  This is the protection domain doorbell register map. Note that
- *  while this map shows doorbells for all Blade Engine supported
- *  protocols, not all of these may be valid in a given function or
- *  protection domain. It is the responsibility of the application
- *  accessing the doorbells to know which are valid. Each doorbell
- *  occupies 32 bytes of space, but unless otherwise specified,
- *  only the first 4 bytes should be written.  There are 32 instances
- *  of these doorbells for the host and 31 virtual machines respectively.
- *  The host and VMs will only map the doorbell pages belonging to its
- *  protection domain. It will not be able to touch the doorbells for
- *  another VM. The doorbells are the only registers directly accessible
- *  by a virtual machine. Similarly, there are 511 additional
- *  doorbells for RDMA protection domains. PD 0 for RDMA shares
- *  the same physical protection domain doorbell page as ETH/iSCSI.
- *
- */
-struct BE_PROTECTION_DOMAIN_DBMAP_AMAP {
-       u8 rsvd0[512];  /* DWORD 0 */
-       struct BE_SQ_DB_AMAP rdma_sq_db;
-       u8 rsvd1[7][32];        /* DWORD 17 */
-       struct BE_WRB_POST_DB_AMAP iscsi_wrb_post_db;
-       u8 rsvd2[7][32];        /* DWORD 25 */
-       struct BE_SQ_DB_AMAP etx_sq_db;
-       u8 rsvd3[7][32];        /* DWORD 33 */
-       struct BE_RQ_DB_AMAP rdma_rq_db;
-       u8 rsvd4[7][32];        /* DWORD 41 */
-       struct BE_DEFAULT_PDU_DB_AMAP iscsi_default_pdu_db;
-       u8 rsvd5[7][32];        /* DWORD 49 */
-       struct BE_TPM_RQ_DB_AMAP tpm_rq_db;
-       u8 rsvd6[7][32];        /* DWORD 57 */
-       struct BE_RQ_DB_AMAP erx_rq_db;
-       u8 rsvd7[7][32];        /* DWORD 65 */
-       struct BE_CQ_DB_AMAP cq_db;
-       u8 rsvd8[7][32];        /* DWORD 73 */
-       struct BE_MCC_DB_AMAP mpu_mcc_db;
-       u8 rsvd9[7][32];        /* DWORD 81 */
-       struct BE_MPU_MAILBOX_DB_AMAP mcc_bootstrap_db;
-       u8 rsvd10[935][32];     /* DWORD 89 */
-} __packed;
-struct PROTECTION_DOMAIN_DBMAP_AMAP {
-       u32 dw[1024];
-};
-
-#endif /* __doorbells_amap_h__ */
diff --git a/drivers/staging/benet/ep.h b/drivers/staging/benet/ep.h
deleted file mode 100644 (file)
index 72fcf64..0000000
+++ /dev/null
@@ -1,66 +0,0 @@
-/*
- * Copyright (C) 2005 - 2008 ServerEngines
- * All rights reserved.
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License version 2
- * as published by the Free Software Foundation.  The full GNU General
- * Public License is included in this distribution in the file called COPYING.
- *
- * Contact Information:
- * linux-drivers@serverengines.com
- *
- * ServerEngines
- * 209 N. Fair Oaks Ave
- * Sunnyvale, CA 94085
- */
-/*
- * Autogenerated by srcgen version: 0127
- */
-#ifndef __ep_amap_h__
-#define __ep_amap_h__
-
-/* General Control and Status Register. */
-struct BE_EP_CONTROL_CSR_AMAP {
-       u8 m0_RxPbuf;   /* DWORD 0 */
-       u8 m1_RxPbuf;   /* DWORD 0 */
-       u8 m2_RxPbuf;   /* DWORD 0 */
-       u8 ff_en;               /* DWORD 0 */
-       u8 rsvd0[27];   /* DWORD 0 */
-       u8 CPU_reset;   /* DWORD 0 */
-} __packed;
-struct EP_CONTROL_CSR_AMAP {
-       u32 dw[1];
-};
-
-/* Semaphore Register. */
-struct BE_EP_SEMAPHORE_CSR_AMAP {
-       u8 value[32];   /* DWORD 0 */
-} __packed;
-struct EP_SEMAPHORE_CSR_AMAP {
-       u32 dw[1];
-};
-
-/* Embedded Processor Specific Registers. */
-struct BE_EP_CSRMAP_AMAP {
-       struct BE_EP_CONTROL_CSR_AMAP ep_control;
-       u8 rsvd0[32];   /* DWORD 1 */
-       u8 rsvd1[32];   /* DWORD 2 */
-       u8 rsvd2[32];   /* DWORD 3 */
-       u8 rsvd3[32];   /* DWORD 4 */
-       u8 rsvd4[32];   /* DWORD 5 */
-       u8 rsvd5[8][128];       /* DWORD 6 */
-       u8 rsvd6[32];   /* DWORD 38 */
-       u8 rsvd7[32];   /* DWORD 39 */
-       u8 rsvd8[32];   /* DWORD 40 */
-       u8 rsvd9[32];   /* DWORD 41 */
-       u8 rsvd10[32];  /* DWORD 42 */
-       struct BE_EP_SEMAPHORE_CSR_AMAP ep_semaphore;
-       u8 rsvd11[32];  /* DWORD 44 */
-       u8 rsvd12[19][32];      /* DWORD 45 */
-} __packed;
-struct EP_CSRMAP_AMAP {
-       u32 dw[64];
-};
-
-#endif /* __ep_amap_h__ */
diff --git a/drivers/staging/benet/eq.c b/drivers/staging/benet/eq.c
deleted file mode 100644 (file)
index db92ccd..0000000
+++ /dev/null
@@ -1,299 +0,0 @@
-/*
- * Copyright (C) 2005 - 2008 ServerEngines
- * All rights reserved.
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License version 2
- * as published by the Free Software Foundation.  The full GNU General
- * Public License is included in this distribution in the file called COPYING.
- *
- * Contact Information:
- * linux-drivers@serverengines.com
- *
- * ServerEngines
- * 209 N. Fair Oaks Ave
- * Sunnyvale, CA 94085
- */
-#include "hwlib.h"
-#include "bestatus.h"
-/*
-    This routine creates an event queue based on the client completion
-    queue configuration information.
-
-    FunctionObject      - Handle to a function object
-    EqBaseVa            - Base VA for a the EQ ring
-    SizeEncoding        - The encoded size for the EQ entries. This value is
-                       either CEV_EQ_SIZE_4 or CEV_EQ_SIZE_16
-    NumEntries          - CEV_CQ_CNT_* values.
-    Watermark           - Enables watermark based coalescing.  This parameter
-                       must be of the type CEV_WMARK_* if watermarks
-                       are enabled.  If watermarks to to be disabled
-                       this value should be-1.
-    TimerDelay          - If a timer delay is enabled this value should be the
-                       time of the delay in 8 microsecond units.  If
-                       delays are not used this parameter should be
-                       set to -1.
-    ppEqObject          - Internal EQ Handle returned.
-
-    Returns BE_SUCCESS if successfull,, otherwise a useful error code
-       is returned.
-
-    IRQL < DISPATCH_LEVEL
-*/
-int
-be_eq_create(struct be_function_object *pfob,
-               struct ring_desc *rd, u32 eqe_size, u32 num_entries,
-               u32 watermark,  /* CEV_WMARK_* or -1 */
-               u32 timer_delay,        /* in 8us units, or -1 */
-               struct be_eq_object *eq_object)
-{
-       int status = BE_SUCCESS;
-       u32 num_entries_encoding, eqe_size_encoding, length;
-       struct FWCMD_COMMON_EQ_CREATE *fwcmd = NULL;
-       struct MCC_WRB_AMAP *wrb = NULL;
-       u32 n;
-       unsigned long irql;
-
-       ASSERT(rd);
-       ASSERT(eq_object);
-
-       switch (num_entries) {
-       case 256:
-               num_entries_encoding = CEV_EQ_CNT_256;
-               break;
-       case 512:
-               num_entries_encoding = CEV_EQ_CNT_512;
-               break;
-       case 1024:
-               num_entries_encoding = CEV_EQ_CNT_1024;
-               break;
-       case 2048:
-               num_entries_encoding = CEV_EQ_CNT_2048;
-               break;
-       case 4096:
-               num_entries_encoding = CEV_EQ_CNT_4096;
-               break;
-       default:
-               ASSERT(0);
-               return BE_STATUS_INVALID_PARAMETER;
-       }
-
-       switch (eqe_size) {
-       case 4:
-               eqe_size_encoding = CEV_EQ_SIZE_4;
-               break;
-       case 16:
-               eqe_size_encoding = CEV_EQ_SIZE_16;
-               break;
-       default:
-               ASSERT(0);
-               return BE_STATUS_INVALID_PARAMETER;
-       }
-
-       if ((eqe_size == 4 && num_entries < 1024) ||
-           (eqe_size == 16 && num_entries == 4096)) {
-               TRACE(DL_ERR, "Bad EQ size. eqe_size:%d num_entries:%d",
-                     eqe_size, num_entries);
-               ASSERT(0);
-               return BE_STATUS_INVALID_PARAMETER;
-       }
-
-       memset(eq_object, 0, sizeof(*eq_object));
-
-       atomic_set(&eq_object->ref_count, 0);
-       eq_object->parent_function = pfob;
-       eq_object->eq_id = 0xFFFFFFFF;
-
-       INIT_LIST_HEAD(&eq_object->cq_list_head);
-
-       length = num_entries * eqe_size;
-
-       spin_lock_irqsave(&pfob->post_lock, irql);
-
-       wrb = be_function_peek_mcc_wrb(pfob);
-       if (!wrb) {
-               ASSERT(wrb);
-               TRACE(DL_ERR, "No free MCC WRBs in create EQ.");
-               status = BE_STATUS_NO_MCC_WRB;
-               goto Error;
-       }
-       /* Prepares an embedded fwcmd, including request/response sizes. */
-       fwcmd = BE_PREPARE_EMBEDDED_FWCMD(pfob, wrb, COMMON_EQ_CREATE);
-
-       fwcmd->params.request.num_pages = PAGES_SPANNED(OFFSET_IN_PAGE(rd->va),
-                                                                       length);
-       n = pfob->pci_function_number;
-       AMAP_SET_BITS_PTR(EQ_CONTEXT, Func, &fwcmd->params.request.context, n);
-
-       AMAP_SET_BITS_PTR(EQ_CONTEXT, valid, &fwcmd->params.request.context, 1);
-
-       AMAP_SET_BITS_PTR(EQ_CONTEXT, Size,
-                       &fwcmd->params.request.context, eqe_size_encoding);
-
-       n = 0; /* Protection Domain is always 0 in  Linux  driver */
-       AMAP_SET_BITS_PTR(EQ_CONTEXT, PD, &fwcmd->params.request.context, n);
-
-       /* Let the caller ARM the EQ with the doorbell. */
-       AMAP_SET_BITS_PTR(EQ_CONTEXT, Armed, &fwcmd->params.request.context, 0);
-
-       AMAP_SET_BITS_PTR(EQ_CONTEXT, Count, &fwcmd->params.request.context,
-                                       num_entries_encoding);
-
-       n = pfob->pci_function_number * 32;
-       AMAP_SET_BITS_PTR(EQ_CONTEXT, EventVect,
-                               &fwcmd->params.request.context, n);
-       if (watermark != -1) {
-               AMAP_SET_BITS_PTR(EQ_CONTEXT, WME,
-                               &fwcmd->params.request.context, 1);
-               AMAP_SET_BITS_PTR(EQ_CONTEXT, Watermark,
-                               &fwcmd->params.request.context, watermark);
-               ASSERT(watermark <= CEV_WMARK_240);
-       } else
-               AMAP_SET_BITS_PTR(EQ_CONTEXT, WME,
-                                       &fwcmd->params.request.context, 0);
-       if (timer_delay != -1) {
-               AMAP_SET_BITS_PTR(EQ_CONTEXT, TMR,
-                                       &fwcmd->params.request.context, 1);
-
-               ASSERT(timer_delay <= 250);     /* max value according to EAS */
-               timer_delay = min(timer_delay, (u32)250);
-
-               AMAP_SET_BITS_PTR(EQ_CONTEXT, Delay,
-                               &fwcmd->params.request.context, timer_delay);
-       } else {
-               AMAP_SET_BITS_PTR(EQ_CONTEXT, TMR,
-                               &fwcmd->params.request.context, 0);
-       }
-       /* Create a page list for the FWCMD. */
-       be_rd_to_pa_list(rd, fwcmd->params.request.pages,
-                         ARRAY_SIZE(fwcmd->params.request.pages));
-
-       status = be_function_post_mcc_wrb(pfob, wrb, NULL, NULL, NULL,
-                                       NULL, NULL, fwcmd, NULL);
-       if (status != BE_SUCCESS) {
-               TRACE(DL_ERR, "MCC to create EQ failed.");
-               goto Error;
-       }
-       /* Get the EQ id.  The MPU allocates the IDs. */
-       eq_object->eq_id = fwcmd->params.response.eq_id;
-
-Error:
-       spin_unlock_irqrestore(&pfob->post_lock, irql);
-
-       if (pfob->pend_queue_driving && pfob->mcc) {
-               pfob->pend_queue_driving = 0;
-               be_drive_mcc_wrb_queue(pfob->mcc);
-       }
-       return status;
-}
-
-/*
-    Deferences the given object. Once the object's reference count drops to
-    zero, the object is destroyed and all resources that are held by this
-    object are released.  The on-chip context is also destroyed along with
-    the queue ID, and any mappings made into the UT.
-
-    eq_object            - EQ handle returned from eq_object_create.
-
-    Returns BE_SUCCESS if successfull, otherwise a useful error code
-       is returned.
-
-    IRQL: IRQL < DISPATCH_LEVEL
-*/
-int be_eq_destroy(struct be_eq_object *eq_object)
-{
-       int status = 0;
-
-       ASSERT(atomic_read(&eq_object->ref_count) == 0);
-       /* no CQs should reference this EQ now */
-       ASSERT(list_empty(&eq_object->cq_list_head));
-
-       /* Send fwcmd to destroy the EQ. */
-       status = be_function_ring_destroy(eq_object->parent_function,
-                            eq_object->eq_id, FWCMD_RING_TYPE_EQ,
-                                       NULL, NULL, NULL, NULL);
-       ASSERT(status == 0);
-
-       return BE_SUCCESS;
-}
-/*
- *---------------------------------------------------------------------------
- * Function: be_eq_modify_delay
- *   Changes the EQ delay for a group of EQs.
- * num_eq             - The number of EQs in the eq_array to adjust.
- *                     This also is the number of delay values in
- *                     the eq_delay_array.
- * eq_array           - Array of struct be_eq_object pointers to adjust.
- * eq_delay_array     - Array of "num_eq" timer delays in units
- *                     of microseconds. The be_eq_query_delay_range
- *                     fwcmd returns the resolution and range of
- *                      legal EQ delays.
- * cb           -
- * cb_context   -
- * q_ctxt             - Optional. Pointer to a previously allocated
- *                     struct. If the MCC WRB ring is full, this
- *                     structure is used to queue the operation. It
- *                      will be posted to the MCC ring when space
- *                      becomes available. All queued commands will
- *                      be posted to the ring in the order they are
- *                      received. It is always valid to pass a pointer to
- *                      a generic be_generic_q_cntxt. However,
- *                      the specific context structs
- *                      are generally smaller than the generic struct.
- * return pend_status - BE_SUCCESS (0) on success.
- *                     BE_PENDING (postive value) if the FWCMD
- *                      completion is pending. Negative error code on failure.
- *-------------------------------------------------------------------------
- */
-int
-be_eq_modify_delay(struct be_function_object *pfob,
-                  u32 num_eq, struct be_eq_object **eq_array,
-                  u32 *eq_delay_array, mcc_wrb_cqe_callback cb,
-                  void *cb_context, struct be_eq_modify_delay_q_ctxt *q_ctxt)
-{
-       struct FWCMD_COMMON_MODIFY_EQ_DELAY *fwcmd = NULL;
-       struct MCC_WRB_AMAP *wrb = NULL;
-       int status = 0;
-       struct be_generic_q_ctxt *gen_ctxt = NULL;
-       u32 i;
-       unsigned long irql;
-
-       spin_lock_irqsave(&pfob->post_lock, irql);
-
-       wrb = be_function_peek_mcc_wrb(pfob);
-       if (!wrb) {
-               if (q_ctxt && cb) {
-                       wrb = (struct MCC_WRB_AMAP *) &q_ctxt->wrb_header;
-                       gen_ctxt = (struct be_generic_q_ctxt *) q_ctxt;
-                       gen_ctxt->context.bytes = sizeof(*q_ctxt);
-               } else {
-                       status = BE_STATUS_NO_MCC_WRB;
-                       goto Error;
-               }
-       }
-       /* Prepares an embedded fwcmd, including request/response sizes. */
-       fwcmd = BE_PREPARE_EMBEDDED_FWCMD(pfob, wrb, COMMON_MODIFY_EQ_DELAY);
-
-       ASSERT(num_eq > 0);
-       ASSERT(num_eq <= ARRAY_SIZE(fwcmd->params.request.delay));
-       fwcmd->params.request.num_eq = num_eq;
-       for (i = 0; i < num_eq; i++) {
-               fwcmd->params.request.delay[i].eq_id = eq_array[i]->eq_id;
-               fwcmd->params.request.delay[i].delay_in_microseconds =
-                   eq_delay_array[i];
-       }
-
-       /* Post the f/w command */
-       status = be_function_post_mcc_wrb(pfob, wrb, gen_ctxt,
-                       cb, cb_context, NULL, NULL, fwcmd, NULL);
-
-Error:
-       spin_unlock_irqrestore(&pfob->post_lock, irql);
-
-       if (pfob->pend_queue_driving && pfob->mcc) {
-               pfob->pend_queue_driving = 0;
-               be_drive_mcc_wrb_queue(pfob->mcc);
-       }
-       return status;
-}
-
diff --git a/drivers/staging/benet/eth.c b/drivers/staging/benet/eth.c
deleted file mode 100644 (file)
index f641b62..0000000
+++ /dev/null
@@ -1,1273 +0,0 @@
-/*
- * Copyright (C) 2005 - 2008 ServerEngines
- * All rights reserved.
- *
- * This program is free software; you can redistribute it&n