Doug / smarc-fsl-linux-kernel | Embedian Git Server

Commit c827ba4cb49a30ce581201fd0ba2be77cde412c7

Authored by Linus Torvalds 2007-02-12 03:37:45 +0800

Exists in master and in 7 other branches

Merge master.kernel.org:/pub/scm/linux/kernel/git/davem/sparc-2.6

* master.kernel.org:/pub/scm/linux/kernel/git/davem/sparc-2.6:
  [SPARC64]: Update defconfig.
  [SPARC64]: Add PCI MSI support on Niagara.
  [SPARC64] IRQ: Use irq_desc->chip_data instead of irq_desc->handler_data
  [SPARC64]: Add obppath sysfs attribute for SBUS and PCI devices.
  [PARTITION]: Add whole_disk attribute.

Showing 17 changed files Inline Diff

arch/sparc64/defconfig
arch/sparc64/kernel/irq.c
arch/sparc64/kernel/pci.c
arch/sparc64/kernel/pci_common.c
arch/sparc64/kernel/pci_sun4v.c
arch/sparc64/kernel/pci_sun4v.h
arch/sparc64/kernel/pci_sun4v_asm.S
block/ioctl.c
drivers/pci/Kconfig
drivers/sbus/sbus.c
fs/partitions/check.c
fs/partitions/msdos.c
fs/partitions/sgi.c
fs/partitions/sun.c
include/asm-sparc64/irq.h
include/asm-sparc64/pbm.h
include/linux/genhd.h

arch/sparc64/defconfig

Diff comments View file @ c827ba4

 #
 # Automatically generated make config: don't edit
-# Linux kernel version: 2.6.20-rc2
+# Linux kernel version: 2.6.20
-# Thu Dec 28 15:09:49 2006
+# Sat Feb 10 23:08:12 2007
 #
 CONFIG_SPARC=y
 CONFIG_SPARC64=y
 CONFIG_64BIT=y
 CONFIG_MMU=y
 CONFIG_STACKTRACE_SUPPORT=y
 CONFIG_LOCKDEP_SUPPORT=y
 CONFIG_TIME_INTERPOLATION=y
 CONFIG_ARCH_MAY_HAVE_PC_FDC=y
 # CONFIG_ARCH_HAS_ILOG2_U32 is not set
 # CONFIG_ARCH_HAS_ILOG2_U64 is not set
 CONFIG_AUDIT_ARCH=y
 CONFIG_SPARC64_PAGE_SIZE_8KB=y
 # CONFIG_SPARC64_PAGE_SIZE_64KB is not set
 # CONFIG_SPARC64_PAGE_SIZE_512KB is not set
 # CONFIG_SPARC64_PAGE_SIZE_4MB is not set
 CONFIG_SECCOMP=y
 CONFIG_HZ_100=y
 # CONFIG_HZ_250 is not set
 # CONFIG_HZ_300 is not set
 # CONFIG_HZ_1000 is not set
 CONFIG_HZ=100
 CONFIG_DEFCONFIG_LIST="/lib/modules/$UNAME_RELEASE/.config"
 #
 # Code maturity level options
 #
 CONFIG_EXPERIMENTAL=y
 CONFIG_BROKEN_ON_SMP=y
 CONFIG_INIT_ENV_ARG_LIMIT=32
 #
 # General setup
 #
 CONFIG_LOCALVERSION=""
 # CONFIG_LOCALVERSION_AUTO is not set
 CONFIG_SWAP=y
 CONFIG_SYSVIPC=y
 # CONFIG_IPC_NS is not set
 CONFIG_POSIX_MQUEUE=y
 # CONFIG_BSD_PROCESS_ACCT is not set
 # CONFIG_TASKSTATS is not set
 # CONFIG_UTS_NS is not set
 # CONFIG_AUDIT is not set
 # CONFIG_IKCONFIG is not set
 CONFIG_SYSFS_DEPRECATED=y
 CONFIG_RELAY=y
 CONFIG_INITRAMFS_SOURCE=""
 CONFIG_CC_OPTIMIZE_FOR_SIZE=y
 CONFIG_SYSCTL=y
 # CONFIG_EMBEDDED is not set
 CONFIG_UID16=y
 CONFIG_SYSCTL_SYSCALL=y
 CONFIG_KALLSYMS=y
 # CONFIG_KALLSYMS_ALL is not set
 # CONFIG_KALLSYMS_EXTRA_PASS is not set
 CONFIG_HOTPLUG=y
 CONFIG_PRINTK=y
 CONFIG_BUG=y
 CONFIG_ELF_CORE=y
 CONFIG_BASE_FULL=y
 CONFIG_FUTEX=y
 CONFIG_EPOLL=y
 CONFIG_SHMEM=y
 CONFIG_SLAB=y
 CONFIG_VM_EVENT_COUNTERS=y
 CONFIG_RT_MUTEXES=y
 # CONFIG_TINY_SHMEM is not set
 CONFIG_BASE_SMALL=0
 # CONFIG_SLOB is not set
 #
 # Loadable module support
 #
 CONFIG_MODULES=y
 CONFIG_MODULE_UNLOAD=y
 CONFIG_MODULE_FORCE_UNLOAD=y
 CONFIG_MODVERSIONS=y
 CONFIG_MODULE_SRCVERSION_ALL=y
 CONFIG_KMOD=y
 #
 # Block layer
 #
 CONFIG_BLOCK=y
 CONFIG_BLK_DEV_IO_TRACE=y
 #
 # IO Schedulers
 #
 CONFIG_IOSCHED_NOOP=y
 CONFIG_IOSCHED_AS=y
 CONFIG_IOSCHED_DEADLINE=y
 CONFIG_IOSCHED_CFQ=y
 CONFIG_DEFAULT_AS=y
 # CONFIG_DEFAULT_DEADLINE is not set
 # CONFIG_DEFAULT_CFQ is not set
 # CONFIG_DEFAULT_NOOP is not set
 CONFIG_DEFAULT_IOSCHED="anticipatory"
 CONFIG_SYSVIPC_COMPAT=y
 CONFIG_GENERIC_HARDIRQS=y
 #
 # General machine setup
 #
 # CONFIG_SMP is not set
 # CONFIG_PREEMPT is not set
 CONFIG_CPU_FREQ=y
 CONFIG_CPU_FREQ_TABLE=m
 # CONFIG_CPU_FREQ_DEBUG is not set
 CONFIG_CPU_FREQ_STAT=m
 CONFIG_CPU_FREQ_STAT_DETAILS=y
 CONFIG_CPU_FREQ_DEFAULT_GOV_PERFORMANCE=y
 # CONFIG_CPU_FREQ_DEFAULT_GOV_USERSPACE is not set
 CONFIG_CPU_FREQ_GOV_PERFORMANCE=y
 CONFIG_CPU_FREQ_GOV_POWERSAVE=m
 CONFIG_CPU_FREQ_GOV_USERSPACE=m
 CONFIG_CPU_FREQ_GOV_ONDEMAND=m
 CONFIG_CPU_FREQ_GOV_CONSERVATIVE=m
 CONFIG_US3_FREQ=m
 CONFIG_US2E_FREQ=m
 CONFIG_RWSEM_XCHGADD_ALGORITHM=y
 CONFIG_GENERIC_FIND_NEXT_BIT=y
 CONFIG_GENERIC_HWEIGHT=y
 CONFIG_GENERIC_CALIBRATE_DELAY=y
 CONFIG_HUGETLB_PAGE_SIZE_4MB=y
 # CONFIG_HUGETLB_PAGE_SIZE_512K is not set
 # CONFIG_HUGETLB_PAGE_SIZE_64K is not set
 CONFIG_ARCH_SELECT_MEMORY_MODEL=y
 CONFIG_ARCH_SPARSEMEM_ENABLE=y
 CONFIG_ARCH_SPARSEMEM_DEFAULT=y
 CONFIG_LARGE_ALLOCS=y
 CONFIG_SELECT_MEMORY_MODEL=y
 # CONFIG_FLATMEM_MANUAL is not set
 # CONFIG_DISCONTIGMEM_MANUAL is not set
 CONFIG_SPARSEMEM_MANUAL=y
 CONFIG_SPARSEMEM=y
 CONFIG_HAVE_MEMORY_PRESENT=y
 # CONFIG_SPARSEMEM_STATIC is not set
 CONFIG_SPARSEMEM_EXTREME=y
 CONFIG_SPLIT_PTLOCK_CPUS=4
 CONFIG_RESOURCES_64BIT=y
 CONFIG_GENERIC_ISA_DMA=y
 CONFIG_SBUS=y
 CONFIG_SBUSCHAR=y
 CONFIG_SUN_AUXIO=y
 CONFIG_SUN_IO=y
 CONFIG_PCI=y
 CONFIG_PCI_DOMAINS=y
-# CONFIG_PCI_MULTITHREAD_PROBE is not set
+CONFIG_PCI_MSI=y
 # CONFIG_PCI_DEBUG is not set
 CONFIG_SUN_OPENPROMFS=m
 CONFIG_SPARC32_COMPAT=y
 CONFIG_COMPAT=y
 CONFIG_BINFMT_ELF32=y
 # CONFIG_BINFMT_AOUT32 is not set
 #
 # Executable file formats
 #
 CONFIG_BINFMT_ELF=y
 CONFIG_BINFMT_MISC=m
 CONFIG_SOLARIS_EMUL=y
 # CONFIG_CMDLINE_BOOL is not set
 #
 # Networking
 #
 CONFIG_NET=y
 #
 # Networking options
 #
 # CONFIG_NETDEBUG is not set
 CONFIG_PACKET=y
 CONFIG_PACKET_MMAP=y
 CONFIG_UNIX=y
 CONFIG_XFRM=y
 CONFIG_XFRM_USER=m
 # CONFIG_XFRM_SUB_POLICY is not set
+CONFIG_XFRM_MIGRATE=y
 CONFIG_NET_KEY=m
+CONFIG_NET_KEY_MIGRATE=y
 CONFIG_INET=y
 CONFIG_IP_MULTICAST=y
 # CONFIG_IP_ADVANCED_ROUTER is not set
 CONFIG_IP_FIB_HASH=y
 # CONFIG_IP_PNP is not set
 CONFIG_NET_IPIP=m
 CONFIG_NET_IPGRE=m
 CONFIG_NET_IPGRE_BROADCAST=y
 CONFIG_IP_MROUTE=y
 CONFIG_IP_PIMSM_V1=y
 CONFIG_IP_PIMSM_V2=y
 CONFIG_ARPD=y
 CONFIG_SYN_COOKIES=y
 CONFIG_INET_AH=y
 CONFIG_INET_ESP=y
 CONFIG_INET_IPCOMP=y
 CONFIG_INET_XFRM_TUNNEL=y
 CONFIG_INET_TUNNEL=y
 CONFIG_INET_XFRM_MODE_TRANSPORT=y
 CONFIG_INET_XFRM_MODE_TUNNEL=y
 CONFIG_INET_XFRM_MODE_BEET=y
 CONFIG_INET_DIAG=y
 CONFIG_INET_TCP_DIAG=y
 # CONFIG_TCP_CONG_ADVANCED is not set
 CONFIG_TCP_CONG_CUBIC=y
 CONFIG_DEFAULT_TCP_CONG="cubic"
 # CONFIG_TCP_MD5SIG is not set
 CONFIG_IPV6=m
 CONFIG_IPV6_PRIVACY=y
 CONFIG_IPV6_ROUTER_PREF=y
 CONFIG_IPV6_ROUTE_INFO=y
 CONFIG_INET6_AH=m
 CONFIG_INET6_ESP=m
 CONFIG_INET6_IPCOMP=m
 # CONFIG_IPV6_MIP6 is not set
 CONFIG_INET6_XFRM_TUNNEL=m
 CONFIG_INET6_TUNNEL=m
 CONFIG_INET6_XFRM_MODE_TRANSPORT=m
 CONFIG_INET6_XFRM_MODE_TUNNEL=m
 CONFIG_INET6_XFRM_MODE_BEET=m
 # CONFIG_INET6_XFRM_MODE_ROUTEOPTIMIZATION is not set
 CONFIG_IPV6_SIT=m
 CONFIG_IPV6_TUNNEL=m
 # CONFIG_IPV6_MULTIPLE_TABLES is not set
 # CONFIG_NETWORK_SECMARK is not set
 # CONFIG_NETFILTER is not set
 #
 # DCCP Configuration (EXPERIMENTAL)
 #
 CONFIG_IP_DCCP=m
 CONFIG_INET_DCCP_DIAG=m
 CONFIG_IP_DCCP_ACKVEC=y
 #
 # DCCP CCIDs Configuration (EXPERIMENTAL)
 #
 CONFIG_IP_DCCP_CCID2=m
 # CONFIG_IP_DCCP_CCID2_DEBUG is not set
 CONFIG_IP_DCCP_CCID3=m
 CONFIG_IP_DCCP_TFRC_LIB=m
 # CONFIG_IP_DCCP_CCID3_DEBUG is not set
 CONFIG_IP_DCCP_CCID3_RTO=100
 #
 # DCCP Kernel Hacking
 #
 # CONFIG_IP_DCCP_DEBUG is not set
 # CONFIG_NET_DCCPPROBE is not set
 #
 # SCTP Configuration (EXPERIMENTAL)
 #
 # CONFIG_IP_SCTP is not set
 #
 # TIPC Configuration (EXPERIMENTAL)
 #
 # CONFIG_TIPC is not set
 # CONFIG_ATM is not set
 # CONFIG_BRIDGE is not set
 CONFIG_VLAN_8021Q=m
 # CONFIG_DECNET is not set
 # CONFIG_LLC2 is not set
 # CONFIG_IPX is not set
 # CONFIG_ATALK is not set
 # CONFIG_X25 is not set
 # CONFIG_LAPB is not set
 # CONFIG_ECONET is not set
 # CONFIG_WAN_ROUTER is not set
 #
 # QoS and/or fair queueing
 #
 # CONFIG_NET_SCHED is not set
 #
 # Network testing
 #
 CONFIG_NET_PKTGEN=m
 CONFIG_NET_TCPPROBE=m
 # CONFIG_HAMRADIO is not set
 # CONFIG_IRDA is not set
 # CONFIG_BT is not set
 # CONFIG_IEEE80211 is not set
 #
 # Device Drivers
 #
 #
 # Generic Driver Options
 #
 CONFIG_STANDALONE=y
 # CONFIG_PREVENT_FIRMWARE_BUILD is not set
 CONFIG_FW_LOADER=y
 # CONFIG_DEBUG_DRIVER is not set
+# CONFIG_DEBUG_DEVRES is not set
 # CONFIG_SYS_HYPERVISOR is not set
 #
 # Connector - unified userspace <-> kernelspace linker
 #
 CONFIG_CONNECTOR=m
 #
 # Memory Technology Devices (MTD)
 #
 # CONFIG_MTD is not set
 #
 # Parallel port support
 #
 # CONFIG_PARPORT is not set
 #
 # Plug and Play support
 #
 #
 # Block devices
 #
 # CONFIG_BLK_DEV_FD is not set
 # CONFIG_BLK_CPQ_DA is not set
 # CONFIG_BLK_CPQ_CISS_DA is not set
 # CONFIG_BLK_DEV_DAC960 is not set
 # CONFIG_BLK_DEV_UMEM is not set
 # CONFIG_BLK_DEV_COW_COMMON is not set
 CONFIG_BLK_DEV_LOOP=m
 CONFIG_BLK_DEV_CRYPTOLOOP=m
 CONFIG_BLK_DEV_NBD=m
 # CONFIG_BLK_DEV_SX8 is not set
 # CONFIG_BLK_DEV_UB is not set
 # CONFIG_BLK_DEV_RAM is not set
 # CONFIG_BLK_DEV_INITRD is not set
 CONFIG_CDROM_PKTCDVD=m
 CONFIG_CDROM_PKTCDVD_BUFFERS=8
 CONFIG_CDROM_PKTCDVD_WCACHE=y
 CONFIG_ATA_OVER_ETH=m
 #
 # Misc devices
 #
 # CONFIG_SGI_IOC4 is not set
 # CONFIG_TIFM_CORE is not set
 #
 # ATA/ATAPI/MFM/RLL support
 #
 CONFIG_IDE=y
 CONFIG_BLK_DEV_IDE=y
 #
 # Please see Documentation/ide.txt for help/info on IDE drives
 #
 # CONFIG_BLK_DEV_IDE_SATA is not set
 CONFIG_BLK_DEV_IDEDISK=y
 # CONFIG_IDEDISK_MULTI_MODE is not set
 CONFIG_BLK_DEV_IDECD=y
 # CONFIG_BLK_DEV_IDETAPE is not set
 # CONFIG_BLK_DEV_IDEFLOPPY is not set
 # CONFIG_BLK_DEV_IDESCSI is not set
 # CONFIG_IDE_TASK_IOCTL is not set
 #
 # IDE chipset support/bugfixes
 #
 CONFIG_IDE_GENERIC=y
 CONFIG_BLK_DEV_IDEPCI=y
 # CONFIG_IDEPCI_SHARE_IRQ is not set
 # CONFIG_BLK_DEV_OFFBOARD is not set
 # CONFIG_BLK_DEV_GENERIC is not set
 # CONFIG_BLK_DEV_OPTI621 is not set
 CONFIG_BLK_DEV_IDEDMA_PCI=y
 # CONFIG_BLK_DEV_IDEDMA_FORCED is not set
 CONFIG_IDEDMA_PCI_AUTO=y
 CONFIG_IDEDMA_ONLYDISK=y
 # CONFIG_BLK_DEV_AEC62XX is not set
 CONFIG_BLK_DEV_ALI15X3=y
 # CONFIG_WDC_ALI15X3 is not set
 # CONFIG_BLK_DEV_AMD74XX is not set
 # CONFIG_BLK_DEV_CMD64X is not set
 # CONFIG_BLK_DEV_TRIFLEX is not set
 # CONFIG_BLK_DEV_CY82C693 is not set
 # CONFIG_BLK_DEV_CS5520 is not set
 # CONFIG_BLK_DEV_CS5530 is not set
 # CONFIG_BLK_DEV_HPT34X is not set
 # CONFIG_BLK_DEV_HPT366 is not set
 # CONFIG_BLK_DEV_JMICRON is not set
 # CONFIG_BLK_DEV_SC1200 is not set
 # CONFIG_BLK_DEV_PIIX is not set
+# CONFIG_BLK_DEV_IT8213 is not set
 # CONFIG_BLK_DEV_IT821X is not set
 # CONFIG_BLK_DEV_NS87415 is not set
 # CONFIG_BLK_DEV_PDC202XX_OLD is not set
 # CONFIG_BLK_DEV_PDC202XX_NEW is not set
 # CONFIG_BLK_DEV_SVWKS is not set
 # CONFIG_BLK_DEV_SIIMAGE is not set
 # CONFIG_BLK_DEV_SLC90E66 is not set
 # CONFIG_BLK_DEV_TRM290 is not set
 # CONFIG_BLK_DEV_VIA82CXXX is not set
+# CONFIG_BLK_DEV_TC86C001 is not set
 # CONFIG_IDE_ARM is not set
 CONFIG_BLK_DEV_IDEDMA=y
 # CONFIG_IDEDMA_IVB is not set
 CONFIG_IDEDMA_AUTO=y
 # CONFIG_BLK_DEV_HD is not set
 #
 # SCSI device support
 #
 CONFIG_RAID_ATTRS=m
 CONFIG_SCSI=y
 # CONFIG_SCSI_TGT is not set
 CONFIG_SCSI_NETLINK=y
 CONFIG_SCSI_PROC_FS=y
 #
 # SCSI support type (disk, tape, CD-ROM)
 #
 CONFIG_BLK_DEV_SD=y
 # CONFIG_CHR_DEV_ST is not set
 # CONFIG_CHR_DEV_OSST is not set
 CONFIG_BLK_DEV_SR=m
 CONFIG_BLK_DEV_SR_VENDOR=y
 CONFIG_CHR_DEV_SG=m
 # CONFIG_CHR_DEV_SCH is not set
 #
 # Some SCSI devices (e.g. CD jukebox) support multiple LUNs
 #
 CONFIG_SCSI_MULTI_LUN=y
 CONFIG_SCSI_CONSTANTS=y
 # CONFIG_SCSI_LOGGING is not set
 # CONFIG_SCSI_SCAN_ASYNC is not set
 #
 # SCSI Transports
 #
 CONFIG_SCSI_SPI_ATTRS=y
 CONFIG_SCSI_FC_ATTRS=y
 CONFIG_SCSI_ISCSI_ATTRS=m
 # CONFIG_SCSI_SAS_ATTRS is not set
 # CONFIG_SCSI_SAS_LIBSAS is not set
 #
 # SCSI low-level drivers
 #
 CONFIG_ISCSI_TCP=m
 # CONFIG_BLK_DEV_3W_XXXX_RAID is not set
 # CONFIG_SCSI_3W_9XXX is not set
 # CONFIG_SCSI_ACARD is not set
 # CONFIG_SCSI_AACRAID is not set
 # CONFIG_SCSI_AIC7XXX is not set
 # CONFIG_SCSI_AIC7XXX_OLD is not set
 # CONFIG_SCSI_AIC79XX is not set
 # CONFIG_SCSI_AIC94XX is not set
 # CONFIG_SCSI_ARCMSR is not set
 # CONFIG_MEGARAID_NEWGEN is not set
 # CONFIG_MEGARAID_LEGACY is not set
 # CONFIG_MEGARAID_SAS is not set
 # CONFIG_SCSI_HPTIOP is not set
 # CONFIG_SCSI_DMX3191D is not set
 # CONFIG_SCSI_FUTURE_DOMAIN is not set
 # CONFIG_SCSI_IPS is not set
 # CONFIG_SCSI_INITIO is not set
 # CONFIG_SCSI_INIA100 is not set
 # CONFIG_SCSI_STEX is not set
 # CONFIG_SCSI_SYM53C8XX_2 is not set
 # CONFIG_SCSI_QLOGIC_1280 is not set
 # CONFIG_SCSI_QLOGICPTI is not set
 # CONFIG_SCSI_QLA_FC is not set
 # CONFIG_SCSI_QLA_ISCSI is not set
 # CONFIG_SCSI_LPFC is not set
 # CONFIG_SCSI_DC395x is not set
 # CONFIG_SCSI_DC390T is not set
 # CONFIG_SCSI_DEBUG is not set
 # CONFIG_SCSI_SUNESP is not set
 # CONFIG_SCSI_SRP is not set
 #
 # Serial ATA (prod) and Parallel ATA (experimental) drivers
 #
 # CONFIG_ATA is not set
 #
 # Multi-device support (RAID and LVM)
 #
 CONFIG_MD=y
 CONFIG_BLK_DEV_MD=m
 CONFIG_MD_LINEAR=m
 CONFIG_MD_RAID0=m
 CONFIG_MD_RAID1=m
 CONFIG_MD_RAID10=m
 CONFIG_MD_RAID456=m
 # CONFIG_MD_RAID5_RESHAPE is not set
 CONFIG_MD_MULTIPATH=m
 # CONFIG_MD_FAULTY is not set
 CONFIG_BLK_DEV_DM=m
 # CONFIG_DM_DEBUG is not set
 CONFIG_DM_CRYPT=m
 CONFIG_DM_SNAPSHOT=m
 CONFIG_DM_MIRROR=m
 CONFIG_DM_ZERO=m
 # CONFIG_DM_MULTIPATH is not set
 #
 # Fusion MPT device support
 #
 # CONFIG_FUSION is not set
 # CONFIG_FUSION_SPI is not set
 # CONFIG_FUSION_FC is not set
 # CONFIG_FUSION_SAS is not set
 #
 # IEEE 1394 (FireWire) support
 #
 # CONFIG_IEEE1394 is not set
 #
 # I2O device support
 #
 # CONFIG_I2O is not set
 #
 # Network device support
 #
 CONFIG_NETDEVICES=y
 CONFIG_DUMMY=m
 # CONFIG_BONDING is not set
 # CONFIG_EQUALIZER is not set
 # CONFIG_TUN is not set
 #
 # ARCnet devices
 #
 # CONFIG_ARCNET is not set
 #
 # PHY device support
 #
 # CONFIG_PHYLIB is not set
 #
 # Ethernet (10 or 100Mbit)
 #
 CONFIG_NET_ETHERNET=y
 CONFIG_MII=m
 # CONFIG_SUNLANCE is not set
 # CONFIG_HAPPYMEAL is not set
 # CONFIG_SUNBMAC is not set
 # CONFIG_SUNQE is not set
 # CONFIG_SUNGEM is not set
 CONFIG_CASSINI=m
 # CONFIG_NET_VENDOR_3COM is not set
 #
 # Tulip family network device support
 #
 # CONFIG_NET_TULIP is not set
 # CONFIG_HP100 is not set
 CONFIG_NET_PCI=y
 # CONFIG_PCNET32 is not set
 # CONFIG_AMD8111_ETH is not set
 # CONFIG_ADAPTEC_STARFIRE is not set
 # CONFIG_B44 is not set
 # CONFIG_FORCEDETH is not set
 # CONFIG_DGRS is not set
 # CONFIG_EEPRO100 is not set
 # CONFIG_E100 is not set
 # CONFIG_FEALNX is not set
 # CONFIG_NATSEMI is not set
 # CONFIG_NE2K_PCI is not set
 # CONFIG_8139CP is not set
 # CONFIG_8139TOO is not set
 # CONFIG_SIS900 is not set
 # CONFIG_EPIC100 is not set
 # CONFIG_SUNDANCE is not set
 # CONFIG_VIA_RHINE is not set
+# CONFIG_SC92031 is not set
 #
 # Ethernet (1000 Mbit)
 #
 # CONFIG_ACENIC is not set
 # CONFIG_DL2K is not set
 CONFIG_E1000=m
 CONFIG_E1000_NAPI=y
 # CONFIG_E1000_DISABLE_PACKET_SPLIT is not set
 # CONFIG_MYRI_SBUS is not set
 # CONFIG_NS83820 is not set
 # CONFIG_HAMACHI is not set
 # CONFIG_YELLOWFIN is not set
 # CONFIG_R8169 is not set
 # CONFIG_SIS190 is not set
 # CONFIG_SKGE is not set
 # CONFIG_SKY2 is not set
 # CONFIG_SK98LIN is not set
 # CONFIG_VIA_VELOCITY is not set
 CONFIG_TIGON3=m
 CONFIG_BNX2=m
 # CONFIG_QLA3XXX is not set
+# CONFIG_ATL1 is not set
 #
 # Ethernet (10000 Mbit)
 #
 # CONFIG_CHELSIO_T1 is not set
+# CONFIG_CHELSIO_T3 is not set
 # CONFIG_IXGB is not set
 # CONFIG_S2IO is not set
 # CONFIG_MYRI10GE is not set
 # CONFIG_NETXEN_NIC is not set
 #
 # Token Ring devices
 #
 # CONFIG_TR is not set
 #
 # Wireless LAN (non-hamradio)
 #
 # CONFIG_NET_RADIO is not set
 #
 # Wan interfaces
 #
 # CONFIG_WAN is not set
 # CONFIG_FDDI is not set
 # CONFIG_HIPPI is not set
-# CONFIG_PPP is not set
+CONFIG_PPP=m
+CONFIG_PPP_MULTILINK=y
+CONFIG_PPP_FILTER=y
+CONFIG_PPP_ASYNC=m
+CONFIG_PPP_SYNC_TTY=m
+CONFIG_PPP_DEFLATE=m
+CONFIG_PPP_BSDCOMP=m
+CONFIG_PPP_MPPE=m
+CONFIG_PPPOE=m
 # CONFIG_SLIP is not set
+CONFIG_SLHC=m
 # CONFIG_NET_FC is not set
 # CONFIG_SHAPER is not set
 # CONFIG_NETCONSOLE is not set
 # CONFIG_NETPOLL is not set
 # CONFIG_NET_POLL_CONTROLLER is not set
 #
 # ISDN subsystem
 #
 # CONFIG_ISDN is not set
 #
 # Telephony Support
 #
 # CONFIG_PHONE is not set
 #
 # Input device support
 #
 CONFIG_INPUT=y
 # CONFIG_INPUT_FF_MEMLESS is not set
 #
 # Userland interfaces
 #
 CONFIG_INPUT_MOUSEDEV=y
 CONFIG_INPUT_MOUSEDEV_PSAUX=y
 CONFIG_INPUT_MOUSEDEV_SCREEN_X=1024
 CONFIG_INPUT_MOUSEDEV_SCREEN_Y=768
 # CONFIG_INPUT_JOYDEV is not set
 # CONFIG_INPUT_TSDEV is not set
 CONFIG_INPUT_EVDEV=y
 # CONFIG_INPUT_EVBUG is not set
 #
 # Input Device Drivers
 #
 CONFIG_INPUT_KEYBOARD=y
 CONFIG_KEYBOARD_ATKBD=y
 CONFIG_KEYBOARD_SUNKBD=y
 CONFIG_KEYBOARD_LKKBD=m
 # CONFIG_KEYBOARD_XTKBD is not set
 # CONFIG_KEYBOARD_NEWTON is not set
 # CONFIG_KEYBOARD_STOWAWAY is not set
 CONFIG_INPUT_MOUSE=y
 CONFIG_MOUSE_PS2=y
 CONFIG_MOUSE_SERIAL=y
 # CONFIG_MOUSE_VSXXXAA is not set
 # CONFIG_INPUT_JOYSTICK is not set
 # CONFIG_INPUT_TOUCHSCREEN is not set
 CONFIG_INPUT_MISC=y
 CONFIG_INPUT_SPARCSPKR=y
 # CONFIG_INPUT_UINPUT is not set
 #
 # Hardware I/O ports
 #
 CONFIG_SERIO=y
 CONFIG_SERIO_I8042=y
 # CONFIG_SERIO_SERPORT is not set
 CONFIG_SERIO_PCIPS2=m
 CONFIG_SERIO_LIBPS2=y
 CONFIG_SERIO_RAW=m
 # CONFIG_GAMEPORT is not set
 #
 # Character devices
 #
 CONFIG_VT=y
 CONFIG_VT_CONSOLE=y
 CONFIG_HW_CONSOLE=y
 # CONFIG_VT_HW_CONSOLE_BINDING is not set
 # CONFIG_SERIAL_NONSTANDARD is not set
 #
 # Serial drivers
 #
 #
 # Non-8250 serial port support
 #
 CONFIG_SERIAL_SUNCORE=y
 # CONFIG_SERIAL_SUNZILOG is not set
 CONFIG_SERIAL_SUNSU=y
 CONFIG_SERIAL_SUNSU_CONSOLE=y
 CONFIG_SERIAL_SUNSAB=m
 CONFIG_SERIAL_SUNHV=y
 CONFIG_SERIAL_CORE=y
 CONFIG_SERIAL_CORE_CONSOLE=y
 # CONFIG_SERIAL_JSM is not set
 CONFIG_UNIX98_PTYS=y
 # CONFIG_LEGACY_PTYS is not set
 #
 # IPMI
 #
 # CONFIG_IPMI_HANDLER is not set
 #
 # Watchdog Cards
 #
 # CONFIG_WATCHDOG is not set
 # CONFIG_HW_RANDOM is not set
 CONFIG_RTC=y
 # CONFIG_DTLK is not set
 # CONFIG_R3964 is not set
 # CONFIG_APPLICOM is not set
 # CONFIG_DRM is not set
 # CONFIG_RAW_DRIVER is not set
 #
 # TPM devices
 #
 # CONFIG_TCG_TPM is not set
 #
 # I2C support
 #
 CONFIG_I2C=y
 # CONFIG_I2C_CHARDEV is not set
 #
 # I2C Algorithms
 #
 CONFIG_I2C_ALGOBIT=y
 # CONFIG_I2C_ALGOPCF is not set
 # CONFIG_I2C_ALGOPCA is not set
 #
 # I2C Hardware Bus support
 #
 # CONFIG_I2C_ALI1535 is not set
 # CONFIG_I2C_ALI1563 is not set
 # CONFIG_I2C_ALI15X3 is not set
 # CONFIG_I2C_AMD756 is not set
 # CONFIG_I2C_AMD8111 is not set
 # CONFIG_I2C_I801 is not set
 # CONFIG_I2C_I810 is not set
 # CONFIG_I2C_PIIX4 is not set
 # CONFIG_I2C_NFORCE2 is not set
 # CONFIG_I2C_OCORES is not set
 # CONFIG_I2C_PARPORT_LIGHT is not set
 # CONFIG_I2C_PROSAVAGE is not set
 # CONFIG_I2C_SAVAGE4 is not set
 # CONFIG_I2C_SIS5595 is not set
 # CONFIG_I2C_SIS630 is not set
 # CONFIG_I2C_SIS96X is not set
 # CONFIG_I2C_STUB is not set
 # CONFIG_I2C_VIA is not set
 # CONFIG_I2C_VIAPRO is not set
 # CONFIG_I2C_VOODOO3 is not set
 # CONFIG_I2C_PCA_ISA is not set
 #
 # Miscellaneous I2C Chip support
 #
 # CONFIG_SENSORS_DS1337 is not set
 # CONFIG_SENSORS_DS1374 is not set
 # CONFIG_SENSORS_EEPROM is not set
 # CONFIG_SENSORS_PCF8574 is not set
 # CONFIG_SENSORS_PCA9539 is not set
 # CONFIG_SENSORS_PCF8591 is not set
 # CONFIG_SENSORS_MAX6875 is not set
 # CONFIG_I2C_DEBUG_CORE is not set
 # CONFIG_I2C_DEBUG_ALGO is not set
 # CONFIG_I2C_DEBUG_BUS is not set
 # CONFIG_I2C_DEBUG_CHIP is not set
 #
 # SPI support
 #
 # CONFIG_SPI is not set
 # CONFIG_SPI_MASTER is not set
 #
 # Dallas's 1-wire bus
 #
 # CONFIG_W1 is not set
 #
 # Hardware Monitoring support
 #
 CONFIG_HWMON=y
 # CONFIG_HWMON_VID is not set
 # CONFIG_SENSORS_ABITUGURU is not set
 # CONFIG_SENSORS_ADM1021 is not set
 # CONFIG_SENSORS_ADM1025 is not set
 # CONFIG_SENSORS_ADM1026 is not set
 # CONFIG_SENSORS_ADM1031 is not set
 # CONFIG_SENSORS_ADM9240 is not set
 # CONFIG_SENSORS_ASB100 is not set
 # CONFIG_SENSORS_ATXP1 is not set
 # CONFIG_SENSORS_DS1621 is not set
 # CONFIG_SENSORS_F71805F is not set
 # CONFIG_SENSORS_FSCHER is not set
 # CONFIG_SENSORS_FSCPOS is not set
 # CONFIG_SENSORS_GL518SM is not set
 # CONFIG_SENSORS_GL520SM is not set
 # CONFIG_SENSORS_IT87 is not set
 # CONFIG_SENSORS_LM63 is not set
 # CONFIG_SENSORS_LM75 is not set
 # CONFIG_SENSORS_LM77 is not set
 # CONFIG_SENSORS_LM78 is not set
 # CONFIG_SENSORS_LM80 is not set
 # CONFIG_SENSORS_LM83 is not set
 # CONFIG_SENSORS_LM85 is not set
 # CONFIG_SENSORS_LM87 is not set
 # CONFIG_SENSORS_LM90 is not set
 # CONFIG_SENSORS_LM92 is not set
 # CONFIG_SENSORS_MAX1619 is not set
 # CONFIG_SENSORS_PC87360 is not set
 # CONFIG_SENSORS_PC87427 is not set
 # CONFIG_SENSORS_SIS5595 is not set
 # CONFIG_SENSORS_SMSC47M1 is not set
 # CONFIG_SENSORS_SMSC47M192 is not set
 # CONFIG_SENSORS_SMSC47B397 is not set
 # CONFIG_SENSORS_VIA686A is not set
 # CONFIG_SENSORS_VT1211 is not set
 # CONFIG_SENSORS_VT8231 is not set
 # CONFIG_SENSORS_W83781D is not set
 # CONFIG_SENSORS_W83791D is not set
 # CONFIG_SENSORS_W83792D is not set
 # CONFIG_SENSORS_W83793 is not set
 # CONFIG_SENSORS_W83L785TS is not set
 # CONFIG_SENSORS_W83627HF is not set
 # CONFIG_SENSORS_W83627EHF is not set
 # CONFIG_HWMON_DEBUG_CHIP is not set
 #
 # Multimedia devices
 #
 # CONFIG_VIDEO_DEV is not set
 #
 # Digital Video Broadcasting Devices
 #
 # CONFIG_DVB is not set
 # CONFIG_USB_DABUSB is not set
 #
 # Graphics support
 #
 # CONFIG_FIRMWARE_EDID is not set
 CONFIG_FB=y
 CONFIG_FB_DDC=y
 CONFIG_FB_CFB_FILLRECT=y
 CONFIG_FB_CFB_COPYAREA=y
 CONFIG_FB_CFB_IMAGEBLIT=y
 # CONFIG_FB_MACMODES is not set
 # CONFIG_FB_BACKLIGHT is not set
 CONFIG_FB_MODE_HELPERS=y
 CONFIG_FB_TILEBLITTING=y
 # CONFIG_FB_CIRRUS is not set
 # CONFIG_FB_PM2 is not set
 # CONFIG_FB_ASILIANT is not set
 # CONFIG_FB_IMSTT is not set
 # CONFIG_FB_SBUS is not set
 # CONFIG_FB_S1D13XXX is not set
 # CONFIG_FB_NVIDIA is not set
 # CONFIG_FB_RIVA is not set
 # CONFIG_FB_MATROX is not set
 CONFIG_FB_RADEON=y
 CONFIG_FB_RADEON_I2C=y
 # CONFIG_FB_RADEON_DEBUG is not set
 # CONFIG_FB_ATY128 is not set
 # CONFIG_FB_ATY is not set
 # CONFIG_FB_SAVAGE is not set
 # CONFIG_FB_SIS is not set
 # CONFIG_FB_NEOMAGIC is not set
 # CONFIG_FB_KYRO is not set
 # CONFIG_FB_3DFX is not set
 # CONFIG_FB_VOODOO1 is not set
 # CONFIG_FB_TRIDENT is not set
 # CONFIG_FB_PCI is not set
 # CONFIG_FB_VIRTUAL is not set
 #
 # Console display driver support
 #
 # CONFIG_PROM_CONSOLE is not set
 CONFIG_DUMMY_CONSOLE=y
 CONFIG_FRAMEBUFFER_CONSOLE=y
 # CONFIG_FRAMEBUFFER_CONSOLE_ROTATION is not set
 CONFIG_FONTS=y
 # CONFIG_FONT_8x8 is not set
 # CONFIG_FONT_8x16 is not set
 # CONFIG_FONT_6x11 is not set
 # CONFIG_FONT_7x14 is not set
 # CONFIG_FONT_PEARL_8x8 is not set
 # CONFIG_FONT_ACORN_8x8 is not set
 CONFIG_FONT_SUN8x16=y
 # CONFIG_FONT_SUN12x22 is not set
 # CONFIG_FONT_10x18 is not set
 #
 # Logo configuration
 #
 CONFIG_LOGO=y
 # CONFIG_LOGO_LINUX_MONO is not set
 # CONFIG_LOGO_LINUX_VGA16 is not set
 # CONFIG_LOGO_LINUX_CLUT224 is not set
 CONFIG_LOGO_SUN_CLUT224=y
 # CONFIG_BACKLIGHT_LCD_SUPPORT is not set
 #
 # Sound
 #
 CONFIG_SOUND=m
 #
 # Advanced Linux Sound Architecture
 #
 CONFIG_SND=m
 CONFIG_SND_TIMER=m
 CONFIG_SND_PCM=m
 CONFIG_SND_RAWMIDI=m
 CONFIG_SND_SEQUENCER=m
 CONFIG_SND_SEQ_DUMMY=m
 CONFIG_SND_OSSEMUL=y
 CONFIG_SND_MIXER_OSS=m
 CONFIG_SND_PCM_OSS=m
 CONFIG_SND_PCM_OSS_PLUGINS=y
 CONFIG_SND_SEQUENCER_OSS=y
 # CONFIG_SND_RTCTIMER is not set
 # CONFIG_SND_DYNAMIC_MINORS is not set
 CONFIG_SND_SUPPORT_OLD_API=y
 CONFIG_SND_VERBOSE_PROCFS=y
 # CONFIG_SND_VERBOSE_PRINTK is not set
 # CONFIG_SND_DEBUG is not set
 #
 # Generic devices
 #
 CONFIG_SND_MPU401_UART=m
 CONFIG_SND_AC97_CODEC=m
 CONFIG_SND_DUMMY=m
 CONFIG_SND_VIRMIDI=m
 CONFIG_SND_MTPAV=m
 # CONFIG_SND_SERIAL_U16550 is not set
 # CONFIG_SND_MPU401 is not set
 #
 # PCI devices
 #
 # CONFIG_SND_AD1889 is not set
 # CONFIG_SND_ALS300 is not set
 CONFIG_SND_ALI5451=m
 # CONFIG_SND_ATIIXP is not set
 # CONFIG_SND_ATIIXP_MODEM is not set
 # CONFIG_SND_AU8810 is not set
 # CONFIG_SND_AU8820 is not set
 # CONFIG_SND_AU8830 is not set
 # CONFIG_SND_AZT3328 is not set
 # CONFIG_SND_BT87X is not set
 # CONFIG_SND_CA0106 is not set
 # CONFIG_SND_CMIPCI is not set
 # CONFIG_SND_CS4281 is not set
 # CONFIG_SND_CS46XX is not set
 # CONFIG_SND_DARLA20 is not set
 # CONFIG_SND_GINA20 is not set
 # CONFIG_SND_LAYLA20 is not set
 # CONFIG_SND_DARLA24 is not set
 # CONFIG_SND_GINA24 is not set
 # CONFIG_SND_LAYLA24 is not set
 # CONFIG_SND_MONA is not set
 # CONFIG_SND_MIA is not set
 # CONFIG_SND_ECHO3G is not set
 # CONFIG_SND_INDIGO is not set
 # CONFIG_SND_INDIGOIO is not set
 # CONFIG_SND_INDIGODJ is not set
 # CONFIG_SND_EMU10K1 is not set
 # CONFIG_SND_EMU10K1X is not set
 # CONFIG_SND_ENS1370 is not set
 # CONFIG_SND_ENS1371 is not set
 # CONFIG_SND_ES1938 is not set
 # CONFIG_SND_ES1968 is not set
 # CONFIG_SND_FM801 is not set
 # CONFIG_SND_HDA_INTEL is not set
 # CONFIG_SND_HDSP is not set
 # CONFIG_SND_HDSPM is not set
 # CONFIG_SND_ICE1712 is not set
 # CONFIG_SND_ICE1724 is not set
 # CONFIG_SND_INTEL8X0 is not set
 # CONFIG_SND_INTEL8X0M is not set
 # CONFIG_SND_KORG1212 is not set
 # CONFIG_SND_MAESTRO3 is not set
 # CONFIG_SND_MIXART is not set
 # CONFIG_SND_NM256 is not set
 # CONFIG_SND_PCXHR is not set
 # CONFIG_SND_RIPTIDE is not set
 # CONFIG_SND_RME32 is not set
 # CONFIG_SND_RME96 is not set
 # CONFIG_SND_RME9652 is not set
 # CONFIG_SND_SONICVIBES is not set
 # CONFIG_SND_TRIDENT is not set
 # CONFIG_SND_VIA82XX is not set
 # CONFIG_SND_VIA82XX_MODEM is not set
 # CONFIG_SND_VX222 is not set
 # CONFIG_SND_YMFPCI is not set
 # CONFIG_SND_AC97_POWER_SAVE is not set
 #
 # USB devices
 #
 # CONFIG_SND_USB_AUDIO is not set
 #
 # ALSA Sparc devices
 #
 # CONFIG_SND_SUN_AMD7930 is not set
 CONFIG_SND_SUN_CS4231=m
 # CONFIG_SND_SUN_DBRI is not set
 #
+# SoC audio support
+#
+# CONFIG_SND_SOC is not set
+#
 # Open Sound System
 #
 # CONFIG_SOUND_PRIME is not set
 CONFIG_AC97_BUS=m
 #
 # HID Devices
 #
 CONFIG_HID=y
+# CONFIG_HID_DEBUG is not set
 #
 # USB support
 #
 CONFIG_USB_ARCH_HAS_HCD=y
 CONFIG_USB_ARCH_HAS_OHCI=y
 CONFIG_USB_ARCH_HAS_EHCI=y
 CONFIG_USB=y
 # CONFIG_USB_DEBUG is not set
 #
 # Miscellaneous USB options
 #
 CONFIG_USB_DEVICEFS=y
-# CONFIG_USB_BANDWIDTH is not set
 # CONFIG_USB_DYNAMIC_MINORS is not set
-# CONFIG_USB_MULTITHREAD_PROBE is not set
 # CONFIG_USB_OTG is not set
 #
 # USB Host Controller Drivers
 #
 CONFIG_USB_EHCI_HCD=m
 # CONFIG_USB_EHCI_SPLIT_ISO is not set
 # CONFIG_USB_EHCI_ROOT_HUB_TT is not set
 # CONFIG_USB_EHCI_TT_NEWSCHED is not set
+# CONFIG_USB_EHCI_BIG_ENDIAN_MMIO is not set
 # CONFIG_USB_ISP116X_HCD is not set
 CONFIG_USB_OHCI_HCD=y
-# CONFIG_USB_OHCI_BIG_ENDIAN is not set
+# CONFIG_USB_OHCI_BIG_ENDIAN_DESC is not set
+# CONFIG_USB_OHCI_BIG_ENDIAN_MMIO is not set
 CONFIG_USB_OHCI_LITTLE_ENDIAN=y
 CONFIG_USB_UHCI_HCD=m
 # CONFIG_USB_SL811_HCD is not set
 #
 # USB Device Class drivers
 #
 # CONFIG_USB_ACM is not set
 # CONFIG_USB_PRINTER is not set
 #
 # NOTE: USB_STORAGE enables SCSI, and 'SCSI disk support'
 #
 #
 # may also be needed; see USB_STORAGE Help for more information
 #
 CONFIG_USB_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
 # CONFIG_USB_STORAGE_JUMPSHOT is not set
 # CONFIG_USB_STORAGE_ALAUDA is not set
 # CONFIG_USB_STORAGE_ONETOUCH is not set
 # CONFIG_USB_STORAGE_KARMA is not set
 # CONFIG_USB_LIBUSUAL is not set
 #
 # USB Input Devices
 #
 CONFIG_USB_HID=y
 # CONFIG_USB_HIDINPUT_POWERBOOK is not set
 # CONFIG_HID_FF is not set
 CONFIG_USB_HIDDEV=y
 # CONFIG_USB_AIPTEK is not set
 # CONFIG_USB_WACOM is not set
 # CONFIG_USB_ACECAD is not set
 # CONFIG_USB_KBTAB is not set
 # CONFIG_USB_POWERMATE is not set
 # CONFIG_USB_TOUCHSCREEN is not set
 # CONFIG_USB_YEALINK is not set
 # CONFIG_USB_XPAD is not set
 # CONFIG_USB_ATI_REMOTE is not set
 # CONFIG_USB_ATI_REMOTE2 is not set
 # CONFIG_USB_KEYSPAN_REMOTE is not set
 # CONFIG_USB_APPLETOUCH is not set
+# CONFIG_USB_GTCO is not set
 #
 # USB Imaging devices
 #
 # CONFIG_USB_MDC800 is not set
 # CONFIG_USB_MICROTEK is not set
 #
 # USB Network Adapters
 #
 # CONFIG_USB_CATC is not set
 # CONFIG_USB_KAWETH is not set
 # CONFIG_USB_PEGASUS is not set
 # CONFIG_USB_RTL8150 is not set
 # CONFIG_USB_USBNET_MII is not set
 # CONFIG_USB_USBNET is not set
 # CONFIG_USB_MON is not set
 #
 # USB port drivers
 #
 #
 # USB Serial Converter support
 #
 # CONFIG_USB_SERIAL is not set
 #
 # USB Miscellaneous drivers
 #
 # CONFIG_USB_EMI62 is not set
 # CONFIG_USB_EMI26 is not set
 # CONFIG_USB_ADUTUX is not set
 # CONFIG_USB_AUERSWALD is not set
 # CONFIG_USB_RIO500 is not set
 # CONFIG_USB_LEGOTOWER is not set
 # CONFIG_USB_LCD is not set
 # CONFIG_USB_LED is not set
 # CONFIG_USB_CYPRESS_CY7C63 is not set
 # CONFIG_USB_CYTHERM is not set
 # CONFIG_USB_PHIDGET is not set
 # CONFIG_USB_IDMOUSE is not set
 # CONFIG_USB_FTDI_ELAN is not set
 # CONFIG_USB_APPLEDISPLAY is not set
 # CONFIG_USB_SISUSBVGA is not set
 # CONFIG_USB_LD is not set
 # CONFIG_USB_TRANCEVIBRATOR is not set
 # CONFIG_USB_TEST is not set
 #
 # USB DSL modem support
 #
 #
 # USB Gadget Support
 #
 # CONFIG_USB_GADGET is not set
 #
 # MMC/SD Card support
 #
 # CONFIG_MMC is not set
 #
 # LED devices
 #
 # CONFIG_NEW_LEDS is not set
 #
 # LED drivers
 #
 #
 # LED Triggers
 #
 #
 # InfiniBand support
 #
 # CONFIG_INFINIBAND is not set
 #
 # EDAC - error detection and reporting (RAS) (EXPERIMENTAL)
 #
 #
 # Real Time Clock
 #
 # CONFIG_RTC_CLASS is not set
 #
 # DMA Engine support
 #
 # CONFIG_DMA_ENGINE is not set
 #
 # DMA Clients
 #
 #
 # DMA Devices
 #
 #
 # Virtualization
 #
 #
 # Misc Linux/SPARC drivers
 #
 CONFIG_SUN_OPENPROMIO=m
 CONFIG_SUN_MOSTEK_RTC=y
 # CONFIG_OBP_FLASH is not set
 # CONFIG_SUN_BPP is not set
 # CONFIG_BBC_I2C is not set
 # CONFIG_ENVCTRL is not set
 # CONFIG_DISPLAY7SEG is not set
 #
 # Fibre Channel support
 #
 # CONFIG_FC4 is not set
 #
 # File systems
 #
 CONFIG_EXT2_FS=y
 CONFIG_EXT2_FS_XATTR=y
 CONFIG_EXT2_FS_POSIX_ACL=y
 CONFIG_EXT2_FS_SECURITY=y
 # CONFIG_EXT2_FS_XIP is not set
 CONFIG_EXT3_FS=y
 CONFIG_EXT3_FS_XATTR=y
 CONFIG_EXT3_FS_POSIX_ACL=y
 CONFIG_EXT3_FS_SECURITY=y
 # CONFIG_EXT4DEV_FS is not set
 CONFIG_JBD=y
 # CONFIG_JBD_DEBUG is not set
 CONFIG_FS_MBCACHE=y
 # CONFIG_REISERFS_FS is not set
 # CONFIG_JFS_FS is not set
 CONFIG_FS_POSIX_ACL=y
 # CONFIG_XFS_FS is not set
 # CONFIG_GFS2_FS is not set
 # CONFIG_OCFS2_FS is not set
 # CONFIG_MINIX_FS is not set
 # CONFIG_ROMFS_FS is not set
 CONFIG_INOTIFY=y
 CONFIG_INOTIFY_USER=y
 # CONFIG_QUOTA is not set
 CONFIG_DNOTIFY=y
 # CONFIG_AUTOFS_FS is not set
 # CONFIG_AUTOFS4_FS is not set
 # CONFIG_FUSE_FS is not set
 #
 # CD-ROM/DVD Filesystems
 #
 # CONFIG_ISO9660_FS is not set
 # CONFIG_UDF_FS is not set
 #
 # DOS/FAT/NT Filesystems
 #
 # CONFIG_MSDOS_FS is not set
 # CONFIG_VFAT_FS is not set
 # CONFIG_NTFS_FS is not set
 #
 # Pseudo filesystems
 #
 CONFIG_PROC_FS=y
 CONFIG_PROC_KCORE=y
 CONFIG_PROC_SYSCTL=y
 CONFIG_SYSFS=y
 CONFIG_TMPFS=y
 # CONFIG_TMPFS_POSIX_ACL is not set
 CONFIG_HUGETLBFS=y
 CONFIG_HUGETLB_PAGE=y
 CONFIG_RAMFS=y
 # CONFIG_CONFIGFS_FS is not set
 #
 # Miscellaneous filesystems
 #
 # CONFIG_ADFS_FS is not set
 # CONFIG_AFFS_FS is not set
 # CONFIG_ECRYPT_FS is not set
 # CONFIG_HFS_FS is not set
 # CONFIG_HFSPLUS_FS is not set
 # CONFIG_BEFS_FS is not set
 # CONFIG_BFS_FS is not set
 # CONFIG_EFS_FS is not set
 # CONFIG_CRAMFS is not set
 # CONFIG_VXFS_FS is not set
 # CONFIG_HPFS_FS is not set
 # CONFIG_QNX4FS_FS is not set
 # CONFIG_SYSV_FS is not set
 # CONFIG_UFS_FS is not set
 #
 # Network File Systems
 #
 # CONFIG_NFS_FS is not set
 # CONFIG_NFSD is not set
 # CONFIG_SMB_FS is not set
 # CONFIG_CIFS is not set
 # CONFIG_NCP_FS is not set
 # CONFIG_CODA_FS is not set
 # CONFIG_AFS_FS is not set
 # CONFIG_9P_FS is not set
 #
 # Partition Types
 #
 # CONFIG_PARTITION_ADVANCED is not set
 CONFIG_MSDOS_PARTITION=y
 CONFIG_SUN_PARTITION=y
 #
 # Native Language Support
 #
 CONFIG_NLS=m
 CONFIG_NLS_DEFAULT="iso8859-1"
 # CONFIG_NLS_CODEPAGE_437 is not set
 # CONFIG_NLS_CODEPAGE_737 is not set
 # CONFIG_NLS_CODEPAGE_775 is not set
 # CONFIG_NLS_CODEPAGE_850 is not set
 # CONFIG_NLS_CODEPAGE_852 is not set
 # CONFIG_NLS_CODEPAGE_855 is not set
 # CONFIG_NLS_CODEPAGE_857 is not set
 # CONFIG_NLS_CODEPAGE_860 is not set
 # CONFIG_NLS_CODEPAGE_861 is not set
 # CONFIG_NLS_CODEPAGE_862 is not set
 # CONFIG_NLS_CODEPAGE_863 is not set
 # CONFIG_NLS_CODEPAGE_864 is not set
 # CONFIG_NLS_CODEPAGE_865 is not set
 # CONFIG_NLS_CODEPAGE_866 is not set
 # CONFIG_NLS_CODEPAGE_869 is not set
 # CONFIG_NLS_CODEPAGE_936 is not set
 # CONFIG_NLS_CODEPAGE_950 is not set
 # CONFIG_NLS_CODEPAGE_932 is not set
 # CONFIG_NLS_CODEPAGE_949 is not set
 # CONFIG_NLS_CODEPAGE_874 is not set
 # CONFIG_NLS_ISO8859_8 is not set
 # CONFIG_NLS_CODEPAGE_1250 is not set
 # CONFIG_NLS_CODEPAGE_1251 is not set
 # CONFIG_NLS_ASCII is not set
 # CONFIG_NLS_ISO8859_1 is not set
 # CONFIG_NLS_ISO8859_2 is not set
 # CONFIG_NLS_ISO8859_3 is not set
 # CONFIG_NLS_ISO8859_4 is not set
 # CONFIG_NLS_ISO8859_5 is not set
 # CONFIG_NLS_ISO8859_6 is not set
 # CONFIG_NLS_ISO8859_7 is not set
 # CONFIG_NLS_ISO8859_9 is not set
 # CONFIG_NLS_ISO8859_13 is not set
 # CONFIG_NLS_ISO8859_14 is not set
 # CONFIG_NLS_ISO8859_15 is not set
 # CONFIG_NLS_KOI8_R is not set
 # CONFIG_NLS_KOI8_U is not set
 # CONFIG_NLS_UTF8 is not set
 #
 # Distributed Lock Manager
 #
 # CONFIG_DLM is not set
 #
 # Instrumentation Support
 #
 CONFIG_PROFILING=y
 CONFIG_OPROFILE=m
 CONFIG_KPROBES=y
 #
 # Kernel hacking
 #
 CONFIG_TRACE_IRQFLAGS_SUPPORT=y
 CONFIG_PRINTK_TIME=y
 CONFIG_ENABLE_MUST_CHECK=y
 CONFIG_MAGIC_SYSRQ=y
 # CONFIG_UNUSED_SYMBOLS is not set
 CONFIG_DEBUG_FS=y
 # CONFIG_HEADERS_CHECK is not set
 CONFIG_DEBUG_KERNEL=y
 CONFIG_LOG_BUF_SHIFT=18
 CONFIG_DETECT_SOFTLOCKUP=y
 CONFIG_SCHEDSTATS=y
 # CONFIG_DEBUG_SLAB is not set
 # CONFIG_DEBUG_RT_MUTEXES is not set
 # CONFIG_RT_MUTEX_TESTER is not set
 # CONFIG_DEBUG_SPINLOCK is not set
 # CONFIG_DEBUG_MUTEXES is not set
 # CONFIG_DEBUG_RWSEMS is not set
 # CONFIG_DEBUG_LOCK_ALLOC is not set
 # CONFIG_PROVE_LOCKING is not set
 # CONFIG_DEBUG_SPINLOCK_SLEEP is not set
 # CONFIG_DEBUG_LOCKING_API_SELFTESTS is not set
 # CONFIG_DEBUG_KOBJECT is not set
 CONFIG_DEBUG_BUGVERBOSE=y
 # CONFIG_DEBUG_INFO is not set
 # CONFIG_DEBUG_VM is not set
 # CONFIG_DEBUG_LIST is not set
 CONFIG_FORCED_INLINING=y
 # CONFIG_RCU_TORTURE_TEST is not set
 # CONFIG_LKDTM is not set
 # CONFIG_DEBUG_STACK_USAGE is not set
 # CONFIG_DEBUG_DCFLUSH is not set
 # CONFIG_STACK_DEBUG is not set
 # CONFIG_DEBUG_BOOTMEM is not set
 # CONFIG_DEBUG_PAGEALLOC is not set
 #
 # Security options
 #
 CONFIG_KEYS=y
 # CONFIG_KEYS_DEBUG_PROC_KEYS is not set
 # CONFIG_SECURITY is not set
 #
 # Cryptographic options
 #
 CONFIG_CRYPTO=y
 CONFIG_CRYPTO_ALGAPI=y
 CONFIG_CRYPTO_BLKCIPHER=y
 CONFIG_CRYPTO_HASH=y
 CONFIG_CRYPTO_MANAGER=y
 CONFIG_CRYPTO_HMAC=y
 CONFIG_CRYPTO_XCBC=y
 CONFIG_CRYPTO_NULL=m
 CONFIG_CRYPTO_MD4=y
 CONFIG_CRYPTO_MD5=y
 CONFIG_CRYPTO_SHA1=y
 CONFIG_CRYPTO_SHA256=m
 CONFIG_CRYPTO_SHA512=m
 CONFIG_CRYPTO_WP512=m
 CONFIG_CRYPTO_TGR192=m
 CONFIG_CRYPTO_GF128MUL=m
 CONFIG_CRYPTO_ECB=m
 CONFIG_CRYPTO_CBC=y
+CONFIG_CRYPTO_PCBC=m
 CONFIG_CRYPTO_LRW=m
 CONFIG_CRYPTO_DES=y
+CONFIG_CRYPTO_FCRYPT=m
 CONFIG_CRYPTO_BLOWFISH=m
 CONFIG_CRYPTO_TWOFISH=m
 CONFIG_CRYPTO_TWOFISH_COMMON=m
 CONFIG_CRYPTO_SERPENT=m
 CONFIG_CRYPTO_AES=m
 CONFIG_CRYPTO_CAST5=m
 CONFIG_CRYPTO_CAST6=m
 CONFIG_CRYPTO_TEA=m
 CONFIG_CRYPTO_ARC4=m
 CONFIG_CRYPTO_KHAZAD=m
 CONFIG_CRYPTO_ANUBIS=m
 CONFIG_CRYPTO_DEFLATE=y
 CONFIG_CRYPTO_MICHAEL_MIC=m
 CONFIG_CRYPTO_CRC32C=m
+CONFIG_CRYPTO_CAMELLIA=m
 CONFIG_CRYPTO_TEST=m
 #
 # Hardware crypto devices
 #
 #
 # Library routines
 #
 CONFIG_BITREVERSE=y
 CONFIG_CRC_CCITT=m
 CONFIG_CRC16=m
 CONFIG_CRC32=y
 CONFIG_LIBCRC32C=m
 CONFIG_ZLIB_INFLATE=y
 CONFIG_ZLIB_DEFLATE=y
 CONFIG_PLIST=y

arch/sparc64/kernel/irq.c

Diff comments View file @ c827ba4

 /* $Id: irq.c,v 1.114 2002/01/11 08:45:38 davem Exp $
  * irq.c: UltraSparc IRQ handling/init/registry.
  *
  * Copyright (C) 1997  David S. Miller  (davem@caip.rutgers.edu)
  * Copyright (C) 1998  Eddie C. Dost    (ecd@skynet.be)
  * Copyright (C) 1998  Jakub Jelinek    (jj@ultra.linux.cz)
  */
 #include <linux/module.h>
 #include <linux/sched.h>
 #include <linux/ptrace.h>
 #include <linux/errno.h>
 #include <linux/kernel_stat.h>
 #include <linux/signal.h>
 #include <linux/mm.h>
 #include <linux/interrupt.h>
 #include <linux/slab.h>
 #include <linux/random.h>
 #include <linux/init.h>
 #include <linux/delay.h>
 #include <linux/proc_fs.h>
 #include <linux/seq_file.h>
 #include <linux/bootmem.h>
 #include <linux/irq.h>
+#include <linux/msi.h>
 #include <asm/ptrace.h>
 #include <asm/processor.h>
 #include <asm/atomic.h>
 #include <asm/system.h>
 #include <asm/irq.h>
 #include <asm/io.h>
 #include <asm/sbus.h>
 #include <asm/iommu.h>
 #include <asm/upa.h>
 #include <asm/oplib.h>
 #include <asm/prom.h>
 #include <asm/timer.h>
 #include <asm/smp.h>
 #include <asm/starfire.h>
 #include <asm/uaccess.h>
 #include <asm/cache.h>
 #include <asm/cpudata.h>
 #include <asm/auxio.h>
 #include <asm/head.h>
 /* UPA nodes send interrupt packet to UltraSparc with first data reg
  * value low 5 (7 on Starfire) bits holding the IRQ identifier being
  * delivered.  We must translate this into a non-vector IRQ so we can
  * set the softint on this cpu.
  *
  * To make processing these packets efficient and race free we use
  * an array of irq buckets below.  The interrupt vector handler in
  * entry.S feeds incoming packets into per-cpu pil-indexed lists.
  * The IVEC handler does not need to act atomically, the PIL dispatch
  * code uses CAS to get an atomic snapshot of the list and clear it
  * at the same time.
  *
  * If you make changes to ino_bucket, please update hand coded assembler
  * of the vectored interrupt trap handler(s) in entry.S and sun4v_ivec.S
  */
 struct ino_bucket {
 	/* Next handler in per-CPU IRQ worklist.  We know that
 	 * bucket pointers have the high 32-bits clear, so to
 	 * save space we only store the bits we need.
 	 */
 /*0x00*/unsigned int irq_chain;
 	/* Virtual interrupt number assigned to this INO.  */
 /*0x04*/unsigned int virt_irq;
 };
 #define NUM_IVECS	(IMAP_INR + 1)
 struct ino_bucket ivector_table[NUM_IVECS] __attribute__ ((aligned (SMP_CACHE_BYTES)));
 #define __irq_ino(irq) \
         (((struct ino_bucket *)(unsigned long)(irq)) - &ivector_table[0])
 #define __bucket(irq) ((struct ino_bucket *)(unsigned long)(irq))
 #define __irq(bucket) ((unsigned int)(unsigned long)(bucket))
 /* This has to be in the main kernel image, it cannot be
  * turned into per-cpu data.  The reason is that the main
  * kernel image is locked into the TLB and this structure
  * is accessed from the vectored interrupt trap handler.  If
  * access to this structure takes a TLB miss it could cause
  * the 5-level sparc v9 trap stack to overflow.
  */
 #define irq_work(__cpu)	&(trap_block[(__cpu)].irq_worklist)
 static unsigned int virt_to_real_irq_table[NR_IRQS];
-static unsigned char virt_irq_cur = 1;
 static unsigned char virt_irq_alloc(unsigned int real_irq)
 {
 	unsigned char ent;
 	BUILD_BUG_ON(NR_IRQS >= 256);
-	ent = virt_irq_cur;
+	for (ent = 1; ent < NR_IRQS; ent++) {
+		if (!virt_to_real_irq_table[ent])
+			break;
+	}
 	if (ent >= NR_IRQS) {
 		printk(KERN_ERR "IRQ: Out of virtual IRQs.\n");
 		return 0;
 	}
-	virt_irq_cur = ent + 1;
 	virt_to_real_irq_table[ent] = real_irq;
 	return ent;
 }
-#if 0 /* Currently unused. */
+static void virt_irq_free(unsigned int virt_irq)
-static unsigned char real_to_virt_irq(unsigned int real_irq)
 {
-	struct ino_bucket *bucket = __bucket(real_irq);
+	unsigned int real_irq;
-	return bucket->virt_irq;
+	if (virt_irq >= NR_IRQS)
+		return;
+	real_irq = virt_to_real_irq_table[virt_irq];
+	virt_to_real_irq_table[virt_irq] = 0;
+	__bucket(real_irq)->virt_irq = 0;
 }
-#endif
 static unsigned int virt_to_real_irq(unsigned char virt_irq)
 {
 	return virt_to_real_irq_table[virt_irq];
 }
 /*
  * /proc/interrupts printing:
  */
 int show_interrupts(struct seq_file *p, void *v)
 {
 	int i = *(loff_t *) v, j;
 	struct irqaction * action;
 	unsigned long flags;
 	if (i == 0) {
 		seq_printf(p, "           ");
 		for_each_online_cpu(j)
 			seq_printf(p, "CPU%d       ",j);
 		seq_putc(p, '\n');
 	}
 	if (i < NR_IRQS) {
 		spin_lock_irqsave(&irq_desc[i].lock, flags);
 		action = irq_desc[i].action;
 		if (!action)
 			goto skip;
 		seq_printf(p, "%3d: ",i);
 #ifndef CONFIG_SMP
 		seq_printf(p, "%10u ", kstat_irqs(i));
 #else
 		for_each_online_cpu(j)
 			seq_printf(p, "%10u ", kstat_cpu(j).irqs[i]);
 #endif
 		seq_printf(p, " %9s", irq_desc[i].chip->typename);
 		seq_printf(p, "  %s", action->name);
 		for (action=action->next; action; action = action->next)
 			seq_printf(p, ", %s", action->name);
 		seq_putc(p, '\n');
 skip:
 		spin_unlock_irqrestore(&irq_desc[i].lock, flags);
 	}
 	return 0;
 }
 extern unsigned long real_hard_smp_processor_id(void);
 static unsigned int sun4u_compute_tid(unsigned long imap, unsigned long cpuid)
 {
 	unsigned int tid;
 	if (this_is_starfire) {
 		tid = starfire_translate(imap, cpuid);
 		tid <<= IMAP_TID_SHIFT;
 		tid &= IMAP_TID_UPA;
 	} else {
 		if (tlb_type == cheetah || tlb_type == cheetah_plus) {
 			unsigned long ver;
 			__asm__ ("rdpr %%ver, %0" : "=r" (ver));
 			if ((ver >> 32UL) == __JALAPENO_ID ||
 			    (ver >> 32UL) == __SERRANO_ID) {
 				tid = cpuid << IMAP_TID_SHIFT;
 				tid &= IMAP_TID_JBUS;
 			} else {
 				unsigned int a = cpuid & 0x1f;
 				unsigned int n = (cpuid >> 5) & 0x1f;
 				tid = ((a << IMAP_AID_SHIFT) |
 				       (n << IMAP_NID_SHIFT));
 				tid &= (IMAP_AID_SAFARI |
 					IMAP_NID_SAFARI);;
 			}
 		} else {
 			tid = cpuid << IMAP_TID_SHIFT;
 			tid &= IMAP_TID_UPA;
 		}
 	}
 	return tid;
 }
 struct irq_handler_data {
 	unsigned long	iclr;
 	unsigned long	imap;
 	void		(*pre_handler)(unsigned int, void *, void *);
 	void		*pre_handler_arg1;
 	void		*pre_handler_arg2;
 };
 static inline struct ino_bucket *virt_irq_to_bucket(unsigned int virt_irq)
 {
 	unsigned int real_irq = virt_to_real_irq(virt_irq);
 	struct ino_bucket *bucket = NULL;
 	if (likely(real_irq))
 		bucket = __bucket(real_irq);
 	return bucket;
 }
 #ifdef CONFIG_SMP
 static int irq_choose_cpu(unsigned int virt_irq)
 {
 	cpumask_t mask = irq_desc[virt_irq].affinity;
 	int cpuid;
 	if (cpus_equal(mask, CPU_MASK_ALL)) {
 		static int irq_rover;
 		static DEFINE_SPINLOCK(irq_rover_lock);
 		unsigned long flags;
 		/* Round-robin distribution... */
 	do_round_robin:
 		spin_lock_irqsave(&irq_rover_lock, flags);
 		while (!cpu_online(irq_rover)) {
 			if (++irq_rover >= NR_CPUS)
 				irq_rover = 0;
 		}
 		cpuid = irq_rover;
 		do {
 			if (++irq_rover >= NR_CPUS)
 				irq_rover = 0;
 		} while (!cpu_online(irq_rover));
 		spin_unlock_irqrestore(&irq_rover_lock, flags);
 	} else {
 		cpumask_t tmp;
 		cpus_and(tmp, cpu_online_map, mask);
 		if (cpus_empty(tmp))
 			goto do_round_robin;
 		cpuid = first_cpu(tmp);
 	}
 	return cpuid;
 }
 #else
 static int irq_choose_cpu(unsigned int virt_irq)
 {
 	return real_hard_smp_processor_id();
 }
 #endif
 static void sun4u_irq_enable(unsigned int virt_irq)
 {
-	irq_desc_t *desc = irq_desc + virt_irq;
+	struct irq_handler_data *data = get_irq_chip_data(virt_irq);
-	struct irq_handler_data *data = desc->handler_data;
 	if (likely(data)) {
 		unsigned long cpuid, imap;
 		unsigned int tid;
 		cpuid = irq_choose_cpu(virt_irq);
 		imap = data->imap;
 		tid = sun4u_compute_tid(imap, cpuid);
 		upa_writel(tid | IMAP_VALID, imap);
 	}
 }
 static void sun4u_irq_disable(unsigned int virt_irq)
 {
-	irq_desc_t *desc = irq_desc + virt_irq;
+	struct irq_handler_data *data = get_irq_chip_data(virt_irq);
-	struct irq_handler_data *data = desc->handler_data;
 	if (likely(data)) {
 		unsigned long imap = data->imap;
 		u32 tmp = upa_readl(imap);
 		tmp &= ~IMAP_VALID;
 		upa_writel(tmp, imap);
 	}
 }
 static void sun4u_irq_end(unsigned int virt_irq)
 {
-	irq_desc_t *desc = irq_desc + virt_irq;
+	struct irq_handler_data *data = get_irq_chip_data(virt_irq);
-	struct irq_handler_data *data = desc->handler_data;
 	if (likely(data))
 		upa_writel(ICLR_IDLE, data->iclr);
 }
 static void sun4v_irq_enable(unsigned int virt_irq)
 {
 	struct ino_bucket *bucket = virt_irq_to_bucket(virt_irq);
 	unsigned int ino = bucket - &ivector_table[0];
 	if (likely(bucket)) {
 		unsigned long cpuid;
 		int err;
 		cpuid = irq_choose_cpu(virt_irq);
 		err = sun4v_intr_settarget(ino, cpuid);
 		if (err != HV_EOK)
 			printk("sun4v_intr_settarget(%x,%lu): err(%d)\n",
 			       ino, cpuid, err);
 		err = sun4v_intr_setenabled(ino, HV_INTR_ENABLED);
 		if (err != HV_EOK)
 			printk("sun4v_intr_setenabled(%x): err(%d)\n",
 			       ino, err);
 	}
 }
 static void sun4v_irq_disable(unsigned int virt_irq)
 {
 	struct ino_bucket *bucket = virt_irq_to_bucket(virt_irq);
 	unsigned int ino = bucket - &ivector_table[0];
 	if (likely(bucket)) {
 		int err;
 		err = sun4v_intr_setenabled(ino, HV_INTR_DISABLED);
 		if (err != HV_EOK)
 			printk("sun4v_intr_setenabled(%x): "
 			       "err(%d)\n", ino, err);
 	}
 }
+#ifdef CONFIG_PCI_MSI
+static void sun4v_msi_enable(unsigned int virt_irq)
+{
+	sun4v_irq_enable(virt_irq);
+	unmask_msi_irq(virt_irq);
+}
+static void sun4v_msi_disable(unsigned int virt_irq)
+{
+	mask_msi_irq(virt_irq);
+	sun4v_irq_disable(virt_irq);
+}
+#endif
 static void sun4v_irq_end(unsigned int virt_irq)
 {
 	struct ino_bucket *bucket = virt_irq_to_bucket(virt_irq);
 	unsigned int ino = bucket - &ivector_table[0];
 	if (likely(bucket)) {
 		int err;
 		err = sun4v_intr_setstate(ino, HV_INTR_STATE_IDLE);
 		if (err != HV_EOK)
 			printk("sun4v_intr_setstate(%x): "
 			       "err(%d)\n", ino, err);
 	}
 }
 static void run_pre_handler(unsigned int virt_irq)
 {
 	struct ino_bucket *bucket = virt_irq_to_bucket(virt_irq);
-	irq_desc_t *desc = irq_desc + virt_irq;
+	struct irq_handler_data *data = get_irq_chip_data(virt_irq);
-	struct irq_handler_data *data = desc->handler_data;
 	if (likely(data->pre_handler)) {
 		data->pre_handler(__irq_ino(__irq(bucket)),
 				  data->pre_handler_arg1,
 				  data->pre_handler_arg2);
 	}
 }
 static struct irq_chip sun4u_irq = {
 	.typename	= "sun4u",
 	.enable		= sun4u_irq_enable,
 	.disable	= sun4u_irq_disable,
 	.end		= sun4u_irq_end,
 };
 static struct irq_chip sun4u_irq_ack = {
 	.typename	= "sun4u+ack",
 	.enable		= sun4u_irq_enable,
 	.disable	= sun4u_irq_disable,
 	.ack		= run_pre_handler,
 	.end		= sun4u_irq_end,
 };
 static struct irq_chip sun4v_irq = {
 	.typename	= "sun4v",
 	.enable		= sun4v_irq_enable,
 	.disable	= sun4v_irq_disable,
 	.end		= sun4v_irq_end,
 };
 static struct irq_chip sun4v_irq_ack = {
 	.typename	= "sun4v+ack",
 	.enable		= sun4v_irq_enable,
 	.disable	= sun4v_irq_disable,
 	.ack		= run_pre_handler,
 	.end		= sun4v_irq_end,
 };
+#ifdef CONFIG_PCI_MSI
+static struct irq_chip sun4v_msi = {
+	.typename	= "sun4v+msi",
+	.mask		= mask_msi_irq,
+	.unmask		= unmask_msi_irq,
+	.enable		= sun4v_msi_enable,
+	.disable	= sun4v_msi_disable,
+	.ack		= run_pre_handler,
+	.end		= sun4v_irq_end,
+};
+#endif
 void irq_install_pre_handler(int virt_irq,
 			     void (*func)(unsigned int, void *, void *),
 			     void *arg1, void *arg2)
 {
-	irq_desc_t *desc = irq_desc + virt_irq;
+	struct irq_handler_data *data = get_irq_chip_data(virt_irq);
-	struct irq_handler_data *data = desc->handler_data;
+	struct irq_chip *chip;
 	data->pre_handler = func;
 	data->pre_handler_arg1 = arg1;
 	data->pre_handler_arg2 = arg2;
-	if (desc->chip == &sun4u_irq_ack ||
+	chip = get_irq_chip(virt_irq);
-	    desc->chip == &sun4v_irq_ack)
+	if (chip == &sun4u_irq_ack ||
+	    chip == &sun4v_irq_ack
+#ifdef CONFIG_PCI_MSI
+	    || chip == &sun4v_msi
+#endif
+	    )
 		return;
-	desc->chip = (desc->chip == &sun4u_irq ?
+	chip = (chip == &sun4u_irq ?
-		      &sun4u_irq_ack : &sun4v_irq_ack);
+		&sun4u_irq_ack : &sun4v_irq_ack);
+	set_irq_chip(virt_irq, chip);
 }
 unsigned int build_irq(int inofixup, unsigned long iclr, unsigned long imap)
 {
 	struct ino_bucket *bucket;
 	struct irq_handler_data *data;
-	irq_desc_t *desc;
 	int ino;
 	BUG_ON(tlb_type == hypervisor);
 	ino = (upa_readl(imap) & (IMAP_IGN | IMAP_INO)) + inofixup;
 	bucket = &ivector_table[ino];
 	if (!bucket->virt_irq) {
 		bucket->virt_irq = virt_irq_alloc(__irq(bucket));
-		irq_desc[bucket->virt_irq].chip = &sun4u_irq;
+		set_irq_chip(bucket->virt_irq, &sun4u_irq);
 	}
-	desc = irq_desc + bucket->virt_irq;
+	data = get_irq_chip_data(bucket->virt_irq);
-	if (unlikely(desc->handler_data))
+	if (unlikely(data))
 		goto out;
 	data = kzalloc(sizeof(struct irq_handler_data), GFP_ATOMIC);
 	if (unlikely(!data)) {
 		prom_printf("IRQ: kzalloc(irq_handler_data) failed.\n");
 		prom_halt();
 	}
-	desc->handler_data = data;
+	set_irq_chip_data(bucket->virt_irq, data);
 	data->imap  = imap;
 	data->iclr  = iclr;
 out:
 	return bucket->virt_irq;
 }
 unsigned int sun4v_build_irq(u32 devhandle, unsigned int devino)
 {
 	struct ino_bucket *bucket;
 	struct irq_handler_data *data;
 	unsigned long sysino;
-	irq_desc_t *desc;
 	BUG_ON(tlb_type != hypervisor);
 	sysino = sun4v_devino_to_sysino(devhandle, devino);
 	bucket = &ivector_table[sysino];
 	if (!bucket->virt_irq) {
 		bucket->virt_irq = virt_irq_alloc(__irq(bucket));
-		irq_desc[bucket->virt_irq].chip = &sun4v_irq;
+		set_irq_chip(bucket->virt_irq, &sun4v_irq);
 	}
-	desc = irq_desc + bucket->virt_irq;
+	data = get_irq_chip_data(bucket->virt_irq);
-	if (unlikely(desc->handler_data))
+	if (unlikely(data))
 		goto out;
 	data = kzalloc(sizeof(struct irq_handler_data), GFP_ATOMIC);
 	if (unlikely(!data)) {
 		prom_printf("IRQ: kzalloc(irq_handler_data) failed.\n");
 		prom_halt();
 	}
-	desc->handler_data = data;
+	set_irq_chip_data(bucket->virt_irq, data);
 	/* Catch accidental accesses to these things.  IMAP/ICLR handling
 	 * is done by hypervisor calls on sun4v platforms, not by direct
 	 * register accesses.
 	 */
 	data->imap = ~0UL;
 	data->iclr = ~0UL;
 out:
 	return bucket->virt_irq;
 }
+#ifdef CONFIG_PCI_MSI
+unsigned int sun4v_build_msi(u32 devhandle, unsigned int *virt_irq_p,
+			     unsigned int msi_start, unsigned int msi_end)
+{
+	struct ino_bucket *bucket;
+	struct irq_handler_data *data;
+	unsigned long sysino;
+	unsigned int devino;
+	BUG_ON(tlb_type != hypervisor);
+	/* Find a free devino in the given range.  */
+	for (devino = msi_start; devino < msi_end; devino++) {
+		sysino = sun4v_devino_to_sysino(devhandle, devino);
+		bucket = &ivector_table[sysino];
+		if (!bucket->virt_irq)
+			break;
+	}
+	if (devino >= msi_end)
+		return 0;
+	sysino = sun4v_devino_to_sysino(devhandle, devino);
+	bucket = &ivector_table[sysino];
+	bucket->virt_irq = virt_irq_alloc(__irq(bucket));
+	*virt_irq_p = bucket->virt_irq;
+	set_irq_chip(bucket->virt_irq, &sun4v_msi);
+	data = get_irq_chip_data(bucket->virt_irq);
+	if (unlikely(data))
+		return devino;
+	data = kzalloc(sizeof(struct irq_handler_data), GFP_ATOMIC);
+	if (unlikely(!data)) {
+		prom_printf("IRQ: kzalloc(irq_handler_data) failed.\n");
+		prom_halt();
+	}
+	set_irq_chip_data(bucket->virt_irq, data);
+	data->imap = ~0UL;
+	data->iclr = ~0UL;
+	return devino;
+}
+void sun4v_destroy_msi(unsigned int virt_irq)
+{
+	virt_irq_free(virt_irq);
+}
+#endif
 void ack_bad_irq(unsigned int virt_irq)
 {
 	struct ino_bucket *bucket = virt_irq_to_bucket(virt_irq);
 	unsigned int ino = 0xdeadbeef;
 	if (bucket)
 		ino = bucket - &ivector_table[0];
 	printk(KERN_CRIT "Unexpected IRQ from ino[%x] virt_irq[%u]\n",
 	       ino, virt_irq);
 }
 #ifndef CONFIG_SMP
 extern irqreturn_t timer_interrupt(int, void *);
 void timer_irq(int irq, struct pt_regs *regs)
 {
 	unsigned long clr_mask = 1 << irq;
 	unsigned long tick_mask = tick_ops->softint_mask;
 	struct pt_regs *old_regs;
 	if (get_softint() & tick_mask) {
 		irq = 0;
 		clr_mask = tick_mask;
 	}
 	clear_softint(clr_mask);
 	old_regs = set_irq_regs(regs);
 	irq_enter();
 	kstat_this_cpu.irqs[0]++;
 	timer_interrupt(irq, NULL);
 	irq_exit();
 	set_irq_regs(old_regs);
 }
 #endif
 void handler_irq(int irq, struct pt_regs *regs)
 {
 	struct ino_bucket *bucket;
 	struct pt_regs *old_regs;
 	clear_softint(1 << irq);
 	old_regs = set_irq_regs(regs);
 	irq_enter();
 	/* Sliiiick... */
 	bucket = __bucket(xchg32(irq_work(smp_processor_id()), 0));
 	while (bucket) {
 		struct ino_bucket *next = __bucket(bucket->irq_chain);
 		bucket->irq_chain = 0;
 		__do_IRQ(bucket->virt_irq);
 		bucket = next;
 	}
 	irq_exit();
 	set_irq_regs(old_regs);
 }
 struct sun5_timer {
 	u64	count0;
 	u64	limit0;
 	u64	count1;
 	u64	limit1;
 };
 static struct sun5_timer *prom_timers;
 static u64 prom_limit0, prom_limit1;
 static void map_prom_timers(void)
 {
 	struct device_node *dp;
 	unsigned int *addr;
 	/* PROM timer node hangs out in the top level of device siblings... */
 	dp = of_find_node_by_path("/");
 	dp = dp->child;
 	while (dp) {
 		if (!strcmp(dp->name, "counter-timer"))
 			break;
 		dp = dp->sibling;
 	}
 	/* Assume if node is not present, PROM uses different tick mechanism
 	 * which we should not care about.
 	 */
 	if (!dp) {
 		prom_timers = (struct sun5_timer *) 0;
 		return;
 	}
 	/* If PROM is really using this, it must be mapped by him. */
 	addr = of_get_property(dp, "address", NULL);
 	if (!addr) {
 		prom_printf("PROM does not have timer mapped, trying to continue.\n");
 		prom_timers = (struct sun5_timer *) 0;
 		return;
 	}
 	prom_timers = (struct sun5_timer *) ((unsigned long)addr[0]);
 }
 static void kill_prom_timer(void)
 {
 	if (!prom_timers)
 		return;
 	/* Save them away for later. */
 	prom_limit0 = prom_timers->limit0;
 	prom_limit1 = prom_timers->limit1;
 	/* Just as in sun4c/sun4m PROM uses timer which ticks at IRQ 14.
 	 * We turn both off here just to be paranoid.
 	 */
 	prom_timers->limit0 = 0;
 	prom_timers->limit1 = 0;
 	/* Wheee, eat the interrupt packet too... */
 	__asm__ __volatile__(
 "	mov	0x40, %%g2\n"
 "	ldxa	[%%g0] %0, %%g1\n"
 "	ldxa	[%%g2] %1, %%g1\n"
 "	stxa	%%g0, [%%g0] %0\n"
 "	membar	#Sync\n"
 	: /* no outputs */
 	: "i" (ASI_INTR_RECEIVE), "i" (ASI_INTR_R)
 	: "g1", "g2");
 }
 void init_irqwork_curcpu(void)
 {
 	int cpu = hard_smp_processor_id();
 	trap_block[cpu].irq_worklist = 0;
 }
 static void __cpuinit register_one_mondo(unsigned long paddr, unsigned long type)
 {
 	unsigned long num_entries = 128;
 	unsigned long status;
 	status = sun4v_cpu_qconf(type, paddr, num_entries);
 	if (status != HV_EOK) {
 		prom_printf("SUN4V: sun4v_cpu_qconf(%lu:%lx:%lu) failed, "
 			    "err %lu\n", type, paddr, num_entries, status);
 		prom_halt();
 	}
 }
 static void __cpuinit sun4v_register_mondo_queues(int this_cpu)
 {
 	struct trap_per_cpu *tb = &trap_block[this_cpu];
 	register_one_mondo(tb->cpu_mondo_pa, HV_CPU_QUEUE_CPU_MONDO);
 	register_one_mondo(tb->dev_mondo_pa, HV_CPU_QUEUE_DEVICE_MONDO);
 	register_one_mondo(tb->resum_mondo_pa, HV_CPU_QUEUE_RES_ERROR);
 	register_one_mondo(tb->nonresum_mondo_pa, HV_CPU_QUEUE_NONRES_ERROR);
 }
 static void __cpuinit alloc_one_mondo(unsigned long *pa_ptr, int use_bootmem)
 {
 	void *page;
 	if (use_bootmem)
 		page = alloc_bootmem_low_pages(PAGE_SIZE);
 	else
 		page = (void *) get_zeroed_page(GFP_ATOMIC);
 	if (!page) {
 		prom_printf("SUN4V: Error, cannot allocate mondo queue.\n");
 		prom_halt();
 	}
 	*pa_ptr = __pa(page);
 }
 static void __cpuinit alloc_one_kbuf(unsigned long *pa_ptr, int use_bootmem)
 {
 	void *page;
 	if (use_bootmem)
 		page = alloc_bootmem_low_pages(PAGE_SIZE);
 	else
 		page = (void *) get_zeroed_page(GFP_ATOMIC);
 	if (!page) {
 		prom_printf("SUN4V: Error, cannot allocate kbuf page.\n");
 		prom_halt();
 	}
 	*pa_ptr = __pa(page);
 }
 static void __cpuinit init_cpu_send_mondo_info(struct trap_per_cpu *tb, int use_bootmem)
 {
 #ifdef CONFIG_SMP
 	void *page;
 	BUILD_BUG_ON((NR_CPUS * sizeof(u16)) > (PAGE_SIZE - 64));
 	if (use_bootmem)
 		page = alloc_bootmem_low_pages(PAGE_SIZE);
 	else
 		page = (void *) get_zeroed_page(GFP_ATOMIC);
 	if (!page) {
 		prom_printf("SUN4V: Error, cannot allocate cpu mondo page.\n");
 		prom_halt();
 	}
 	tb->cpu_mondo_block_pa = __pa(page);
 	tb->cpu_list_pa = __pa(page + 64);
 #endif
 }
 /* Allocate and register the mondo and error queues for this cpu.  */
 void __cpuinit sun4v_init_mondo_queues(int use_bootmem, int cpu, int alloc, int load)
 {
 	struct trap_per_cpu *tb = &trap_block[cpu];
 	if (alloc) {
 		alloc_one_mondo(&tb->cpu_mondo_pa, use_bootmem);
 		alloc_one_mondo(&tb->dev_mondo_pa, use_bootmem);
 		alloc_one_mondo(&tb->resum_mondo_pa, use_bootmem);
 		alloc_one_kbuf(&tb->resum_kernel_buf_pa, use_bootmem);
 		alloc_one_mondo(&tb->nonresum_mondo_pa, use_bootmem);
 		alloc_one_kbuf(&tb->nonresum_kernel_buf_pa, use_bootmem);
 		init_cpu_send_mondo_info(tb, use_bootmem);
 	}
 	if (load) {
 		if (cpu != hard_smp_processor_id()) {
 			prom_printf("SUN4V: init mondo on cpu %d not %d\n",
 				    cpu, hard_smp_processor_id());
 			prom_halt();
 		}
 		sun4v_register_mondo_queues(cpu);
 	}
 }
 static struct irqaction timer_irq_action = {
 	.name = "timer",
 };
 /* Only invoked on boot processor. */
 void __init init_IRQ(void)
 {
 	map_prom_timers();
 	kill_prom_timer();
 	memset(&ivector_table[0], 0, sizeof(ivector_table));
 	if (tlb_type == hypervisor)
 		sun4v_init_mondo_queues(1, hard_smp_processor_id(), 1, 1);
 	/* We need to clear any IRQ's pending in the soft interrupt
 	 * registers, a spurious one could be left around from the
 	 * PROM timer which we just disabled.
 	 */
 	clear_softint(get_softint());
 	/* Now that ivector table is initialized, it is safe
 	 * to receive IRQ vector traps.  We will normally take
 	 * one or two right now, in case some device PROM used
 	 * to boot us wants to speak to us.  We just ignore them.
 	 */

arch/sparc64/kernel/pci.c

Diff comments View file @ c827ba4

 /* $Id: pci.c,v 1.39 2002/01/05 01:13:43 davem Exp $
  * pci.c: UltraSparc PCI controller support.
  *
  * Copyright (C) 1997, 1998, 1999 David S. Miller (davem@redhat.com)
  * Copyright (C) 1998, 1999 Eddie C. Dost   (ecd@skynet.be)
  * Copyright (C) 1999 Jakub Jelinek   (jj@ultra.linux.cz)
  */
 #include <linux/module.h>
 #include <linux/kernel.h>
 #include <linux/string.h>
 #include <linux/sched.h>
 #include <linux/capability.h>
 #include <linux/errno.h>
 #include <linux/smp_lock.h>
+#include <linux/msi.h>
+#include <linux/irq.h>
 #include <linux/init.h>
 #include <asm/uaccess.h>
 #include <asm/pbm.h>
 #include <asm/pgtable.h>
 #include <asm/irq.h>
 #include <asm/ebus.h>
 #include <asm/isa.h>
 #include <asm/prom.h>
 unsigned long pci_memspace_mask = 0xffffffffUL;
 #ifndef CONFIG_PCI
 /* A "nop" PCI implementation. */
 asmlinkage int sys_pciconfig_read(unsigned long bus, unsigned long dfn,
 				  unsigned long off, unsigned long len,
 				  unsigned char *buf)
 {
 	return 0;
 }
 asmlinkage int sys_pciconfig_write(unsigned long bus, unsigned long dfn,
 				   unsigned long off, unsigned long len,
 				   unsigned char *buf)
 {
 	return 0;
 }
 #else
 /* List of all PCI controllers found in the system. */
 struct pci_controller_info *pci_controller_root = NULL;
 /* Each PCI controller found gets a unique index. */
 int pci_num_controllers = 0;
 volatile int pci_poke_in_progress;
 volatile int pci_poke_cpu = -1;
 volatile int pci_poke_faulted;
 static DEFINE_SPINLOCK(pci_poke_lock);
 void pci_config_read8(u8 *addr, u8 *ret)
 {
 	unsigned long flags;
 	u8 byte;
 	spin_lock_irqsave(&pci_poke_lock, flags);
 	pci_poke_cpu = smp_processor_id();
 	pci_poke_in_progress = 1;
 	pci_poke_faulted = 0;
 	__asm__ __volatile__("membar #Sync\n\t"
 			     "lduba [%1] %2, %0\n\t"
 			     "membar #Sync"
 			     : "=r" (byte)
 			     : "r" (addr), "i" (ASI_PHYS_BYPASS_EC_E_L)
 			     : "memory");
 	pci_poke_in_progress = 0;
 	pci_poke_cpu = -1;
 	if (!pci_poke_faulted)
 		*ret = byte;
 	spin_unlock_irqrestore(&pci_poke_lock, flags);
 }
 void pci_config_read16(u16 *addr, u16 *ret)
 {
 	unsigned long flags;
 	u16 word;
 	spin_lock_irqsave(&pci_poke_lock, flags);
 	pci_poke_cpu = smp_processor_id();
 	pci_poke_in_progress = 1;
 	pci_poke_faulted = 0;
 	__asm__ __volatile__("membar #Sync\n\t"
 			     "lduha [%1] %2, %0\n\t"
 			     "membar #Sync"
 			     : "=r" (word)
 			     : "r" (addr), "i" (ASI_PHYS_BYPASS_EC_E_L)
 			     : "memory");
 	pci_poke_in_progress = 0;
 	pci_poke_cpu = -1;
 	if (!pci_poke_faulted)
 		*ret = word;
 	spin_unlock_irqrestore(&pci_poke_lock, flags);
 }
 void pci_config_read32(u32 *addr, u32 *ret)
 {
 	unsigned long flags;
 	u32 dword;
 	spin_lock_irqsave(&pci_poke_lock, flags);
 	pci_poke_cpu = smp_processor_id();
 	pci_poke_in_progress = 1;
 	pci_poke_faulted = 0;
 	__asm__ __volatile__("membar #Sync\n\t"
 			     "lduwa [%1] %2, %0\n\t"
 			     "membar #Sync"
 			     : "=r" (dword)
 			     : "r" (addr), "i" (ASI_PHYS_BYPASS_EC_E_L)
 			     : "memory");
 	pci_poke_in_progress = 0;
 	pci_poke_cpu = -1;
 	if (!pci_poke_faulted)
 		*ret = dword;
 	spin_unlock_irqrestore(&pci_poke_lock, flags);
 }
 void pci_config_write8(u8 *addr, u8 val)
 {
 	unsigned long flags;
 	spin_lock_irqsave(&pci_poke_lock, flags);
 	pci_poke_cpu = smp_processor_id();
 	pci_poke_in_progress = 1;
 	pci_poke_faulted = 0;
 	__asm__ __volatile__("membar #Sync\n\t"
 			     "stba %0, [%1] %2\n\t"
 			     "membar #Sync"
 			     : /* no outputs */
 			     : "r" (val), "r" (addr), "i" (ASI_PHYS_BYPASS_EC_E_L)
 			     : "memory");
 	pci_poke_in_progress = 0;
 	pci_poke_cpu = -1;
 	spin_unlock_irqrestore(&pci_poke_lock, flags);
 }
 void pci_config_write16(u16 *addr, u16 val)
 {
 	unsigned long flags;
 	spin_lock_irqsave(&pci_poke_lock, flags);
 	pci_poke_cpu = smp_processor_id();
 	pci_poke_in_progress = 1;
 	pci_poke_faulted = 0;
 	__asm__ __volatile__("membar #Sync\n\t"
 			     "stha %0, [%1] %2\n\t"
 			     "membar #Sync"
 			     : /* no outputs */
 			     : "r" (val), "r" (addr), "i" (ASI_PHYS_BYPASS_EC_E_L)
 			     : "memory");
 	pci_poke_in_progress = 0;
 	pci_poke_cpu = -1;
 	spin_unlock_irqrestore(&pci_poke_lock, flags);
 }
 void pci_config_write32(u32 *addr, u32 val)
 {
 	unsigned long flags;
 	spin_lock_irqsave(&pci_poke_lock, flags);
 	pci_poke_cpu = smp_processor_id();
 	pci_poke_in_progress = 1;
 	pci_poke_faulted = 0;
 	__asm__ __volatile__("membar #Sync\n\t"
 			     "stwa %0, [%1] %2\n\t"
 			     "membar #Sync"
 			     : /* no outputs */
 			     : "r" (val), "r" (addr), "i" (ASI_PHYS_BYPASS_EC_E_L)
 			     : "memory");
 	pci_poke_in_progress = 0;
 	pci_poke_cpu = -1;
 	spin_unlock_irqrestore(&pci_poke_lock, flags);
 }
 /* Probe for all PCI controllers in the system. */
 extern void sabre_init(struct device_node *, const char *);
 extern void psycho_init(struct device_node *, const char *);
 extern void schizo_init(struct device_node *, const char *);
 extern void schizo_plus_init(struct device_node *, const char *);
 extern void tomatillo_init(struct device_node *, const char *);
 extern void sun4v_pci_init(struct device_node *, const char *);
 static struct {
 	char *model_name;
 	void (*init)(struct device_node *, const char *);
 } pci_controller_table[] __initdata = {
 	{ "SUNW,sabre", sabre_init },
 	{ "pci108e,a000", sabre_init },
 	{ "pci108e,a001", sabre_init },
 	{ "SUNW,psycho", psycho_init },
 	{ "pci108e,8000", psycho_init },
 	{ "SUNW,schizo", schizo_init },
 	{ "pci108e,8001", schizo_init },
 	{ "SUNW,schizo+", schizo_plus_init },
 	{ "pci108e,8002", schizo_plus_init },
 	{ "SUNW,tomatillo", tomatillo_init },
 	{ "pci108e,a801", tomatillo_init },
 	{ "SUNW,sun4v-pci", sun4v_pci_init },
 };
 #define PCI_NUM_CONTROLLER_TYPES (sizeof(pci_controller_table) / \
 				  sizeof(pci_controller_table[0]))
 static int __init pci_controller_init(const char *model_name, int namelen, struct device_node *dp)
 {
 	int i;
 	for (i = 0; i < PCI_NUM_CONTROLLER_TYPES; i++) {
 		if (!strncmp(model_name,
 			     pci_controller_table[i].model_name,
 			     namelen)) {
 			pci_controller_table[i].init(dp, model_name);
 			return 1;
 		}
 	}
 	return 0;
 }
 static int __init pci_is_controller(const char *model_name, int namelen, struct device_node *dp)
 {
 	int i;
 	for (i = 0; i < PCI_NUM_CONTROLLER_TYPES; i++) {
 		if (!strncmp(model_name,
 			     pci_controller_table[i].model_name,
 			     namelen)) {
 			return 1;
 		}
 	}
 	return 0;
 }
 static int __init pci_controller_scan(int (*handler)(const char *, int, struct device_node *))
 {
 	struct device_node *dp;
 	int count = 0;
 	for_each_node_by_name(dp, "pci") {
 		struct property *prop;
 		int len;
 		prop = of_find_property(dp, "model", &len);
 		if (!prop)
 			prop = of_find_property(dp, "compatible", &len);
 		if (prop) {
 			const char *model = prop->value;
 			int item_len = 0;
 			/* Our value may be a multi-valued string in the
 			 * case of some compatible properties. For sanity,
 			 * only try the first one.
 			 */
 			while (model[item_len] && len) {
 				len--;
 				item_len++;
 			}
 			if (handler(model, item_len, dp))
 				count++;
 		}
 	}
 	return count;
 }
 /* Is there some PCI controller in the system?  */
 int __init pcic_present(void)
 {
 	return pci_controller_scan(pci_is_controller);
 }
 struct pci_iommu_ops *pci_iommu_ops;
 EXPORT_SYMBOL(pci_iommu_ops);
 extern struct pci_iommu_ops pci_sun4u_iommu_ops,
 	pci_sun4v_iommu_ops;
 /* Find each controller in the system, attach and initialize
  * software state structure for each and link into the
  * pci_controller_root.  Setup the controller enough such
  * that bus scanning can be done.
  */
 static void __init pci_controller_probe(void)
 {
 	if (tlb_type == hypervisor)
 		pci_iommu_ops = &pci_sun4v_iommu_ops;
 	else
 		pci_iommu_ops = &pci_sun4u_iommu_ops;
 	printk("PCI: Probing for controllers.\n");
 	pci_controller_scan(pci_controller_init);
 }
 static void __init pci_scan_each_controller_bus(void)
 {
 	struct pci_controller_info *p;
 	for (p = pci_controller_root; p; p = p->next)
 		p->scan_bus(p);
 }
 extern void power_init(void);
 static int __init pcibios_init(void)
 {
 	pci_controller_probe();
 	if (pci_controller_root == NULL)
 		return 0;
 	pci_scan_each_controller_bus();
 	isa_init();
 	ebus_init();
 	power_init();
 	return 0;
 }
 subsys_initcall(pcibios_init);
 void pcibios_fixup_bus(struct pci_bus *pbus)
 {
 	struct pci_pbm_info *pbm = pbus->sysdata;
 	/* Generic PCI bus probing sets these to point at
 	 * &io{port,mem}_resouce which is wrong for us.
 	 */
 	pbus->resource[0] = &pbm->io_space;
 	pbus->resource[1] = &pbm->mem_space;
 }
 struct resource *pcibios_select_root(struct pci_dev *pdev, struct resource *r)
 {
 	struct pci_pbm_info *pbm = pdev->bus->sysdata;
 	struct resource *root = NULL;
 	if (r->flags & IORESOURCE_IO)
 		root = &pbm->io_space;
 	if (r->flags & IORESOURCE_MEM)
 		root = &pbm->mem_space;
 	return root;
 }
 void pcibios_update_irq(struct pci_dev *pdev, int irq)
 {
 }
 void pcibios_align_resource(void *data, struct resource *res,
 			    resource_size_t size, resource_size_t align)
 {
 }
 int pcibios_enable_device(struct pci_dev *pdev, int mask)
 {
 	return 0;
 }
 void pcibios_resource_to_bus(struct pci_dev *pdev, struct pci_bus_region *region,
 			     struct resource *res)
 {
 	struct pci_pbm_info *pbm = pdev->bus->sysdata;
 	struct resource zero_res, *root;
 	zero_res.start = 0;
 	zero_res.end = 0;
 	zero_res.flags = res->flags;
 	if (res->flags & IORESOURCE_IO)
 		root = &pbm->io_space;
 	else
 		root = &pbm->mem_space;
 	pbm->parent->resource_adjust(pdev, &zero_res, root);
 	region->start = res->start - zero_res.start;
 	region->end = res->end - zero_res.start;
 }
 EXPORT_SYMBOL(pcibios_resource_to_bus);
 void pcibios_bus_to_resource(struct pci_dev *pdev, struct resource *res,
 			     struct pci_bus_region *region)
 {
 	struct pci_pbm_info *pbm = pdev->bus->sysdata;
 	struct resource *root;
 	res->start = region->start;
 	res->end = region->end;
 	if (res->flags & IORESOURCE_IO)
 		root = &pbm->io_space;
 	else
 		root = &pbm->mem_space;
 	pbm->parent->resource_adjust(pdev, res, root);
 }
 EXPORT_SYMBOL(pcibios_bus_to_resource);
 char * __init pcibios_setup(char *str)
 {
 	return str;
 }
 /* Platform support for /proc/bus/pci/X/Y mmap()s. */
 /* If the user uses a host-bridge as the PCI device, he may use
  * this to perform a raw mmap() of the I/O or MEM space behind
  * that controller.
  *
  * This can be useful for execution of x86 PCI bios initialization code
  * on a PCI card, like the xfree86 int10 stuff does.
  */
 static int __pci_mmap_make_offset_bus(struct pci_dev *pdev, struct vm_area_struct *vma,
 				      enum pci_mmap_state mmap_state)
 {
 	struct pcidev_cookie *pcp = pdev->sysdata;
 	struct pci_pbm_info *pbm;
 	struct pci_controller_info *p;
 	unsigned long space_size, user_offset, user_size;
 	if (!pcp)
 		return -ENXIO;
 	pbm = pcp->pbm;
 	if (!pbm)
 		return -ENXIO;
 	p = pbm->parent;
 	if (p->pbms_same_domain) {
 		unsigned long lowest, highest;
 		lowest = ~0UL; highest = 0UL;
 		if (mmap_state == pci_mmap_io) {
 			if (p->pbm_A.io_space.flags) {
 				lowest = p->pbm_A.io_space.start;
 				highest = p->pbm_A.io_space.end + 1;
 			}
 			if (p->pbm_B.io_space.flags) {
 				if (lowest > p->pbm_B.io_space.start)
 					lowest = p->pbm_B.io_space.start;
 				if (highest < p->pbm_B.io_space.end + 1)
 					highest = p->pbm_B.io_space.end + 1;
 			}
 			space_size = highest - lowest;
 		} else {
 			if (p->pbm_A.mem_space.flags) {
 				lowest = p->pbm_A.mem_space.start;
 				highest = p->pbm_A.mem_space.end + 1;
 			}
 			if (p->pbm_B.mem_space.flags) {
 				if (lowest > p->pbm_B.mem_space.start)
 					lowest = p->pbm_B.mem_space.start;
 				if (highest < p->pbm_B.mem_space.end + 1)
 					highest = p->pbm_B.mem_space.end + 1;
 			}
 			space_size = highest - lowest;
 		}
 	} else {
 		if (mmap_state == pci_mmap_io) {
 			space_size = (pbm->io_space.end -
 				      pbm->io_space.start) + 1;
 		} else {
 			space_size = (pbm->mem_space.end -
 				      pbm->mem_space.start) + 1;
 		}
 	}
 	/* Make sure the request is in range. */
 	user_offset = vma->vm_pgoff << PAGE_SHIFT;
 	user_size = vma->vm_end - vma->vm_start;
 	if (user_offset >= space_size ||
 	    (user_offset + user_size) > space_size)
 		return -EINVAL;
 	if (p->pbms_same_domain) {
 		unsigned long lowest = ~0UL;
 		if (mmap_state == pci_mmap_io) {
 			if (p->pbm_A.io_space.flags)
 				lowest = p->pbm_A.io_space.start;
 			if (p->pbm_B.io_space.flags &&
 			    lowest > p->pbm_B.io_space.start)
 				lowest = p->pbm_B.io_space.start;
 		} else {
 			if (p->pbm_A.mem_space.flags)
 				lowest = p->pbm_A.mem_space.start;
 			if (p->pbm_B.mem_space.flags &&
 			    lowest > p->pbm_B.mem_space.start)
 				lowest = p->pbm_B.mem_space.start;
 		}
 		vma->vm_pgoff = (lowest + user_offset) >> PAGE_SHIFT;
 	} else {
 		if (mmap_state == pci_mmap_io) {
 			vma->vm_pgoff = (pbm->io_space.start +
 					 user_offset) >> PAGE_SHIFT;
 		} else {
 			vma->vm_pgoff = (pbm->mem_space.start +
 					 user_offset) >> PAGE_SHIFT;
 		}
 	}
 	return 0;
 }
 /* Adjust vm_pgoff of VMA such that it is the physical page offset corresponding
  * to the 32-bit pci bus offset for DEV requested by the user.
  *
  * Basically, the user finds the base address for his device which he wishes
  * to mmap.  They read the 32-bit value from the config space base register,
  * add whatever PAGE_SIZE multiple offset they wish, and feed this into the
  * offset parameter of mmap on /proc/bus/pci/XXX for that device.
  *
  * Returns negative error code on failure, zero on success.
  */
 static int __pci_mmap_make_offset(struct pci_dev *dev, struct vm_area_struct *vma,
 				  enum pci_mmap_state mmap_state)
 {
 	unsigned long user_offset = vma->vm_pgoff << PAGE_SHIFT;
 	unsigned long user32 = user_offset & pci_memspace_mask;
 	unsigned long largest_base, this_base, addr32;
 	int i;
 	if ((dev->class >> 8) == PCI_CLASS_BRIDGE_HOST)
 		return __pci_mmap_make_offset_bus(dev, vma, mmap_state);
 	/* Figure out which base address this is for. */
 	largest_base = 0UL;
 	for (i = 0; i <= PCI_ROM_RESOURCE; i++) {
 		struct resource *rp = &dev->resource[i];
 		/* Active? */
 		if (!rp->flags)
 			continue;
 		/* Same type? */
 		if (i == PCI_ROM_RESOURCE) {
 			if (mmap_state != pci_mmap_mem)
 				continue;
 		} else {
 			if ((mmap_state == pci_mmap_io &&
 			     (rp->flags & IORESOURCE_IO) == 0) ||
 			    (mmap_state == pci_mmap_mem &&
 			     (rp->flags & IORESOURCE_MEM) == 0))
 				continue;
 		}
 		this_base = rp->start;
 		addr32 = (this_base & PAGE_MASK) & pci_memspace_mask;
 		if (mmap_state == pci_mmap_io)
 			addr32 &= 0xffffff;
 		if (addr32 <= user32 && this_base > largest_base)
 			largest_base = this_base;
 	}
 	if (largest_base == 0UL)
 		return -EINVAL;
 	/* Now construct the final physical address. */
 	if (mmap_state == pci_mmap_io)
 		vma->vm_pgoff = (((largest_base & ~0xffffffUL) | user32) >> PAGE_SHIFT);
 	else
 		vma->vm_pgoff = (((largest_base & ~(pci_memspace_mask)) | user32) >> PAGE_SHIFT);
 	return 0;
 }
 /* Set vm_flags of VMA, as appropriate for this architecture, for a pci device
  * mapping.
  */
 static void __pci_mmap_set_flags(struct pci_dev *dev, struct vm_area_struct *vma,
 					    enum pci_mmap_state mmap_state)
 {
 	vma->vm_flags |= (VM_IO | VM_RESERVED);
 }
 /* Set vm_page_prot of VMA, as appropriate for this architecture, for a pci
  * device mapping.
  */
 static void __pci_mmap_set_pgprot(struct pci_dev *dev, struct vm_area_struct *vma,
 					     enum pci_mmap_state mmap_state)
 {
 	/* Our io_remap_pfn_range takes care of this, do nothing.  */
 }
 /* Perform the actual remap of the pages for a PCI device mapping, as appropriate
  * for this architecture.  The region in the process to map is described by vm_start
  * and vm_end members of VMA, the base physical address is found in vm_pgoff.
  * The pci device structure is provided so that architectures may make mapping
  * decisions on a per-device or per-bus basis.
  *
  * Returns a negative error code on failure, zero on success.
  */
 int pci_mmap_page_range(struct pci_dev *dev, struct vm_area_struct *vma,
 			enum pci_mmap_state mmap_state,
 			int write_combine)
 {
 	int ret;
 	ret = __pci_mmap_make_offset(dev, vma, mmap_state);
 	if (ret < 0)
 		return ret;
 	__pci_mmap_set_flags(dev, vma, mmap_state);
 	__pci_mmap_set_pgprot(dev, vma, mmap_state);
 	vma->vm_page_prot = pgprot_noncached(vma->vm_page_prot);
 	ret = io_remap_pfn_range(vma, vma->vm_start,
 				 vma->vm_pgoff,
 				 vma->vm_end - vma->vm_start,
 				 vma->vm_page_prot);
 	if (ret)
 		return ret;
 	return 0;
 }
 /* Return the domain nuber for this pci bus */
 int pci_domain_nr(struct pci_bus *pbus)
 {
 	struct pci_pbm_info *pbm = pbus->sysdata;
 	int ret;
 	if (pbm == NULL || pbm->parent == NULL) {
 		ret = -ENXIO;
 	} else {
 		struct pci_controller_info *p = pbm->parent;
 		ret = p->index;
 		if (p->pbms_same_domain == 0)
 			ret = ((ret << 1) +
 			       ((pbm == &pbm->parent->pbm_B) ? 1 : 0));
 	}
 	return ret;
 }
 EXPORT_SYMBOL(pci_domain_nr);
+#ifdef CONFIG_PCI_MSI
+int arch_setup_msi_irq(struct pci_dev *pdev, struct msi_desc *desc)
+{
+	struct pcidev_cookie *pcp = pdev->sysdata;
+	struct pci_pbm_info *pbm = pcp->pbm;
+	struct pci_controller_info *p = pbm->parent;
+	int virt_irq, err;
+	if (!pbm->msi_num || !p->setup_msi_irq)
+		return -EINVAL;
+	err = p->setup_msi_irq(&virt_irq, pdev, desc);
+	if (err < 0)
+		return err;
+	return virt_irq;
+}
+void arch_teardown_msi_irq(unsigned int virt_irq)
+{
+	struct msi_desc *entry = get_irq_data(virt_irq);
+	struct pci_dev *pdev = entry->dev;
+	struct pcidev_cookie *pcp = pdev->sysdata;
+	struct pci_pbm_info *pbm = pcp->pbm;
+	struct pci_controller_info *p = pbm->parent;
+	if (!pbm->msi_num || !p->setup_msi_irq)
+		return;
+	return p->teardown_msi_irq(virt_irq, pdev);
+}
+#endif /* !(CONFIG_PCI_MSI) */
 #endif /* !(CONFIG_PCI) */

arch/sparc64/kernel/pci_common.c

Diff comments View file @ c827ba4

 /* $Id: pci_common.c,v 1.29 2002/02/01 00:56:03 davem Exp $
  * pci_common.c: PCI controller common support.
  *
  * Copyright (C) 1999 David S. Miller (davem@redhat.com)
  */
 #include <linux/string.h>
 #include <linux/slab.h>
 #include <linux/init.h>
+#include <linux/pci.h>
+#include <linux/device.h>
 #include <asm/pbm.h>
 #include <asm/prom.h>
 #include <asm/of_device.h>
 #include "pci_impl.h"
 /* Fix self device of BUS and hook it into BUS->self.
  * The pci_scan_bus does not do this for the host bridge.
  */
 void __init pci_fixup_host_bridge_self(struct pci_bus *pbus)
 {
 	struct pci_dev *pdev;
 	list_for_each_entry(pdev, &pbus->devices, bus_list) {
 		if (pdev->class >> 8 == PCI_CLASS_BRIDGE_HOST) {
 			pbus->self = pdev;
 			return;
 		}
 	}
 	prom_printf("PCI: Critical error, cannot find host bridge PDEV.\n");
 	prom_halt();
 }
 /* Find the OBP PROM device tree node for a PCI device.  */
 static struct device_node * __init
 find_device_prom_node(struct pci_pbm_info *pbm, struct pci_dev *pdev,
 		      struct device_node *bus_node,
 		      struct linux_prom_pci_registers **pregs,
 		      int *nregs)
 {
 	struct device_node *dp;
 	*nregs = 0;
 	/*
 	 * Return the PBM's PROM node in case we are it's PCI device,
 	 * as the PBM's reg property is different to standard PCI reg
 	 * properties. We would delete this device entry otherwise,
 	 * which confuses XFree86's device probing...
 	 */
 	if ((pdev->bus->number == pbm->pci_bus->number) && (pdev->devfn == 0) &&
 	    (pdev->vendor == PCI_VENDOR_ID_SUN) &&
 	    (pdev->device == PCI_DEVICE_ID_SUN_PBM ||
 	     pdev->device == PCI_DEVICE_ID_SUN_SCHIZO ||
 	     pdev->device == PCI_DEVICE_ID_SUN_TOMATILLO ||
 	     pdev->device == PCI_DEVICE_ID_SUN_SABRE ||
 	     pdev->device == PCI_DEVICE_ID_SUN_HUMMINGBIRD))
 		return bus_node;
 	dp = bus_node->child;
 	while (dp) {
 		struct linux_prom_pci_registers *regs;
 		struct property *prop;
 		int len;
 		prop = of_find_property(dp, "reg", &len);
 		if (!prop)
 			goto do_next_sibling;
 		regs = prop->value;
 		if (((regs[0].phys_hi >> 8) & 0xff) == pdev->devfn) {
 			*pregs = regs;
 			*nregs = len / sizeof(struct linux_prom_pci_registers);
 			return dp;
 		}
 	do_next_sibling:
 		dp = dp->sibling;
 	}
 	return NULL;
 }
 /* Older versions of OBP on PCI systems encode 64-bit MEM
  * space assignments incorrectly, this fixes them up.  We also
  * take the opportunity here to hide other kinds of bogus
  * assignments.
  */
 static void __init fixup_obp_assignments(struct pci_dev *pdev,
 					 struct pcidev_cookie *pcp)
 {
 	int i;
 	if (pdev->vendor == PCI_VENDOR_ID_AL &&
 	    (pdev->device == PCI_DEVICE_ID_AL_M7101 ||
 	     pdev->device == PCI_DEVICE_ID_AL_M1533)) {
 		int i;
 		/* Zap all of the normal resources, they are
 		 * meaningless and generate bogus resource collision
 		 * messages.  This is OpenBoot's ill-fated attempt to
 		 * represent the implicit resources that these devices
 		 * have.
 		 */
 		pcp->num_prom_assignments = 0;
 		for (i = 0; i < 6; i++) {
 			pdev->resource[i].start =
 				pdev->resource[i].end =
 				pdev->resource[i].flags = 0;
 		}
 		pdev->resource[PCI_ROM_RESOURCE].start =
 			pdev->resource[PCI_ROM_RESOURCE].end =
 			pdev->resource[PCI_ROM_RESOURCE].flags = 0;
 		return;
 	}
 	for (i = 0; i < pcp->num_prom_assignments; i++) {
 		struct linux_prom_pci_registers *ap;
 		int space;
 		ap = &pcp->prom_assignments[i];
 		space = ap->phys_hi >> 24;
 		if ((space & 0x3) == 2 &&
 		    (space & 0x4) != 0) {
 			ap->phys_hi &= ~(0x7 << 24);
 			ap->phys_hi |= 0x3 << 24;
 		}
 	}
 }
+static ssize_t
+show_pciobppath_attr(struct device * dev, struct device_attribute * attr, char * buf)
+{
+	struct pci_dev *pdev;
+	struct pcidev_cookie *sysdata;
+	pdev = to_pci_dev(dev);
+	sysdata = pdev->sysdata;
+	return snprintf (buf, PAGE_SIZE, "%s\n", sysdata->prom_node->full_name);
+}
+static DEVICE_ATTR(obppath, S_IRUSR | S_IRGRP | S_IROTH, show_pciobppath_attr, NULL);
 /* Fill in the PCI device cookie sysdata for the given
  * PCI device.  This cookie is the means by which one
  * can get to OBP and PCI controller specific information
  * for a PCI device.
  */
 static void __init pdev_cookie_fillin(struct pci_pbm_info *pbm,
 				      struct pci_dev *pdev,
 				      struct device_node *bus_node)
 {
 	struct linux_prom_pci_registers *pregs = NULL;
 	struct pcidev_cookie *pcp;
 	struct device_node *dp;
 	struct property *prop;
-	int nregs, len;
+	int nregs, len, err;
 	dp = find_device_prom_node(pbm, pdev, bus_node,
 				   &pregs, &nregs);
 	if (!dp) {
 		/* If it is not in the OBP device tree then
 		 * there must be a damn good reason for it.
 		 *
 		 * So what we do is delete the device from the
 		 * PCI device tree completely.  This scenario
 		 * is seen, for example, on CP1500 for the
 		 * second EBUS/HappyMeal pair if the external
 		 * connector for it is not present.
 		 */
 		pci_remove_bus_device(pdev);
 		return;
 	}
 	pcp = kzalloc(sizeof(*pcp), GFP_ATOMIC);
 	if (pcp == NULL) {
 		prom_printf("PCI_COOKIE: Fatal malloc error, aborting...\n");
 		prom_halt();
 	}
 	pcp->pbm = pbm;
 	pcp->prom_node = dp;
 	pcp->op = of_find_device_by_node(dp);
 	memcpy(pcp->prom_regs, pregs,
 	       nregs * sizeof(struct linux_prom_pci_registers));
 	pcp->num_prom_regs = nregs;
 	/* We can't have the pcidev_cookie assignments be just
 	 * direct pointers into the property value, since they
 	 * are potentially modified by the probing process.
 	 */
 	prop = of_find_property(dp, "assigned-addresses", &len);
 	if (!prop) {
 		pcp->num_prom_assignments = 0;
 	} else {
 		memcpy(pcp->prom_assignments, prop->value, len);
 		pcp->num_prom_assignments =
 			(len / sizeof(pcp->prom_assignments[0]));
 	}
 	if (strcmp(dp->name, "ebus") == 0) {
 		struct linux_prom_ebus_ranges *erng;
 		int iter;
 		/* EBUS is special... */
 		prop = of_find_property(dp, "ranges", &len);
 		if (!prop) {
 			prom_printf("EBUS: Fatal error, no range property\n");
 			prom_halt();
 		}
 		erng = prop->value;
 		len = (len / sizeof(erng[0]));
 		for (iter = 0; iter < len; iter++) {
 			struct linux_prom_ebus_ranges *ep = &erng[iter];
 			struct linux_prom_pci_registers *ap;
 			ap = &pcp->prom_assignments[iter];
 			ap->phys_hi = ep->parent_phys_hi;
 			ap->phys_mid = ep->parent_phys_mid;
 			ap->phys_lo = ep->parent_phys_lo;
 			ap->size_hi = 0;
 			ap->size_lo = ep->size;
 		}
 		pcp->num_prom_assignments = len;
 	}
 	fixup_obp_assignments(pdev, pcp);
 	pdev->sysdata = pcp;
+	/* we don't really care if we can create this file or not,
+	 * but we need to assign the result of the call or the world will fall
+	 * under alien invasion and everybody will be frozen on a spaceship
+	 * ready to be eaten on alpha centauri by some green and jelly humanoid.
+	 */
+	err = sysfs_create_file(&pdev->dev.kobj, &dev_attr_obppath.attr);
 }
 void __init pci_fill_in_pbm_cookies(struct pci_bus *pbus,
 				    struct pci_pbm_info *pbm,
 				    struct device_node *dp)
 {
 	struct pci_dev *pdev, *pdev_next;
 	struct pci_bus *this_pbus, *pbus_next;
 	/* This must be _safe because the cookie fillin
 	   routine can delete devices from the tree.  */
 	list_for_each_entry_safe(pdev, pdev_next, &pbus->devices, bus_list)
 		pdev_cookie_fillin(pbm, pdev, dp);
 	list_for_each_entry_safe(this_pbus, pbus_next, &pbus->children, node) {
 		struct pcidev_cookie *pcp = this_pbus->self->sysdata;
 		pci_fill_in_pbm_cookies(this_pbus, pbm, pcp->prom_node);
 	}
 }
 static void __init bad_assignment(struct pci_dev *pdev,
 				  struct linux_prom_pci_registers *ap,
 				  struct resource *res,
 				  int do_prom_halt)
 {
 	prom_printf("PCI: Bogus PROM assignment. BUS[%02x] DEVFN[%x]\n",
 		    pdev->bus->number, pdev->devfn);
 	if (ap)
 		prom_printf("PCI: phys[%08x:%08x:%08x] size[%08x:%08x]\n",
 			    ap->phys_hi, ap->phys_mid, ap->phys_lo,
 			    ap->size_hi, ap->size_lo);
 	if (res)
 		prom_printf("PCI: RES[%016lx-->%016lx:(%lx)]\n",
 			    res->start, res->end, res->flags);
 	if (do_prom_halt)
 		prom_halt();
 }
 static struct resource *
 __init get_root_resource(struct linux_prom_pci_registers *ap,
 			 struct pci_pbm_info *pbm)
 {
 	int space = (ap->phys_hi >> 24) & 3;
 	switch (space) {
 	case 0:
 		/* Configuration space, silently ignore it. */
 		return NULL;
 	case 1:
 		/* 16-bit IO space */
 		return &pbm->io_space;
 	case 2:
 		/* 32-bit MEM space */
 		return &pbm->mem_space;
 	case 3:
 		/* 64-bit MEM space, these are allocated out of
 		 * the 32-bit mem_space range for the PBM, ie.
 		 * we just zero out the upper 32-bits.
 		 */
 		return &pbm->mem_space;
 	default:
 		printk("PCI: What is resource space %x?\n", space);
 		return NULL;
 	};
 }
 static struct resource *
 __init get_device_resource(struct linux_prom_pci_registers *ap,
 			   struct pci_dev *pdev)
 {
 	struct resource *res;
 	int breg = (ap->phys_hi & 0xff);
 	switch (breg) {
 	case  PCI_ROM_ADDRESS:
 		/* Unfortunately I have seen several cases where
 		 * buggy FCODE uses a space value of '1' (I/O space)
 		 * in the register property for the ROM address
 		 * so disable this sanity check for now.
 		 */
 #if 0
 	{
 		int space = (ap->phys_hi >> 24) & 3;
 		/* It had better be MEM space. */
 		if (space != 2)
 			bad_assignment(pdev, ap, NULL, 0);
 	}
 #endif
 		res = &pdev->resource[PCI_ROM_RESOURCE];
 		break;
 	case PCI_BASE_ADDRESS_0:
 	case PCI_BASE_ADDRESS_1:
 	case PCI_BASE_ADDRESS_2:
 	case PCI_BASE_ADDRESS_3:
 	case PCI_BASE_ADDRESS_4:
 	case PCI_BASE_ADDRESS_5:
 		res = &pdev->resource[(breg - PCI_BASE_ADDRESS_0) / 4];
 		break;
 	default:
 		bad_assignment(pdev, ap, NULL, 0);
 		res = NULL;
 		break;
 	};
 	return res;
 }
 static void __init pdev_record_assignments(struct pci_pbm_info *pbm,
 					   struct pci_dev *pdev)
 {
 	struct pcidev_cookie *pcp = pdev->sysdata;
 	int i;
 	for (i = 0; i < pcp->num_prom_assignments; i++) {
 		struct linux_prom_pci_registers *ap;
 		struct resource *root, *res;
 		/* The format of this property is specified in
 		 * the PCI Bus Binding to IEEE1275-1994.
 		 */
 		ap = &pcp->prom_assignments[i];
 		root = get_root_resource(ap, pbm);
 		res = get_device_resource(ap, pdev);
 		if (root == NULL || res == NULL ||
 		    res->flags == 0)
 			continue;
 		/* Ok we know which resource this PROM assignment is
 		 * for, sanity check it.
 		 */
 		if ((res->start & 0xffffffffUL) != ap->phys_lo)
 			bad_assignment(pdev, ap, res, 1);
 		/* If it is a 64-bit MEM space assignment, verify that
 		 * the resource is too and that the upper 32-bits match.
 		 */
 		if (((ap->phys_hi >> 24) & 3) == 3) {
 			if (((res->flags & IORESOURCE_MEM) == 0) ||
 			    ((res->flags & PCI_BASE_ADDRESS_MEM_TYPE_MASK)
 			     != PCI_BASE_ADDRESS_MEM_TYPE_64))
 				bad_assignment(pdev, ap, res, 1);
 			if ((res->start >> 32) != ap->phys_mid)
 				bad_assignment(pdev, ap, res, 1);
 			/* PBM cannot generate cpu initiated PIOs
 			 * to the full 64-bit space.  Therefore the
 			 * upper 32-bits better be zero.  If it is
 			 * not, just skip it and we will assign it
 			 * properly ourselves.
 			 */
 			if ((res->start >> 32) != 0UL) {
 				printk(KERN_ERR "PCI: OBP assigns out of range MEM address "
 				       "%016lx for region %ld on device %s\n",
 				       res->start, (res - &pdev->resource[0]), pci_name(pdev));
 				continue;
 			}
 		}
 		/* Adjust the resource into the physical address space
 		 * of this PBM.
 		 */
 		pbm->parent->resource_adjust(pdev, res, root);
 		if (request_resource(root, res) < 0) {
 			int rnum;
 			/* OK, there is some conflict.  But this is fine
 			 * since we'll reassign it in the fixup pass.
 			 *
 			 * Do not print the warning for ROM resources
 			 * as such a conflict is quite common and
 			 * harmless as the ROM bar is disabled.
 			 */
 			rnum = (res - &pdev->resource[0]);
 			if (rnum != PCI_ROM_RESOURCE)
 				printk(KERN_ERR "PCI: Resource collision, "
 				       "region %d "
 				       "[%016lx:%016lx] of device %s\n",
 				       rnum,
 				       res->start, res->end,
 				       pci_name(pdev));
 		}
 	}
 }
 void __init pci_record_assignments(struct pci_pbm_info *pbm,
 				   struct pci_bus *pbus)
 {
 	struct pci_dev *dev;
 	struct pci_bus *bus;
 	list_for_each_entry(dev, &pbus->devices, bus_list)
 		pdev_record_assignments(pbm, dev);
 	list_for_each_entry(bus, &pbus->children, node)
 		pci_record_assignments(pbm, bus);
 }
 /* Return non-zero if PDEV has implicit I/O resources even
  * though it may not have an I/O base address register
  * active.
  */
 static int __init has_implicit_io(struct pci_dev *pdev)
 {
 	int class = pdev->class >> 8;
 	if (class == PCI_CLASS_NOT_DEFINED ||
 	    class == PCI_CLASS_NOT_DEFINED_VGA ||
 	    class == PCI_CLASS_STORAGE_IDE ||
 	    (pdev->class >> 16) == PCI_BASE_CLASS_DISPLAY)
 		return 1;
 	return 0;
 }
 static void __init pdev_assign_unassigned(struct pci_pbm_info *pbm,
 					  struct pci_dev *pdev)
 {
 	u32 reg;
 	u16 cmd;
 	int i, io_seen, mem_seen;
 	io_seen = mem_seen = 0;
 	for (i = 0; i < PCI_NUM_RESOURCES; i++) {
 		struct resource *root, *res;
 		unsigned long size, min, max, align;
 		res = &pdev->resource[i];
 		if (res->flags & IORESOURCE_IO)
 			io_seen++;
 		else if (res->flags & IORESOURCE_MEM)
 			mem_seen++;
 		/* If it is already assigned or the resource does
 		 * not exist, there is nothing to do.
 		 */
 		if (res->parent != NULL || res->flags == 0UL)
 			continue;
 		/* Determine the root we allocate from. */
 		if (res->flags & IORESOURCE_IO) {
 			root = &pbm->io_space;
 			min = root->start + 0x400UL;
 			max = root->end;
 		} else {
 			root = &pbm->mem_space;
 			min = root->start;
 			max = min + 0x80000000UL;
 		}
 		size = res->end - res->start;
 		align = size + 1;
 		if (allocate_resource(root, res, size + 1, min, max, align, NULL, NULL) < 0) {
 			/* uh oh */
 			prom_printf("PCI: Failed to allocate resource %d for %s\n",
 				    i, pci_name(pdev));
 			prom_halt();
 		}
 		/* Update PCI config space. */
 		pbm->parent->base_address_update(pdev, i);
 	}
 	/* Special case, disable the ROM.  Several devices
 	 * act funny (ie. do not respond to memory space writes)
 	 * when it is left enabled.  A good example are Qlogic,ISP
 	 * adapters.
 	 */
 	pci_read_config_dword(pdev, PCI_ROM_ADDRESS, &reg);
 	reg &= ~PCI_ROM_ADDRESS_ENABLE;
 	pci_write_config_dword(pdev, PCI_ROM_ADDRESS, reg);
 	/* If we saw I/O or MEM resources, enable appropriate
 	 * bits in PCI command register.
 	 */
 	if (io_seen || mem_seen) {
 		pci_read_config_word(pdev, PCI_COMMAND, &cmd);
 		if (io_seen || has_implicit_io(pdev))
 			cmd |= PCI_COMMAND_IO;
 		if (mem_seen)
 			cmd |= PCI_COMMAND_MEMORY;
 		pci_write_config_word(pdev, PCI_COMMAND, cmd);
 	}
 	/* If this is a PCI bridge or an IDE controller,
 	 * enable bus mastering.  In the former case also
 	 * set the cache line size correctly.
 	 */
 	if (((pdev->class >> 8) == PCI_CLASS_BRIDGE_PCI) ||
 	    (((pdev->class >> 8) == PCI_CLASS_STORAGE_IDE) &&
 	     ((pdev->class & 0x80) != 0))) {
 		pci_read_config_word(pdev, PCI_COMMAND, &cmd);
 		cmd |= PCI_COMMAND_MASTER;
 		pci_write_config_word(pdev, PCI_COMMAND, cmd);
 		if ((pdev->class >> 8) == PCI_CLASS_BRIDGE_PCI)
 			pci_write_config_byte(pdev,
 					      PCI_CACHE_LINE_SIZE,
 					      (64 / sizeof(u32)));
 	}
 }
 void __init pci_assign_unassigned(struct pci_pbm_info *pbm,
 				  struct pci_bus *pbus)
 {
 	struct pci_dev *dev;
 	struct pci_bus *bus;
 	list_for_each_entry(dev, &pbus->devices, bus_list)
 		pdev_assign_unassigned(pbm, dev);
 	list_for_each_entry(bus, &pbus->children, node)
 		pci_assign_unassigned(pbm, bus);
 }
 static void __init pdev_fixup_irq(struct pci_dev *pdev)
 {
 	struct pcidev_cookie *pcp = pdev->sysdata;
 	struct of_device *op = pcp->op;
 	if (op->irqs[0] == 0xffffffff) {
 		pdev->irq = PCI_IRQ_NONE;
 		return;
 	}
 	pdev->irq = op->irqs[0];
 	pci_write_config_byte(pdev, PCI_INTERRUPT_LINE,
 			      pdev->irq & PCI_IRQ_INO);
 }
 void __init pci_fixup_irq(struct pci_pbm_info *pbm,
 			  struct pci_bus *pbus)
 {
 	struct pci_dev *dev;
 	struct pci_bus *bus;
 	list_for_each_entry(dev, &pbus->devices, bus_list)
 		pdev_fixup_irq(dev);
 	list_for_each_entry(bus, &pbus->children, node)
 		pci_fixup_irq(pbm, bus);
 }
 static void pdev_setup_busmastering(struct pci_dev *pdev, int is_66mhz)
 {
 	u16 cmd;
 	u8 hdr_type, min_gnt, ltimer;
 	pci_read_config_word(pdev, PCI_COMMAND, &cmd);
 	cmd |= PCI_COMMAND_MASTER;
 	pci_write_config_word(pdev, PCI_COMMAND, cmd);
 	/* Read it back, if the mastering bit did not
 	 * get set, the device does not support bus
 	 * mastering so we have nothing to do here.
 	 */
 	pci_read_config_word(pdev, PCI_COMMAND, &cmd);
 	if ((cmd & PCI_COMMAND_MASTER) == 0)
 		return;
 	/* Set correct cache line size, 64-byte on all
 	 * Sparc64 PCI systems.  Note that the value is
 	 * measured in 32-bit words.
 	 */
 	pci_write_config_byte(pdev, PCI_CACHE_LINE_SIZE,
 			      64 / sizeof(u32));
 	pci_read_config_byte(pdev, PCI_HEADER_TYPE, &hdr_type);
 	hdr_type &= ~0x80;
 	if (hdr_type != PCI_HEADER_TYPE_NORMAL)
 		return;
 	/* If the latency timer is already programmed with a non-zero
 	 * value, assume whoever set it (OBP or whoever) knows what
 	 * they are doing.
 	 */
 	pci_read_config_byte(pdev, PCI_LATENCY_TIMER, &ltimer);
 	if (ltimer != 0)
 		return;
 	/* XXX Since I'm tipping off the min grant value to
 	 * XXX choose a suitable latency timer value, I also
 	 * XXX considered making use of the max latency value
 	 * XXX as well.  Unfortunately I've seen too many bogusly
 	 * XXX low settings for it to the point where it lacks
 	 * XXX any usefulness.  In one case, an ethernet card
 	 * XXX claimed a min grant of 10 and a max latency of 5.
 	 * XXX Now, if I had two such cards on the same bus I
 	 * XXX could not set the desired burst period (calculated
 	 * XXX from min grant) without violating the max latency
 	 * XXX bound.  Duh...
 	 * XXX
 	 * XXX I blame dumb PC bios implementors for stuff like
 	 * XXX this, most of them don't even try to do something
 	 * XXX sensible with latency timer values and just set some
 	 * XXX default value (usually 32) into every device.
 	 */
 	pci_read_config_byte(pdev, PCI_MIN_GNT, &min_gnt);
 	if (min_gnt == 0) {
 		/* If no min_gnt setting then use a default
 		 * value.
 		 */
 		if (is_66mhz)
 			ltimer = 16;
 		else
 			ltimer = 32;
 	} else {
 		int shift_factor;
 		if (is_66mhz)
 			shift_factor = 2;
 		else
 			shift_factor = 3;
 		/* Use a default value when the min_gnt value
 		 * is erroneously high.
 		 */
 		if (((unsigned int) min_gnt << shift_factor) > 512 ||
 		    ((min_gnt << shift_factor) & 0xff) == 0) {
 			ltimer = 8 << shift_factor;
 		} else {
 			ltimer = min_gnt << shift_factor;
 		}
 	}
 	pci_write_config_byte(pdev, PCI_LATENCY_TIMER, ltimer);
 }
 void pci_determine_66mhz_disposition(struct pci_pbm_info *pbm,
 				     struct pci_bus *pbus)
 {
 	struct pci_dev *pdev;
 	int all_are_66mhz;
 	u16 status;
 	if (pbm->is_66mhz_capable == 0) {
 		all_are_66mhz = 0;
 		goto out;
 	}
 	all_are_66mhz = 1;
 	list_for_each_entry(pdev, &pbus->devices, bus_list) {
 		pci_read_config_word(pdev, PCI_STATUS, &status);
 		if (!(status & PCI_STATUS_66MHZ)) {
 			all_are_66mhz = 0;
 			break;
 		}
 	}
 out:
 	pbm->all_devs_66mhz = all_are_66mhz;
 	printk("PCI%d(PBM%c): Bus running at %dMHz\n",
 	       pbm->parent->index,
 	       (pbm == &pbm->parent->pbm_A) ? 'A' : 'B',
 	       (all_are_66mhz ? 66 : 33));
 }
 void pci_setup_busmastering(struct pci_pbm_info *pbm,
 			    struct pci_bus *pbus)
 {
 	struct pci_dev *dev;
 	struct pci_bus *bus;
 	int is_66mhz;
 	is_66mhz = pbm->is_66mhz_capable && pbm->all_devs_66mhz;
 	list_for_each_entry(dev, &pbus->devices, bus_list)
 		pdev_setup_busmastering(dev, is_66mhz);
 	list_for_each_entry(bus, &pbus->children, node)
 		pci_setup_busmastering(pbm, bus);
 }
 void pci_register_legacy_regions(struct resource *io_res,
 				 struct resource *mem_res)
 {
 	struct resource *p;
 	/* VGA Video RAM. */
 	p = kzalloc(sizeof(*p), GFP_KERNEL);
 	if (!p)
 		return;
 	p->name = "Video RAM area";
 	p->start = mem_res->start + 0xa0000UL;
 	p->end = p->start + 0x1ffffUL;
 	p->flags = IORESOURCE_BUSY;
 	request_resource(mem_res, p);
 	p = kzalloc(sizeof(*p), GFP_KERNEL);
 	if (!p)
 		return;
 	p->name = "System ROM";
 	p->start = mem_res->start + 0xf0000UL;
 	p->end = p->start + 0xffffUL;
 	p->flags = IORESOURCE_BUSY;
 	request_resource(mem_res, p);
 	p = kzalloc(sizeof(*p), GFP_KERNEL);
 	if (!p)
 		return;
 	p->name = "Video ROM";
 	p->start = mem_res->start + 0xc0000UL;
 	p->end = p->start + 0x7fffUL;
 	p->flags = IORESOURCE_BUSY;
 	request_resource(mem_res, p);
 }
 /* Generic helper routines for PCI error reporting. */
 void pci_scan_for_target_abort(struct pci_controller_info *p,
 			       struct pci_pbm_info *pbm,
 			       struct pci_bus *pbus)
 {
 	struct pci_dev *pdev;
 	struct pci_bus *bus;
 	list_for_each_entry(pdev, &pbus->devices, bus_list) {
 		u16 status, error_bits;
 		pci_read_config_word(pdev, PCI_STATUS, &status);
 		error_bits =
 			(status & (PCI_STATUS_SIG_TARGET_ABORT |
 				   PCI_STATUS_REC_TARGET_ABORT));
 		if (error_bits) {
 			pci_write_config_word(pdev, PCI_STATUS, error_bits);
 			printk("PCI%d(PBM%c): Device [%s] saw Target Abort [%016x]\n",
 			       p->index, ((pbm == &p->pbm_A) ? 'A' : 'B'),
 			       pci_name(pdev), status);
 		}
 	}
 	list_for_each_entry(bus, &pbus->children, node)
 		pci_scan_for_target_abort(p, pbm, bus);
 }
 void pci_scan_for_master_abort(struct pci_controller_info *p,
 			       struct pci_pbm_info *pbm,
 			       struct pci_bus *pbus)
 {
 	struct pci_dev *pdev;
 	struct pci_bus *bus;
 	list_for_each_entry(pdev, &pbus->devices, bus_list) {
 		u16 status, error_bits;
 		pci_read_config_word(pdev, PCI_STATUS, &status);
 		error_bits =
 			(status & (PCI_STATUS_REC_MASTER_ABORT));
 		if (error_bits) {
 			pci_write_config_word(pdev, PCI_STATUS, error_bits);
 			printk("PCI%d(PBM%c): Device [%s] received Master Abort [%016x]\n",
 			       p->index, ((pbm == &p->pbm_A) ? 'A' : 'B'),
 			       pci_name(pdev), status);
 		}
 	}
 	list_for_each_entry(bus, &pbus->children, node)
 		pci_scan_for_master_abort(p, pbm, bus);
 }
 void pci_scan_for_parity_error(struct pci_controller_info *p,
 			       struct pci_pbm_info *pbm,
 			       struct pci_bus *pbus)
 {
 	struct pci_dev *pdev;
 	struct pci_bus *bus;
 	list_for_each_entry(pdev, &pbus->devices, bus_list) {
 		u16 status, error_bits;
 		pci_read_config_word(pdev, PCI_STATUS, &status);
 		error_bits =
 			(status & (PCI_STATUS_PARITY |
 				   PCI_STATUS_DETECTED_PARITY));
 		if (error_bits) {
 			pci_write_config_word(pdev, PCI_STATUS, error_bits);
 			printk("PCI%d(PBM%c): Device [%s] saw Parity Error [%016x]\n",
 			       p->index, ((pbm == &p->pbm_A) ? 'A' : 'B'),
 			       pci_name(pdev), status);
 		}
 	}
 	list_for_each_entry(bus, &pbus->children, node)
 		pci_scan_for_parity_error(p, pbm, bus);
 }

arch/sparc64/kernel/pci_sun4v.c

Diff comments View file @ c827ba4

 /* pci_sun4v.c: SUN4V specific PCI controller support.
  *
  * Copyright (C) 2006 David S. Miller (davem@davemloft.net)
  */
 #include <linux/kernel.h>
 #include <linux/types.h>
 #include <linux/pci.h>
 #include <linux/init.h>
 #include <linux/slab.h>
 #include <linux/interrupt.h>
 #include <linux/percpu.h>
+#include <linux/irq.h>
+#include <linux/msi.h>
 #include <asm/pbm.h>
 #include <asm/iommu.h>
 #include <asm/irq.h>
 #include <asm/upa.h>
 #include <asm/pstate.h>
 #include <asm/oplib.h>
 #include <asm/hypervisor.h>
 #include <asm/prom.h>
 #include "pci_impl.h"
 #include "iommu_common.h"
 #include "pci_sun4v.h"
 #define PGLIST_NENTS	(PAGE_SIZE / sizeof(u64))
 struct pci_iommu_batch {
 	struct pci_dev	*pdev;		/* Device mapping is for.	*/
 	unsigned long	prot;		/* IOMMU page protections	*/
 	unsigned long	entry;		/* Index into IOTSB.		*/
 	u64		*pglist;	/* List of physical pages	*/
 	unsigned long	npages;		/* Number of pages in list.	*/
 };
 static DEFINE_PER_CPU(struct pci_iommu_batch, pci_iommu_batch);
 /* Interrupts must be disabled.  */
 static inline void pci_iommu_batch_start(struct pci_dev *pdev, unsigned long prot, unsigned long entry)
 {
 	struct pci_iommu_batch *p = &__get_cpu_var(pci_iommu_batch);
 	p->pdev		= pdev;
 	p->prot		= prot;
 	p->entry	= entry;
 	p->npages	= 0;
 }
 /* Interrupts must be disabled.  */
 static long pci_iommu_batch_flush(struct pci_iommu_batch *p)
 {
 	struct pcidev_cookie *pcp = p->pdev->sysdata;
 	unsigned long devhandle = pcp->pbm->devhandle;
 	unsigned long prot = p->prot;
 	unsigned long entry = p->entry;
 	u64 *pglist = p->pglist;
 	unsigned long npages = p->npages;
 	while (npages != 0) {
 		long num;
 		num = pci_sun4v_iommu_map(devhandle, HV_PCI_TSBID(0, entry),
 					  npages, prot, __pa(pglist));
 		if (unlikely(num < 0)) {
 			if (printk_ratelimit())
 				printk("pci_iommu_batch_flush: IOMMU map of "
 				       "[%08lx:%08lx:%lx:%lx:%lx] failed with "
 				       "status %ld\n",
 				       devhandle, HV_PCI_TSBID(0, entry),
 				       npages, prot, __pa(pglist), num);
 			return -1;
 		}
 		entry += num;
 		npages -= num;
 		pglist += num;
 	}
 	p->entry = entry;
 	p->npages = 0;
 	return 0;
 }
 /* Interrupts must be disabled.  */
 static inline long pci_iommu_batch_add(u64 phys_page)
 {
 	struct pci_iommu_batch *p = &__get_cpu_var(pci_iommu_batch);
 	BUG_ON(p->npages >= PGLIST_NENTS);
 	p->pglist[p->npages++] = phys_page;
 	if (p->npages == PGLIST_NENTS)
 		return pci_iommu_batch_flush(p);
 	return 0;
 }
 /* Interrupts must be disabled.  */
 static inline long pci_iommu_batch_end(void)
 {
 	struct pci_iommu_batch *p = &__get_cpu_var(pci_iommu_batch);
 	BUG_ON(p->npages >= PGLIST_NENTS);
 	return pci_iommu_batch_flush(p);
 }
 static long pci_arena_alloc(struct pci_iommu_arena *arena, unsigned long npages)
 {
 	unsigned long n, i, start, end, limit;
 	int pass;
 	limit = arena->limit;
 	start = arena->hint;
 	pass = 0;
 again:
 	n = find_next_zero_bit(arena->map, limit, start);
 	end = n + npages;
 	if (unlikely(end >= limit)) {
 		if (likely(pass < 1)) {
 			limit = start;
 			start = 0;
 			pass++;
 			goto again;
 		} else {
 			/* Scanned the whole thing, give up. */
 			return -1;
 		}
 	}
 	for (i = n; i < end; i++) {
 		if (test_bit(i, arena->map)) {
 			start = i + 1;
 			goto again;
 		}
 	}
 	for (i = n; i < end; i++)
 		__set_bit(i, arena->map);
 	arena->hint = end;
 	return n;
 }
 static void pci_arena_free(struct pci_iommu_arena *arena, unsigned long base, unsigned long npages)
 {
 	unsigned long i;
 	for (i = base; i < (base + npages); i++)
 		__clear_bit(i, arena->map);
 }
 static void *pci_4v_alloc_consistent(struct pci_dev *pdev, size_t size, dma_addr_t *dma_addrp, gfp_t gfp)
 {
 	struct pcidev_cookie *pcp;
 	struct pci_iommu *iommu;
 	unsigned long flags, order, first_page, npages, n;
 	void *ret;
 	long entry;
 	size = IO_PAGE_ALIGN(size);
 	order = get_order(size);
 	if (unlikely(order >= MAX_ORDER))
 		return NULL;
 	npages = size >> IO_PAGE_SHIFT;
 	first_page = __get_free_pages(gfp, order);
 	if (unlikely(first_page == 0UL))
 		return NULL;
 	memset((char *)first_page, 0, PAGE_SIZE << order);
 	pcp = pdev->sysdata;
 	iommu = pcp->pbm->iommu;
 	spin_lock_irqsave(&iommu->lock, flags);
 	entry = pci_arena_alloc(&iommu->arena, npages);
 	spin_unlock_irqrestore(&iommu->lock, flags);
 	if (unlikely(entry < 0L))
 		goto arena_alloc_fail;
 	*dma_addrp = (iommu->page_table_map_base +
 		      (entry << IO_PAGE_SHIFT));
 	ret = (void *) first_page;
 	first_page = __pa(first_page);
 	local_irq_save(flags);
 	pci_iommu_batch_start(pdev,
 			      (HV_PCI_MAP_ATTR_READ |
 			       HV_PCI_MAP_ATTR_WRITE),
 			      entry);
 	for (n = 0; n < npages; n++) {
 		long err = pci_iommu_batch_add(first_page + (n * PAGE_SIZE));
 		if (unlikely(err < 0L))
 			goto iommu_map_fail;
 	}
 	if (unlikely(pci_iommu_batch_end() < 0L))
 		goto iommu_map_fail;
 	local_irq_restore(flags);
 	return ret;
 iommu_map_fail:
 	/* Interrupts are disabled.  */
 	spin_lock(&iommu->lock);
 	pci_arena_free(&iommu->arena, entry, npages);
 	spin_unlock_irqrestore(&iommu->lock, flags);
 arena_alloc_fail:
 	free_pages(first_page, order);
 	return NULL;
 }
 static void pci_4v_free_consistent(struct pci_dev *pdev, size_t size, void *cpu, dma_addr_t dvma)
 {
 	struct pcidev_cookie *pcp;
 	struct pci_iommu *iommu;
 	unsigned long flags, order, npages, entry;
 	u32 devhandle;
 	npages = IO_PAGE_ALIGN(size) >> IO_PAGE_SHIFT;
 	pcp = pdev->sysdata;
 	iommu = pcp->pbm->iommu;
 	devhandle = pcp->pbm->devhandle;
 	entry = ((dvma - iommu->page_table_map_base) >> IO_PAGE_SHIFT);
 	spin_lock_irqsave(&iommu->lock, flags);
 	pci_arena_free(&iommu->arena, entry, npages);
 	do {
 		unsigned long num;
 		num = pci_sun4v_iommu_demap(devhandle, HV_PCI_TSBID(0, entry),
 					    npages);
 		entry += num;
 		npages -= num;
 	} while (npages != 0);
 	spin_unlock_irqrestore(&iommu->lock, flags);
 	order = get_order(size);
 	if (order < 10)
 		free_pages((unsigned long)cpu, order);
 }
 static dma_addr_t pci_4v_map_single(struct pci_dev *pdev, void *ptr, size_t sz, int direction)
 {
 	struct pcidev_cookie *pcp;
 	struct pci_iommu *iommu;
 	unsigned long flags, npages, oaddr;
 	unsigned long i, base_paddr;
 	u32 bus_addr, ret;
 	unsigned long prot;
 	long entry;
 	pcp = pdev->sysdata;
 	iommu = pcp->pbm->iommu;
 	if (unlikely(direction == PCI_DMA_NONE))
 		goto bad;
 	oaddr = (unsigned long)ptr;
 	npages = IO_PAGE_ALIGN(oaddr + sz) - (oaddr & IO_PAGE_MASK);
 	npages >>= IO_PAGE_SHIFT;
 	spin_lock_irqsave(&iommu->lock, flags);
 	entry = pci_arena_alloc(&iommu->arena, npages);
 	spin_unlock_irqrestore(&iommu->lock, flags);
 	if (unlikely(entry < 0L))
 		goto bad;
 	bus_addr = (iommu->page_table_map_base +
 		    (entry << IO_PAGE_SHIFT));
 	ret = bus_addr | (oaddr & ~IO_PAGE_MASK);
 	base_paddr = __pa(oaddr & IO_PAGE_MASK);
 	prot = HV_PCI_MAP_ATTR_READ;
 	if (direction != PCI_DMA_TODEVICE)
 		prot |= HV_PCI_MAP_ATTR_WRITE;
 	local_irq_save(flags);
 	pci_iommu_batch_start(pdev, prot, entry);
 	for (i = 0; i < npages; i++, base_paddr += IO_PAGE_SIZE) {
 		long err = pci_iommu_batch_add(base_paddr);
 		if (unlikely(err < 0L))
 			goto iommu_map_fail;
 	}
 	if (unlikely(pci_iommu_batch_end() < 0L))
 		goto iommu_map_fail;
 	local_irq_restore(flags);
 	return ret;
 bad:
 	if (printk_ratelimit())
 		WARN_ON(1);
 	return PCI_DMA_ERROR_CODE;
 iommu_map_fail:
 	/* Interrupts are disabled.  */
 	spin_lock(&iommu->lock);
 	pci_arena_free(&iommu->arena, entry, npages);
 	spin_unlock_irqrestore(&iommu->lock, flags);
 	return PCI_DMA_ERROR_CODE;
 }
 static void pci_4v_unmap_single(struct pci_dev *pdev, dma_addr_t bus_addr, size_t sz, int direction)
 {
 	struct pcidev_cookie *pcp;
 	struct pci_iommu *iommu;
 	unsigned long flags, npages;
 	long entry;
 	u32 devhandle;
 	if (unlikely(direction == PCI_DMA_NONE)) {
 		if (printk_ratelimit())
 			WARN_ON(1);
 		return;
 	}
 	pcp = pdev->sysdata;
 	iommu = pcp->pbm->iommu;
 	devhandle = pcp->pbm->devhandle;
 	npages = IO_PAGE_ALIGN(bus_addr + sz) - (bus_addr & IO_PAGE_MASK);
 	npages >>= IO_PAGE_SHIFT;
 	bus_addr &= IO_PAGE_MASK;
 	spin_lock_irqsave(&iommu->lock, flags);
 	entry = (bus_addr - iommu->page_table_map_base) >> IO_PAGE_SHIFT;
 	pci_arena_free(&iommu->arena, entry, npages);
 	do {
 		unsigned long num;
 		num = pci_sun4v_iommu_demap(devhandle, HV_PCI_TSBID(0, entry),
 					    npages);
 		entry += num;
 		npages -= num;
 	} while (npages != 0);
 	spin_unlock_irqrestore(&iommu->lock, flags);
 }
 #define SG_ENT_PHYS_ADDRESS(SG)	\
 	(__pa(page_address((SG)->page)) + (SG)->offset)
 static inline long fill_sg(long entry, struct pci_dev *pdev,
 			   struct scatterlist *sg,
 			   int nused, int nelems, unsigned long prot)
 {
 	struct scatterlist *dma_sg = sg;
 	struct scatterlist *sg_end = sg + nelems;
 	unsigned long flags;
 	int i;
 	local_irq_save(flags);
 	pci_iommu_batch_start(pdev, prot, entry);
 	for (i = 0; i < nused; i++) {
 		unsigned long pteval = ~0UL;
 		u32 dma_npages;
 		dma_npages = ((dma_sg->dma_address & (IO_PAGE_SIZE - 1UL)) +
 			      dma_sg->dma_length +
 			      ((IO_PAGE_SIZE - 1UL))) >> IO_PAGE_SHIFT;
 		do {
 			unsigned long offset;
 			signed int len;
 			/* If we are here, we know we have at least one
 			 * more page to map.  So walk forward until we
 			 * hit a page crossing, and begin creating new
 			 * mappings from that spot.
 			 */
 			for (;;) {
 				unsigned long tmp;
 				tmp = SG_ENT_PHYS_ADDRESS(sg);
 				len = sg->length;
 				if (((tmp ^ pteval) >> IO_PAGE_SHIFT) != 0UL) {
 					pteval = tmp & IO_PAGE_MASK;
 					offset = tmp & (IO_PAGE_SIZE - 1UL);
 					break;
 				}
 				if (((tmp ^ (tmp + len - 1UL)) >> IO_PAGE_SHIFT) != 0UL) {
 					pteval = (tmp + IO_PAGE_SIZE) & IO_PAGE_MASK;
 					offset = 0UL;
 					len -= (IO_PAGE_SIZE - (tmp & (IO_PAGE_SIZE - 1UL)));
 					break;
 				}
 				sg++;
 			}
 			pteval = (pteval & IOPTE_PAGE);
 			while (len > 0) {
 				long err;
 				err = pci_iommu_batch_add(pteval);
 				if (unlikely(err < 0L))
 					goto iommu_map_failed;
 				pteval += IO_PAGE_SIZE;
 				len -= (IO_PAGE_SIZE - offset);
 				offset = 0;
 				dma_npages--;
 			}
 			pteval = (pteval & IOPTE_PAGE) + len;
 			sg++;
 			/* Skip over any tail mappings we've fully mapped,
 			 * adjusting pteval along the way.  Stop when we
 			 * detect a page crossing event.
 			 */
 			while (sg < sg_end &&
 			       (pteval << (64 - IO_PAGE_SHIFT)) != 0UL &&
 			       (pteval == SG_ENT_PHYS_ADDRESS(sg)) &&
 			       ((pteval ^
 				 (SG_ENT_PHYS_ADDRESS(sg) + sg->length - 1UL)) >> IO_PAGE_SHIFT) == 0UL) {
 				pteval += sg->length;
 				sg++;
 			}
 			if ((pteval << (64 - IO_PAGE_SHIFT)) == 0UL)
 				pteval = ~0UL;
 		} while (dma_npages != 0);
 		dma_sg++;
 	}
 	if (unlikely(pci_iommu_batch_end() < 0L))
 		goto iommu_map_failed;
 	local_irq_restore(flags);
 	return 0;
 iommu_map_failed:
 	local_irq_restore(flags);
 	return -1L;
 }
 static int pci_4v_map_sg(struct pci_dev *pdev, struct scatterlist *sglist, int nelems, int direction)
 {
 	struct pcidev_cookie *pcp;
 	struct pci_iommu *iommu;
 	unsigned long flags, npages, prot;
 	u32 dma_base;
 	struct scatterlist *sgtmp;
 	long entry, err;
 	int used;
 	/* Fast path single entry scatterlists. */
 	if (nelems == 1) {
 		sglist->dma_address =
 			pci_4v_map_single(pdev,
 					  (page_address(sglist->page) + sglist->offset),
 					  sglist->length, direction);
 		if (unlikely(sglist->dma_address == PCI_DMA_ERROR_CODE))
 			return 0;
 		sglist->dma_length = sglist->length;
 		return 1;
 	}
 	pcp = pdev->sysdata;
 	iommu = pcp->pbm->iommu;
 	if (unlikely(direction == PCI_DMA_NONE))
 		goto bad;
 	/* Step 1: Prepare scatter list. */
 	npages = prepare_sg(sglist, nelems);
 	/* Step 2: Allocate a cluster and context, if necessary. */
 	spin_lock_irqsave(&iommu->lock, flags);
 	entry = pci_arena_alloc(&iommu->arena, npages);
 	spin_unlock_irqrestore(&iommu->lock, flags);
 	if (unlikely(entry < 0L))
 		goto bad;
 	dma_base = iommu->page_table_map_base +
 		(entry << IO_PAGE_SHIFT);
 	/* Step 3: Normalize DMA addresses. */
 	used = nelems;
 	sgtmp = sglist;
 	while (used && sgtmp->dma_length) {
 		sgtmp->dma_address += dma_base;
 		sgtmp++;
 		used--;
 	}
 	used = nelems - used;
 	/* Step 4: Create the mappings. */
 	prot = HV_PCI_MAP_ATTR_READ;
 	if (direction != PCI_DMA_TODEVICE)
 		prot |= HV_PCI_MAP_ATTR_WRITE;
 	err = fill_sg(entry, pdev, sglist, used, nelems, prot);
 	if (unlikely(err < 0L))
 		goto iommu_map_failed;
 	return used;
 bad:
 	if (printk_ratelimit())
 		WARN_ON(1);
 	return 0;
 iommu_map_failed:
 	spin_lock_irqsave(&iommu->lock, flags);
 	pci_arena_free(&iommu->arena, entry, npages);
 	spin_unlock_irqrestore(&iommu->lock, flags);
 	return 0;
 }
 static void pci_4v_unmap_sg(struct pci_dev *pdev, struct scatterlist *sglist, int nelems, int direction)
 {
 	struct pcidev_cookie *pcp;
 	struct pci_iommu *iommu;
 	unsigned long flags, i, npages;
 	long entry;
 	u32 devhandle, bus_addr;
 	if (unlikely(direction == PCI_DMA_NONE)) {
 		if (printk_ratelimit())
 			WARN_ON(1);
 	}
 	pcp = pdev->sysdata;
 	iommu = pcp->pbm->iommu;
 	devhandle = pcp->pbm->devhandle;
 	bus_addr = sglist->dma_address & IO_PAGE_MASK;
 	for (i = 1; i < nelems; i++)
 		if (sglist[i].dma_length == 0)
 			break;
 	i--;
 	npages = (IO_PAGE_ALIGN(sglist[i].dma_address + sglist[i].dma_length) -
 		  bus_addr) >> IO_PAGE_SHIFT;
 	entry = ((bus_addr - iommu->page_table_map_base) >> IO_PAGE_SHIFT);
 	spin_lock_irqsave(&iommu->lock, flags);
 	pci_arena_free(&iommu->arena, entry, npages);
 	do {
 		unsigned long num;
 		num = pci_sun4v_iommu_demap(devhandle, HV_PCI_TSBID(0, entry),
 					    npages);
 		entry += num;
 		npages -= num;
 	} while (npages != 0);
 	spin_unlock_irqrestore(&iommu->lock, flags);
 }
 static void pci_4v_dma_sync_single_for_cpu(struct pci_dev *pdev, dma_addr_t bus_addr, size_t sz, int direction)
 {
 	/* Nothing to do... */
 }
 static void pci_4v_dma_sync_sg_for_cpu(struct pci_dev *pdev, struct scatterlist *sglist, int nelems, int direction)
 {
 	/* Nothing to do... */
 }
 struct pci_iommu_ops pci_sun4v_iommu_ops = {
 	.alloc_consistent		= pci_4v_alloc_consistent,
 	.free_consistent		= pci_4v_free_consistent,
 	.map_single			= pci_4v_map_single,
 	.unmap_single			= pci_4v_unmap_single,
 	.map_sg				= pci_4v_map_sg,
 	.unmap_sg			= pci_4v_unmap_sg,
 	.dma_sync_single_for_cpu	= pci_4v_dma_sync_single_for_cpu,
 	.dma_sync_sg_for_cpu		= pci_4v_dma_sync_sg_for_cpu,
 };
 /* SUN4V PCI configuration space accessors. */
 struct pdev_entry {
 	struct pdev_entry	*next;
 	u32			devhandle;
 	unsigned int		bus;
 	unsigned int		device;
 	unsigned int		func;
 };
 #define PDEV_HTAB_SIZE	16
 #define PDEV_HTAB_MASK	(PDEV_HTAB_SIZE - 1)
 static struct pdev_entry *pdev_htab[PDEV_HTAB_SIZE];
 static inline unsigned int pdev_hashfn(u32 devhandle, unsigned int bus, unsigned int device, unsigned int func)
 {
 	unsigned int val;
 	val = (devhandle ^ (devhandle >> 4));
 	val ^= bus;
 	val ^= device;
 	val ^= func;
 	return val & PDEV_HTAB_MASK;
 }
 static int pdev_htab_add(u32 devhandle, unsigned int bus, unsigned int device, unsigned int func)
 {
 	struct pdev_entry *p = kmalloc(sizeof(*p), GFP_KERNEL);
 	struct pdev_entry **slot;
 	if (!p)
 		return -ENOMEM;
 	slot = &pdev_htab[pdev_hashfn(devhandle, bus, device, func)];
 	p->next = *slot;
 	*slot = p;
 	p->devhandle = devhandle;
 	p->bus = bus;
 	p->device = device;
 	p->func = func;
 	return 0;
 }
 /* Recursively descend into the OBP device tree, rooted at toplevel_node,
  * looking for a PCI device matching bus and devfn.
  */
 static int obp_find(struct device_node *toplevel_node, unsigned int bus, unsigned int devfn)
 {
 	toplevel_node = toplevel_node->child;
 	while (toplevel_node != NULL) {
 		struct linux_prom_pci_registers *regs;
 		struct property *prop;
 		int ret;
 		ret = obp_find(toplevel_node, bus, devfn);
 		if (ret != 0)
 			return ret;
 		prop = of_find_property(toplevel_node, "reg", NULL);
 		if (!prop)
 			goto next_sibling;
 		regs = prop->value;
 		if (((regs->phys_hi >> 16) & 0xff) == bus &&
 		    ((regs->phys_hi >> 8) & 0xff) == devfn)
 			break;
 	next_sibling:
 		toplevel_node = toplevel_node->sibling;
 	}
 	return toplevel_node != NULL;
 }
 static int pdev_htab_populate(struct pci_pbm_info *pbm)
 {
 	u32 devhandle = pbm->devhandle;
 	unsigned int bus;
 	for (bus = pbm->pci_first_busno; bus <= pbm->pci_last_busno; bus++) {
 		unsigned int devfn;
 		for (devfn = 0; devfn < 256; devfn++) {
 			unsigned int device = PCI_SLOT(devfn);
 			unsigned int func = PCI_FUNC(devfn);
 			if (obp_find(pbm->prom_node, bus, devfn)) {
 				int err = pdev_htab_add(devhandle, bus,
 							device, func);
 				if (err)
 					return err;
 			}
 		}
 	}
 	return 0;
 }
 static struct pdev_entry *pdev_find(u32 devhandle, unsigned int bus, unsigned int device, unsigned int func)
 {
 	struct pdev_entry *p;
 	p = pdev_htab[pdev_hashfn(devhandle, bus, device, func)];
 	while (p) {
 		if (p->devhandle == devhandle &&
 		    p->bus == bus &&
 		    p->device == device &&
 		    p->func == func)
 			break;
 		p = p->next;
 	}
 	return p;
 }
 static inline int pci_sun4v_out_of_range(struct pci_pbm_info *pbm, unsigned int bus, unsigned int device, unsigned int func)
 {
 	if (bus < pbm->pci_first_busno ||
 	    bus > pbm->pci_last_busno)
 		return 1;
 	return pdev_find(pbm->devhandle, bus, device, func) == NULL;
 }
 static int pci_sun4v_read_pci_cfg(struct pci_bus *bus_dev, unsigned int devfn,
 				  int where, int size, u32 *value)
 {
 	struct pci_pbm_info *pbm = bus_dev->sysdata;
 	u32 devhandle = pbm->devhandle;
 	unsigned int bus = bus_dev->number;
 	unsigned int device = PCI_SLOT(devfn);
 	unsigned int func = PCI_FUNC(devfn);
 	unsigned long ret;
 	if (pci_sun4v_out_of_range(pbm, bus, device, func)) {
 		ret = ~0UL;
 	} else {
 		ret = pci_sun4v_config_get(devhandle,
 				HV_PCI_DEVICE_BUILD(bus, device, func),
 				where, size);
 #if 0
 		printk("rcfg: [%x:%x:%x:%d]=[%lx]\n",
 		       devhandle, HV_PCI_DEVICE_BUILD(bus, device, func),
 		       where, size, ret);
 #endif
 	}
 	switch (size) {
 	case 1:
 		*value = ret & 0xff;
 		break;
 	case 2:
 		*value = ret & 0xffff;
 		break;
 	case 4:
 		*value = ret & 0xffffffff;
 		break;
 	};
 	return PCIBIOS_SUCCESSFUL;
 }
 static int pci_sun4v_write_pci_cfg(struct pci_bus *bus_dev, unsigned int devfn,
 				   int where, int size, u32 value)
 {
 	struct pci_pbm_info *pbm = bus_dev->sysdata;
 	u32 devhandle = pbm->devhandle;
 	unsigned int bus = bus_dev->number;
 	unsigned int device = PCI_SLOT(devfn);
 	unsigned int func = PCI_FUNC(devfn);
 	unsigned long ret;
 	if (pci_sun4v_out_of_range(pbm, bus, device, func)) {
 		/* Do nothing. */
 	} else {
 		ret = pci_sun4v_config_put(devhandle,
 				HV_PCI_DEVICE_BUILD(bus, device, func),
 				where, size, value);
 #if 0
 		printk("wcfg: [%x:%x:%x:%d] v[%x] == [%lx]\n",
 		       devhandle, HV_PCI_DEVICE_BUILD(bus, device, func),
 		       where, size, value, ret);
 #endif
 	}
 	return PCIBIOS_SUCCESSFUL;
 }
 static struct pci_ops pci_sun4v_ops = {
 	.read =		pci_sun4v_read_pci_cfg,
 	.write =	pci_sun4v_write_pci_cfg,
 };
 static void pbm_scan_bus(struct pci_controller_info *p,
 			 struct pci_pbm_info *pbm)
 {
 	struct pcidev_cookie *cookie = kzalloc(sizeof(*cookie), GFP_KERNEL);
 	if (!cookie) {
 		prom_printf("%s: Critical allocation failure.\n", pbm->name);
 		prom_halt();
 	}
 	/* All we care about is the PBM. */
 	cookie->pbm = pbm;
 	pbm->pci_bus = pci_scan_bus(pbm->pci_first_busno, p->pci_ops, pbm);
 #if 0
 	pci_fixup_host_bridge_self(pbm->pci_bus);
 	pbm->pci_bus->self->sysdata = cookie;
 #endif
 	pci_fill_in_pbm_cookies(pbm->pci_bus, pbm, pbm->prom_node);
 	pci_record_assignments(pbm, pbm->pci_bus);
 	pci_assign_unassigned(pbm, pbm->pci_bus);
 	pci_fixup_irq(pbm, pbm->pci_bus);
 	pci_determine_66mhz_disposition(pbm, pbm->pci_bus);
 	pci_setup_busmastering(pbm, pbm->pci_bus);
 }
 static void pci_sun4v_scan_bus(struct pci_controller_info *p)
 {
 	struct property *prop;
 	struct device_node *dp;
 	if ((dp = p->pbm_A.prom_node) != NULL) {
 		prop = of_find_property(dp, "66mhz-capable", NULL);
 		p->pbm_A.is_66mhz_capable = (prop != NULL);
 		pbm_scan_bus(p, &p->pbm_A);
 	}
 	if ((dp = p->pbm_B.prom_node) != NULL) {
 		prop = of_find_property(dp, "66mhz-capable", NULL);
 		p->pbm_B.is_66mhz_capable = (prop != NULL);
 		pbm_scan_bus(p, &p->pbm_B);
 	}
 	/* XXX register error interrupt handlers XXX */
 }
 static void pci_sun4v_base_address_update(struct pci_dev *pdev, int resource)
 {
 	struct pcidev_cookie *pcp = pdev->sysdata;
 	struct pci_pbm_info *pbm = pcp->pbm;
 	struct resource *res, *root;
 	u32 reg;
 	int where, size, is_64bit;
 	res = &pdev->resource[resource];
 	if (resource < 6) {
 		where = PCI_BASE_ADDRESS_0 + (resource * 4);
 	} else if (resource == PCI_ROM_RESOURCE) {
 		where = pdev->rom_base_reg;
 	} else {
 		/* Somebody might have asked allocation of a non-standard resource */
 		return;
 	}
 	/* XXX 64-bit MEM handling is not %100 correct... XXX */
 	is_64bit = 0;
 	if (res->flags & IORESOURCE_IO)
 		root = &pbm->io_space;
 	else {
 		root = &pbm->mem_space;
 		if ((res->flags & PCI_BASE_ADDRESS_MEM_TYPE_MASK)
 		    == PCI_BASE_ADDRESS_MEM_TYPE_64)
 			is_64bit = 1;
 	}
 	size = res->end - res->start;
 	pci_read_config_dword(pdev, where, &reg);
 	reg = ((reg & size) |
 	       (((u32)(res->start - root->start)) & ~size));
 	if (resource == PCI_ROM_RESOURCE) {
 		reg |= PCI_ROM_ADDRESS_ENABLE;
 		res->flags |= IORESOURCE_ROM_ENABLE;
 	}
 	pci_write_config_dword(pdev, where, reg);
 	/* This knows that the upper 32-bits of the address
 	 * must be zero.  Our PCI common layer enforces this.
 	 */
 	if (is_64bit)
 		pci_write_config_dword(pdev, where + 4, 0);
 }
 static void pci_sun4v_resource_adjust(struct pci_dev *pdev,
 				      struct resource *res,
 				      struct resource *root)
 {
 	res->start += root->start;
 	res->end += root->start;
 }
 /* Use ranges property to determine where PCI MEM, I/O, and Config
  * space are for this PCI bus module.
  */
 static void pci_sun4v_determine_mem_io_space(struct pci_pbm_info *pbm)
 {
 	int i, saw_mem, saw_io;
 	saw_mem = saw_io = 0;
 	for (i = 0; i < pbm->num_pbm_ranges; i++) {
 		struct linux_prom_pci_ranges *pr = &pbm->pbm_ranges[i];
 		unsigned long a;
 		int type;
 		type = (pr->child_phys_hi >> 24) & 0x3;
 		a = (((unsigned long)pr->parent_phys_hi << 32UL) |
 		     ((unsigned long)pr->parent_phys_lo  <<  0UL));
 		switch (type) {
 		case 1:
 			/* 16-bit IO space, 16MB */
 			pbm->io_space.start = a;
 			pbm->io_space.end = a + ((16UL*1024UL*1024UL) - 1UL);
 			pbm->io_space.flags = IORESOURCE_IO;
 			saw_io = 1;
 			break;
 		case 2:
 			/* 32-bit MEM space, 2GB */
 			pbm->mem_space.start = a;
 			pbm->mem_space.end = a + (0x80000000UL - 1UL);
 			pbm->mem_space.flags = IORESOURCE_MEM;
 			saw_mem = 1;
 			break;
 		case 3:
 			/* XXX 64-bit MEM handling XXX */
 		default:
 			break;
 		};
 	}
 	if (!saw_io || !saw_mem) {
 		prom_printf("%s: Fatal error, missing %s PBM range.\n",
 			    pbm->name,
 			    (!saw_io ? "IO" : "MEM"));
 		prom_halt();
 	}
 	printk("%s: PCI IO[%lx] MEM[%lx]\n",
 	       pbm->name,
 	       pbm->io_space.start,
 	       pbm->mem_space.start);
 }
 static void pbm_register_toplevel_resources(struct pci_controller_info *p,
 					    struct pci_pbm_info *pbm)
 {
 	pbm->io_space.name = pbm->mem_space.name = pbm->name;
 	request_resource(&ioport_resource, &pbm->io_space);
 	request_resource(&iomem_resource, &pbm->mem_space);
 	pci_register_legacy_regions(&pbm->io_space,
 				    &pbm->mem_space);
 }
 static unsigned long probe_existing_entries(struct pci_pbm_info *pbm,
 					    struct pci_iommu *iommu)
 {
 	struct pci_iommu_arena *arena = &iommu->arena;
 	unsigned long i, cnt = 0;
 	u32 devhandle;
 	devhandle = pbm->devhandle;
 	for (i = 0; i < arena->limit; i++) {
 		unsigned long ret, io_attrs, ra;
 		ret = pci_sun4v_iommu_getmap(devhandle,
 					     HV_PCI_TSBID(0, i),
 					     &io_attrs, &ra);
 		if (ret == HV_EOK) {
 			if (page_in_phys_avail(ra)) {
 				pci_sun4v_iommu_demap(devhandle,
 						      HV_PCI_TSBID(0, i), 1);
 			} else {
 				cnt++;
 				__set_bit(i, arena->map);
 			}
 		}
 	}
 	return cnt;
 }
 static void pci_sun4v_iommu_init(struct pci_pbm_info *pbm)
 {
 	struct pci_iommu *iommu = pbm->iommu;
 	struct property *prop;
 	unsigned long num_tsb_entries, sz;
 	u32 vdma[2], dma_mask, dma_offset;
 	int tsbsize;
 	prop = of_find_property(pbm->prom_node, "virtual-dma", NULL);
 	if (prop) {
 		u32 *val = prop->value;
 		vdma[0] = val[0];
 		vdma[1] = val[1];
 	} else {
 		/* No property, use default values. */
 		vdma[0] = 0x80000000;
 		vdma[1] = 0x80000000;
 	}
 	dma_mask = vdma[0];
 	switch (vdma[1]) {
 		case 0x20000000:
 			dma_mask |= 0x1fffffff;
 			tsbsize = 64;
 			break;
 		case 0x40000000:
 			dma_mask |= 0x3fffffff;
 			tsbsize = 128;
 			break;
 		case 0x80000000:
 			dma_mask |= 0x7fffffff;
 			tsbsize = 256;
 			break;
 		default:
 			prom_printf("PCI-SUN4V: strange virtual-dma size.\n");
 			prom_halt();
 	};
 	tsbsize *= (8 * 1024);
 	num_tsb_entries = tsbsize / sizeof(iopte_t);
 	dma_offset = vdma[0];
 	/* Setup initial software IOMMU state. */
 	spin_lock_init(&iommu->lock);
 	iommu->ctx_lowest_free = 1;
 	iommu->page_table_map_base = dma_offset;
 	iommu->dma_addr_mask = dma_mask;
 	/* Allocate and initialize the free area map.  */
 	sz = num_tsb_entries / 8;
 	sz = (sz + 7UL) & ~7UL;
 	iommu->arena.map = kzalloc(sz, GFP_KERNEL);
 	if (!iommu->arena.map) {
 		prom_printf("PCI_IOMMU: Error, kmalloc(arena.map) failed.\n");
 		prom_halt();
 	}
 	iommu->arena.limit = num_tsb_entries;
 	sz = probe_existing_entries(pbm, iommu);
 	if (sz)
 		printk("%s: Imported %lu TSB entries from OBP\n",
 		       pbm->name, sz);
 }
 static void pci_sun4v_get_bus_range(struct pci_pbm_info *pbm)
 {
 	struct property *prop;
 	unsigned int *busrange;
 	prop = of_find_property(pbm->prom_node, "bus-range", NULL);
 	busrange = prop->value;
 	pbm->pci_first_busno = busrange[0];
 	pbm->pci_last_busno = busrange[1];
 }
+#ifdef CONFIG_PCI_MSI
+struct pci_sun4v_msiq_entry {
+	u64		version_type;
+#define MSIQ_VERSION_MASK		0xffffffff00000000UL
+#define MSIQ_VERSION_SHIFT		32
+#define MSIQ_TYPE_MASK			0x00000000000000ffUL
+#define MSIQ_TYPE_SHIFT			0
+#define MSIQ_TYPE_NONE			0x00
+#define MSIQ_TYPE_MSG			0x01
+#define MSIQ_TYPE_MSI32			0x02
+#define MSIQ_TYPE_MSI64			0x03
+#define MSIQ_TYPE_INTX			0x08
+#define MSIQ_TYPE_NONE2			0xff
+	u64		intx_sysino;
+	u64		reserved1;
+	u64		stick;
+	u64		req_id;  /* bus/device/func */
+#define MSIQ_REQID_BUS_MASK		0xff00UL
+#define MSIQ_REQID_BUS_SHIFT		8
+#define MSIQ_REQID_DEVICE_MASK		0x00f8UL
+#define MSIQ_REQID_DEVICE_SHIFT		3
+#define MSIQ_REQID_FUNC_MASK		0x0007UL
+#define MSIQ_REQID_FUNC_SHIFT		0
+	u64		msi_address;
+	/* The format of this value is message type dependant.
+	 * For MSI bits 15:0 are the data from the MSI packet.
+	 * For MSI-X bits 31:0 are the data from the MSI packet.
+	 * For MSG, the message code and message routing code where:
+	 * 	bits 39:32 is the bus/device/fn of the msg target-id
+	 *	bits 18:16 is the message routing code
+	 *	bits 7:0 is the message code
+	 * For INTx the low order 2-bits are:
+	 *	00 - INTA
+	 *	01 - INTB
+	 *	10 - INTC
+	 *	11 - INTD
+	 */
+	u64		msi_data;
+	u64		reserved2;
+};
+/* For now this just runs as a pre-handler for the real interrupt handler.
+ * So we just walk through the queue and ACK all the entries, update the
+ * head pointer, and return.
+ *
+ * In the longer term it would be nice to do something more integrated
+ * wherein we can pass in some of this MSI info to the drivers.  This
+ * would be most useful for PCIe fabric error messages, although we could
+ * invoke those directly from the loop here in order to pass the info around.
+ */
+static void pci_sun4v_msi_prehandler(unsigned int ino, void *data1, void *data2)
+{
+	struct pci_pbm_info *pbm = data1;
+	struct pci_sun4v_msiq_entry *base, *ep;
+	unsigned long msiqid, orig_head, head, type, err;
+	msiqid = (unsigned long) data2;
+	head = 0xdeadbeef;
+	err = pci_sun4v_msiq_gethead(pbm->devhandle, msiqid, &head);
+	if (unlikely(err))
+		goto hv_error_get;
+	if (unlikely(head >= (pbm->msiq_ent_count * sizeof(struct pci_sun4v_msiq_entry))))
+		goto bad_offset;
+	head /= sizeof(struct pci_sun4v_msiq_entry);
+	orig_head = head;
+	base = (pbm->msi_queues + ((msiqid - pbm->msiq_first) *
+				   (pbm->msiq_ent_count *
+				    sizeof(struct pci_sun4v_msiq_entry))));
+	ep = &base[head];
+	while ((ep->version_type & MSIQ_TYPE_MASK) != 0) {
+		type = (ep->version_type & MSIQ_TYPE_MASK) >> MSIQ_TYPE_SHIFT;
+		if (unlikely(type != MSIQ_TYPE_MSI32 &&
+			     type != MSIQ_TYPE_MSI64))
+			goto bad_type;
+		pci_sun4v_msi_setstate(pbm->devhandle,
+				       ep->msi_data /* msi_num */,
+				       HV_MSISTATE_IDLE);
+		/* Clear the entry.  */
+		ep->version_type &= ~MSIQ_TYPE_MASK;
+		/* Go to next entry in ring.  */
+		head++;
+		if (head >= pbm->msiq_ent_count)
+			head = 0;
+		ep = &base[head];
+	}
+	if (likely(head != orig_head)) {
+		/* ACK entries by updating head pointer.  */
+		head *= sizeof(struct pci_sun4v_msiq_entry);
+		err = pci_sun4v_msiq_sethead(pbm->devhandle, msiqid, head);
+		if (unlikely(err))
+			goto hv_error_set;
+	}
+	return;
+hv_error_set:
+	printk(KERN_EMERG "MSI: Hypervisor set head gives error %lu\n", err);
+	goto hv_error_cont;
+hv_error_get:
+	printk(KERN_EMERG "MSI: Hypervisor get head gives error %lu\n", err);
+hv_error_cont:
+	printk(KERN_EMERG "MSI: devhandle[%x] msiqid[%lx] head[%lu]\n",
+	       pbm->devhandle, msiqid, head);
+	return;
+bad_offset:
+	printk(KERN_EMERG "MSI: Hypervisor gives bad offset %lx max(%lx)\n",
+	       head, pbm->msiq_ent_count * sizeof(struct pci_sun4v_msiq_entry));
+	return;
+bad_type:
+	printk(KERN_EMERG "MSI: Entry has bad type %lx\n", type);
+	return;
+}
+static int msi_bitmap_alloc(struct pci_pbm_info *pbm)
+{
+	unsigned long size, bits_per_ulong;
+	bits_per_ulong = sizeof(unsigned long) * 8;
+	size = (pbm->msi_num + (bits_per_ulong - 1)) & ~(bits_per_ulong - 1);
+	size /= 8;
+	BUG_ON(size % sizeof(unsigned long));
+	pbm->msi_bitmap = kzalloc(size, GFP_KERNEL);
+	if (!pbm->msi_bitmap)
+		return -ENOMEM;
+	return 0;
+}
+static void msi_bitmap_free(struct pci_pbm_info *pbm)
+{
+	kfree(pbm->msi_bitmap);
+	pbm->msi_bitmap = NULL;
+}
+static int msi_queue_alloc(struct pci_pbm_info *pbm)
+{
+	unsigned long q_size, alloc_size, pages, order;
+	int i;
+	q_size = pbm->msiq_ent_count * sizeof(struct pci_sun4v_msiq_entry);
+	alloc_size = (pbm->msiq_num * q_size);
+	order = get_order(alloc_size);
+	pages = __get_free_pages(GFP_KERNEL | __GFP_COMP, order);
+	if (pages == 0UL) {
+		printk(KERN_ERR "MSI: Cannot allocate MSI queues (o=%lu).\n",
+		       order);
+		return -ENOMEM;
+	}
+	memset((char *)pages, 0, PAGE_SIZE << order);
+	pbm->msi_queues = (void *) pages;
+	for (i = 0; i < pbm->msiq_num; i++) {
+		unsigned long err, base = __pa(pages + (i * q_size));
+		unsigned long ret1, ret2;
+		err = pci_sun4v_msiq_conf(pbm->devhandle,
+					  pbm->msiq_first + i,
+					  base, pbm->msiq_ent_count);
+		if (err) {
+			printk(KERN_ERR "MSI: msiq register fails (err=%lu)\n",
+			       err);
+			goto h_error;
+		}
+		err = pci_sun4v_msiq_info(pbm->devhandle,
+					  pbm->msiq_first + i,
+					  &ret1, &ret2);
+		if (err) {
+			printk(KERN_ERR "MSI: Cannot read msiq (err=%lu)\n",
+			       err);
+			goto h_error;
+		}
+		if (ret1 != base || ret2 != pbm->msiq_ent_count) {
+			printk(KERN_ERR "MSI: Bogus qconf "
+			       "expected[%lx:%x] got[%lx:%lx]\n",
+			       base, pbm->msiq_ent_count,
+			       ret1, ret2);
+			goto h_error;
+		}
+	}
+	return 0;
+h_error:
+	free_pages(pages, order);
+	return -EINVAL;
+}
+static void pci_sun4v_msi_init(struct pci_pbm_info *pbm)
+{
+	u32 *val;
+	int len;
+	val = of_get_property(pbm->prom_node, "#msi-eqs", &len);
+	if (!val || len != 4)
+		goto no_msi;
+	pbm->msiq_num = *val;
+	if (pbm->msiq_num) {
+		struct msiq_prop {
+			u32 first_msiq;
+			u32 num_msiq;
+			u32 first_devino;
+		} *mqp;
+		struct msi_range_prop {
+			u32 first_msi;
+			u32 num_msi;
+		} *mrng;
+		struct addr_range_prop {
+			u32 msi32_high;
+			u32 msi32_low;
+			u32 msi32_len;
+			u32 msi64_high;
+			u32 msi64_low;
+			u32 msi64_len;
+		} *arng;
+		val = of_get_property(pbm->prom_node, "msi-eq-size", &len);
+		if (!val || len != 4)
+			goto no_msi;
+		pbm->msiq_ent_count = *val;
+		mqp = of_get_property(pbm->prom_node,
+				      "msi-eq-to-devino", &len);
+		if (!mqp || len != sizeof(struct msiq_prop))
+			goto no_msi;
+		pbm->msiq_first = mqp->first_msiq;
+		pbm->msiq_first_devino = mqp->first_devino;
+		val = of_get_property(pbm->prom_node, "#msi", &len);
+		if (!val || len != 4)
+			goto no_msi;
+		pbm->msi_num = *val;
+		mrng = of_get_property(pbm->prom_node, "msi-ranges", &len);
+		if (!mrng || len != sizeof(struct msi_range_prop))
+			goto no_msi;
+		pbm->msi_first = mrng->first_msi;
+		val = of_get_property(pbm->prom_node, "msi-data-mask", &len);
+		if (!val || len != 4)
+			goto no_msi;
+		pbm->msi_data_mask = *val;
+		val = of_get_property(pbm->prom_node, "msix-data-width", &len);
+		if (!val || len != 4)
+			goto no_msi;
+		pbm->msix_data_width = *val;
+		arng = of_get_property(pbm->prom_node, "msi-address-ranges",
+				       &len);
+		if (!arng || len != sizeof(struct addr_range_prop))
+			goto no_msi;
+		pbm->msi32_start = ((u64)arng->msi32_high << 32) |
+			(u64) arng->msi32_low;
+		pbm->msi64_start = ((u64)arng->msi64_high << 32) |
+			(u64) arng->msi64_low;
+		pbm->msi32_len = arng->msi32_len;
+		pbm->msi64_len = arng->msi64_len;
+		if (msi_bitmap_alloc(pbm))
+			goto no_msi;
+		if (msi_queue_alloc(pbm)) {
+			msi_bitmap_free(pbm);
+			goto no_msi;
+		}
+		printk(KERN_INFO "%s: MSI Queue first[%u] num[%u] count[%u] "
+		       "devino[0x%x]\n",
+		       pbm->name,
+		       pbm->msiq_first, pbm->msiq_num,
+		       pbm->msiq_ent_count,
+		       pbm->msiq_first_devino);
+		printk(KERN_INFO "%s: MSI first[%u] num[%u] mask[0x%x] "
+		       "width[%u]\n",
+		       pbm->name,
+		       pbm->msi_first, pbm->msi_num, pbm->msi_data_mask,
+		       pbm->msix_data_width);
+		printk(KERN_INFO "%s: MSI addr32[0x%lx:0x%x] "
+		       "addr64[0x%lx:0x%x]\n",
+		       pbm->name,
+		       pbm->msi32_start, pbm->msi32_len,
+		       pbm->msi64_start, pbm->msi64_len);
+		printk(KERN_INFO "%s: MSI queues at RA [%p]\n",
+		       pbm->name,
+		       pbm->msi_queues);
+	}
+	return;
+no_msi:
+	pbm->msiq_num = 0;
+	printk(KERN_INFO "%s: No MSI support.\n", pbm->name);
+}
+static int alloc_msi(struct pci_pbm_info *pbm)
+{
+	int i;
+	for (i = 0; i < pbm->msi_num; i++) {
+		if (!test_and_set_bit(i, pbm->msi_bitmap))
+			return i + pbm->msi_first;
+	}
+	return -ENOENT;
+}
+static void free_msi(struct pci_pbm_info *pbm, int msi_num)
+{
+	msi_num -= pbm->msi_first;
+	clear_bit(msi_num, pbm->msi_bitmap);
+}
+static int pci_sun4v_setup_msi_irq(unsigned int *virt_irq_p,
+				   struct pci_dev *pdev,
+				   struct msi_desc *entry)
+{
+	struct pcidev_cookie *pcp = pdev->sysdata;
+	struct pci_pbm_info *pbm = pcp->pbm;
+	unsigned long devino, msiqid;
+	struct msi_msg msg;
+	int msi_num, err;
+	*virt_irq_p = 0;
+	msi_num = alloc_msi(pbm);
+	if (msi_num < 0)
+		return msi_num;
+	devino = sun4v_build_msi(pbm->devhandle, virt_irq_p,
+				 pbm->msiq_first_devino,
+				 (pbm->msiq_first_devino +
+				  pbm->msiq_num));
+	err = -ENOMEM;
+	if (!devino)
+		goto out_err;
+	set_irq_msi(*virt_irq_p, entry);
+	msiqid = ((devino - pbm->msiq_first_devino) +
+		  pbm->msiq_first);
+	err = -EINVAL;
+	if (pci_sun4v_msiq_setstate(pbm->devhandle, msiqid, HV_MSIQSTATE_IDLE))
+	if (err)
+		goto out_err;
+	if (pci_sun4v_msiq_setvalid(pbm->devhandle, msiqid, HV_MSIQ_VALID))
+		goto out_err;
+	if (pci_sun4v_msi_setmsiq(pbm->devhandle,
+				  msi_num, msiqid,
+				  (entry->msi_attrib.is_64 ?
+				   HV_MSITYPE_MSI64 : HV_MSITYPE_MSI32)))
+		goto out_err;
+	if (pci_sun4v_msi_setstate(pbm->devhandle, msi_num, HV_MSISTATE_IDLE))
+		goto out_err;
+	if (pci_sun4v_msi_setvalid(pbm->devhandle, msi_num, HV_MSIVALID_VALID))
+		goto out_err;
+	pcp->msi_num = msi_num;
+	if (entry->msi_attrib.is_64) {
+		msg.address_hi = pbm->msi64_start >> 32;
+		msg.address_lo = pbm->msi64_start & 0xffffffff;
+	} else {
+		msg.address_hi = 0;
+		msg.address_lo = pbm->msi32_start;
+	}
+	msg.data = msi_num;
+	write_msi_msg(*virt_irq_p, &msg);
+	irq_install_pre_handler(*virt_irq_p,
+				pci_sun4v_msi_prehandler,
+				pbm, (void *) msiqid);
+	return 0;
+out_err:
+	free_msi(pbm, msi_num);
+	sun4v_destroy_msi(*virt_irq_p);
+	*virt_irq_p = 0;
+	return err;
+}
+static void pci_sun4v_teardown_msi_irq(unsigned int virt_irq,
+				       struct pci_dev *pdev)
+{
+	struct pcidev_cookie *pcp = pdev->sysdata;
+	struct pci_pbm_info *pbm = pcp->pbm;
+	unsigned long msiqid, err;
+	unsigned int msi_num;
+	msi_num = pcp->msi_num;
+	err = pci_sun4v_msi_getmsiq(pbm->devhandle, msi_num, &msiqid);
+	if (err) {
+		printk(KERN_ERR "%s: getmsiq gives error %lu\n",
+		       pbm->name, err);
+		return;
+	}
+	pci_sun4v_msi_setvalid(pbm->devhandle, msi_num, HV_MSIVALID_INVALID);
+	pci_sun4v_msiq_setvalid(pbm->devhandle, msiqid, HV_MSIQ_INVALID);
+	free_msi(pbm, msi_num);
+	/* The sun4v_destroy_msi() will liberate the devino and thus the MSIQ
+	 * allocation.
+	 */
+	sun4v_destroy_msi(virt_irq);
+}
+#else /* CONFIG_PCI_MSI */
+static void pci_sun4v_msi_init(struct pci_pbm_info *pbm)
+{
+}
+#endif /* !(CONFIG_PCI_MSI) */
 static void pci_sun4v_pbm_init(struct pci_controller_info *p, struct device_node *dp, u32 devhandle)
 {
 	struct pci_pbm_info *pbm;
 	struct property *prop;
 	int len, i;
 	if (devhandle & 0x40)
 		pbm = &p->pbm_B;
 	else
 		pbm = &p->pbm_A;
 	pbm->parent = p;
 	pbm->prom_node = dp;
 	pbm->pci_first_slot = 1;
 	pbm->devhandle = devhandle;
 	pbm->name = dp->full_name;
 	printk("%s: SUN4V PCI Bus Module\n", pbm->name);
 	prop = of_find_property(dp, "ranges", &len);
 	pbm->pbm_ranges = prop->value;
 	pbm->num_pbm_ranges =
 		(len / sizeof(struct linux_prom_pci_ranges));
 	/* Mask out the top 8 bits of the ranges, leaving the real
 	 * physical address.
 	 */
 	for (i = 0; i < pbm->num_pbm_ranges; i++)
 		pbm->pbm_ranges[i].parent_phys_hi &= 0x0fffffff;
 	pci_sun4v_determine_mem_io_space(pbm);
 	pbm_register_toplevel_resources(p, pbm);
 	prop = of_find_property(dp, "interrupt-map", &len);
 	pbm->pbm_intmap = prop->value;
 	pbm->num_pbm_intmap =
 		(len / sizeof(struct linux_prom_pci_intmap));
 	prop = of_find_property(dp, "interrupt-map-mask", NULL);
 	pbm->pbm_intmask = prop->value;
 	pci_sun4v_get_bus_range(pbm);
 	pci_sun4v_iommu_init(pbm);
+	pci_sun4v_msi_init(pbm);
 	pdev_htab_populate(pbm);
 }
 void sun4v_pci_init(struct device_node *dp, char *model_name)
 {
 	struct pci_controller_info *p;
 	struct pci_iommu *iommu;
 	struct property *prop;
 	struct linux_prom64_registers *regs;
 	u32 devhandle;
 	int i;
 	prop = of_find_property(dp, "reg", NULL);
 	regs = prop->value;
 	devhandle = (regs->phys_addr >> 32UL) & 0x0fffffff;
 	for (p = pci_controller_root; p; p = p->next) {
 		struct pci_pbm_info *pbm;
 		if (p->pbm_A.prom_node && p->pbm_B.prom_node)
 			continue;
 		pbm = (p->pbm_A.prom_node ?
 		       &p->pbm_A :
 		       &p->pbm_B);
 		if (pbm->devhandle == (devhandle ^ 0x40)) {
 			pci_sun4v_pbm_init(p, dp, devhandle);
 			return;
 		}
 	}
 	for_each_possible_cpu(i) {
 		unsigned long page = get_zeroed_page(GFP_ATOMIC);
 		if (!page)
 			goto fatal_memory_error;
 		per_cpu(pci_iommu_batch, i).pglist = (u64 *) page;
 	}
 	p = kzalloc(sizeof(struct pci_controller_info), GFP_ATOMIC);
 	if (!p)
 		goto fatal_memory_error;
 	iommu = kzalloc(sizeof(struct pci_iommu), GFP_ATOMIC);
 	if (!iommu)
 		goto fatal_memory_error;
 	p->pbm_A.iommu = iommu;
 	iommu = kzalloc(sizeof(struct pci_iommu), GFP_ATOMIC);
 	if (!iommu)
 		goto fatal_memory_error;
 	p->pbm_B.iommu = iommu;
 	p->next = pci_controller_root;
 	pci_controller_root = p;
 	p->index = pci_num_controllers++;
 	p->pbms_same_domain = 0;
 	p->scan_bus = pci_sun4v_scan_bus;
 	p->base_address_update = pci_sun4v_base_address_update;
 	p->resource_adjust = pci_sun4v_resource_adjust;
+#ifdef CONFIG_PCI_MSI
+	p->setup_msi_irq = pci_sun4v_setup_msi_irq;
+	p->teardown_msi_irq = pci_sun4v_teardown_msi_irq;
+#endif
 	p->pci_ops = &pci_sun4v_ops;
 	/* Like PSYCHO and SCHIZO we have a 2GB aligned area
 	 * for memory space.
 	 */
 	pci_memspace_mask = 0x7fffffffUL;
 	pci_sun4v_pbm_init(p, dp, devhandle);
 	return;
 fatal_memory_error:
 	prom_printf("SUN4V_PCI: Fatal memory allocation error.\n");
 	prom_halt();
 }

arch/sparc64/kernel/pci_sun4v.h

Diff comments View file @ c827ba4

1	/* pci_sun4v.h: SUN4V specific PCI controller support.	1	/* pci_sun4v.h: SUN4V specific PCI controller support.
2	*	2	*
3	* Copyright (C) 2006 David S. Miller (davem@davemloft.net)	3	* Copyright (C) 2006 David S. Miller (davem@davemloft.net)
4	*/	4	*/
5		5
6	#ifndef _PCI_SUN4V_H	6	#ifndef _PCI_SUN4V_H
7	#define _PCI_SUN4V_H	7	#define _PCI_SUN4V_H
8		8
9	extern long pci_sun4v_iommu_map(unsigned long devhandle,	9	extern long pci_sun4v_iommu_map(unsigned long devhandle,
10	unsigned long tsbid,	10	unsigned long tsbid,
11	unsigned long num_ttes,	11	unsigned long num_ttes,
12	unsigned long io_attributes,	12	unsigned long io_attributes,
13	unsigned long io_page_list_pa);	13	unsigned long io_page_list_pa);
14	extern unsigned long pci_sun4v_iommu_demap(unsigned long devhandle,	14	extern unsigned long pci_sun4v_iommu_demap(unsigned long devhandle,
15	unsigned long tsbid,	15	unsigned long tsbid,
16	unsigned long num_ttes);	16	unsigned long num_ttes);
17	extern unsigned long pci_sun4v_iommu_getmap(unsigned long devhandle,	17	extern unsigned long pci_sun4v_iommu_getmap(unsigned long devhandle,
18	unsigned long tsbid,	18	unsigned long tsbid,
19	unsigned long *io_attributes,	19	unsigned long *io_attributes,
20	unsigned long *real_address);	20	unsigned long *real_address);
21	extern unsigned long pci_sun4v_config_get(unsigned long devhandle,	21	extern unsigned long pci_sun4v_config_get(unsigned long devhandle,
22	unsigned long pci_device,	22	unsigned long pci_device,
23	unsigned long config_offset,	23	unsigned long config_offset,
24	unsigned long size);	24	unsigned long size);
25	extern int pci_sun4v_config_put(unsigned long devhandle,	25	extern int pci_sun4v_config_put(unsigned long devhandle,
26	unsigned long pci_device,	26	unsigned long pci_device,
27	unsigned long config_offset,	27	unsigned long config_offset,
28	unsigned long size,	28	unsigned long size,
29	unsigned long data);	29	unsigned long data);
30		30
		31	extern unsigned long pci_sun4v_msiq_conf(unsigned long devhandle,
		32	unsigned long msiqid,
		33	unsigned long msiq_paddr,
		34	unsigned long num_entries);
		35	extern unsigned long pci_sun4v_msiq_info(unsigned long devhandle,
		36	unsigned long msiqid,
		37	unsigned long *msiq_paddr,
		38	unsigned long *num_entries);
		39	extern unsigned long pci_sun4v_msiq_getvalid(unsigned long devhandle,
		40	unsigned long msiqid,
		41	unsigned long *valid);
		42	extern unsigned long pci_sun4v_msiq_setvalid(unsigned long devhandle,
		43	unsigned long msiqid,
		44	unsigned long valid);
		45	extern unsigned long pci_sun4v_msiq_getstate(unsigned long devhandle,
		46	unsigned long msiqid,
		47	unsigned long *state);
		48	extern unsigned long pci_sun4v_msiq_setstate(unsigned long devhandle,
		49	unsigned long msiqid,
		50	unsigned long state);
		51	extern unsigned long pci_sun4v_msiq_gethead(unsigned long devhandle,
		52	unsigned long msiqid,
		53	unsigned long *head);
		54	extern unsigned long pci_sun4v_msiq_sethead(unsigned long devhandle,
		55	unsigned long msiqid,
		56	unsigned long head);
		57	extern unsigned long pci_sun4v_msiq_gettail(unsigned long devhandle,
		58	unsigned long msiqid,
		59	unsigned long *head);
		60	extern unsigned long pci_sun4v_msi_getvalid(unsigned long devhandle,
		61	unsigned long msinum,
		62	unsigned long *valid);
		63	extern unsigned long pci_sun4v_msi_setvalid(unsigned long devhandle,
		64	unsigned long msinum,
		65	unsigned long valid);
		66	extern unsigned long pci_sun4v_msi_getmsiq(unsigned long devhandle,
		67	unsigned long msinum,
		68	unsigned long *msiq);
		69	extern unsigned long pci_sun4v_msi_setmsiq(unsigned long devhandle,
		70	unsigned long msinum,
		71	unsigned long msiq,
		72	unsigned long msitype);
		73	extern unsigned long pci_sun4v_msi_getstate(unsigned long devhandle,
		74	unsigned long msinum,
		75	unsigned long *state);
		76	extern unsigned long pci_sun4v_msi_setstate(unsigned long devhandle,
		77	unsigned long msinum,
		78	unsigned long state);
		79	extern unsigned long pci_sun4v_msg_getmsiq(unsigned long devhandle,
		80	unsigned long msinum,
		81	unsigned long *msiq);
		82	extern unsigned long pci_sun4v_msg_setmsiq(unsigned long devhandle,
		83	unsigned long msinum,
		84	unsigned long msiq);
		85	extern unsigned long pci_sun4v_msg_getvalid(unsigned long devhandle,
		86	unsigned long msinum,
		87	unsigned long *valid);
		88	extern unsigned long pci_sun4v_msg_setvalid(unsigned long devhandle,
		89	unsigned long msinum,
		90	unsigned long valid);
		91
31	#endif /* !(_PCI_SUN4V_H) */	92	#endif /* !(_PCI_SUN4V_H) */
32		93

arch/sparc64/kernel/pci_sun4v_asm.S

Diff comments View file @ c827ba4

1	/* pci_sun4v_asm: Hypervisor calls for PCI support.	1	/* pci_sun4v_asm: Hypervisor calls for PCI support.
2	*	2	*
3	* Copyright (C) 2006 David S. Miller <davem@davemloft.net>	3	* Copyright (C) 2006 David S. Miller <davem@davemloft.net>
4	*/	4	*/
5		5
6	#include <asm/hypervisor.h>	6	#include <asm/hypervisor.h>
7		7
8	/* %o0: devhandle	8	/* %o0: devhandle
9	* %o1: tsbid	9	* %o1: tsbid
10	* %o2: num ttes	10	* %o2: num ttes
11	* %o3: io_attributes	11	* %o3: io_attributes
12	* %o4: io_page_list phys address	12	* %o4: io_page_list phys address
13	*	13	*
14	* returns %o0: -status if status was non-zero, else	14	* returns %o0: -status if status was non-zero, else
15	* %o0: num pages mapped	15	* %o0: num pages mapped
16	*/	16	*/
17	.globl pci_sun4v_iommu_map	17	.globl pci_sun4v_iommu_map
18	pci_sun4v_iommu_map:	18	pci_sun4v_iommu_map:
19	mov %o5, %g1	19	mov %o5, %g1
20	mov HV_FAST_PCI_IOMMU_MAP, %o5	20	mov HV_FAST_PCI_IOMMU_MAP, %o5
21	ta HV_FAST_TRAP	21	ta HV_FAST_TRAP
22	brnz,pn %o0, 1f	22	brnz,pn %o0, 1f
23	sub %g0, %o0, %o0	23	sub %g0, %o0, %o0
24	mov %o1, %o0	24	mov %o1, %o0
25	1: retl	25	1: retl
26	nop	26	nop
27		27
28	/* %o0: devhandle	28	/* %o0: devhandle
29	* %o1: tsbid	29	* %o1: tsbid
30	* %o2: num ttes	30	* %o2: num ttes
31	*	31	*
32	* returns %o0: num ttes demapped	32	* returns %o0: num ttes demapped
33	*/	33	*/
34	.globl pci_sun4v_iommu_demap	34	.globl pci_sun4v_iommu_demap
35	pci_sun4v_iommu_demap:	35	pci_sun4v_iommu_demap:
36	mov HV_FAST_PCI_IOMMU_DEMAP, %o5	36	mov HV_FAST_PCI_IOMMU_DEMAP, %o5
37	ta HV_FAST_TRAP	37	ta HV_FAST_TRAP
38	retl	38	retl
39	mov %o1, %o0	39	mov %o1, %o0
40		40
41	/* %o0: devhandle	41	/* %o0: devhandle
42	* %o1: tsbid	42	* %o1: tsbid
43	* %o2: &io_attributes	43	* %o2: &io_attributes
44	* %o3: &real_address	44	* %o3: &real_address
45	*	45	*
46	* returns %o0: status	46	* returns %o0: status
47	*/	47	*/
48	.globl pci_sun4v_iommu_getmap	48	.globl pci_sun4v_iommu_getmap
49	pci_sun4v_iommu_getmap:	49	pci_sun4v_iommu_getmap:
50	mov %o2, %o4	50	mov %o2, %o4
51	mov HV_FAST_PCI_IOMMU_GETMAP, %o5	51	mov HV_FAST_PCI_IOMMU_GETMAP, %o5
52	ta HV_FAST_TRAP	52	ta HV_FAST_TRAP
53	stx %o1, [%o4]	53	stx %o1, [%o4]
54	stx %o2, [%o3]	54	stx %o2, [%o3]
55	retl	55	retl
56	mov %o0, %o0	56	mov %o0, %o0
57		57
58	/* %o0: devhandle	58	/* %o0: devhandle
59	* %o1: pci_device	59	* %o1: pci_device
60	* %o2: pci_config_offset	60	* %o2: pci_config_offset
61	* %o3: size	61	* %o3: size
62	*	62	*
63	* returns %o0: data	63	* returns %o0: data
64	*	64	*
65	* If there is an error, the data will be returned	65	* If there is an error, the data will be returned
66	* as all 1's.	66	* as all 1's.
67	*/	67	*/
68	.globl pci_sun4v_config_get	68	.globl pci_sun4v_config_get
69	pci_sun4v_config_get:	69	pci_sun4v_config_get:
70	mov HV_FAST_PCI_CONFIG_GET, %o5	70	mov HV_FAST_PCI_CONFIG_GET, %o5
71	ta HV_FAST_TRAP	71	ta HV_FAST_TRAP
72	brnz,a,pn %o1, 1f	72	brnz,a,pn %o1, 1f
73	mov -1, %o2	73	mov -1, %o2
74	1: retl	74	1: retl
75	mov %o2, %o0	75	mov %o2, %o0
76		76
77	/* %o0: devhandle	77	/* %o0: devhandle
78	* %o1: pci_device	78	* %o1: pci_device
79	* %o2: pci_config_offset	79	* %o2: pci_config_offset
80	* %o3: size	80	* %o3: size
81	* %o4: data	81	* %o4: data
82	*	82	*
83	* returns %o0: status	83	* returns %o0: status
84	*	84	*
85	* status will be zero if the operation completed	85	* status will be zero if the operation completed
86	* successfully, else -1 if not	86	* successfully, else -1 if not
87	*/	87	*/
88	.globl pci_sun4v_config_put	88	.globl pci_sun4v_config_put
89	pci_sun4v_config_put:	89	pci_sun4v_config_put:
90	mov HV_FAST_PCI_CONFIG_PUT, %o5	90	mov HV_FAST_PCI_CONFIG_PUT, %o5
91	ta HV_FAST_TRAP	91	ta HV_FAST_TRAP
92	brnz,a,pn %o1, 1f	92	brnz,a,pn %o1, 1f
93	mov -1, %o1	93	mov -1, %o1
94	1: retl	94	1: retl
95	mov %o1, %o0	95	mov %o1, %o0
		96
		97	/* %o0: devhandle
		98	* %o1: msiqid
		99	* %o2: msiq phys address
		100	* %o3: num entries
		101	*
		102	* returns %o0: status
		103	*
		104	* status will be zero if the operation completed
		105	* successfully, else -1 if not
		106	*/
		107	.globl pci_sun4v_msiq_conf
		108	pci_sun4v_msiq_conf:
		109	mov HV_FAST_PCI_MSIQ_CONF, %o5
		110	ta HV_FAST_TRAP
		111	retl
		112	mov %o0, %o0
		113
		114	/* %o0: devhandle
		115	* %o1: msiqid
		116	* %o2: &msiq_phys_addr
		117	* %o3: &msiq_num_entries
		118	*
		119	* returns %o0: status
		120	*/
		121	.globl pci_sun4v_msiq_info
		122	pci_sun4v_msiq_info:
		123	mov %o2, %o4
		124	mov HV_FAST_PCI_MSIQ_INFO, %o5
		125	ta HV_FAST_TRAP
		126	stx %o1, [%o4]
		127	stx %o2, [%o3]
		128	retl
		129	mov %o0, %o0
		130
		131	/* %o0: devhandle
		132	* %o1: msiqid
		133	* %o2: &valid
		134	*
		135	* returns %o0: status
		136	*/
		137	.globl pci_sun4v_msiq_getvalid
		138	pci_sun4v_msiq_getvalid:
		139	mov HV_FAST_PCI_MSIQ_GETVALID, %o5
		140	ta HV_FAST_TRAP
		141	stx %o1, [%o2]
		142	retl
		143	mov %o0, %o0
		144
		145	/* %o0: devhandle
		146	* %o1: msiqid
		147	* %o2: valid
		148	*
		149	* returns %o0: status
		150	*/
		151	.globl pci_sun4v_msiq_setvalid
		152	pci_sun4v_msiq_setvalid:
		153	mov HV_FAST_PCI_MSIQ_SETVALID, %o5
		154	ta HV_FAST_TRAP
		155	retl
		156	mov %o0, %o0
		157
		158	/* %o0: devhandle
		159	* %o1: msiqid
		160	* %o2: &state
		161	*
		162	* returns %o0: status
		163	*/
		164	.globl pci_sun4v_msiq_getstate
		165	pci_sun4v_msiq_getstate:
		166	mov HV_FAST_PCI_MSIQ_GETSTATE, %o5
		167	ta HV_FAST_TRAP
		168	stx %o1, [%o2]
		169	retl
		170	mov %o0, %o0
		171
		172	/* %o0: devhandle
		173	* %o1: msiqid
		174	* %o2: state
		175	*
		176	* returns %o0: status
		177	*/
		178	.globl pci_sun4v_msiq_setstate
		179	pci_sun4v_msiq_setstate:
		180	mov HV_FAST_PCI_MSIQ_SETSTATE, %o5
		181	ta HV_FAST_TRAP
		182	retl
		183	mov %o0, %o0
		184
		185	/* %o0: devhandle
		186	* %o1: msiqid
		187	* %o2: &head
		188	*
		189	* returns %o0: status
		190	*/
		191	.globl pci_sun4v_msiq_gethead
		192	pci_sun4v_msiq_gethead:
		193	mov HV_FAST_PCI_MSIQ_GETHEAD, %o5
		194	ta HV_FAST_TRAP
		195	stx %o1, [%o2]
		196	retl
		197	mov %o0, %o0
		198
		199	/* %o0: devhandle
		200	* %o1: msiqid
		201	* %o2: head
		202	*
		203	* returns %o0: status
		204	*/
		205	.globl pci_sun4v_msiq_sethead
		206	pci_sun4v_msiq_sethead:
		207	mov HV_FAST_PCI_MSIQ_SETHEAD, %o5
		208	ta HV_FAST_TRAP
		209	retl
		210	mov %o0, %o0
		211
		212	/* %o0: devhandle
		213	* %o1: msiqid
		214	* %o2: &tail
		215	*
		216	* returns %o0: status
		217	*/
		218	.globl pci_sun4v_msiq_gettail
		219	pci_sun4v_msiq_gettail:
		220	mov HV_FAST_PCI_MSIQ_GETTAIL, %o5
		221	ta HV_FAST_TRAP
		222	stx %o1, [%o2]
		223	retl
		224	mov %o0, %o0
		225
		226	/* %o0: devhandle
		227	* %o1: msinum
		228	* %o2: &valid
		229	*
		230	* returns %o0: status
		231	*/
		232	.globl pci_sun4v_msi_getvalid
		233	pci_sun4v_msi_getvalid:
		234	mov HV_FAST_PCI_MSI_GETVALID, %o5
		235	ta HV_FAST_TRAP
		236	stx %o1, [%o2]
		237	retl
		238	mov %o0, %o0
		239
		240	/* %o0: devhandle
		241	* %o1: msinum
		242	* %o2: valid
		243	*
		244	* returns %o0: status
		245	*/
		246	.globl pci_sun4v_msi_setvalid
		247	pci_sun4v_msi_setvalid:
		248	mov HV_FAST_PCI_MSI_SETVALID, %o5
		249	ta HV_FAST_TRAP
		250	retl
		251	mov %o0, %o0
		252
		253	/* %o0: devhandle
		254	* %o1: msinum
		255	* %o2: &msiq
		256	*
		257	* returns %o0: status
		258	*/
		259	.globl pci_sun4v_msi_getmsiq
		260	pci_sun4v_msi_getmsiq:
		261	mov HV_FAST_PCI_MSI_GETMSIQ, %o5
		262	ta HV_FAST_TRAP
		263	stx %o1, [%o2]
		264	retl
		265	mov %o0, %o0
		266
		267	/* %o0: devhandle
		268	* %o1: msinum
		269	* %o2: msitype
		270	* %o3: msiq
		271	*
		272	* returns %o0: status
		273	*/
		274	.globl pci_sun4v_msi_setmsiq
		275	pci_sun4v_msi_setmsiq:
		276	mov HV_FAST_PCI_MSI_SETMSIQ, %o5
		277	ta HV_FAST_TRAP
		278	retl
		279	mov %o0, %o0
		280
		281	/* %o0: devhandle
		282	* %o1: msinum
		283	* %o2: &state
		284	*
		285	* returns %o0: status
		286	*/
		287	.globl pci_sun4v_msi_getstate
		288	pci_sun4v_msi_getstate:
		289	mov HV_FAST_PCI_MSI_GETSTATE, %o5
		290	ta HV_FAST_TRAP
		291	stx %o1, [%o2]
		292	retl
		293	mov %o0, %o0
		294
		295	/* %o0: devhandle
		296	* %o1: msinum
		297	* %o2: state
		298	*
		299	* returns %o0: status
		300	*/
		301	.globl pci_sun4v_msi_setstate
		302	pci_sun4v_msi_setstate:
		303	mov HV_FAST_PCI_MSI_SETSTATE, %o5
		304	ta HV_FAST_TRAP
		305	retl
		306	mov %o0, %o0
		307
		308	/* %o0: devhandle
		309	* %o1: msinum
		310	* %o2: &msiq
		311	*
		312	* returns %o0: status
		313	*/
		314	.globl pci_sun4v_msg_getmsiq
		315	pci_sun4v_msg_getmsiq:
		316	mov HV_FAST_PCI_MSG_GETMSIQ, %o5
		317	ta HV_FAST_TRAP
		318	stx %o1, [%o2]
		319	retl
		320	mov %o0, %o0
		321
		322	/* %o0: devhandle
		323	* %o1: msinum
		324	* %o2: msiq
		325	*
		326	* returns %o0: status
		327	*/
		328	.globl pci_sun4v_msg_setmsiq
		329	pci_sun4v_msg_setmsiq:
		330	mov HV_FAST_PCI_MSG_SETMSIQ, %o5
		331	ta HV_FAST_TRAP
		332	retl
		333	mov %o0, %o0
		334
		335	/* %o0: devhandle
		336	* %o1: msinum
		337	* %o2: &valid
		338	*
		339	* returns %o0: status
		340	*/
		341	.globl pci_sun4v_msg_getvalid
		342	pci_sun4v_msg_getvalid:
		343	mov HV_FAST_PCI_MSG_GETVALID, %o5
		344	ta HV_FAST_TRAP
		345	stx %o1, [%o2]
		346	retl
		347	mov %o0, %o0
		348
		349	/* %o0: devhandle
		350	* %o1: msinum
		351	* %o2: valid
		352	*
		353	* returns %o0: status
		354	*/
		355	.globl pci_sun4v_msg_setvalid
		356	pci_sun4v_msg_setvalid:
		357	mov HV_FAST_PCI_MSG_SETVALID, %o5
		358	ta HV_FAST_TRAP
		359	retl
		360	mov %o0, %o0
96		361
		362

block/ioctl.c

Diff comments View file @ c827ba4

1	#include <linux/capability.h>	1	#include <linux/capability.h>
2	#include <linux/blkdev.h>	2	#include <linux/blkdev.h>
3	#include <linux/blkpg.h>	3	#include <linux/blkpg.h>
4	#include <linux/hdreg.h>	4	#include <linux/hdreg.h>
5	#include <linux/backing-dev.h>	5	#include <linux/backing-dev.h>
6	#include <linux/buffer_head.h>	6	#include <linux/buffer_head.h>
7	#include <linux/smp_lock.h>	7	#include <linux/smp_lock.h>
8	#include <linux/blktrace_api.h>	8	#include <linux/blktrace_api.h>
9	#include <asm/uaccess.h>	9	#include <asm/uaccess.h>
10		10
11	static int blkpg_ioctl(struct block_device bdev, struct blkpg_ioctl_arg __user arg)	11	static int blkpg_ioctl(struct block_device bdev, struct blkpg_ioctl_arg __user arg)
12	{	12	{
13	struct block_device *bdevp;	13	struct block_device *bdevp;
14	struct gendisk *disk;	14	struct gendisk *disk;
15	struct blkpg_ioctl_arg a;	15	struct blkpg_ioctl_arg a;
16	struct blkpg_partition p;	16	struct blkpg_partition p;
17	long long start, length;	17	long long start, length;
18	int part;	18	int part;
19	int i;	19	int i;
20		20
21	if (!capable(CAP_SYS_ADMIN))	21	if (!capable(CAP_SYS_ADMIN))
22	return -EACCES;	22	return -EACCES;
23	if (copy_from_user(&a, arg, sizeof(struct blkpg_ioctl_arg)))	23	if (copy_from_user(&a, arg, sizeof(struct blkpg_ioctl_arg)))
24	return -EFAULT;	24	return -EFAULT;
25	if (copy_from_user(&p, a.data, sizeof(struct blkpg_partition)))	25	if (copy_from_user(&p, a.data, sizeof(struct blkpg_partition)))
26	return -EFAULT;	26	return -EFAULT;
27	disk = bdev->bd_disk;	27	disk = bdev->bd_disk;
28	if (bdev != bdev->bd_contains)	28	if (bdev != bdev->bd_contains)
29	return -EINVAL;	29	return -EINVAL;
30	part = p.pno;	30	part = p.pno;
31	if (part <= 0 \|\| part >= disk->minors)	31	if (part <= 0 \|\| part >= disk->minors)
32	return -EINVAL;	32	return -EINVAL;
33	switch (a.op) {	33	switch (a.op) {
34	case BLKPG_ADD_PARTITION:	34	case BLKPG_ADD_PARTITION:
35	start = p.start >> 9;	35	start = p.start >> 9;
36	length = p.length >> 9;	36	length = p.length >> 9;
37	/* check for fit in a hd_struct */	37	/* check for fit in a hd_struct */
38	if (sizeof(sector_t) == sizeof(long) &&	38	if (sizeof(sector_t) == sizeof(long) &&
39	sizeof(long long) > sizeof(long)) {	39	sizeof(long long) > sizeof(long)) {
40	long pstart = start, plength = length;	40	long pstart = start, plength = length;
41	if (pstart != start \|\| plength != length	41	if (pstart != start \|\| plength != length
42	\|\| pstart < 0 \|\| plength < 0)	42	\|\| pstart < 0 \|\| plength < 0)
43	return -EINVAL;	43	return -EINVAL;
44	}	44	}
45	/* partition number in use? */	45	/* partition number in use? */
46	mutex_lock(&bdev->bd_mutex);	46	mutex_lock(&bdev->bd_mutex);
47	if (disk->part[part - 1]) {	47	if (disk->part[part - 1]) {
48	mutex_unlock(&bdev->bd_mutex);	48	mutex_unlock(&bdev->bd_mutex);
49	return -EBUSY;	49	return -EBUSY;
50	}	50	}
51	/* overlap? */	51	/* overlap? */
52	for (i = 0; i < disk->minors - 1; i++) {	52	for (i = 0; i < disk->minors - 1; i++) {
53	struct hd_struct *s = disk->part[i];	53	struct hd_struct *s = disk->part[i];
54		54
55	if (!s)	55	if (!s)
56	continue;	56	continue;
57	if (!(start+length <= s->start_sect \|\|	57	if (!(start+length <= s->start_sect \|\|
58	start >= s->start_sect + s->nr_sects)) {	58	start >= s->start_sect + s->nr_sects)) {
59	mutex_unlock(&bdev->bd_mutex);	59	mutex_unlock(&bdev->bd_mutex);
60	return -EBUSY;	60	return -EBUSY;
61	}	61	}
62	}	62	}
63	/* all seems OK */	63	/* all seems OK */
64	add_partition(disk, part, start, length);	64	add_partition(disk, part, start, length, ADDPART_FLAG_NONE);
65	mutex_unlock(&bdev->bd_mutex);	65	mutex_unlock(&bdev->bd_mutex);
66	return 0;	66	return 0;
67	case BLKPG_DEL_PARTITION:	67	case BLKPG_DEL_PARTITION:
68	if (!disk->part[part-1])	68	if (!disk->part[part-1])
69	return -ENXIO;	69	return -ENXIO;
70	if (disk->part[part - 1]->nr_sects == 0)	70	if (disk->part[part - 1]->nr_sects == 0)
71	return -ENXIO;	71	return -ENXIO;
72	bdevp = bdget_disk(disk, part);	72	bdevp = bdget_disk(disk, part);
73	if (!bdevp)	73	if (!bdevp)
74	return -ENOMEM;	74	return -ENOMEM;
75	mutex_lock(&bdevp->bd_mutex);	75	mutex_lock(&bdevp->bd_mutex);
76	if (bdevp->bd_openers) {	76	if (bdevp->bd_openers) {
77	mutex_unlock(&bdevp->bd_mutex);	77	mutex_unlock(&bdevp->bd_mutex);
78	bdput(bdevp);	78	bdput(bdevp);
79	return -EBUSY;	79	return -EBUSY;
80	}	80	}
81	/* all seems OK */	81	/* all seems OK */
82	fsync_bdev(bdevp);	82	fsync_bdev(bdevp);
83	invalidate_bdev(bdevp, 0);	83	invalidate_bdev(bdevp, 0);
84		84
85	mutex_lock(&bdev->bd_mutex);	85	mutex_lock(&bdev->bd_mutex);
86	delete_partition(disk, part);	86	delete_partition(disk, part);
87	mutex_unlock(&bdev->bd_mutex);	87	mutex_unlock(&bdev->bd_mutex);
88	mutex_unlock(&bdevp->bd_mutex);	88	mutex_unlock(&bdevp->bd_mutex);
89	bdput(bdevp);	89	bdput(bdevp);
90		90
91	return 0;	91	return 0;
92	default:	92	default:
93	return -EINVAL;	93	return -EINVAL;
94	}	94	}
95	}	95	}
96		96
97	static int blkdev_reread_part(struct block_device *bdev)	97	static int blkdev_reread_part(struct block_device *bdev)
98	{	98	{
99	struct gendisk *disk = bdev->bd_disk;	99	struct gendisk *disk = bdev->bd_disk;
100	int res;	100	int res;
101		101
102	if (disk->minors == 1 \|\| bdev != bdev->bd_contains)	102	if (disk->minors == 1 \|\| bdev != bdev->bd_contains)
103	return -EINVAL;	103	return -EINVAL;
104	if (!capable(CAP_SYS_ADMIN))	104	if (!capable(CAP_SYS_ADMIN))
105	return -EACCES;	105	return -EACCES;
106	if (!mutex_trylock(&bdev->bd_mutex))	106	if (!mutex_trylock(&bdev->bd_mutex))
107	return -EBUSY;	107	return -EBUSY;
108	res = rescan_partitions(disk, bdev);	108	res = rescan_partitions(disk, bdev);
109	mutex_unlock(&bdev->bd_mutex);	109	mutex_unlock(&bdev->bd_mutex);
110	return res;	110	return res;
111	}	111	}
112		112
113	static int put_ushort(unsigned long arg, unsigned short val)	113	static int put_ushort(unsigned long arg, unsigned short val)
114	{	114	{
115	return put_user(val, (unsigned short __user *)arg);	115	return put_user(val, (unsigned short __user *)arg);
116	}	116	}
117		117
118	static int put_int(unsigned long arg, int val)	118	static int put_int(unsigned long arg, int val)
119	{	119	{
120	return put_user(val, (int __user *)arg);	120	return put_user(val, (int __user *)arg);
121	}	121	}
122		122
123	static int put_long(unsigned long arg, long val)	123	static int put_long(unsigned long arg, long val)
124	{	124	{
125	return put_user(val, (long __user *)arg);	125	return put_user(val, (long __user *)arg);
126	}	126	}
127		127
128	static int put_ulong(unsigned long arg, unsigned long val)	128	static int put_ulong(unsigned long arg, unsigned long val)
129	{	129	{
130	return put_user(val, (unsigned long __user *)arg);	130	return put_user(val, (unsigned long __user *)arg);
131	}	131	}
132		132
133	static int put_u64(unsigned long arg, u64 val)	133	static int put_u64(unsigned long arg, u64 val)
134	{	134	{
135	return put_user(val, (u64 __user *)arg);	135	return put_user(val, (u64 __user *)arg);
136	}	136	}
137		137
138	static int blkdev_locked_ioctl(struct file file, struct block_device bdev,	138	static int blkdev_locked_ioctl(struct file file, struct block_device bdev,
139	unsigned cmd, unsigned long arg)	139	unsigned cmd, unsigned long arg)
140	{	140	{
141	struct backing_dev_info *bdi;	141	struct backing_dev_info *bdi;
142	int ret, n;	142	int ret, n;
143		143
144	switch (cmd) {	144	switch (cmd) {
145	case BLKRAGET:	145	case BLKRAGET:
146	case BLKFRAGET:	146	case BLKFRAGET:
147	if (!arg)	147	if (!arg)
148	return -EINVAL;	148	return -EINVAL;
149	bdi = blk_get_backing_dev_info(bdev);	149	bdi = blk_get_backing_dev_info(bdev);
150	if (bdi == NULL)	150	if (bdi == NULL)
151	return -ENOTTY;	151	return -ENOTTY;
152	return put_long(arg, (bdi->ra_pages * PAGE_CACHE_SIZE) / 512);	152	return put_long(arg, (bdi->ra_pages * PAGE_CACHE_SIZE) / 512);
153	case BLKROGET:	153	case BLKROGET:
154	return put_int(arg, bdev_read_only(bdev) != 0);	154	return put_int(arg, bdev_read_only(bdev) != 0);
155	case BLKBSZGET: /* get the logical block size (cf. BLKSSZGET) */	155	case BLKBSZGET: /* get the logical block size (cf. BLKSSZGET) */
156	return put_int(arg, block_size(bdev));	156	return put_int(arg, block_size(bdev));
157	case BLKSSZGET: /* get block device hardware sector size */	157	case BLKSSZGET: /* get block device hardware sector size */
158	return put_int(arg, bdev_hardsect_size(bdev));	158	return put_int(arg, bdev_hardsect_size(bdev));
159	case BLKSECTGET:	159	case BLKSECTGET:
160	return put_ushort(arg, bdev_get_queue(bdev)->max_sectors);	160	return put_ushort(arg, bdev_get_queue(bdev)->max_sectors);
161	case BLKRASET:	161	case BLKRASET:
162	case BLKFRASET:	162	case BLKFRASET:
163	if(!capable(CAP_SYS_ADMIN))	163	if(!capable(CAP_SYS_ADMIN))
164	return -EACCES;	164	return -EACCES;
165	bdi = blk_get_backing_dev_info(bdev);	165	bdi = blk_get_backing_dev_info(bdev);
166	if (bdi == NULL)	166	if (bdi == NULL)
167	return -ENOTTY;	167	return -ENOTTY;
168	bdi->ra_pages = (arg * 512) / PAGE_CACHE_SIZE;	168	bdi->ra_pages = (arg * 512) / PAGE_CACHE_SIZE;
169	return 0;	169	return 0;
170	case BLKBSZSET:	170	case BLKBSZSET:
171	/* set the logical block size */	171	/* set the logical block size */
172	if (!capable(CAP_SYS_ADMIN))	172	if (!capable(CAP_SYS_ADMIN))
173	return -EACCES;	173	return -EACCES;
174	if (!arg)	174	if (!arg)
175	return -EINVAL;	175	return -EINVAL;
176	if (get_user(n, (int __user *) arg))	176	if (get_user(n, (int __user *) arg))
177	return -EFAULT;	177	return -EFAULT;
178	if (bd_claim(bdev, file) < 0)	178	if (bd_claim(bdev, file) < 0)
179	return -EBUSY;	179	return -EBUSY;
180	ret = set_blocksize(bdev, n);	180	ret = set_blocksize(bdev, n);
181	bd_release(bdev);	181	bd_release(bdev);
182	return ret;	182	return ret;
183	case BLKPG:	183	case BLKPG:
184	return blkpg_ioctl(bdev, (struct blkpg_ioctl_arg __user *) arg);	184	return blkpg_ioctl(bdev, (struct blkpg_ioctl_arg __user *) arg);
185	case BLKRRPART:	185	case BLKRRPART:
186	return blkdev_reread_part(bdev);	186	return blkdev_reread_part(bdev);
187	case BLKGETSIZE:	187	case BLKGETSIZE:
188	if ((bdev->bd_inode->i_size >> 9) > ~0UL)	188	if ((bdev->bd_inode->i_size >> 9) > ~0UL)
189	return -EFBIG;	189	return -EFBIG;
190	return put_ulong(arg, bdev->bd_inode->i_size >> 9);	190	return put_ulong(arg, bdev->bd_inode->i_size >> 9);
191	case BLKGETSIZE64:	191	case BLKGETSIZE64:
192	return put_u64(arg, bdev->bd_inode->i_size);	192	return put_u64(arg, bdev->bd_inode->i_size);
193	case BLKTRACESTART:	193	case BLKTRACESTART:
194	case BLKTRACESTOP:	194	case BLKTRACESTOP:
195	case BLKTRACESETUP:	195	case BLKTRACESETUP:
196	case BLKTRACETEARDOWN:	196	case BLKTRACETEARDOWN:
197	return blk_trace_ioctl(bdev, cmd, (char __user *) arg);	197	return blk_trace_ioctl(bdev, cmd, (char __user *) arg);
198	}	198	}
199	return -ENOIOCTLCMD;	199	return -ENOIOCTLCMD;
200	}	200	}
201		201
202	int blkdev_driver_ioctl(struct inode inode, struct file file,	202	int blkdev_driver_ioctl(struct inode inode, struct file file,
203	struct gendisk *disk, unsigned cmd, unsigned long arg)	203	struct gendisk *disk, unsigned cmd, unsigned long arg)
204	{	204	{
205	int ret;	205	int ret;
206	if (disk->fops->unlocked_ioctl)	206	if (disk->fops->unlocked_ioctl)
207	return disk->fops->unlocked_ioctl(file, cmd, arg);	207	return disk->fops->unlocked_ioctl(file, cmd, arg);
208		208
209	if (disk->fops->ioctl) {	209	if (disk->fops->ioctl) {
210	lock_kernel();	210	lock_kernel();
211	ret = disk->fops->ioctl(inode, file, cmd, arg);	211	ret = disk->fops->ioctl(inode, file, cmd, arg);
212	unlock_kernel();	212	unlock_kernel();
213	return ret;	213	return ret;
214	}	214	}
215		215
216	return -ENOTTY;	216	return -ENOTTY;
217	}	217	}
218	EXPORT_SYMBOL_GPL(blkdev_driver_ioctl);	218	EXPORT_SYMBOL_GPL(blkdev_driver_ioctl);
219		219
220	int blkdev_ioctl(struct inode inode, struct file file, unsigned cmd,	220	int blkdev_ioctl(struct inode inode, struct file file, unsigned cmd,
221	unsigned long arg)	221	unsigned long arg)
222	{	222	{
223	struct block_device *bdev = inode->i_bdev;	223	struct block_device *bdev = inode->i_bdev;
224	struct gendisk *disk = bdev->bd_disk;	224	struct gendisk *disk = bdev->bd_disk;
225	int ret, n;	225	int ret, n;
226		226
227	switch(cmd) {	227	switch(cmd) {
228	case BLKFLSBUF:	228	case BLKFLSBUF:
229	if (!capable(CAP_SYS_ADMIN))	229	if (!capable(CAP_SYS_ADMIN))
230	return -EACCES;	230	return -EACCES;
231		231
232	ret = blkdev_driver_ioctl(inode, file, disk, cmd, arg);	232	ret = blkdev_driver_ioctl(inode, file, disk, cmd, arg);
233	/* -EINVAL to handle old uncorrected drivers */	233	/* -EINVAL to handle old uncorrected drivers */
234	if (ret != -EINVAL && ret != -ENOTTY)	234	if (ret != -EINVAL && ret != -ENOTTY)
235	return ret;	235	return ret;
236		236
237	lock_kernel();	237	lock_kernel();
238	fsync_bdev(bdev);	238	fsync_bdev(bdev);
239	invalidate_bdev(bdev, 0);	239	invalidate_bdev(bdev, 0);
240	unlock_kernel();	240	unlock_kernel();
241	return 0;	241	return 0;
242		242
243	case BLKROSET:	243	case BLKROSET:
244	ret = blkdev_driver_ioctl(inode, file, disk, cmd, arg);	244	ret = blkdev_driver_ioctl(inode, file, disk, cmd, arg);
245	/* -EINVAL to handle old uncorrected drivers */	245	/* -EINVAL to handle old uncorrected drivers */
246	if (ret != -EINVAL && ret != -ENOTTY)	246	if (ret != -EINVAL && ret != -ENOTTY)
247	return ret;	247	return ret;
248	if (!capable(CAP_SYS_ADMIN))	248	if (!capable(CAP_SYS_ADMIN))
249	return -EACCES;	249	return -EACCES;
250	if (get_user(n, (int __user *)(arg)))	250	if (get_user(n, (int __user *)(arg)))
251	return -EFAULT;	251	return -EFAULT;
252	lock_kernel();	252	lock_kernel();
253	set_device_ro(bdev, n);	253	set_device_ro(bdev, n);
254	unlock_kernel();	254	unlock_kernel();
255	return 0;	255	return 0;
256	case HDIO_GETGEO: {	256	case HDIO_GETGEO: {
257	struct hd_geometry geo;	257	struct hd_geometry geo;
258		258
259	if (!arg)	259	if (!arg)
260	return -EINVAL;	260	return -EINVAL;
261	if (!disk->fops->getgeo)	261	if (!disk->fops->getgeo)
262	return -ENOTTY;	262	return -ENOTTY;
263		263
264	/*	264	/*
265	* We need to set the startsect first, the driver may	265	* We need to set the startsect first, the driver may
266	* want to override it.	266	* want to override it.
267	*/	267	*/
268	geo.start = get_start_sect(bdev);	268	geo.start = get_start_sect(bdev);
269	ret = disk->fops->getgeo(bdev, &geo);	269	ret = disk->fops->getgeo(bdev, &geo);
270	if (ret)	270	if (ret)
271	return ret;	271	return ret;
272	if (copy_to_user((struct hd_geometry __user *)arg, &geo,	272	if (copy_to_user((struct hd_geometry __user *)arg, &geo,
273	sizeof(geo)))	273	sizeof(geo)))
274	return -EFAULT;	274	return -EFAULT;
275	return 0;	275	return 0;
276	}	276	}
277	}	277	}
278		278
279	lock_kernel();	279	lock_kernel();
280	ret = blkdev_locked_ioctl(file, bdev, cmd, arg);	280	ret = blkdev_locked_ioctl(file, bdev, cmd, arg);
281	unlock_kernel();	281	unlock_kernel();
282	if (ret != -ENOIOCTLCMD)	282	if (ret != -ENOIOCTLCMD)
283	return ret;	283	return ret;
284		284
285	return blkdev_driver_ioctl(inode, file, disk, cmd, arg);	285	return blkdev_driver_ioctl(inode, file, disk, cmd, arg);
286	}	286	}
287		287
288	/* Most of the generic ioctls are handled in the normal fallback path.	288	/* Most of the generic ioctls are handled in the normal fallback path.
289	This assumes the blkdev's low level compat_ioctl always returns	289	This assumes the blkdev's low level compat_ioctl always returns
290	ENOIOCTLCMD for unknown ioctls. */	290	ENOIOCTLCMD for unknown ioctls. */
291	long compat_blkdev_ioctl(struct file *file, unsigned cmd, unsigned long arg)	291	long compat_blkdev_ioctl(struct file *file, unsigned cmd, unsigned long arg)
292	{	292	{
293	struct block_device *bdev = file->f_path.dentry->d_inode->i_bdev;	293	struct block_device *bdev = file->f_path.dentry->d_inode->i_bdev;
294	struct gendisk *disk = bdev->bd_disk;	294	struct gendisk *disk = bdev->bd_disk;
295	int ret = -ENOIOCTLCMD;	295	int ret = -ENOIOCTLCMD;
296	if (disk->fops->compat_ioctl) {	296	if (disk->fops->compat_ioctl) {
297	lock_kernel();	297	lock_kernel();
298	ret = disk->fops->compat_ioctl(file, cmd, arg);	298	ret = disk->fops->compat_ioctl(file, cmd, arg);
299	unlock_kernel();	299	unlock_kernel();
300	}	300	}
301	return ret;	301	return ret;
302	}	302	}
303		303
304	EXPORT_SYMBOL_GPL(blkdev_ioctl);	304	EXPORT_SYMBOL_GPL(blkdev_ioctl);
305		305

drivers/pci/Kconfig

Diff comments View file @ c827ba4

drivers/sbus/sbus.c

Diff comments View file @ c827ba4

 /* sbus.c: SBus support routines.
  *
  * Copyright (C) 1995, 2006 David S. Miller (davem@davemloft.net)
  */
 #include <linux/kernel.h>
 #include <linux/slab.h>
 #include <linux/init.h>
 #include <linux/pci.h>
+#include <linux/device.h>
 #include <asm/system.h>
 #include <asm/sbus.h>
 #include <asm/dma.h>
 #include <asm/oplib.h>
 #include <asm/prom.h>
 #include <asm/of_device.h>
 #include <asm/bpp.h>
 #include <asm/irq.h>
+static ssize_t
+show_sbusobppath_attr(struct device * dev, struct device_attribute * attr, char * buf)
+{
+	struct sbus_dev *sbus;
+	sbus = to_sbus_device(dev);
+	return snprintf (buf, PAGE_SIZE, "%s\n", sbus->ofdev.node->full_name);
+}
+static DEVICE_ATTR(obppath, S_IRUSR | S_IRGRP | S_IROTH, show_sbusobppath_attr, NULL);
 struct sbus_bus *sbus_root;
 static void __init fill_sbus_device(struct device_node *dp, struct sbus_dev *sdev)
 {
 	unsigned long base;
 	void *pval;
-	int len;
+	int len, err;
 	sdev->prom_node = dp->node;
 	strcpy(sdev->prom_name, dp->name);
 	pval = of_get_property(dp, "reg", &len);
 	sdev->num_registers = 0;
 	if (pval) {
 		memcpy(sdev->reg_addrs, pval, len);
 		sdev->num_registers =
 			len / sizeof(struct linux_prom_registers);
 		base = (unsigned long) sdev->reg_addrs[0].phys_addr;
 		/* Compute the slot number. */
 		if (base >= SUN_SBUS_BVADDR && sparc_cpu_model == sun4m)
 			sdev->slot = sbus_dev_slot(base);
 		else
 			sdev->slot = sdev->reg_addrs[0].which_io;
 	}
 	pval = of_get_property(dp, "ranges", &len);
 	sdev->num_device_ranges = 0;
 	if (pval) {
 		memcpy(sdev->device_ranges, pval, len);
 		sdev->num_device_ranges =
 			len / sizeof(struct linux_prom_ranges);
 	}
 	sbus_fill_device_irq(sdev);
 	sdev->ofdev.node = dp;
 	if (sdev->parent)
 		sdev->ofdev.dev.parent = &sdev->parent->ofdev.dev;
 	else
 		sdev->ofdev.dev.parent = &sdev->bus->ofdev.dev;
 	sdev->ofdev.dev.bus = &sbus_bus_type;
 	sprintf(sdev->ofdev.dev.bus_id, "sbus[%08x]", dp->node);
 	if (of_device_register(&sdev->ofdev) != 0)
 		printk(KERN_DEBUG "sbus: device registration error for %s!\n",
 		       dp->path_component_name);
+	/* WE HAVE BEEN INVADED BY ALIENS! */
+	err = sysfs_create_file(&sdev->ofdev.dev.kobj, &dev_attr_obppath.attr);
 }
 static void __init sbus_bus_ranges_init(struct device_node *dp, struct sbus_bus *sbus)
 {
 	void *pval;
 	int len;
 	pval = of_get_property(dp, "ranges", &len);
 	sbus->num_sbus_ranges = 0;
 	if (pval) {
 		memcpy(sbus->sbus_ranges, pval, len);
 		sbus->num_sbus_ranges =
 			len / sizeof(struct linux_prom_ranges);
 		sbus_arch_bus_ranges_init(dp->parent, sbus);
 	}
 }
 static void __init __apply_ranges_to_regs(struct linux_prom_ranges *ranges,
 					  int num_ranges,
 					  struct linux_prom_registers *regs,
 					  int num_regs)
 {
 	if (num_ranges) {
 		int regnum;
 		for (regnum = 0; regnum < num_regs; regnum++) {
 			int rngnum;
 			for (rngnum = 0; rngnum < num_ranges; rngnum++) {
 				if (regs[regnum].which_io == ranges[rngnum].ot_child_space)
 					break;
 			}
 			if (rngnum == num_ranges) {
 				/* We used to flag this as an error.  Actually
 				 * some devices do not report the regs as we expect.
 				 * For example, see SUNW,pln device.  In that case
 				 * the reg property is in a format internal to that
 				 * node, ie. it is not in the SBUS register space
 				 * per se. -DaveM
 				 */
 				return;
 			}
 			regs[regnum].which_io = ranges[rngnum].ot_parent_space;
 			regs[regnum].phys_addr -= ranges[rngnum].ot_child_base;
 			regs[regnum].phys_addr += ranges[rngnum].ot_parent_base;
 		}
 	}
 }
 static void __init __fixup_regs_sdev(struct sbus_dev *sdev)
 {
 	if (sdev->num_registers != 0) {
 		struct sbus_dev *parent = sdev->parent;
 		int i;
 		while (parent != NULL) {
 			__apply_ranges_to_regs(parent->device_ranges,
 					       parent->num_device_ranges,
 					       sdev->reg_addrs,
 					       sdev->num_registers);
 			parent = parent->parent;
 		}
 		__apply_ranges_to_regs(sdev->bus->sbus_ranges,
 				       sdev->bus->num_sbus_ranges,
 				       sdev->reg_addrs,
 				       sdev->num_registers);
 		for (i = 0; i < sdev->num_registers; i++) {
 			struct resource *res = &sdev->resource[i];
 			res->start = sdev->reg_addrs[i].phys_addr;
 			res->end = (res->start +
 				    (unsigned long)sdev->reg_addrs[i].reg_size - 1UL);
 			res->flags = IORESOURCE_IO |
 				(sdev->reg_addrs[i].which_io & 0xff);
 		}
 	}
 }
 static void __init sbus_fixup_all_regs(struct sbus_dev *first_sdev)
 {
 	struct sbus_dev *sdev;
 	for (sdev = first_sdev; sdev; sdev = sdev->next) {
 		if (sdev->child)
 			sbus_fixup_all_regs(sdev->child);
 		__fixup_regs_sdev(sdev);
 	}
 }
 /* We preserve the "probe order" of these bus and device lists to give
  * the same ordering as the old code.
  */
 static void __init sbus_insert(struct sbus_bus *sbus, struct sbus_bus **root)
 {
 	while (*root)
 		root = &(*root)->next;
 	*root = sbus;
 	sbus->next = NULL;
 }
 static void __init sdev_insert(struct sbus_dev *sdev, struct sbus_dev **root)
 {
 	while (*root)
 		root = &(*root)->next;
 	*root = sdev;
 	sdev->next = NULL;
 }
 static void __init walk_children(struct device_node *dp, struct sbus_dev *parent, struct sbus_bus *sbus)
 {
 	dp = dp->child;
 	while (dp) {
 		struct sbus_dev *sdev;
 		sdev = kzalloc(sizeof(struct sbus_dev), GFP_ATOMIC);
 		if (sdev) {
 			sdev_insert(sdev, &parent->child);
 			sdev->bus = sbus;
 			sdev->parent = parent;
 			fill_sbus_device(dp, sdev);
 			walk_children(dp, sdev, sbus);
 		}
 		dp = dp->sibling;
 	}
 }
 static void __init build_one_sbus(struct device_node *dp, int num_sbus)
 {
 	struct sbus_bus *sbus;
 	unsigned int sbus_clock;
 	struct device_node *dev_dp;
 	sbus = kzalloc(sizeof(struct sbus_bus), GFP_ATOMIC);
 	if (!sbus)
 		return;
 	sbus_insert(sbus, &sbus_root);
 	sbus->prom_node = dp->node;
 	sbus_setup_iommu(sbus, dp);
 	printk("sbus%d: ", num_sbus);
 	sbus_clock = of_getintprop_default(dp, "clock-frequency",
 					   (25*1000*1000));
 	sbus->clock_freq = sbus_clock;
 	printk("Clock %d.%d MHz\n", (int) ((sbus_clock/1000)/1000),
 	       (int) (((sbus_clock/1000)%1000 != 0) ?
 		      (((sbus_clock/1000)%1000) + 1000) : 0));
 	strcpy(sbus->prom_name, dp->name);
 	sbus_setup_arch_props(sbus, dp);
 	sbus_bus_ranges_init(dp, sbus);
 	sbus->ofdev.node = dp;
 	sbus->ofdev.dev.parent = NULL;
 	sbus->ofdev.dev.bus = &sbus_bus_type;
 	sprintf(sbus->ofdev.dev.bus_id, "sbus%d", num_sbus);
 	if (of_device_register(&sbus->ofdev) != 0)
 		printk(KERN_DEBUG "sbus: device registration error for %s!\n",
 		       sbus->ofdev.dev.bus_id);
 	dev_dp = dp->child;
 	while (dev_dp) {
 		struct sbus_dev *sdev;
 		sdev = kzalloc(sizeof(struct sbus_dev), GFP_ATOMIC);
 		if (sdev) {
 			sdev_insert(sdev, &sbus->devices);
 			sdev->bus = sbus;
 			sdev->parent = NULL;
 			fill_sbus_device(dev_dp, sdev);
 			walk_children(dev_dp, sdev, sbus);
 		}
 		dev_dp = dev_dp->sibling;
 	}
 	sbus_fixup_all_regs(sbus->devices);
 	dvma_init(sbus);
 }
 static int __init sbus_init(void)
 {
 	struct device_node *dp;
 	const char *sbus_name = "sbus";
 	int num_sbus = 0;
 	if (sbus_arch_preinit())
 		return 0;
 	if (sparc_cpu_model == sun4d)
 		sbus_name = "sbi";
 	for_each_node_by_name(dp, sbus_name) {
 		build_one_sbus(dp, num_sbus);
 		num_sbus++;
 	}
 	sbus_arch_postinit();
 	return 0;
 }
 subsys_initcall(sbus_init);

fs/partitions/check.c

Diff comments View file @ c827ba4

 /*
  *  fs/partitions/check.c
  *
  *  Code extracted from drivers/block/genhd.c
  *  Copyright (C) 1991-1998  Linus Torvalds
  *  Re-organised Feb 1998 Russell King
  *
  *  We now have independent partition support from the
  *  block drivers, which allows all the partition code to
  *  be grouped in one location, and it to be mostly self
  *  contained.
  *
  *  Added needed MAJORS for new pairs, {hdi,hdj}, {hdk,hdl}
  */
 #include <linux/init.h>
 #include <linux/module.h>
 #include <linux/fs.h>
 #include <linux/kmod.h>
 #include <linux/ctype.h>
 #include "check.h"
 #include "acorn.h"
 #include "amiga.h"
 #include "atari.h"
 #include "ldm.h"
 #include "mac.h"
 #include "msdos.h"
 #include "osf.h"
 #include "sgi.h"
 #include "sun.h"
 #include "ibm.h"
 #include "ultrix.h"
 #include "efi.h"
 #include "karma.h"
 #ifdef CONFIG_BLK_DEV_MD
 extern void md_autodetect_dev(dev_t dev);
 #endif
 int warn_no_part = 1; /*This is ugly: should make genhd removable media aware*/
 static int (*check_part[])(struct parsed_partitions *, struct block_device *) = {
 	/*
 	 * Probe partition formats with tables at disk address 0
 	 * that also have an ADFS boot block at 0xdc0.
 	 */
 #ifdef CONFIG_ACORN_PARTITION_ICS
 	adfspart_check_ICS,
 #endif
 #ifdef CONFIG_ACORN_PARTITION_POWERTEC
 	adfspart_check_POWERTEC,
 #endif
 #ifdef CONFIG_ACORN_PARTITION_EESOX
 	adfspart_check_EESOX,
 #endif
 	/*
 	 * Now move on to formats that only have partition info at
 	 * disk address 0xdc0.  Since these may also have stale
 	 * PC/BIOS partition tables, they need to come before
 	 * the msdos entry.
 	 */
 #ifdef CONFIG_ACORN_PARTITION_CUMANA
 	adfspart_check_CUMANA,
 #endif
 #ifdef CONFIG_ACORN_PARTITION_ADFS
 	adfspart_check_ADFS,
 #endif
 #ifdef CONFIG_EFI_PARTITION
 	efi_partition,		/* this must come before msdos */
 #endif
 #ifdef CONFIG_SGI_PARTITION
 	sgi_partition,
 #endif
 #ifdef CONFIG_LDM_PARTITION
 	ldm_partition,		/* this must come before msdos */
 #endif
 #ifdef CONFIG_MSDOS_PARTITION
 	msdos_partition,
 #endif
 #ifdef CONFIG_OSF_PARTITION
 	osf_partition,
 #endif
 #ifdef CONFIG_SUN_PARTITION
 	sun_partition,
 #endif
 #ifdef CONFIG_AMIGA_PARTITION
 	amiga_partition,
 #endif
 #ifdef CONFIG_ATARI_PARTITION
 	atari_partition,
 #endif
 #ifdef CONFIG_MAC_PARTITION
 	mac_partition,
 #endif
 #ifdef CONFIG_ULTRIX_PARTITION
 	ultrix_partition,
 #endif
 #ifdef CONFIG_IBM_PARTITION
 	ibm_partition,
 #endif
 #ifdef CONFIG_KARMA_PARTITION
 	karma_partition,
 #endif
 	NULL
 };
 /*
  * disk_name() is used by partition check code and the genhd driver.
  * It formats the devicename of the indicated disk into
  * the supplied buffer (of size at least 32), and returns
  * a pointer to that same buffer (for convenience).
  */
 char *disk_name(struct gendisk *hd, int part, char *buf)
 {
 	if (!part)
 		snprintf(buf, BDEVNAME_SIZE, "%s", hd->disk_name);
 	else if (isdigit(hd->disk_name[strlen(hd->disk_name)-1]))
 		snprintf(buf, BDEVNAME_SIZE, "%sp%d", hd->disk_name, part);
 	else
 		snprintf(buf, BDEVNAME_SIZE, "%s%d", hd->disk_name, part);
 	return buf;
 }
 const char *bdevname(struct block_device *bdev, char *buf)
 {
 	int part = MINOR(bdev->bd_dev) - bdev->bd_disk->first_minor;
 	return disk_name(bdev->bd_disk, part, buf);
 }
 EXPORT_SYMBOL(bdevname);
 /*
  * There's very little reason to use this, you should really
  * have a struct block_device just about everywhere and use
  * bdevname() instead.
  */
 const char *__bdevname(dev_t dev, char *buffer)
 {
 	scnprintf(buffer, BDEVNAME_SIZE, "unknown-block(%u,%u)",
 				MAJOR(dev), MINOR(dev));
 	return buffer;
 }
 EXPORT_SYMBOL(__bdevname);
 static struct parsed_partitions *
 check_partition(struct gendisk *hd, struct block_device *bdev)
 {
 	struct parsed_partitions *state;
 	int i, res, err;
 	state = kmalloc(sizeof(struct parsed_partitions), GFP_KERNEL);
 	if (!state)
 		return NULL;
 	disk_name(hd, 0, state->name);
 	printk(KERN_INFO " %s:", state->name);
 	if (isdigit(state->name[strlen(state->name)-1]))
 		sprintf(state->name, "p");
 	state->limit = hd->minors;
 	i = res = err = 0;
 	while (!res && check_part[i]) {
 		memset(&state->parts, 0, sizeof(state->parts));
 		res = check_part[i++](state, bdev);
 		if (res < 0) {
 			/* We have hit an I/O error which we don't report now.
 		 	* But record it, and let the others do their job.
 		 	*/
 			err = res;
 			res = 0;
 		}
 	}
 	if (res > 0)
 		return state;
 	if (!err)
 	/* The partition is unrecognized. So report I/O errors if there were any */
 		res = err;
 	if (!res)
 		printk(" unknown partition table\n");
 	else if (warn_no_part)
 		printk(" unable to read partition table\n");
 	kfree(state);
 	return ERR_PTR(res);
 }
 /*
  * sysfs bindings for partitions
  */
 struct part_attribute {
 	struct attribute attr;
 	ssize_t (*show)(struct hd_struct *,char *);
 	ssize_t (*store)(struct hd_struct *,const char *, size_t);
 };
 static ssize_t
 part_attr_show(struct kobject * kobj, struct attribute * attr, char * page)
 {
 	struct hd_struct * p = container_of(kobj,struct hd_struct,kobj);
 	struct part_attribute * part_attr = container_of(attr,struct part_attribute,attr);
 	ssize_t ret = 0;
 	if (part_attr->show)
 		ret = part_attr->show(p, page);
 	return ret;
 }
 static ssize_t
 part_attr_store(struct kobject * kobj, struct attribute * attr,
 		const char *page, size_t count)
 {
 	struct hd_struct * p = container_of(kobj,struct hd_struct,kobj);
 	struct part_attribute * part_attr = container_of(attr,struct part_attribute,attr);
 	ssize_t ret = 0;
 	if (part_attr->store)
 		ret = part_attr->store(p, page, count);
 	return ret;
 }
 static struct sysfs_ops part_sysfs_ops = {
 	.show	=	part_attr_show,
 	.store	=	part_attr_store,
 };
 static ssize_t part_uevent_store(struct hd_struct * p,
 				 const char *page, size_t count)
 {
 	kobject_uevent(&p->kobj, KOBJ_ADD);
 	return count;
 }
 static ssize_t part_dev_read(struct hd_struct * p, char *page)
 {
 	struct gendisk *disk = container_of(p->kobj.parent,struct gendisk,kobj);
 	dev_t dev = MKDEV(disk->major, disk->first_minor + p->partno);
 	return print_dev_t(page, dev);
 }
 static ssize_t part_start_read(struct hd_struct * p, char *page)
 {
 	return sprintf(page, "%llu\n",(unsigned long long)p->start_sect);
 }
 static ssize_t part_size_read(struct hd_struct * p, char *page)
 {
 	return sprintf(page, "%llu\n",(unsigned long long)p->nr_sects);
 }
 static ssize_t part_stat_read(struct hd_struct * p, char *page)
 {
 	return sprintf(page, "%8u %8llu %8u %8llu\n",
 		       p->ios[0], (unsigned long long)p->sectors[0],
 		       p->ios[1], (unsigned long long)p->sectors[1]);
 }
 static struct part_attribute part_attr_uevent = {
 	.attr = {.name = "uevent", .mode = S_IWUSR },
 	.store	= part_uevent_store
 };
 static struct part_attribute part_attr_dev = {
 	.attr = {.name = "dev", .mode = S_IRUGO },
 	.show	= part_dev_read
 };
 static struct part_attribute part_attr_start = {
 	.attr = {.name = "start", .mode = S_IRUGO },
 	.show	= part_start_read
 };
 static struct part_attribute part_attr_size = {
 	.attr = {.name = "size", .mode = S_IRUGO },
 	.show	= part_size_read
 };
 static struct part_attribute part_attr_stat = {
 	.attr = {.name = "stat", .mode = S_IRUGO },
 	.show	= part_stat_read
 };
 #ifdef CONFIG_FAIL_MAKE_REQUEST
 static ssize_t part_fail_store(struct hd_struct * p,
 			       const char *buf, size_t count)
 {
 	int i;
 	if (count > 0 && sscanf(buf, "%d", &i) > 0)
 		p->make_it_fail = (i == 0) ? 0 : 1;
 	return count;
 }
 static ssize_t part_fail_read(struct hd_struct * p, char *page)
 {
 	return sprintf(page, "%d\n", p->make_it_fail);
 }
 static struct part_attribute part_attr_fail = {
 	.attr = {.name = "make-it-fail", .mode = S_IRUGO | S_IWUSR },
 	.store	= part_fail_store,
 	.show	= part_fail_read
 };
 #endif
 static struct attribute * default_attrs[] = {
 	&part_attr_uevent.attr,
 	&part_attr_dev.attr,
 	&part_attr_start.attr,
 	&part_attr_size.attr,
 	&part_attr_stat.attr,
 #ifdef CONFIG_FAIL_MAKE_REQUEST
 	&part_attr_fail.attr,
 #endif
 	NULL,
 };
 extern struct subsystem block_subsys;
 static void part_release(struct kobject *kobj)
 {
 	struct hd_struct * p = container_of(kobj,struct hd_struct,kobj);
 	kfree(p);
 }
 struct kobj_type ktype_part = {
 	.release	= part_release,
 	.default_attrs	= default_attrs,
 	.sysfs_ops	= &part_sysfs_ops,
 };
 static inline void partition_sysfs_add_subdir(struct hd_struct *p)
 {
 	struct kobject *k;
 	k = kobject_get(&p->kobj);
 	p->holder_dir = kobject_add_dir(k, "holders");
 	kobject_put(k);
 }
 static inline void disk_sysfs_add_subdirs(struct gendisk *disk)
 {
 	struct kobject *k;
 	k = kobject_get(&disk->kobj);
 	disk->holder_dir = kobject_add_dir(k, "holders");
 	disk->slave_dir = kobject_add_dir(k, "slaves");
 	kobject_put(k);
 }
 void delete_partition(struct gendisk *disk, int part)
 {
 	struct hd_struct *p = disk->part[part-1];
 	if (!p)
 		return;
 	if (!p->nr_sects)
 		return;
 	disk->part[part-1] = NULL;
 	p->start_sect = 0;
 	p->nr_sects = 0;
 	p->ios[0] = p->ios[1] = 0;
 	p->sectors[0] = p->sectors[1] = 0;
 	sysfs_remove_link(&p->kobj, "subsystem");
 	if (p->holder_dir)
 		kobject_unregister(p->holder_dir);
 	kobject_uevent(&p->kobj, KOBJ_REMOVE);
 	kobject_del(&p->kobj);
 	kobject_put(&p->kobj);
 }
-void add_partition(struct gendisk *disk, int part, sector_t start, sector_t len)
+void add_partition(struct gendisk *disk, int part, sector_t start, sector_t len, int flags)
 {
 	struct hd_struct *p;
 	p = kmalloc(sizeof(*p), GFP_KERNEL);
 	if (!p)
 		return;
 	memset(p, 0, sizeof(*p));
 	p->start_sect = start;
 	p->nr_sects = len;
 	p->partno = part;
 	p->policy = disk->policy;
 	if (isdigit(disk->kobj.name[strlen(disk->kobj.name)-1]))
 		snprintf(p->kobj.name,KOBJ_NAME_LEN,"%sp%d",disk->kobj.name,part);
 	else
 		snprintf(p->kobj.name,KOBJ_NAME_LEN,"%s%d",disk->kobj.name,part);
 	p->kobj.parent = &disk->kobj;
 	p->kobj.ktype = &ktype_part;
 	kobject_init(&p->kobj);
 	kobject_add(&p->kobj);
 	if (!disk->part_uevent_suppress)
 		kobject_uevent(&p->kobj, KOBJ_ADD);
 	sysfs_create_link(&p->kobj, &block_subsys.kset.kobj, "subsystem");
+	if (flags & ADDPART_FLAG_WHOLEDISK) {
+		static struct attribute addpartattr = {
+			.name = "whole_disk",
+			.mode = S_IRUSR | S_IRGRP | S_IROTH,
+			.owner = THIS_MODULE,
+		};
+		sysfs_create_file(&p->kobj, &addpartattr);
+	}
 	partition_sysfs_add_subdir(p);
 	disk->part[part-1] = p;
 }
 static char *make_block_name(struct gendisk *disk)
 {
 	char *name;
 	static char *block_str = "block:";
 	int size;
 	char *s;
 	size = strlen(block_str) + strlen(disk->disk_name) + 1;
 	name = kmalloc(size, GFP_KERNEL);
 	if (!name)
 		return NULL;
 	strcpy(name, block_str);
 	strcat(name, disk->disk_name);
 	/* ewww... some of these buggers have / in name... */
 	s = strchr(name, '/');
 	if (s)
 		*s = '!';
 	return name;
 }
 static int disk_sysfs_symlinks(struct gendisk *disk)
 {
 	struct device *target = get_device(disk->driverfs_dev);
 	int err;
 	char *disk_name = NULL;
 	if (target) {
 		disk_name = make_block_name(disk);
 		if (!disk_name) {
 			err = -ENOMEM;
 			goto err_out;
 		}
 		err = sysfs_create_link(&disk->kobj, &target->kobj, "device");
 		if (err)
 			goto err_out_disk_name;
 		err = sysfs_create_link(&target->kobj, &disk->kobj, disk_name);
 		if (err)
 			goto err_out_dev_link;
 	}
 	err = sysfs_create_link(&disk->kobj, &block_subsys.kset.kobj,
 				"subsystem");
 	if (err)
 		goto err_out_disk_name_lnk;
 	kfree(disk_name);
 	return 0;
 err_out_disk_name_lnk:
 	if (target) {
 		sysfs_remove_link(&target->kobj, disk_name);
 err_out_dev_link:
 		sysfs_remove_link(&disk->kobj, "device");
 err_out_disk_name:
 		kfree(disk_name);
 err_out:
 		put_device(target);
 	}
 	return err;
 }
 /* Not exported, helper to add_disk(). */
 void register_disk(struct gendisk *disk)
 {
 	struct block_device *bdev;
 	char *s;
 	int i;
 	struct hd_struct *p;
 	int err;
 	strlcpy(disk->kobj.name,disk->disk_name,KOBJ_NAME_LEN);
 	/* ewww... some of these buggers have / in name... */
 	s = strchr(disk->kobj.name, '/');
 	if (s)
 		*s = '!';
 	if ((err = kobject_add(&disk->kobj)))
 		return;
 	err = disk_sysfs_symlinks(disk);
 	if (err) {
 		kobject_del(&disk->kobj);
 		return;
 	}
  	disk_sysfs_add_subdirs(disk);
 	/* No minors to use for partitions */
 	if (disk->minors == 1)
 		goto exit;
 	/* No such device (e.g., media were just removed) */
 	if (!get_capacity(disk))
 		goto exit;
 	bdev = bdget_disk(disk, 0);
 	if (!bdev)
 		goto exit;
 	/* scan partition table, but suppress uevents */
 	bdev->bd_invalidated = 1;
 	disk->part_uevent_suppress = 1;
 	err = blkdev_get(bdev, FMODE_READ, 0);
 	disk->part_uevent_suppress = 0;
 	if (err < 0)
 		goto exit;
 	blkdev_put(bdev);
 exit:
 	/* announce disk after possible partitions are already created */
 	kobject_uevent(&disk->kobj, KOBJ_ADD);
 	/* announce possible partitions */
 	for (i = 1; i < disk->minors; i++) {
 		p = disk->part[i-1];
 		if (!p || !p->nr_sects)
 			continue;
 		kobject_uevent(&p->kobj, KOBJ_ADD);
 	}
 }
 int rescan_partitions(struct gendisk *disk, struct block_device *bdev)
 {
 	struct parsed_partitions *state;
 	int p, res;
 	if (bdev->bd_part_count)
 		return -EBUSY;
 	res = invalidate_partition(disk, 0);
 	if (res)
 		return res;
 	bdev->bd_invalidated = 0;
 	for (p = 1; p < disk->minors; p++)
 		delete_partition(disk, p);
 	if (disk->fops->revalidate_disk)
 		disk->fops->revalidate_disk(disk);
 	if (!get_capacity(disk) || !(state = check_partition(disk, bdev)))
 		return 0;
 	if (IS_ERR(state))	/* I/O error reading the partition table */
 		return PTR_ERR(state);
 	for (p = 1; p < state->limit; p++) {
 		sector_t size = state->parts[p].size;
 		sector_t from = state->parts[p].from;
 		if (!size)
 			continue;
 		if (from + size > get_capacity(disk)) {
 			printk(" %s: p%d exceeds device capacity\n",
 				disk->disk_name, p);
 		}
-		add_partition(disk, p, from, size);
+		add_partition(disk, p, from, size, state->parts[p].flags);
 #ifdef CONFIG_BLK_DEV_MD
-		if (state->parts[p].flags)
+		if (state->parts[p].flags & ADDPART_FLAG_RAID)
 			md_autodetect_dev(bdev->bd_dev+p);
 #endif
 	}
 	kfree(state);
 	return 0;
 }
 unsigned char *read_dev_sector(struct block_device *bdev, sector_t n, Sector *p)
 {
 	struct address_space *mapping = bdev->bd_inode->i_mapping;
 	struct page *page;
 	page = read_mapping_page(mapping, (pgoff_t)(n >> (PAGE_CACHE_SHIFT-9)),
 				 NULL);
 	if (!IS_ERR(page)) {
 		wait_on_page_locked(page);
 		if (!PageUptodate(page))
 			goto fail;
 		if (PageError(page))
 			goto fail;
 		p->v = page;
 		return (unsigned char *)page_address(page) +  ((n & ((1 << (PAGE_CACHE_SHIFT - 9)) - 1)) << 9);
 fail:
 		page_cache_release(page);
 	}
 	p->v = NULL;
 	return NULL;
 }
 EXPORT_SYMBOL(read_dev_sector);
 void del_gendisk(struct gendisk *disk)
 {
 	int p;
 	/* invalidate stuff */
 	for (p = disk->minors - 1; p > 0; p--) {
 		invalidate_partition(disk, p);
 		delete_partition(disk, p);
 	}
 	invalidate_partition(disk, 0);
 	disk->capacity = 0;
 	disk->flags &= ~GENHD_FL_UP;
 	unlink_gendisk(disk);
 	disk_stat_set_all(disk, 0);
 	disk->stamp = 0;
 	kobject_uevent(&disk->kobj, KOBJ_REMOVE);
 	if (disk->holder_dir)
 		kobject_unregister(disk->holder_dir);
 	if (disk->slave_dir)
 		kobject_unregister(disk->slave_dir);
 	if (disk->driverfs_dev) {
 		char *disk_name = make_block_name(disk);
 		sysfs_remove_link(&disk->kobj, "device");
 		if (disk_name) {
 			sysfs_remove_link(&disk->driverfs_dev->kobj, disk_name);
 			kfree(disk_name);
 		}
 		put_device(disk->driverfs_dev);
 		disk->driverfs_dev = NULL;
 	}
 	sysfs_remove_link(&disk->kobj, "subsystem");
 	kobject_del(&disk->kobj);
 }

fs/partitions/msdos.c

Diff comments View file @ c827ba4

1	/*	1	/*
2	* fs/partitions/msdos.c	2	* fs/partitions/msdos.c
3	*	3	*
4	* Code extracted from drivers/block/genhd.c	4	* Code extracted from drivers/block/genhd.c
5	* Copyright (C) 1991-1998 Linus Torvalds	5	* Copyright (C) 1991-1998 Linus Torvalds
6	*	6	*
7	* Thanks to Branko Lankester, lankeste@fwi.uva.nl, who found a bug	7	* Thanks to Branko Lankester, lankeste@fwi.uva.nl, who found a bug
8	* in the early extended-partition checks and added DM partitions	8	* in the early extended-partition checks and added DM partitions
9	*	9	*
10	* Support for DiskManager v6.0x added by Mark Lord,	10	* Support for DiskManager v6.0x added by Mark Lord,
11	* with information provided by OnTrack. This now works for linux fdisk	11	* with information provided by OnTrack. This now works for linux fdisk
12	* and LILO, as well as loadlin and bootln. Note that disks other than	12	* and LILO, as well as loadlin and bootln. Note that disks other than
13	* /dev/hda must have a "DOS" type 0x51 partition in the first slot (hda1).	13	* /dev/hda must have a "DOS" type 0x51 partition in the first slot (hda1).
14	*	14	*
15	* More flexible handling of extended partitions - aeb, 950831	15	* More flexible handling of extended partitions - aeb, 950831
16	*	16	*
17	* Check partition table on IDE disks for common CHS translations	17	* Check partition table on IDE disks for common CHS translations
18	*	18	*
19	* Re-organised Feb 1998 Russell King	19	* Re-organised Feb 1998 Russell King
20	*/	20	*/
21		21
22		22
23	#include "check.h"	23	#include "check.h"
24	#include "msdos.h"	24	#include "msdos.h"
25	#include "efi.h"	25	#include "efi.h"
26		26
27	/*	27	/*
28	* Many architectures don't like unaligned accesses, while	28	* Many architectures don't like unaligned accesses, while
29	* the nr_sects and start_sect partition table entries are	29	* the nr_sects and start_sect partition table entries are
30	* at a 2 (mod 4) address.	30	* at a 2 (mod 4) address.
31	*/	31	*/
32	#include <asm/unaligned.h>	32	#include <asm/unaligned.h>
33		33
34	#define SYS_IND(p) (get_unaligned(&p->sys_ind))	34	#define SYS_IND(p) (get_unaligned(&p->sys_ind))
35	#define NR_SECTS(p) ({ __le32 __a = get_unaligned(&p->nr_sects); \	35	#define NR_SECTS(p) ({ __le32 __a = get_unaligned(&p->nr_sects); \
36	le32_to_cpu(__a); \	36	le32_to_cpu(__a); \
37	})	37	})
38		38
39	#define START_SECT(p) ({ __le32 __a = get_unaligned(&p->start_sect); \	39	#define START_SECT(p) ({ __le32 __a = get_unaligned(&p->start_sect); \
40	le32_to_cpu(__a); \	40	le32_to_cpu(__a); \
41	})	41	})
42		42
43	static inline int is_extended_partition(struct partition *p)	43	static inline int is_extended_partition(struct partition *p)
44	{	44	{
45	return (SYS_IND(p) == DOS_EXTENDED_PARTITION \|\|	45	return (SYS_IND(p) == DOS_EXTENDED_PARTITION \|\|
46	SYS_IND(p) == WIN98_EXTENDED_PARTITION \|\|	46	SYS_IND(p) == WIN98_EXTENDED_PARTITION \|\|
47	SYS_IND(p) == LINUX_EXTENDED_PARTITION);	47	SYS_IND(p) == LINUX_EXTENDED_PARTITION);
48	}	48	}
49		49
50	#define MSDOS_LABEL_MAGIC1 0x55	50	#define MSDOS_LABEL_MAGIC1 0x55
51	#define MSDOS_LABEL_MAGIC2 0xAA	51	#define MSDOS_LABEL_MAGIC2 0xAA
52		52
53	static inline int	53	static inline int
54	msdos_magic_present(unsigned char *p)	54	msdos_magic_present(unsigned char *p)
55	{	55	{
56	return (p[0] == MSDOS_LABEL_MAGIC1 && p[1] == MSDOS_LABEL_MAGIC2);	56	return (p[0] == MSDOS_LABEL_MAGIC1 && p[1] == MSDOS_LABEL_MAGIC2);
57	}	57	}
58		58
59	/* Value is EBCDIC 'IBMA' */	59	/* Value is EBCDIC 'IBMA' */
60	#define AIX_LABEL_MAGIC1 0xC9	60	#define AIX_LABEL_MAGIC1 0xC9
61	#define AIX_LABEL_MAGIC2 0xC2	61	#define AIX_LABEL_MAGIC2 0xC2
62	#define AIX_LABEL_MAGIC3 0xD4	62	#define AIX_LABEL_MAGIC3 0xD4
63	#define AIX_LABEL_MAGIC4 0xC1	63	#define AIX_LABEL_MAGIC4 0xC1
64	static int aix_magic_present(unsigned char p, struct block_device bdev)	64	static int aix_magic_present(unsigned char p, struct block_device bdev)
65	{	65	{
66	struct partition pt = (struct partition ) (p + 0x1be);	66	struct partition pt = (struct partition ) (p + 0x1be);
67	Sector sect;	67	Sector sect;
68	unsigned char *d;	68	unsigned char *d;
69	int slot, ret = 0;	69	int slot, ret = 0;
70		70
71	if (!(p[0] == AIX_LABEL_MAGIC1 &&	71	if (!(p[0] == AIX_LABEL_MAGIC1 &&
72	p[1] == AIX_LABEL_MAGIC2 &&	72	p[1] == AIX_LABEL_MAGIC2 &&
73	p[2] == AIX_LABEL_MAGIC3 &&	73	p[2] == AIX_LABEL_MAGIC3 &&
74	p[3] == AIX_LABEL_MAGIC4))	74	p[3] == AIX_LABEL_MAGIC4))
75	return 0;	75	return 0;
76	/* Assume the partition table is valid if Linux partitions exists */	76	/* Assume the partition table is valid if Linux partitions exists */
77	for (slot = 1; slot <= 4; slot++, pt++) {	77	for (slot = 1; slot <= 4; slot++, pt++) {
78	if (pt->sys_ind == LINUX_SWAP_PARTITION \|\|	78	if (pt->sys_ind == LINUX_SWAP_PARTITION \|\|
79	pt->sys_ind == LINUX_RAID_PARTITION \|\|	79	pt->sys_ind == LINUX_RAID_PARTITION \|\|
80	pt->sys_ind == LINUX_DATA_PARTITION \|\|	80	pt->sys_ind == LINUX_DATA_PARTITION \|\|
81	pt->sys_ind == LINUX_LVM_PARTITION \|\|	81	pt->sys_ind == LINUX_LVM_PARTITION \|\|
82	is_extended_partition(pt))	82	is_extended_partition(pt))
83	return 0;	83	return 0;
84	}	84	}
85	d = read_dev_sector(bdev, 7, &sect);	85	d = read_dev_sector(bdev, 7, &sect);
86	if (d) {	86	if (d) {
87	if (d[0] == '_' && d[1] == 'L' && d[2] == 'V' && d[3] == 'M')	87	if (d[0] == '_' && d[1] == 'L' && d[2] == 'V' && d[3] == 'M')
88	ret = 1;	88	ret = 1;
89	put_dev_sector(sect);	89	put_dev_sector(sect);
90	};	90	};
91	return ret;	91	return ret;
92	}	92	}
93		93
94	/*	94	/*
95	* Create devices for each logical partition in an extended partition.	95	* Create devices for each logical partition in an extended partition.
96	* The logical partitions form a linked list, with each entry being	96	* The logical partitions form a linked list, with each entry being
97	* a partition table with two entries. The first entry	97	* a partition table with two entries. The first entry
98	* is the real data partition (with a start relative to the partition	98	* is the real data partition (with a start relative to the partition
99	* table start). The second is a pointer to the next logical partition	99	* table start). The second is a pointer to the next logical partition
100	* (with a start relative to the entire extended partition).	100	* (with a start relative to the entire extended partition).
101	* We do not create a Linux partition for the partition tables, but	101	* We do not create a Linux partition for the partition tables, but
102	* only for the actual data partitions.	102	* only for the actual data partitions.
103	*/	103	*/
104		104
105	static void	105	static void
106	parse_extended(struct parsed_partitions state, struct block_device bdev,	106	parse_extended(struct parsed_partitions state, struct block_device bdev,
107	u32 first_sector, u32 first_size)	107	u32 first_sector, u32 first_size)
108	{	108	{
109	struct partition *p;	109	struct partition *p;
110	Sector sect;	110	Sector sect;
111	unsigned char *data;	111	unsigned char *data;
112	u32 this_sector, this_size;	112	u32 this_sector, this_size;
113	int sector_size = bdev_hardsect_size(bdev) / 512;	113	int sector_size = bdev_hardsect_size(bdev) / 512;
114	int loopct = 0; /* number of links followed	114	int loopct = 0; /* number of links followed
115	without finding a data partition */	115	without finding a data partition */
116	int i;	116	int i;
117		117
118	this_sector = first_sector;	118	this_sector = first_sector;
119	this_size = first_size;	119	this_size = first_size;
120		120
121	while (1) {	121	while (1) {
122	if (++loopct > 100)	122	if (++loopct > 100)
123	return;	123	return;
124	if (state->next == state->limit)	124	if (state->next == state->limit)
125	return;	125	return;
126	data = read_dev_sector(bdev, this_sector, &sect);	126	data = read_dev_sector(bdev, this_sector, &sect);
127	if (!data)	127	if (!data)
128	return;	128	return;
129		129
130	if (!msdos_magic_present(data + 510))	130	if (!msdos_magic_present(data + 510))
131	goto done;	131	goto done;
132		132
133	p = (struct partition *) (data + 0x1be);	133	p = (struct partition *) (data + 0x1be);
134		134
135	/*	135	/*
136	* Usually, the first entry is the real data partition,	136	* Usually, the first entry is the real data partition,
137	* the 2nd entry is the next extended partition, or empty,	137	* the 2nd entry is the next extended partition, or empty,
138	* and the 3rd and 4th entries are unused.	138	* and the 3rd and 4th entries are unused.
139	* However, DRDOS sometimes has the extended partition as	139	* However, DRDOS sometimes has the extended partition as
140	* the first entry (when the data partition is empty),	140	* the first entry (when the data partition is empty),
141	* and OS/2 seems to use all four entries.	141	* and OS/2 seems to use all four entries.
142	*/	142	*/
143		143
144	/*	144	/*
145	* First process the data partition(s)	145	* First process the data partition(s)
146	*/	146	*/
147	for (i=0; i<4; i++, p++) {	147	for (i=0; i<4; i++, p++) {
148	u32 offs, size, next;	148	u32 offs, size, next;
149	if (!NR_SECTS(p) \|\| is_extended_partition(p))	149	if (!NR_SECTS(p) \|\| is_extended_partition(p))
150	continue;	150	continue;
151		151
152	/* Check the 3rd and 4th entries -	152	/* Check the 3rd and 4th entries -
153	these sometimes contain random garbage */	153	these sometimes contain random garbage */
154	offs = START_SECT(p)*sector_size;	154	offs = START_SECT(p)*sector_size;
155	size = NR_SECTS(p)*sector_size;	155	size = NR_SECTS(p)*sector_size;
156	next = this_sector + offs;	156	next = this_sector + offs;
157	if (i >= 2) {	157	if (i >= 2) {
158	if (offs + size > this_size)	158	if (offs + size > this_size)
159	continue;	159	continue;
160	if (next < first_sector)	160	if (next < first_sector)
161	continue;	161	continue;
162	if (next + size > first_sector + first_size)	162	if (next + size > first_sector + first_size)
163	continue;	163	continue;
164	}	164	}
165		165
166	put_partition(state, state->next, next, size);	166	put_partition(state, state->next, next, size);
167	if (SYS_IND(p) == LINUX_RAID_PARTITION)	167	if (SYS_IND(p) == LINUX_RAID_PARTITION)
168	state->parts[state->next].flags = 1;	168	state->parts[state->next].flags = ADDPART_FLAG_RAID;
169	loopct = 0;	169	loopct = 0;
170	if (++state->next == state->limit)	170	if (++state->next == state->limit)
171	goto done;	171	goto done;
172	}	172	}
173	/*	173	/*
174	* Next, process the (first) extended partition, if present.	174	* Next, process the (first) extended partition, if present.
175	* (So far, there seems to be no reason to make	175	* (So far, there seems to be no reason to make
176	* parse_extended() recursive and allow a tree	176	* parse_extended() recursive and allow a tree
177	* of extended partitions.)	177	* of extended partitions.)
178	* It should be a link to the next logical partition.	178	* It should be a link to the next logical partition.
179	*/	179	*/
180	p -= 4;	180	p -= 4;
181	for (i=0; i<4; i++, p++)	181	for (i=0; i<4; i++, p++)
182	if (NR_SECTS(p) && is_extended_partition(p))	182	if (NR_SECTS(p) && is_extended_partition(p))
183	break;	183	break;
184	if (i == 4)	184	if (i == 4)
185	goto done; /* nothing left to do */	185	goto done; /* nothing left to do */
186		186
187	this_sector = first_sector + START_SECT(p) * sector_size;	187	this_sector = first_sector + START_SECT(p) * sector_size;
188	this_size = NR_SECTS(p) * sector_size;	188	this_size = NR_SECTS(p) * sector_size;
189	put_dev_sector(sect);	189	put_dev_sector(sect);
190	}	190	}
191	done:	191	done:
192	put_dev_sector(sect);	192	put_dev_sector(sect);
193	}	193	}
194		194
195	/* james@bpgc.com: Solaris has a nasty indicator: 0x82 which also	195	/* james@bpgc.com: Solaris has a nasty indicator: 0x82 which also
196	indicates linux swap. Be careful before believing this is Solaris. */	196	indicates linux swap. Be careful before believing this is Solaris. */
197		197
198	static void	198	static void
199	parse_solaris_x86(struct parsed_partitions state, struct block_device bdev,	199	parse_solaris_x86(struct parsed_partitions state, struct block_device bdev,
200	u32 offset, u32 size, int origin)	200	u32 offset, u32 size, int origin)
201	{	201	{
202	#ifdef CONFIG_SOLARIS_X86_PARTITION	202	#ifdef CONFIG_SOLARIS_X86_PARTITION
203	Sector sect;	203	Sector sect;
204	struct solaris_x86_vtoc *v;	204	struct solaris_x86_vtoc *v;
205	int i;	205	int i;
206		206
207	v = (struct solaris_x86_vtoc *)read_dev_sector(bdev, offset+1, &sect);	207	v = (struct solaris_x86_vtoc *)read_dev_sector(bdev, offset+1, &sect);
208	if (!v)	208	if (!v)
209	return;	209	return;
210	if (le32_to_cpu(v->v_sanity) != SOLARIS_X86_VTOC_SANE) {	210	if (le32_to_cpu(v->v_sanity) != SOLARIS_X86_VTOC_SANE) {
211	put_dev_sector(sect);	211	put_dev_sector(sect);
212	return;	212	return;
213	}	213	}
214	printk(" %s%d: <solaris:", state->name, origin);	214	printk(" %s%d: <solaris:", state->name, origin);
215	if (le32_to_cpu(v->v_version) != 1) {	215	if (le32_to_cpu(v->v_version) != 1) {
216	printk(" cannot handle version %d vtoc>\n",	216	printk(" cannot handle version %d vtoc>\n",
217	le32_to_cpu(v->v_version));	217	le32_to_cpu(v->v_version));
218	put_dev_sector(sect);	218	put_dev_sector(sect);
219	return;	219	return;
220	}	220	}
221	for (i=0; i<SOLARIS_X86_NUMSLICE && state->next<state->limit; i++) {	221	for (i=0; i<SOLARIS_X86_NUMSLICE && state->next<state->limit; i++) {
222	struct solaris_x86_slice *s = &v->v_slice[i];	222	struct solaris_x86_slice *s = &v->v_slice[i];
223	if (s->s_size == 0)	223	if (s->s_size == 0)
224	continue;	224	continue;
225	printk(" [s%d]", i);	225	printk(" [s%d]", i);
226	/* solaris partitions are relative to current MS-DOS	226	/* solaris partitions are relative to current MS-DOS
227	* one; must add the offset of the current partition */	227	* one; must add the offset of the current partition */
228	put_partition(state, state->next++,	228	put_partition(state, state->next++,
229	le32_to_cpu(s->s_start)+offset,	229	le32_to_cpu(s->s_start)+offset,
230	le32_to_cpu(s->s_size));	230	le32_to_cpu(s->s_size));
231	}	231	}
232	put_dev_sector(sect);	232	put_dev_sector(sect);
233	printk(" >\n");	233	printk(" >\n");
234	#endif	234	#endif
235	}	235	}
236		236
237	#if defined(CONFIG_BSD_DISKLABEL)	237	#if defined(CONFIG_BSD_DISKLABEL)
238	/*	238	/*
239	* Create devices for BSD partitions listed in a disklabel, under a	239	* Create devices for BSD partitions listed in a disklabel, under a
240	* dos-like partition. See parse_extended() for more information.	240	* dos-like partition. See parse_extended() for more information.
241	*/	241	*/
242	static void	242	static void
243	parse_bsd(struct parsed_partitions state, struct block_device bdev,	243	parse_bsd(struct parsed_partitions state, struct block_device bdev,
244	u32 offset, u32 size, int origin, char *flavour,	244	u32 offset, u32 size, int origin, char *flavour,
245	int max_partitions)	245	int max_partitions)
246	{	246	{
247	Sector sect;	247	Sector sect;
248	struct bsd_disklabel *l;	248	struct bsd_disklabel *l;
249	struct bsd_partition *p;	249	struct bsd_partition *p;
250		250
251	l = (struct bsd_disklabel *)read_dev_sector(bdev, offset+1, &sect);	251	l = (struct bsd_disklabel *)read_dev_sector(bdev, offset+1, &sect);
252	if (!l)	252	if (!l)
253	return;	253	return;
254	if (le32_to_cpu(l->d_magic) != BSD_DISKMAGIC) {	254	if (le32_to_cpu(l->d_magic) != BSD_DISKMAGIC) {
255	put_dev_sector(sect);	255	put_dev_sector(sect);
256	return;	256	return;
257	}	257	}
258	printk(" %s%d: <%s:", state->name, origin, flavour);	258	printk(" %s%d: <%s:", state->name, origin, flavour);
259		259
260	if (le16_to_cpu(l->d_npartitions) < max_partitions)	260	if (le16_to_cpu(l->d_npartitions) < max_partitions)
261	max_partitions = le16_to_cpu(l->d_npartitions);	261	max_partitions = le16_to_cpu(l->d_npartitions);
262	for (p = l->d_partitions; p - l->d_partitions < max_partitions; p++) {	262	for (p = l->d_partitions; p - l->d_partitions < max_partitions; p++) {
263	u32 bsd_start, bsd_size;	263	u32 bsd_start, bsd_size;
264		264
265	if (state->next == state->limit)	265	if (state->next == state->limit)
266	break;	266	break;
267	if (p->p_fstype == BSD_FS_UNUSED)	267	if (p->p_fstype == BSD_FS_UNUSED)
268	continue;	268	continue;
269	bsd_start = le32_to_cpu(p->p_offset);	269	bsd_start = le32_to_cpu(p->p_offset);
270	bsd_size = le32_to_cpu(p->p_size);	270	bsd_size = le32_to_cpu(p->p_size);
271	if (offset == bsd_start && size == bsd_size)	271	if (offset == bsd_start && size == bsd_size)
272	/* full parent partition, we have it already */	272	/* full parent partition, we have it already */
273	continue;	273	continue;
274	if (offset > bsd_start \|\| offset+size < bsd_start+bsd_size) {	274	if (offset > bsd_start \|\| offset+size < bsd_start+bsd_size) {
275	printk("bad subpartition - ignored\n");	275	printk("bad subpartition - ignored\n");
276	continue;	276	continue;
277	}	277	}
278	put_partition(state, state->next++, bsd_start, bsd_size);	278	put_partition(state, state->next++, bsd_start, bsd_size);
279	}	279	}
280	put_dev_sector(sect);	280	put_dev_sector(sect);
281	if (le16_to_cpu(l->d_npartitions) > max_partitions)	281	if (le16_to_cpu(l->d_npartitions) > max_partitions)
282	printk(" (ignored %d more)",	282	printk(" (ignored %d more)",
283	le16_to_cpu(l->d_npartitions) - max_partitions);	283	le16_to_cpu(l->d_npartitions) - max_partitions);
284	printk(" >\n");	284	printk(" >\n");
285	}	285	}
286	#endif	286	#endif
287		287
288	static void	288	static void
289	parse_freebsd(struct parsed_partitions state, struct block_device bdev,	289	parse_freebsd(struct parsed_partitions state, struct block_device bdev,
290	u32 offset, u32 size, int origin)	290	u32 offset, u32 size, int origin)
291	{	291	{
292	#ifdef CONFIG_BSD_DISKLABEL	292	#ifdef CONFIG_BSD_DISKLABEL
293	parse_bsd(state, bdev, offset, size, origin,	293	parse_bsd(state, bdev, offset, size, origin,
294	"bsd", BSD_MAXPARTITIONS);	294	"bsd", BSD_MAXPARTITIONS);
295	#endif	295	#endif
296	}	296	}
297		297
298	static void	298	static void
299	parse_netbsd(struct parsed_partitions state, struct block_device bdev,	299	parse_netbsd(struct parsed_partitions state, struct block_device bdev,
300	u32 offset, u32 size, int origin)	300	u32 offset, u32 size, int origin)
301	{	301	{
302	#ifdef CONFIG_BSD_DISKLABEL	302	#ifdef CONFIG_BSD_DISKLABEL
303	parse_bsd(state, bdev, offset, size, origin,	303	parse_bsd(state, bdev, offset, size, origin,
304	"netbsd", BSD_MAXPARTITIONS);	304	"netbsd", BSD_MAXPARTITIONS);
305	#endif	305	#endif
306	}	306	}
307		307
308	static void	308	static void
309	parse_openbsd(struct parsed_partitions state, struct block_device bdev,	309	parse_openbsd(struct parsed_partitions state, struct block_device bdev,
310	u32 offset, u32 size, int origin)	310	u32 offset, u32 size, int origin)
311	{	311	{
312	#ifdef CONFIG_BSD_DISKLABEL	312	#ifdef CONFIG_BSD_DISKLABEL
313	parse_bsd(state, bdev, offset, size, origin,	313	parse_bsd(state, bdev, offset, size, origin,
314	"openbsd", OPENBSD_MAXPARTITIONS);	314	"openbsd", OPENBSD_MAXPARTITIONS);
315	#endif	315	#endif
316	}	316	}
317		317
318	/*	318	/*
319	* Create devices for Unixware partitions listed in a disklabel, under a	319	* Create devices for Unixware partitions listed in a disklabel, under a
320	* dos-like partition. See parse_extended() for more information.	320	* dos-like partition. See parse_extended() for more information.
321	*/	321	*/
322	static void	322	static void
323	parse_unixware(struct parsed_partitions state, struct block_device bdev,	323	parse_unixware(struct parsed_partitions state, struct block_device bdev,
324	u32 offset, u32 size, int origin)	324	u32 offset, u32 size, int origin)
325	{	325	{
326	#ifdef CONFIG_UNIXWARE_DISKLABEL	326	#ifdef CONFIG_UNIXWARE_DISKLABEL
327	Sector sect;	327	Sector sect;
328	struct unixware_disklabel *l;	328	struct unixware_disklabel *l;
329	struct unixware_slice *p;	329	struct unixware_slice *p;
330		330
331	l = (struct unixware_disklabel *)read_dev_sector(bdev, offset+29, &sect);	331	l = (struct unixware_disklabel *)read_dev_sector(bdev, offset+29, &sect);
332	if (!l)	332	if (!l)
333	return;	333	return;
334	if (le32_to_cpu(l->d_magic) != UNIXWARE_DISKMAGIC \|\|	334	if (le32_to_cpu(l->d_magic) != UNIXWARE_DISKMAGIC \|\|
335	le32_to_cpu(l->vtoc.v_magic) != UNIXWARE_DISKMAGIC2) {	335	le32_to_cpu(l->vtoc.v_magic) != UNIXWARE_DISKMAGIC2) {
336	put_dev_sector(sect);	336	put_dev_sector(sect);
337	return;	337	return;
338	}	338	}
339	printk(" %s%d: <unixware:", state->name, origin);	339	printk(" %s%d: <unixware:", state->name, origin);
340	p = &l->vtoc.v_slice[1];	340	p = &l->vtoc.v_slice[1];
341	/* I omit the 0th slice as it is the same as whole disk. */	341	/* I omit the 0th slice as it is the same as whole disk. */
342	while (p - &l->vtoc.v_slice[0] < UNIXWARE_NUMSLICE) {	342	while (p - &l->vtoc.v_slice[0] < UNIXWARE_NUMSLICE) {
343	if (state->next == state->limit)	343	if (state->next == state->limit)
344	break;	344	break;
345		345
346	if (p->s_label != UNIXWARE_FS_UNUSED)	346	if (p->s_label != UNIXWARE_FS_UNUSED)
347	put_partition(state, state->next++,	347	put_partition(state, state->next++,
348	START_SECT(p), NR_SECTS(p));	348	START_SECT(p), NR_SECTS(p));
349	p++;	349	p++;
350	}	350	}
351	put_dev_sector(sect);	351	put_dev_sector(sect);
352	printk(" >\n");	352	printk(" >\n");
353	#endif	353	#endif
354	}	354	}
355		355
356	/*	356	/*
357	* Minix 2.0.0/2.0.2 subpartition support.	357	* Minix 2.0.0/2.0.2 subpartition support.
358	* Anand Krishnamurthy <anandk@wiproge.med.ge.com>	358	* Anand Krishnamurthy <anandk@wiproge.med.ge.com>
359	* Rajeev V. Pillai <rajeevvp@yahoo.com>	359	* Rajeev V. Pillai <rajeevvp@yahoo.com>
360	*/	360	*/
361	static void	361	static void
362	parse_minix(struct parsed_partitions state, struct block_device bdev,	362	parse_minix(struct parsed_partitions state, struct block_device bdev,
363	u32 offset, u32 size, int origin)	363	u32 offset, u32 size, int origin)
364	{	364	{
365	#ifdef CONFIG_MINIX_SUBPARTITION	365	#ifdef CONFIG_MINIX_SUBPARTITION
366	Sector sect;	366	Sector sect;
367	unsigned char *data;	367	unsigned char *data;
368	struct partition *p;	368	struct partition *p;
369	int i;	369	int i;
370		370
371	data = read_dev_sector(bdev, offset, &sect);	371	data = read_dev_sector(bdev, offset, &sect);
372	if (!data)	372	if (!data)
373	return;	373	return;
374		374
375	p = (struct partition *)(data + 0x1be);	375	p = (struct partition *)(data + 0x1be);
376		376
377	/* The first sector of a Minix partition can have either	377	/* The first sector of a Minix partition can have either
378	* a secondary MBR describing its subpartitions, or	378	* a secondary MBR describing its subpartitions, or
379	* the normal boot sector. */	379	* the normal boot sector. */
380	if (msdos_magic_present (data + 510) &&	380	if (msdos_magic_present (data + 510) &&
381	SYS_IND(p) == MINIX_PARTITION) { /* subpartition table present */	381	SYS_IND(p) == MINIX_PARTITION) { /* subpartition table present */
382		382
383	printk(" %s%d: <minix:", state->name, origin);	383	printk(" %s%d: <minix:", state->name, origin);
384	for (i = 0; i < MINIX_NR_SUBPARTITIONS; i++, p++) {	384	for (i = 0; i < MINIX_NR_SUBPARTITIONS; i++, p++) {
385	if (state->next == state->limit)	385	if (state->next == state->limit)
386	break;	386	break;
387	/* add each partition in use */	387	/* add each partition in use */
388	if (SYS_IND(p) == MINIX_PARTITION)	388	if (SYS_IND(p) == MINIX_PARTITION)
389	put_partition(state, state->next++,	389	put_partition(state, state->next++,
390	START_SECT(p), NR_SECTS(p));	390	START_SECT(p), NR_SECTS(p));
391	}	391	}
392	printk(" >\n");	392	printk(" >\n");
393	}	393	}
394	put_dev_sector(sect);	394	put_dev_sector(sect);
395	#endif /* CONFIG_MINIX_SUBPARTITION */	395	#endif /* CONFIG_MINIX_SUBPARTITION */
396	}	396	}
397		397
398	static struct {	398	static struct {
399	unsigned char id;	399	unsigned char id;
400	void (parse)(struct parsed_partitions , struct block_device *,	400	void (parse)(struct parsed_partitions , struct block_device *,
401	u32, u32, int);	401	u32, u32, int);
402	} subtypes[] = {	402	} subtypes[] = {
403	{FREEBSD_PARTITION, parse_freebsd},	403	{FREEBSD_PARTITION, parse_freebsd},
404	{NETBSD_PARTITION, parse_netbsd},	404	{NETBSD_PARTITION, parse_netbsd},
405	{OPENBSD_PARTITION, parse_openbsd},	405	{OPENBSD_PARTITION, parse_openbsd},
406	{MINIX_PARTITION, parse_minix},	406	{MINIX_PARTITION, parse_minix},
407	{UNIXWARE_PARTITION, parse_unixware},	407	{UNIXWARE_PARTITION, parse_unixware},
408	{SOLARIS_X86_PARTITION, parse_solaris_x86},	408	{SOLARIS_X86_PARTITION, parse_solaris_x86},
409	{NEW_SOLARIS_X86_PARTITION, parse_solaris_x86},	409	{NEW_SOLARIS_X86_PARTITION, parse_solaris_x86},
410	{0, NULL},	410	{0, NULL},
411	};	411	};
412		412
413	int msdos_partition(struct parsed_partitions state, struct block_device bdev)	413	int msdos_partition(struct parsed_partitions state, struct block_device bdev)
414	{	414	{
415	int sector_size = bdev_hardsect_size(bdev) / 512;	415	int sector_size = bdev_hardsect_size(bdev) / 512;
416	Sector sect;	416	Sector sect;
417	unsigned char *data;	417	unsigned char *data;
418	struct partition *p;	418	struct partition *p;
419	int slot;	419	int slot;
420		420
421	data = read_dev_sector(bdev, 0, &sect);	421	data = read_dev_sector(bdev, 0, &sect);
422	if (!data)	422	if (!data)
423	return -1;	423	return -1;
424	if (!msdos_magic_present(data + 510)) {	424	if (!msdos_magic_present(data + 510)) {
425	put_dev_sector(sect);	425	put_dev_sector(sect);
426	return 0;	426	return 0;
427	}	427	}
428		428
429	if (aix_magic_present(data, bdev)) {	429	if (aix_magic_present(data, bdev)) {
430	put_dev_sector(sect);	430	put_dev_sector(sect);
431	printk( " [AIX]");	431	printk( " [AIX]");
432	return 0;	432	return 0;
433	}	433	}
434		434
435	/*	435	/*
436	* Now that the 55aa signature is present, this is probably	436	* Now that the 55aa signature is present, this is probably
437	* either the boot sector of a FAT filesystem or a DOS-type	437	* either the boot sector of a FAT filesystem or a DOS-type
438	* partition table. Reject this in case the boot indicator	438	* partition table. Reject this in case the boot indicator
439	* is not 0 or 0x80.	439	* is not 0 or 0x80.
440	*/	440	*/
441	p = (struct partition *) (data + 0x1be);	441	p = (struct partition *) (data + 0x1be);
442	for (slot = 1; slot <= 4; slot++, p++) {	442	for (slot = 1; slot <= 4; slot++, p++) {
443	if (p->boot_ind != 0 && p->boot_ind != 0x80) {	443	if (p->boot_ind != 0 && p->boot_ind != 0x80) {
444	put_dev_sector(sect);	444	put_dev_sector(sect);
445	return 0;	445	return 0;
446	}	446	}
447	}	447	}
448		448
449	#ifdef CONFIG_EFI_PARTITION	449	#ifdef CONFIG_EFI_PARTITION
450	p = (struct partition *) (data + 0x1be);	450	p = (struct partition *) (data + 0x1be);
451	for (slot = 1 ; slot <= 4 ; slot++, p++) {	451	for (slot = 1 ; slot <= 4 ; slot++, p++) {
452	/* If this is an EFI GPT disk, msdos should ignore it. */	452	/* If this is an EFI GPT disk, msdos should ignore it. */
453	if (SYS_IND(p) == EFI_PMBR_OSTYPE_EFI_GPT) {	453	if (SYS_IND(p) == EFI_PMBR_OSTYPE_EFI_GPT) {
454	put_dev_sector(sect);	454	put_dev_sector(sect);
455	return 0;	455	return 0;
456	}	456	}
457	}	457	}
458	#endif	458	#endif
459	p = (struct partition *) (data + 0x1be);	459	p = (struct partition *) (data + 0x1be);
460		460
461	/*	461	/*
462	* Look for partitions in two passes:	462	* Look for partitions in two passes:
463	* First find the primary and DOS-type extended partitions.	463	* First find the primary and DOS-type extended partitions.
464	* On the second pass look inside *BSD, Unixware and Solaris partitions.	464	* On the second pass look inside *BSD, Unixware and Solaris partitions.
465	*/	465	*/
466		466
467	state->next = 5;	467	state->next = 5;
468	for (slot = 1 ; slot <= 4 ; slot++, p++) {	468	for (slot = 1 ; slot <= 4 ; slot++, p++) {
469	u32 start = START_SECT(p)*sector_size;	469	u32 start = START_SECT(p)*sector_size;
470	u32 size = NR_SECTS(p)*sector_size;	470	u32 size = NR_SECTS(p)*sector_size;
471	if (!size)	471	if (!size)
472	continue;	472	continue;
473	if (is_extended_partition(p)) {	473	if (is_extended_partition(p)) {
474	/* prevent someone doing mkfs or mkswap on an	474	/* prevent someone doing mkfs or mkswap on an
475	extended partition, but leave room for LILO */	475	extended partition, but leave room for LILO */
476	put_partition(state, slot, start, size == 1 ? 1 : 2);	476	put_partition(state, slot, start, size == 1 ? 1 : 2);
477	printk(" <");	477	printk(" <");
478	parse_extended(state, bdev, start, size);	478	parse_extended(state, bdev, start, size);
479	printk(" >");	479	printk(" >");
480	continue;	480	continue;
481	}	481	}
482	put_partition(state, slot, start, size);	482	put_partition(state, slot, start, size);
483	if (SYS_IND(p) == LINUX_RAID_PARTITION)	483	if (SYS_IND(p) == LINUX_RAID_PARTITION)
484	state->parts[slot].flags = 1;	484	state->parts[slot].flags = 1;
485	if (SYS_IND(p) == DM6_PARTITION)	485	if (SYS_IND(p) == DM6_PARTITION)
486	printk("[DM]");	486	printk("[DM]");
487	if (SYS_IND(p) == EZD_PARTITION)	487	if (SYS_IND(p) == EZD_PARTITION)
488	printk("[EZD]");	488	printk("[EZD]");
489	}	489	}
490		490
491	printk("\n");	491	printk("\n");
492		492
493	/* second pass - output for each on a separate line */	493	/* second pass - output for each on a separate line */
494	p = (struct partition *) (0x1be + data);	494	p = (struct partition *) (0x1be + data);
495	for (slot = 1 ; slot <= 4 ; slot++, p++) {	495	for (slot = 1 ; slot <= 4 ; slot++, p++) {
496	unsigned char id = SYS_IND(p);	496	unsigned char id = SYS_IND(p);
497	int n;	497	int n;
498		498
499	if (!NR_SECTS(p))	499	if (!NR_SECTS(p))
500	continue;	500	continue;
501		501
502	for (n = 0; subtypes[n].parse && id != subtypes[n].id; n++)	502	for (n = 0; subtypes[n].parse && id != subtypes[n].id; n++)
503	;	503	;
504		504
505	if (!subtypes[n].parse)	505	if (!subtypes[n].parse)
506	continue;	506	continue;
507	subtypes[n].parse(state, bdev, START_SECT(p)*sector_size,	507	subtypes[n].parse(state, bdev, START_SECT(p)*sector_size,
508	NR_SECTS(p)*sector_size, slot);	508	NR_SECTS(p)*sector_size, slot);
509	}	509	}
510	put_dev_sector(sect);	510	put_dev_sector(sect);
511	return 1;	511	return 1;
512	}	512	}
513		513

fs/partitions/sgi.c

Diff comments View file @ c827ba4

1	/*	1	/*
2	* fs/partitions/sgi.c	2	* fs/partitions/sgi.c
3	*	3	*
4	* Code extracted from drivers/block/genhd.c	4	* Code extracted from drivers/block/genhd.c
5	*/	5	*/
6		6
7	#include "check.h"	7	#include "check.h"
8	#include "sgi.h"	8	#include "sgi.h"
9		9
10	struct sgi_disklabel {	10	struct sgi_disklabel {
11	__be32 magic_mushroom; /* Big fat spliff... */	11	__be32 magic_mushroom; /* Big fat spliff... */
12	__be16 root_part_num; /* Root partition number */	12	__be16 root_part_num; /* Root partition number */
13	__be16 swap_part_num; /* Swap partition number */	13	__be16 swap_part_num; /* Swap partition number */
14	s8 boot_file[16]; /* Name of boot file for ARCS */	14	s8 boot_file[16]; /* Name of boot file for ARCS */
15	u8 _unused0[48]; /* Device parameter useless crapola.. */	15	u8 _unused0[48]; /* Device parameter useless crapola.. */
16	struct sgi_volume {	16	struct sgi_volume {
17	s8 name[8]; /* Name of volume */	17	s8 name[8]; /* Name of volume */
18	__be32 block_num; /* Logical block number */	18	__be32 block_num; /* Logical block number */
19	__be32 num_bytes; /* How big, in bytes */	19	__be32 num_bytes; /* How big, in bytes */
20	} volume[15];	20	} volume[15];
21	struct sgi_partition {	21	struct sgi_partition {
22	__be32 num_blocks; /* Size in logical blocks */	22	__be32 num_blocks; /* Size in logical blocks */
23	__be32 first_block; /* First logical block */	23	__be32 first_block; /* First logical block */
24	__be32 type; /* Type of this partition */	24	__be32 type; /* Type of this partition */
25	} partitions[16];	25	} partitions[16];
26	__be32 csum; /* Disk label checksum */	26	__be32 csum; /* Disk label checksum */
27	__be32 _unused1; /* Padding */	27	__be32 _unused1; /* Padding */
28	};	28	};
29		29
30	int sgi_partition(struct parsed_partitions state, struct block_device bdev)	30	int sgi_partition(struct parsed_partitions state, struct block_device bdev)
31	{	31	{
32	int i, csum;	32	int i, csum;
33	__be32 magic;	33	__be32 magic;
34	int slot = 1;	34	int slot = 1;
35	unsigned int start, blocks;	35	unsigned int start, blocks;
36	__be32 *ui, cs;	36	__be32 *ui, cs;
37	Sector sect;	37	Sector sect;
38	struct sgi_disklabel *label;	38	struct sgi_disklabel *label;
39	struct sgi_partition *p;	39	struct sgi_partition *p;
40	char b[BDEVNAME_SIZE];	40	char b[BDEVNAME_SIZE];
41		41
42	label = (struct sgi_disklabel *) read_dev_sector(bdev, 0, &sect);	42	label = (struct sgi_disklabel *) read_dev_sector(bdev, 0, &sect);
43	if (!label)	43	if (!label)
44	return -1;	44	return -1;
45	p = &label->partitions[0];	45	p = &label->partitions[0];
46	magic = label->magic_mushroom;	46	magic = label->magic_mushroom;
47	if(be32_to_cpu(magic) != SGI_LABEL_MAGIC) {	47	if(be32_to_cpu(magic) != SGI_LABEL_MAGIC) {
48	/*printk("Dev %s SGI disklabel: bad magic %08x\n",	48	/*printk("Dev %s SGI disklabel: bad magic %08x\n",
49	bdevname(bdev, b), be32_to_cpu(magic));*/	49	bdevname(bdev, b), be32_to_cpu(magic));*/
50	put_dev_sector(sect);	50	put_dev_sector(sect);
51	return 0;	51	return 0;
52	}	52	}
53	ui = ((__be32 *) (label + 1)) - 1;	53	ui = ((__be32 *) (label + 1)) - 1;
54	for(csum = 0; ui >= ((__be32 *) label);) {	54	for(csum = 0; ui >= ((__be32 *) label);) {
55	cs = *ui--;	55	cs = *ui--;
56	csum += be32_to_cpu(cs);	56	csum += be32_to_cpu(cs);
57	}	57	}
58	if(csum) {	58	if(csum) {
59	printk(KERN_WARNING "Dev %s SGI disklabel: csum bad, label corrupted\n",	59	printk(KERN_WARNING "Dev %s SGI disklabel: csum bad, label corrupted\n",
60	bdevname(bdev, b));	60	bdevname(bdev, b));
61	put_dev_sector(sect);	61	put_dev_sector(sect);
62	return 0;	62	return 0;
63	}	63	}
64	/* All SGI disk labels have 16 partitions, disks under Linux only	64	/* All SGI disk labels have 16 partitions, disks under Linux only
65	* have 15 minor's. Luckily there are always a few zero length	65	* have 15 minor's. Luckily there are always a few zero length
66	* partitions which we don't care about so we never overflow the	66	* partitions which we don't care about so we never overflow the
67	* current_minor.	67	* current_minor.
68	*/	68	*/
69	for(i = 0; i < 16; i++, p++) {	69	for(i = 0; i < 16; i++, p++) {
70	blocks = be32_to_cpu(p->num_blocks);	70	blocks = be32_to_cpu(p->num_blocks);
71	start = be32_to_cpu(p->first_block);	71	start = be32_to_cpu(p->first_block);
72	if (blocks) {	72	if (blocks) {
73	put_partition(state, slot, start, blocks);	73	put_partition(state, slot, start, blocks);
74	if (be32_to_cpu(p->type) == LINUX_RAID_PARTITION)	74	if (be32_to_cpu(p->type) == LINUX_RAID_PARTITION)
75	state->parts[slot].flags = 1;	75	state->parts[slot].flags = ADDPART_FLAG_RAID;
76	}	76	}
77	slot++;	77	slot++;
78	}	78	}
79	printk("\n");	79	printk("\n");
80	put_dev_sector(sect);	80	put_dev_sector(sect);
81	return 1;	81	return 1;
82	}	82	}
83		83

fs/partitions/sun.c

Diff comments View file @ c827ba4

 /*
  *  fs/partitions/sun.c
  *
  *  Code extracted from drivers/block/genhd.c
  *
  *  Copyright (C) 1991-1998  Linus Torvalds
  *  Re-organised Feb 1998 Russell King
  */
 #include "check.h"
 #include "sun.h"
 int sun_partition(struct parsed_partitions *state, struct block_device *bdev)
 {
 	int i;
 	__be16 csum;
 	int slot = 1;
 	__be16 *ush;
 	Sector sect;
 	struct sun_disklabel {
 		unsigned char info[128];   /* Informative text string */
 		unsigned char spare0[14];
 		struct sun_info {
 			unsigned char spare1;
 			unsigned char id;
 			unsigned char spare2;
 			unsigned char flags;
 		} infos[8];
 		unsigned char spare[246];  /* Boot information etc. */
 		__be16 rspeed;     /* Disk rotational speed */
 		__be16 pcylcount;  /* Physical cylinder count */
 		__be16 sparecyl;   /* extra sects per cylinder */
 		unsigned char spare2[4];   /* More magic... */
 		__be16 ilfact;     /* Interleave factor */
 		__be16 ncyl;       /* Data cylinder count */
 		__be16 nacyl;      /* Alt. cylinder count */
 		__be16 ntrks;      /* Tracks per cylinder */
 		__be16 nsect;      /* Sectors per track */
 		unsigned char spare3[4];   /* Even more magic... */
 		struct sun_partition {
 			__be32 start_cylinder;
 			__be32 num_sectors;
 		} partitions[8];
 		__be16 magic;      /* Magic number */
 		__be16 csum;       /* Label xor'd checksum */
 	} * label;
 	struct sun_partition *p;
 	unsigned long spc;
 	char b[BDEVNAME_SIZE];
 	label = (struct sun_disklabel *)read_dev_sector(bdev, 0, &sect);
 	if (!label)
 		return -1;
 	p = label->partitions;
 	if (be16_to_cpu(label->magic) != SUN_LABEL_MAGIC) {
 /*		printk(KERN_INFO "Dev %s Sun disklabel: bad magic %04x\n",
 		       bdevname(bdev, b), be16_to_cpu(label->magic)); */
 		put_dev_sector(sect);
 		return 0;
 	}
 	/* Look at the checksum */
 	ush = ((__be16 *) (label+1)) - 1;
 	for (csum = 0; ush >= ((__be16 *) label);)
 		csum ^= *ush--;
 	if (csum) {
 		printk("Dev %s Sun disklabel: Csum bad, label corrupted\n",
 		       bdevname(bdev, b));
 		put_dev_sector(sect);
 		return 0;
 	}
 	/* All Sun disks have 8 partition entries */
 	spc = be16_to_cpu(label->ntrks) * be16_to_cpu(label->nsect);
 	for (i = 0; i < 8; i++, p++) {
 		unsigned long st_sector;
 		unsigned int num_sectors;
 		st_sector = be32_to_cpu(p->start_cylinder) * spc;
 		num_sectors = be32_to_cpu(p->num_sectors);
 		if (num_sectors) {
 			put_partition(state, slot, st_sector, num_sectors);
+			state->parts[slot].flags = 0;
 			if (label->infos[i].id == LINUX_RAID_PARTITION)
-				state->parts[slot].flags = 1;
+				state->parts[slot].flags |= ADDPART_FLAG_RAID;
+			if (label->infos[i].id == SUN_WHOLE_DISK)
+				state->parts[slot].flags |= ADDPART_FLAG_WHOLEDISK;
 		}
 		slot++;
 	}
 	printk("\n");
 	put_dev_sector(sect);
 	return 1;
 }

include/asm-sparc64/irq.h

Diff comments View file @ c827ba4

 /* $Id: irq.h,v 1.21 2002/01/23 11:27:36 davem Exp $
  * irq.h: IRQ registers on the 64-bit Sparc.
  *
  * Copyright (C) 1996 David S. Miller (davem@caip.rutgers.edu)
  * Copyright (C) 1998 Jakub Jelinek (jj@ultra.linux.cz)
  */
 #ifndef _SPARC64_IRQ_H
 #define _SPARC64_IRQ_H
 #include <linux/linkage.h>
 #include <linux/kernel.h>
 #include <linux/errno.h>
 #include <linux/interrupt.h>
 #include <asm/pil.h>
 #include <asm/ptrace.h>
 /* IMAP/ICLR register defines */
 #define IMAP_VALID		0x80000000	/* IRQ Enabled		*/
 #define IMAP_TID_UPA		0x7c000000	/* UPA TargetID		*/
 #define IMAP_TID_JBUS		0x7c000000	/* JBUS TargetID	*/
 #define IMAP_TID_SHIFT		26
 #define IMAP_AID_SAFARI		0x7c000000	/* Safari AgentID	*/
 #define IMAP_AID_SHIFT		26
 #define IMAP_NID_SAFARI		0x03e00000	/* Safari NodeID	*/
 #define IMAP_NID_SHIFT		21
 #define IMAP_IGN		0x000007c0	/* IRQ Group Number	*/
 #define IMAP_INO		0x0000003f	/* IRQ Number		*/
 #define IMAP_INR		0x000007ff	/* Full interrupt number*/
 #define ICLR_IDLE		0x00000000	/* Idle state		*/
 #define ICLR_TRANSMIT		0x00000001	/* Transmit state	*/
 #define ICLR_PENDING		0x00000003	/* Pending state	*/
 /* The largest number of unique interrupt sources we support.
  * If this needs to ever be larger than 255, you need to change
  * the type of ino_bucket->virt_irq as appropriate.
  *
  * ino_bucket->virt_irq allocation is made during {sun4v_,}build_irq().
  */
 #define NR_IRQS    255
 extern void irq_install_pre_handler(int virt_irq,
 				    void (*func)(unsigned int, void *, void *),
 				    void *arg1, void *arg2);
 #define irq_canonicalize(irq)	(irq)
 extern unsigned int build_irq(int inofixup, unsigned long iclr, unsigned long imap);
 extern unsigned int sun4v_build_irq(u32 devhandle, unsigned int devino);
+extern unsigned int sun4v_build_msi(u32 devhandle, unsigned int *virt_irq_p,
+				    unsigned int msi_devino_start,
+				    unsigned int msi_devino_end);
+extern void sun4v_destroy_msi(unsigned int virt_irq);
 extern unsigned int sbus_build_irq(void *sbus, unsigned int ino);
 static __inline__ void set_softint(unsigned long bits)
 {
 	__asm__ __volatile__("wr	%0, 0x0, %%set_softint"
 			     : /* No outputs */
 			     : "r" (bits));
 }
 static __inline__ void clear_softint(unsigned long bits)
 {
 	__asm__ __volatile__("wr	%0, 0x0, %%clear_softint"
 			     : /* No outputs */
 			     : "r" (bits));
 }
 static __inline__ unsigned long get_softint(void)
 {
 	unsigned long retval;
 	__asm__ __volatile__("rd	%%softint, %0"
 			     : "=r" (retval));
 	return retval;
 }
 #endif

include/asm-sparc64/pbm.h

Diff comments View file @ c827ba4

 /* $Id: pbm.h,v 1.27 2001/08/12 13:18:23 davem Exp $
  * pbm.h: UltraSparc PCI controller software state.
  *
  * Copyright (C) 1997, 1998, 1999 David S. Miller (davem@redhat.com)
  */
 #ifndef __SPARC64_PBM_H
 #define __SPARC64_PBM_H
 #include <linux/types.h>
 #include <linux/pci.h>
 #include <linux/ioport.h>
 #include <linux/spinlock.h>
+#include <linux/msi.h>
 #include <asm/io.h>
 #include <asm/page.h>
 #include <asm/oplib.h>
 #include <asm/prom.h>
 #include <asm/of_device.h>
 #include <asm/iommu.h>
 /* The abstraction used here is that there are PCI controllers,
  * each with one (Sabre) or two (PSYCHO/SCHIZO) PCI bus modules
  * underneath.  Each PCI bus module uses an IOMMU (shared by both
  * PBMs of a controller, or per-PBM), and if a streaming buffer
  * is present, each PCI bus module has it's own. (ie. the IOMMU
  * might be shared between PBMs, the STC is never shared)
  * Furthermore, each PCI bus module controls it's own autonomous
  * PCI bus.
  */
 struct pci_controller_info;
 /* This contains the software state necessary to drive a PCI
  * controller's IOMMU.
  */
 struct pci_iommu_arena {
 	unsigned long	*map;
 	unsigned int	hint;
 	unsigned int	limit;
 };
 struct pci_iommu {
 	/* This protects the controller's IOMMU and all
 	 * streaming buffers underneath.
 	 */
 	spinlock_t	lock;
 	struct pci_iommu_arena arena;
 	/* IOMMU page table, a linear array of ioptes. */
 	iopte_t		*page_table;		/* The page table itself. */
 	/* Base PCI memory space address where IOMMU mappings
 	 * begin.
 	 */
 	u32		page_table_map_base;
 	/* IOMMU Controller Registers */
 	unsigned long	iommu_control;		/* IOMMU control register */
 	unsigned long	iommu_tsbbase;		/* IOMMU page table base register */
 	unsigned long	iommu_flush;		/* IOMMU page flush register */
 	unsigned long	iommu_ctxflush;		/* IOMMU context flush register */
 	/* This is a register in the PCI controller, which if
 	 * read will have no side-effects but will guarantee
 	 * completion of all previous writes into IOMMU/STC.
 	 */
 	unsigned long	write_complete_reg;
 	/* In order to deal with some buggy third-party PCI bridges that
 	 * do wrong prefetching, we never mark valid mappings as invalid.
 	 * Instead we point them at this dummy page.
 	 */
 	unsigned long	dummy_page;
 	unsigned long	dummy_page_pa;
 	/* CTX allocation. */
 	unsigned long ctx_lowest_free;
 	unsigned long ctx_bitmap[IOMMU_NUM_CTXS / (sizeof(unsigned long) * 8)];
 	/* Here a PCI controller driver describes the areas of
 	 * PCI memory space where DMA to/from physical memory
 	 * are addressed.  Drivers interrogate the PCI layer
 	 * if their device has addressing limitations.  They
 	 * do so via pci_dma_supported, and pass in a mask of
 	 * DMA address bits their device can actually drive.
 	 *
 	 * The test for being usable is:
 	 * 	(device_mask & dma_addr_mask) == dma_addr_mask
 	 */
 	u32 dma_addr_mask;
 };
 extern void pci_iommu_table_init(struct pci_iommu *iommu, int tsbsize, u32 dma_offset, u32 dma_addr_mask);
 /* This describes a PCI bus module's streaming buffer. */
 struct pci_strbuf {
 	int		strbuf_enabled;		/* Present and using it? */
 	/* Streaming Buffer Control Registers */
 	unsigned long	strbuf_control;		/* STC control register */
 	unsigned long	strbuf_pflush;		/* STC page flush register */
 	unsigned long	strbuf_fsync;		/* STC flush synchronization reg */
 	unsigned long	strbuf_ctxflush;	/* STC context flush register */
 	unsigned long	strbuf_ctxmatch_base;	/* STC context flush match reg */
 	unsigned long	strbuf_flushflag_pa;	/* Physical address of flush flag */
 	volatile unsigned long *strbuf_flushflag; /* The flush flag itself */
 	/* And this is the actual flush flag area.
 	 * We allocate extra because the chips require
 	 * a 64-byte aligned area.
 	 */
 	volatile unsigned long	__flushflag_buf[(64 + (64 - 1)) / sizeof(long)];
 };
 #define PCI_STC_FLUSHFLAG_INIT(STC) \
 	(*((STC)->strbuf_flushflag) = 0UL)
 #define PCI_STC_FLUSHFLAG_SET(STC) \
 	(*((STC)->strbuf_flushflag) != 0UL)
 /* There can be quite a few ranges and interrupt maps on a PCI
  * segment.  Thus...
  */
 #define PROM_PCIRNG_MAX		64
 #define PROM_PCIIMAP_MAX	64
 struct pci_pbm_info {
 	/* PCI controller we sit under. */
 	struct pci_controller_info	*parent;
 	/* Physical address base of controller registers. */
 	unsigned long			controller_regs;
 	/* Physical address base of PBM registers. */
 	unsigned long			pbm_regs;
 	/* Physical address of DMA sync register, if any.  */
 	unsigned long			sync_reg;
 	/* Opaque 32-bit system bus Port ID. */
 	u32				portid;
 	/* Opaque 32-bit handle used for hypervisor calls.  */
 	u32				devhandle;
 	/* Chipset version information. */
 	int				chip_type;
 #define PBM_CHIP_TYPE_SABRE		1
 #define PBM_CHIP_TYPE_PSYCHO		2
 #define PBM_CHIP_TYPE_SCHIZO		3
 #define PBM_CHIP_TYPE_SCHIZO_PLUS	4
 #define PBM_CHIP_TYPE_TOMATILLO		5
 	int				chip_version;
 	int				chip_revision;
 	/* Name used for top-level resources. */
 	char				*name;
 	/* OBP specific information. */
 	struct device_node		*prom_node;
 	struct linux_prom_pci_ranges	*pbm_ranges;
 	int				num_pbm_ranges;
 	struct linux_prom_pci_intmap	*pbm_intmap;
 	int				num_pbm_intmap;
 	struct linux_prom_pci_intmask	*pbm_intmask;
 	u64				ino_bitmap;
 	/* PBM I/O and Memory space resources. */
 	struct resource			io_space;
 	struct resource			mem_space;
 	/* Base of PCI Config space, can be per-PBM or shared. */
 	unsigned long			config_space;
 	/* State of 66MHz capabilities on this PBM. */
 	int				is_66mhz_capable;
 	int				all_devs_66mhz;
+#ifdef CONFIG_PCI_MSI
+	/* MSI info.  */
+	u32				msiq_num;
+	u32				msiq_ent_count;
+	u32				msiq_first;
+	u32				msiq_first_devino;
+	u32				msi_num;
+	u32				msi_first;
+	u32				msi_data_mask;
+	u32				msix_data_width;
+	u64				msi32_start;
+	u64				msi64_start;
+	u32				msi32_len;
+	u32				msi64_len;
+	void				*msi_queues;
+	unsigned long			*msi_bitmap;
+#endif /* !(CONFIG_PCI_MSI) */
 	/* This PBM's streaming buffer. */
 	struct pci_strbuf		stc;
 	/* IOMMU state, potentially shared by both PBM segments. */
 	struct pci_iommu		*iommu;
 	/* PCI slot mapping. */
 	unsigned int			pci_first_slot;
 	/* Now things for the actual PCI bus probes. */
 	unsigned int			pci_first_busno;
 	unsigned int			pci_last_busno;
 	struct pci_bus			*pci_bus;
 };
 struct pci_controller_info {
 	/* List of all PCI controllers. */
 	struct pci_controller_info	*next;
 	/* Each controller gets a unique index, used mostly for
 	 * error logging purposes.
 	 */
 	int				index;
 	/* Do the PBMs both exist in the same PCI domain? */
 	int				pbms_same_domain;
 	/* The PCI bus modules controlled by us. */
 	struct pci_pbm_info		pbm_A;
 	struct pci_pbm_info		pbm_B;
 	/* Operations which are controller specific. */
 	void (*scan_bus)(struct pci_controller_info *);
 	void (*base_address_update)(struct pci_dev *, int);
 	void (*resource_adjust)(struct pci_dev *, struct resource *, struct resource *);
+#ifdef CONFIG_PCI_MSI
+	int (*setup_msi_irq)(unsigned int *virt_irq_p, struct pci_dev *pdev,
+			     struct msi_desc *entry);
+	void (*teardown_msi_irq)(unsigned int virt_irq, struct pci_dev *pdev);
+#endif
 	/* Now things for the actual PCI bus probes. */
 	struct pci_ops			*pci_ops;
 	unsigned int			pci_first_busno;
 	unsigned int			pci_last_busno;
 };
 /* PCI devices which are not bridges have this placed in their pci_dev
  * sysdata member.  This makes OBP aware PCI device drivers easier to
  * code.
  */
 struct pcidev_cookie {
 	struct pci_pbm_info		*pbm;
 	struct device_node		*prom_node;
 	struct of_device		*op;
 	struct linux_prom_pci_registers	prom_regs[PROMREG_MAX];
 	int num_prom_regs;
 	struct linux_prom_pci_registers prom_assignments[PROMREG_MAX];
 	int num_prom_assignments;
+#ifdef CONFIG_PCI_MSI
+	unsigned int			msi_num;
+#endif
 };
 /* Currently these are the same across all PCI controllers
  * we support.  Someday they may not be...
  */
 #define PCI_IRQ_IGN	0x000007c0	/* Interrupt Group Number */
 #define PCI_IRQ_INO	0x0000003f	/* Interrupt Number */
 #endif /* !(__SPARC64_PBM_H) */

include/linux/genhd.h

Diff comments View file @ c827ba4

 #ifndef _LINUX_GENHD_H
 #define _LINUX_GENHD_H
 /*
  * 	genhd.h Copyright (C) 1992 Drew Eckhardt
  *	Generic hard disk header file by
  * 		Drew Eckhardt
  *
  *		<drew@colorado.edu>
  */
 #include <linux/types.h>
 #ifdef CONFIG_BLOCK
 enum {
 /* These three have identical behaviour; use the second one if DOS FDISK gets
    confused about extended/logical partitions starting past cylinder 1023. */
 	DOS_EXTENDED_PARTITION = 5,
 	LINUX_EXTENDED_PARTITION = 0x85,
 	WIN98_EXTENDED_PARTITION = 0x0f,
+	SUN_WHOLE_DISK = DOS_EXTENDED_PARTITION,
 	LINUX_SWAP_PARTITION = 0x82,
 	LINUX_DATA_PARTITION = 0x83,
 	LINUX_LVM_PARTITION = 0x8e,
 	LINUX_RAID_PARTITION = 0xfd,	/* autodetect RAID partition */
 	SOLARIS_X86_PARTITION =	LINUX_SWAP_PARTITION,
 	NEW_SOLARIS_X86_PARTITION = 0xbf,
 	DM6_AUX1PARTITION = 0x51,	/* no DDO:  use xlated geom */
 	DM6_AUX3PARTITION = 0x53,	/* no DDO:  use xlated geom */
 	DM6_PARTITION =	0x54,		/* has DDO: use xlated geom & offset */
 	EZD_PARTITION =	0x55,		/* EZ-DRIVE */
 	FREEBSD_PARTITION = 0xa5,	/* FreeBSD Partition ID */
 	OPENBSD_PARTITION = 0xa6,	/* OpenBSD Partition ID */
 	NETBSD_PARTITION = 0xa9,	/* NetBSD Partition ID */
 	BSDI_PARTITION = 0xb7,		/* BSDI Partition ID */
 	MINIX_PARTITION = 0x81,		/* Minix Partition ID */
 	UNIXWARE_PARTITION = 0x63,	/* Same as GNU_HURD and SCO Unix */
 };
 #ifndef __KERNEL__
 struct partition {
 	unsigned char boot_ind;		/* 0x80 - active */
 	unsigned char head;		/* starting head */
 	unsigned char sector;		/* starting sector */
 	unsigned char cyl;		/* starting cylinder */
 	unsigned char sys_ind;		/* What partition type */
 	unsigned char end_head;		/* end head */
 	unsigned char end_sector;	/* end sector */
 	unsigned char end_cyl;		/* end cylinder */
 	unsigned int start_sect;	/* starting sector counting from 0 */
 	unsigned int nr_sects;		/* nr of sectors in partition */
 } __attribute__((packed));
 #endif
 #ifdef __KERNEL__
 #include <linux/major.h>
 #include <linux/device.h>
 #include <linux/smp.h>
 #include <linux/string.h>
 #include <linux/fs.h>
 struct partition {
 	unsigned char boot_ind;		/* 0x80 - active */
 	unsigned char head;		/* starting head */
 	unsigned char sector;		/* starting sector */
 	unsigned char cyl;		/* starting cylinder */
 	unsigned char sys_ind;		/* What partition type */
 	unsigned char end_head;		/* end head */
 	unsigned char end_sector;	/* end sector */
 	unsigned char end_cyl;		/* end cylinder */
 	__le32 start_sect;	/* starting sector counting from 0 */
 	__le32 nr_sects;		/* nr of sectors in partition */
 } __attribute__((packed));
 struct hd_struct {
 	sector_t start_sect;
 	sector_t nr_sects;
 	struct kobject kobj;
 	struct kobject *holder_dir;
 	unsigned ios[2], sectors[2];	/* READs and WRITEs */
 	int policy, partno;
 #ifdef CONFIG_FAIL_MAKE_REQUEST
 	int make_it_fail;
 #endif
 };
 #define GENHD_FL_REMOVABLE			1
 #define GENHD_FL_DRIVERFS			2
 #define GENHD_FL_CD				8
 #define GENHD_FL_UP				16
 #define GENHD_FL_SUPPRESS_PARTITION_INFO	32
 #define GENHD_FL_FAIL				64
 struct disk_stats {
 	unsigned long sectors[2];	/* READs and WRITEs */
 	unsigned long ios[2];
 	unsigned long merges[2];
 	unsigned long ticks[2];
 	unsigned long io_ticks;
 	unsigned long time_in_queue;
 };
 struct gendisk {
 	int major;			/* major number of driver */
 	int first_minor;
 	int minors;                     /* maximum number of minors, =1 for
                                          * disks that can't be partitioned. */
 	char disk_name[32];		/* name of major driver */
 	struct hd_struct **part;	/* [indexed by minor] */
 	int part_uevent_suppress;
 	struct block_device_operations *fops;
 	struct request_queue *queue;
 	void *private_data;
 	sector_t capacity;
 	int flags;
 	struct device *driverfs_dev;
 	struct kobject kobj;
 	struct kobject *holder_dir;
 	struct kobject *slave_dir;
 	struct timer_rand_state *random;
 	int policy;
 	atomic_t sync_io;		/* RAID */
 	unsigned long stamp;
 	int in_flight;
 #ifdef	CONFIG_SMP
 	struct disk_stats *dkstats;
 #else
 	struct disk_stats dkstats;
 #endif
 };
 /* Structure for sysfs attributes on block devices */
 struct disk_attribute {
 	struct attribute attr;
 	ssize_t (*show)(struct gendisk *, char *);
 	ssize_t (*store)(struct gendisk *, const char *, size_t);
 };
 /*
  * Macros to operate on percpu disk statistics:
  *
  * The __ variants should only be called in critical sections. The full
  * variants disable/enable preemption.
  */
 #ifdef	CONFIG_SMP
 #define __disk_stat_add(gendiskp, field, addnd) 	\
 	(per_cpu_ptr(gendiskp->dkstats, smp_processor_id())->field += addnd)
 #define disk_stat_read(gendiskp, field)					\
 ({									\
 	typeof(gendiskp->dkstats->field) res = 0;			\
 	int i;								\
 	for_each_possible_cpu(i)					\
 		res += per_cpu_ptr(gendiskp->dkstats, i)->field;	\
 	res;								\
 })
 static inline void disk_stat_set_all(struct gendisk *gendiskp, int value)	{
 	int i;
 	for_each_possible_cpu(i)
 		memset(per_cpu_ptr(gendiskp->dkstats, i), value,
 				sizeof (struct disk_stats));
 }
 #else
 #define __disk_stat_add(gendiskp, field, addnd) \
 				(gendiskp->dkstats.field += addnd)
 #define disk_stat_read(gendiskp, field)	(gendiskp->dkstats.field)
 static inline void disk_stat_set_all(struct gendisk *gendiskp, int value)	{
 	memset(&gendiskp->dkstats, value, sizeof (struct disk_stats));
 }
 #endif
 #define disk_stat_add(gendiskp, field, addnd)			\
 	do {							\
 		preempt_disable();				\
 		__disk_stat_add(gendiskp, field, addnd);	\
 		preempt_enable();				\
 	} while (0)
 #define __disk_stat_dec(gendiskp, field) __disk_stat_add(gendiskp, field, -1)
 #define disk_stat_dec(gendiskp, field) disk_stat_add(gendiskp, field, -1)
 #define __disk_stat_inc(gendiskp, field) __disk_stat_add(gendiskp, field, 1)
 #define disk_stat_inc(gendiskp, field) disk_stat_add(gendiskp, field, 1)
 #define __disk_stat_sub(gendiskp, field, subnd) \
 		__disk_stat_add(gendiskp, field, -subnd)
 #define disk_stat_sub(gendiskp, field, subnd) \
 		disk_stat_add(gendiskp, field, -subnd)
 /* Inlines to alloc and free disk stats in struct gendisk */
 #ifdef  CONFIG_SMP
 static inline int init_disk_stats(struct gendisk *disk)
 {
 	disk->dkstats = alloc_percpu(struct disk_stats);
 	if (!disk->dkstats)
 		return 0;
 	return 1;
 }
 static inline void free_disk_stats(struct gendisk *disk)
 {
 	free_percpu(disk->dkstats);
 }
 #else	/* CONFIG_SMP */
 static inline int init_disk_stats(struct gendisk *disk)
 {
 	return 1;
 }
 static inline void free_disk_stats(struct gendisk *disk)
 {
 }
 #endif	/* CONFIG_SMP */
 /* drivers/block/ll_rw_blk.c */
 extern void disk_round_stats(struct gendisk *disk);
 /* drivers/block/genhd.c */
 extern int get_blkdev_list(char *, int);
 extern void add_disk(struct gendisk *disk);
 extern void del_gendisk(struct gendisk *gp);
 extern void unlink_gendisk(struct gendisk *gp);
 extern struct gendisk *get_gendisk(dev_t dev, int *part);
 extern void set_device_ro(struct block_device *bdev, int flag);
 extern void set_disk_ro(struct gendisk *disk, int flag);
 /* drivers/char/random.c */
 extern void add_disk_randomness(struct gendisk *disk);
 extern void rand_initialize_disk(struct gendisk *disk);
 static inline sector_t get_start_sect(struct block_device *bdev)
 {
 	return bdev->bd_contains == bdev ? 0 : bdev->bd_part->start_sect;
 }
 static inline sector_t get_capacity(struct gendisk *disk)
 {
 	return disk->capacity;
 }
 static inline void set_capacity(struct gendisk *disk, sector_t size)
 {
 	disk->capacity = size;
 }
 #endif  /*  __KERNEL__  */
 #ifdef CONFIG_SOLARIS_X86_PARTITION
 #define SOLARIS_X86_NUMSLICE	8
 #define SOLARIS_X86_VTOC_SANE	(0x600DDEEEUL)
 struct solaris_x86_slice {
 	__le16 s_tag;		/* ID tag of partition */
 	__le16 s_flag;		/* permission flags */
 	__le32 s_start;		/* start sector no of partition */
 	__le32 s_size;		/* # of blocks in partition */
 };
 struct solaris_x86_vtoc {
 	unsigned int v_bootinfo[3];	/* info needed by mboot (unsupported) */
 	__le32 v_sanity;		/* to verify vtoc sanity */
 	__le32 v_version;		/* layout version */
 	char	v_volume[8];		/* volume name */
 	__le16	v_sectorsz;		/* sector size in bytes */
 	__le16	v_nparts;		/* number of partitions */
 	unsigned int v_reserved[10];	/* free space */
 	struct solaris_x86_slice
 		v_slice[SOLARIS_X86_NUMSLICE]; /* slice headers */
 	unsigned int timestamp[SOLARIS_X86_NUMSLICE]; /* timestamp (unsupported) */
 	char	v_asciilabel[128];	/* for compatibility */
 };
 #endif /* CONFIG_SOLARIS_X86_PARTITION */
 #ifdef CONFIG_BSD_DISKLABEL
 /*
  * BSD disklabel support by Yossi Gottlieb <yogo@math.tau.ac.il>
  * updated by Marc Espie <Marc.Espie@openbsd.org>
  */
 /* check against BSD src/sys/sys/disklabel.h for consistency */
 #define BSD_DISKMAGIC	(0x82564557UL)	/* The disk magic number */
 #define BSD_MAXPARTITIONS	16
 #define OPENBSD_MAXPARTITIONS	16
 #define BSD_FS_UNUSED		0	/* disklabel unused partition entry ID */
 struct bsd_disklabel {
 	__le32	d_magic;		/* the magic number */
 	__s16	d_type;			/* drive type */
 	__s16	d_subtype;		/* controller/d_type specific */
 	char	d_typename[16];		/* type name, e.g. "eagle" */
 	char	d_packname[16];			/* pack identifier */
 	__u32	d_secsize;		/* # of bytes per sector */
 	__u32	d_nsectors;		/* # of data sectors per track */
 	__u32	d_ntracks;		/* # of tracks per cylinder */
 	__u32	d_ncylinders;		/* # of data cylinders per unit */
 	__u32	d_secpercyl;		/* # of data sectors per cylinder */
 	__u32	d_secperunit;		/* # of data sectors per unit */
 	__u16	d_sparespertrack;	/* # of spare sectors per track */
 	__u16	d_sparespercyl;		/* # of spare sectors per cylinder */
 	__u32	d_acylinders;		/* # of alt. cylinders per unit */
 	__u16	d_rpm;			/* rotational speed */
 	__u16	d_interleave;		/* hardware sector interleave */
 	__u16	d_trackskew;		/* sector 0 skew, per track */
 	__u16	d_cylskew;		/* sector 0 skew, per cylinder */
 	__u32	d_headswitch;		/* head switch time, usec */
 	__u32	d_trkseek;		/* track-to-track seek, usec */
 	__u32	d_flags;		/* generic flags */
 #define NDDATA 5
 	__u32	d_drivedata[NDDATA];	/* drive-type specific information */
 #define NSPARE 5
 	__u32	d_spare[NSPARE];	/* reserved for future use */
 	__le32	d_magic2;		/* the magic number (again) */
 	__le16	d_checksum;		/* xor of data incl. partitions */
 			/* filesystem and partition information: */
 	__le16	d_npartitions;		/* number of partitions in following */
 	__le32	d_bbsize;		/* size of boot area at sn0, bytes */
 	__le32	d_sbsize;		/* max size of fs superblock, bytes */
 	struct	bsd_partition {		/* the partition table */
 		__le32	p_size;		/* number of sectors in partition */
 		__le32	p_offset;	/* starting sector */
 		__le32	p_fsize;	/* filesystem basic fragment size */
 		__u8	p_fstype;	/* filesystem type, see below */
 		__u8	p_frag;		/* filesystem fragments per block */
 		__le16	p_cpg;		/* filesystem cylinders per group */
 	} d_partitions[BSD_MAXPARTITIONS];	/* actually may be more */
 };
 #endif	/* CONFIG_BSD_DISKLABEL */
 #ifdef CONFIG_UNIXWARE_DISKLABEL
 /*
  * Unixware slices support by Andrzej Krzysztofowicz <ankry@mif.pg.gda.pl>
  * and Krzysztof G. Baranowski <kgb@knm.org.pl>
  */
 #define UNIXWARE_DISKMAGIC     (0xCA5E600DUL)	/* The disk magic number */
 #define UNIXWARE_DISKMAGIC2    (0x600DDEEEUL)	/* The slice table magic nr */
 #define UNIXWARE_NUMSLICE      16
 #define UNIXWARE_FS_UNUSED     0		/* Unused slice entry ID */
 struct unixware_slice {
 	__le16   s_label;	/* label */
 	__le16   s_flags;	/* permission flags */
 	__le32   start_sect;	/* starting sector */
 	__le32   nr_sects;	/* number of sectors in slice */
 };
 struct unixware_disklabel {
 	__le32   d_type;               	/* drive type */
 	__le32   d_magic;                /* the magic number */
 	__le32   d_version;              /* version number */
 	char    d_serial[12];           /* serial number of the device */
 	__le32   d_ncylinders;           /* # of data cylinders per device */
 	__le32   d_ntracks;              /* # of tracks per cylinder */
 	__le32   d_nsectors;             /* # of data sectors per track */
 	__le32   d_secsize;              /* # of bytes per sector */
 	__le32   d_part_start;           /* # of first sector of this partition */
 	__le32   d_unknown1[12];         /* ? */
  	__le32	d_alt_tbl;              /* byte offset of alternate table */
  	__le32	d_alt_len;              /* byte length of alternate table */
  	__le32	d_phys_cyl;             /* # of physical cylinders per device */
  	__le32	d_phys_trk;             /* # of physical tracks per cylinder */
  	__le32	d_phys_sec;             /* # of physical sectors per track */
  	__le32	d_phys_bytes;           /* # of physical bytes per sector */
  	__le32	d_unknown2;             /* ? */
 	__le32   d_unknown3;             /* ? */
 	__le32	d_pad[8];               /* pad */
 	struct unixware_vtoc {
 		__le32	v_magic;		/* the magic number */
 		__le32	v_version;		/* version number */
 		char	v_name[8];		/* volume name */
 		__le16	v_nslices;		/* # of slices */
 		__le16	v_unknown1;		/* ? */
 		__le32	v_reserved[10];		/* reserved */
 		struct unixware_slice
 			v_slice[UNIXWARE_NUMSLICE];	/* slice headers */
 	} vtoc;
 };  /* 408 */
 #endif /* CONFIG_UNIXWARE_DISKLABEL */
 #ifdef CONFIG_MINIX_SUBPARTITION
 #   define MINIX_NR_SUBPARTITIONS  4
 #endif /* CONFIG_MINIX_SUBPARTITION */
 #ifdef __KERNEL__
+#define ADDPART_FLAG_NONE	0
+#define ADDPART_FLAG_RAID	1
+#define ADDPART_FLAG_WHOLEDISK	2
 char *disk_name (struct gendisk *hd, int part, char *buf);
 extern int rescan_partitions(struct gendisk *disk, struct block_device *bdev);
-extern void add_partition(struct gendisk *, int, sector_t, sector_t);
+extern void add_partition(struct gendisk *, int, sector_t, sector_t, int);
 extern void delete_partition(struct gendisk *, int);
 extern struct gendisk *alloc_disk_node(int minors, int node_id);
 extern struct gendisk *alloc_disk(int minors);
 extern struct kobject *get_disk(struct gendisk *disk);
 extern void put_disk(struct gendisk *disk);
 extern void blk_register_region(dev_t dev, unsigned long range,
 			struct module *module,
 			struct kobject *(*probe)(dev_t, int *, void *),
 			int (*lock)(dev_t, void *),
 			void *data);
 extern void blk_unregister_region(dev_t dev, unsigned long range);
 static inline struct block_device *bdget_disk(struct gendisk *disk, int index)
 {
 	return bdget(MKDEV(disk->major, disk->first_minor) + index);
 }
 #endif
 #endif
 #endif

1	#	1	#
2	# PCI configuration	2	# PCI configuration
3	#	3	#
4	config PCI_MSI	4	config PCI_MSI
5	bool "Message Signaled Interrupts (MSI and MSI-X)"	5	bool "Message Signaled Interrupts (MSI and MSI-X)"
6	depends on PCI	6	depends on PCI
7	depends on (X86_LOCAL_APIC && X86_IO_APIC) \|\| IA64	7	depends on (X86_LOCAL_APIC && X86_IO_APIC) \|\| IA64 \|\| SPARC64
8	help	8	help
9	This allows device drivers to enable MSI (Message Signaled	9	This allows device drivers to enable MSI (Message Signaled
10	Interrupts). Message Signaled Interrupts enable a device to	10	Interrupts). Message Signaled Interrupts enable a device to
11	generate an interrupt using an inbound Memory Write on its	11	generate an interrupt using an inbound Memory Write on its
12	PCI bus instead of asserting a device IRQ pin.	12	PCI bus instead of asserting a device IRQ pin.
13		13
14	Use of PCI MSI interrupts can be disabled at kernel boot time	14	Use of PCI MSI interrupts can be disabled at kernel boot time
15	by using the 'pci=nomsi' option. This disables MSI for the	15	by using the 'pci=nomsi' option. This disables MSI for the
16	entire system.	16	entire system.
17		17
18	If you don't know what to do here, say N.	18	If you don't know what to do here, say N.
19		19
20	config PCI_MULTITHREAD_PROBE	20	config PCI_MULTITHREAD_PROBE
21	bool "PCI Multi-threaded probe (EXPERIMENTAL)"	21	bool "PCI Multi-threaded probe (EXPERIMENTAL)"
22	depends on PCI && EXPERIMENTAL && BROKEN	22	depends on PCI && EXPERIMENTAL && BROKEN
23	help	23	help
24	Say Y here if you want the PCI core to spawn a new thread for	24	Say Y here if you want the PCI core to spawn a new thread for
25	every PCI device that is probed. This can cause a huge	25	every PCI device that is probed. This can cause a huge
26	speedup in boot times on multiprocessor machines, and even a	26	speedup in boot times on multiprocessor machines, and even a
27	smaller speedup on single processor machines.	27	smaller speedup on single processor machines.
28		28
29	But it can also cause lots of bad things to happen. A number	29	But it can also cause lots of bad things to happen. A number
30	of PCI drivers cannot properly handle running in this way,	30	of PCI drivers cannot properly handle running in this way,
31	some will just not work properly at all, while others might	31	some will just not work properly at all, while others might
32	decide to blow up power supplies with a huge load all at once,	32	decide to blow up power supplies with a huge load all at once,
33	so use this option at your own risk.	33	so use this option at your own risk.
34		34
35	It is very unwise to use this option if you are not using a	35	It is very unwise to use this option if you are not using a
36	boot process that can handle devices being created in any	36	boot process that can handle devices being created in any
37	order. A program that can create persistent block and network	37	order. A program that can create persistent block and network
38	device names (like udev) is a good idea if you wish to use	38	device names (like udev) is a good idea if you wish to use
39	this option.	39	this option.
40		40
41	Again, use this option at your own risk, you have been warned!	41	Again, use this option at your own risk, you have been warned!
42		42
43	When in doubt, say N.	43	When in doubt, say N.
44		44
45	config PCI_DEBUG	45	config PCI_DEBUG
46	bool "PCI Debugging"	46	bool "PCI Debugging"
47	depends on PCI && DEBUG_KERNEL	47	depends on PCI && DEBUG_KERNEL
48	help	48	help
49	Say Y here if you want the PCI core to produce a bunch of debug	49	Say Y here if you want the PCI core to produce a bunch of debug
50	messages to the system log. Select this if you are having a	50	messages to the system log. Select this if you are having a
51	problem with PCI support and want to see more of what is going on.	51	problem with PCI support and want to see more of what is going on.
52		52
53	When in doubt, say N.	53	When in doubt, say N.
54		54
55	config HT_IRQ	55	config HT_IRQ
56	bool "Interrupts on hypertransport devices"	56	bool "Interrupts on hypertransport devices"
57	default y	57	default y
58	depends on PCI && X86_LOCAL_APIC && X86_IO_APIC	58	depends on PCI && X86_LOCAL_APIC && X86_IO_APIC
59	help	59	help
60	This allows native hypertransport devices to use interrupts.	60	This allows native hypertransport devices to use interrupts.
61		61
62	If unsure say Y.	62	If unsure say Y.
63		63