Merge master.kernel.org:/pub/scm/linux/kernel/git/gregkh/w1-2.6
authorLinus Torvalds <torvalds@g5.osdl.org>
Thu, 8 Sep 2005 22:55:53 +0000 (15:55 -0700)
committerLinus Torvalds <torvalds@g5.osdl.org>
Thu, 8 Sep 2005 22:55:53 +0000 (15:55 -0700)
158 files changed:
Documentation/feature-removal-schedule.txt
MAINTAINERS
arch/alpha/kernel/sys_marvel.c
arch/arm/common/locomo.c
arch/arm/configs/s3c2410_defconfig
arch/arm/mach-clps7500/core.c
arch/arm/mach-ebsa110/core.c
arch/arm/mach-epxa10db/arch.c
arch/arm/mach-footbridge/isa.c
arch/arm/mach-h720x/cpu-h7202.c
arch/arm/mach-ixp2000/core.c
arch/arm/mach-ixp4xx/coyote-setup.c
arch/arm/mach-ixp4xx/gtwx5715-setup.c
arch/arm/mach-ixp4xx/ixdp425-setup.c
arch/arm/mach-omap1/Kconfig
arch/arm/mach-omap1/Makefile
arch/arm/mach-omap1/board-generic.c
arch/arm/mach-omap1/board-h2.c
arch/arm/mach-omap1/board-h3.c
arch/arm/mach-omap1/board-innovator.c
arch/arm/mach-omap1/board-netstar.c
arch/arm/mach-omap1/board-osk.c
arch/arm/mach-omap1/board-perseus2.c
arch/arm/mach-omap1/board-voiceblue.c
arch/arm/mach-omap1/devices.c [new file with mode: 0644]
arch/arm/mach-omap1/fpga.c
arch/arm/mach-omap1/io.c
arch/arm/mach-omap1/irq.c
arch/arm/mach-omap1/leds-h2p2-debug.c
arch/arm/mach-omap1/leds-innovator.c
arch/arm/mach-omap1/leds-osk.c
arch/arm/mach-omap1/leds.c
arch/arm/mach-omap1/serial.c
arch/arm/mach-omap1/time.c
arch/arm/mach-rpc/riscpc.c
arch/arm/mach-s3c2410/mach-bast.c
arch/arm/mach-s3c2410/mach-vr1000.c
arch/arm/mach-shark/core.c
arch/arm/mm/flush.c
arch/i386/pci/i386.c
arch/ppc/kernel/pci.c
arch/ppc/syslib/mpc10x_common.c
arch/ppc/syslib/mpc83xx_devices.c
arch/ppc/syslib/mpc85xx_devices.c
arch/ppc64/kernel/eeh.c
arch/ppc64/kernel/iSeries_VpdInfo.c
arch/ppc64/kernel/pci.c
arch/ppc64/kernel/setup.c
arch/sparc64/kernel/pci.c
arch/sparc64/kernel/pci_psycho.c
arch/sparc64/kernel/pci_sabre.c
arch/sparc64/kernel/pci_schizo.c
arch/sparc64/kernel/sparc64_ksyms.c
arch/sparc64/lib/Makefile
arch/sparc64/lib/mb.S [deleted file]
drivers/char/drm/drmP.h
drivers/i2c/busses/Kconfig
drivers/i2c/busses/Makefile
drivers/i2c/busses/i2c-pxa.c [new file with mode: 0644]
drivers/infiniband/hw/mthca/mthca_main.c
drivers/infiniband/hw/mthca/mthca_reset.c
drivers/mmc/mmc.c
drivers/mmc/mmci.c
drivers/mmc/pxamci.c
drivers/mmc/wbsd.c
drivers/net/bnx2.c
drivers/net/bnx2.h
drivers/net/irda/vlsi_ir.h
drivers/parport/parport_pc.c
drivers/pci/Kconfig
drivers/pci/Makefile
drivers/pci/bus.c
drivers/pci/gen-devlist.c [deleted file]
drivers/pci/hotplug/Makefile
drivers/pci/hotplug/pciehp.h
drivers/pci/hotplug/rpadlpar_core.c
drivers/pci/hotplug/rpaphp.h
drivers/pci/hotplug/rpaphp_core.c
drivers/pci/hotplug/rpaphp_pci.c
drivers/pci/hotplug/rpaphp_slot.c
drivers/pci/hotplug/rpaphp_vio.c [deleted file]
drivers/pci/hotplug/sgi_hotplug.c
drivers/pci/hotplug/shpchp.h
drivers/pci/msi.c
drivers/pci/names.c [deleted file]
drivers/pci/pci-driver.c
drivers/pci/pci.c
drivers/pci/pci.ids [deleted file]
drivers/pci/pcie/portdrv_pci.c
drivers/pci/probe.c
drivers/pci/proc.c
drivers/pci/quirks.c
drivers/pci/setup-res.c
drivers/scsi/ahci.c
drivers/scsi/ata_piix.c
drivers/scsi/sata_sis.c
drivers/scsi/sata_uli.c
drivers/serial/8250.c
drivers/serial/8250_accent.c
drivers/serial/8250_boca.c
drivers/serial/8250_fourport.c
drivers/serial/8250_hub6.c
drivers/serial/8250_mca.c
drivers/usb/core/hcd-pci.c
drivers/usb/host/ehci-hcd.c
drivers/video/nvidia/nvidia.c
drivers/video/riva/fbdev.c
include/asm-alpha/pci.h
include/asm-arm/arch-pxa/hardware.h
include/asm-arm/arch-pxa/i2c.h [new file with mode: 0644]
include/asm-arm/arch-pxa/mmc.h
include/asm-arm/arch-sa1100/hardware.h
include/asm-arm/cacheflush.h
include/asm-arm/pci.h
include/asm-generic/pci.h
include/asm-ia64/pci.h
include/asm-parisc/pci.h
include/asm-ppc/pci.h
include/asm-ppc64/pci.h
include/asm-sparc64/pci.h
include/asm-sparc64/system.h
include/linux/i2c-pxa.h [new file with mode: 0644]
include/linux/in6.h
include/linux/ipv6.h
include/linux/mempolicy.h
include/linux/mmc/host.h
include/linux/pci.h
include/linux/pci_regs.h [new file with mode: 0644]
include/linux/serial_8250.h
include/linux/serial_core.h
include/linux/skbuff.h
include/net/ax25.h
include/net/compat.h
include/net/ipv6.h
include/net/transp_v6.h
mm/mempolicy.c
net/ax25/ax25_addr.c
net/ieee80211/Kconfig
net/ipv4/netfilter/ip_conntrack_netbios_ns.c
net/ipv4/netfilter/ipt_REJECT.c
net/ipv4/route.c
net/ipv4/tcp_output.c
net/ipv4/udp.c
net/ipv6/datagram.c
net/ipv6/exthdrs.c
net/ipv6/icmp.c
net/ipv6/ip6_flowlabel.c
net/ipv6/ip6_output.c
net/ipv6/ip6_tunnel.c
net/ipv6/ipv6_sockglue.c
net/ipv6/ndisc.c
net/ipv6/netfilter/ip6t_REJECT.c
net/ipv6/raw.c
net/ipv6/reassembly.c
net/ipv6/tcp_ipv6.c
net/ipv6/udp.c
net/rose/rose_subr.c
net/xfrm/xfrm_policy.c

index 2e0a01b21fe040503243c963a65f8411e795961b..5f95d4b3cab1a4f6625f65431a720703e1ce2a05 100644 (file)
@@ -25,15 +25,6 @@ Who: Pavel Machek <pavel@suse.cz>
 
 ---------------------------
 
-What:  PCI Name Database (CONFIG_PCI_NAMES)
-When:  July 2005
-Why:   It bloats the kernel unnecessarily, and is handled by userspace better
-       (pciutils supports it.)  Will eliminate the need to try to keep the
-       pci.ids file in sync with the sf.net database all of the time.
-Who:   Greg Kroah-Hartman <gregkh@suse.de>
-
----------------------------
-
 What:  io_remap_page_range() (macro or function)
 When:  September 2005
 Why:   Replaced by io_remap_pfn_range() which allows more memory space
index 8e4e829210708b741327b1f3aeefd032bdd3dd6c..cb389067cf66959b9c9516676c03056253cdcb3d 100644 (file)
@@ -1813,13 +1813,6 @@ M:       hch@infradead.org
 L:     linux-abi-devel@lists.sourceforge.net
 S:     Maintained
 
-PCI ID DATABASE
-P:     Martin Mares
-M:     mj@ucw.cz
-L:     pciids-devel@lists.sourceforge.net
-W:     http://pciids.sourceforge.net/
-S:     Maintained
-
 PCI SOUND DRIVERS (ES1370, ES1371 and SONICVIBES)
 P:     Thomas Sailer
 M:     sailer@ife.ee.ethz.ch
index 804727853d2576dcd05f35120fbe3db3573f2335..e32fee50522076c7cfaf685d80690e2c0846c135 100644 (file)
@@ -373,12 +373,11 @@ marvel_map_irq(struct pci_dev *dev, u8 slot, u8 pin)
                irq += 0x80;                    /* offset for lsi       */
 
 #if 1
-               printk("PCI:%d:%d:%d (hose %d) [%s] is using MSI\n",
+               printk("PCI:%d:%d:%d (hose %d) is using MSI\n",
                       dev->bus->number, 
                       PCI_SLOT(dev->devfn), 
                       PCI_FUNC(dev->devfn),
-                      hose->index,
-                      pci_pretty_name (dev));
+                      hose->index);
                printk("  %d message(s) from 0x%04x\n", 
                       1 << ((msg_ctl & PCI_MSI_FLAGS_QSIZE) >> 4),
                       msg_dat);
index 51f430cc2fbf5b7a08bcfed5bc6dee1e97fb1435..2786f7c34b3fc9e7627d613a00e63e9aaf40681d 100644 (file)
@@ -541,6 +541,103 @@ locomo_init_one_child(struct locomo *lchip, struct locomo_dev_info *info)
        return ret;
 }
 
+#ifdef CONFIG_PM
+
+struct locomo_save_data {
+       u16     LCM_GPO;
+       u16     LCM_SPICT;
+       u16     LCM_GPE;
+       u16     LCM_ASD;
+       u16     LCM_SPIMD;
+};
+
+static int locomo_suspend(struct device *dev, u32 pm_message_t, u32 level)
+{
+       struct locomo *lchip = dev_get_drvdata(dev);
+       struct locomo_save_data *save;
+       unsigned long flags;
+
+       if (level != SUSPEND_DISABLE)
+               return 0;
+
+       save = kmalloc(sizeof(struct locomo_save_data), GFP_KERNEL);
+       if (!save)
+               return -ENOMEM;
+
+       dev->power.saved_state = (void *) save;
+
+       spin_lock_irqsave(&lchip->lock, flags);
+
+       save->LCM_GPO     = locomo_readl(lchip->base + LOCOMO_GPO);     /* GPIO */
+       locomo_writel(0x00, lchip->base + LOCOMO_GPO);
+       save->LCM_SPICT   = locomo_readl(lchip->base + LOCOMO_SPICT);   /* SPI */
+       locomo_writel(0x40, lchip->base + LOCOMO_SPICT);
+       save->LCM_GPE     = locomo_readl(lchip->base + LOCOMO_GPE);     /* GPIO */
+       locomo_writel(0x00, lchip->base + LOCOMO_GPE);
+       save->LCM_ASD     = locomo_readl(lchip->base + LOCOMO_ASD);     /* ADSTART */
+       locomo_writel(0x00, lchip->base + LOCOMO_ASD);
+       save->LCM_SPIMD   = locomo_readl(lchip->base + LOCOMO_SPIMD);   /* SPI */
+       locomo_writel(0x3C14, lchip->base + LOCOMO_SPIMD);
+
+       locomo_writel(0x00, lchip->base + LOCOMO_PAIF);
+       locomo_writel(0x00, lchip->base + LOCOMO_DAC);
+       locomo_writel(0x00, lchip->base + LOCOMO_BACKLIGHT + LOCOMO_TC);
+
+       if ( (locomo_readl(lchip->base + LOCOMO_LED + LOCOMO_LPT0) & 0x88) && (locomo_readl(lchip->base + LOCOMO_LED + LOCOMO_LPT1) & 0x88) )
+               locomo_writel(0x00, lchip->base + LOCOMO_C32K);         /* CLK32 off */
+       else
+               /* 18MHz already enabled, so no wait */
+               locomo_writel(0xc1, lchip->base + LOCOMO_C32K);         /* CLK32 on */
+
+       locomo_writel(0x00, lchip->base + LOCOMO_TADC);         /* 18MHz clock off*/
+       locomo_writel(0x00, lchip->base + LOCOMO_AUDIO + LOCOMO_ACC);                   /* 22MHz/24MHz clock off */
+       locomo_writel(0x00, lchip->base + LOCOMO_FRONTLIGHT + LOCOMO_ALS);                      /* FL */
+
+       spin_unlock_irqrestore(&lchip->lock, flags);
+
+       return 0;
+}
+
+static int locomo_resume(struct device *dev, u32 level)
+{
+       struct locomo *lchip = dev_get_drvdata(dev);
+       struct locomo_save_data *save;
+       unsigned long r;
+       unsigned long flags;
+       
+       if (level != RESUME_ENABLE)
+               return 0;
+
+       save = (struct locomo_save_data *) dev->power.saved_state;
+       if (!save)
+               return 0;
+
+       spin_lock_irqsave(&lchip->lock, flags);
+
+       locomo_writel(save->LCM_GPO, lchip->base + LOCOMO_GPO);
+       locomo_writel(save->LCM_SPICT, lchip->base + LOCOMO_SPICT);
+       locomo_writel(save->LCM_GPE, lchip->base + LOCOMO_GPE);
+       locomo_writel(save->LCM_ASD, lchip->base + LOCOMO_ASD);
+       locomo_writel(save->LCM_SPIMD, lchip->base + LOCOMO_SPIMD);
+
+       locomo_writel(0x00, lchip->base + LOCOMO_C32K);
+       locomo_writel(0x90, lchip->base + LOCOMO_TADC);
+
+       locomo_writel(0, lchip->base + LOCOMO_KEYBOARD + LOCOMO_KSC);
+       r = locomo_readl(lchip->base + LOCOMO_KEYBOARD + LOCOMO_KIC);
+       r &= 0xFEFF;
+       locomo_writel(r, lchip->base + LOCOMO_KEYBOARD + LOCOMO_KIC);
+       locomo_writel(0x1, lchip->base + LOCOMO_KEYBOARD + LOCOMO_KCMD);
+
+       spin_unlock_irqrestore(&lchip->lock, flags);
+
+       dev->power.saved_state = NULL;
+       kfree(save);
+
+       return 0;
+}
+#endif
+
 /**
  *     locomo_probe - probe for a single LoCoMo chip.
  *     @phys_addr: physical address of device.
@@ -707,6 +804,10 @@ static struct device_driver locomo_device_driver = {
        .bus            = &platform_bus_type,
        .probe          = locomo_probe,
        .remove         = locomo_remove,
+#ifdef CONFIG_PM
+       .suspend        = locomo_suspend,
+       .resume         = locomo_resume,
+#endif
 };
 
 /*
index 96a794d8de842d2476a6776ce0bc46c0afd5369e..756348bf51702c982b17521ecfd66719842b845f 100644 (file)
@@ -1,7 +1,7 @@
 #
 # Automatically generated make config: don't edit
-# Linux kernel version: 2.6.12-git4
-# Wed Jun 22 15:56:42 2005
+# Linux kernel version: 2.6.13-git8
+# Thu Sep  8 19:24:02 2005
 #
 CONFIG_ARM=y
 CONFIG_MMU=y
@@ -22,6 +22,7 @@ CONFIG_INIT_ENV_ARG_LIMIT=32
 # General setup
 #
 CONFIG_LOCALVERSION=""
+CONFIG_LOCALVERSION_AUTO=y
 CONFIG_SWAP=y
 CONFIG_SYSVIPC=y
 # CONFIG_POSIX_MQUEUE is not set
@@ -31,6 +32,7 @@ CONFIG_SYSCTL=y
 # CONFIG_HOTPLUG is not set
 CONFIG_KOBJECT_UEVENT=y
 # CONFIG_IKCONFIG is not set
+CONFIG_INITRAMFS_SOURCE=""
 # CONFIG_EMBEDDED is not set
 CONFIG_KALLSYMS=y
 # CONFIG_KALLSYMS_ALL is not set
@@ -88,7 +90,9 @@ CONFIG_ARCH_S3C2410=y
 #
 # S3C24XX Implementations
 #
+CONFIG_MACH_ANUBIS=y
 CONFIG_ARCH_BAST=y
+CONFIG_BAST_PC104_IRQ=y
 CONFIG_ARCH_H1940=y
 CONFIG_MACH_N30=y
 CONFIG_ARCH_SMDK2410=y
@@ -112,6 +116,7 @@ CONFIG_S3C2410_DMA=y
 # CONFIG_S3C2410_DMA_DEBUG is not set
 # CONFIG_S3C2410_PM_DEBUG is not set
 # CONFIG_S3C2410_PM_CHECK is not set
+CONFIG_PM_SIMTEC=y
 CONFIG_S3C2410_LOWLEVEL_UART_PORT=0
 
 #
@@ -149,7 +154,15 @@ CONFIG_ISA_DMA_API=y
 #
 # CONFIG_SMP is not set
 # CONFIG_PREEMPT is not set
-# CONFIG_DISCONTIGMEM is not set
+# CONFIG_NO_IDLE_HZ is not set
+# CONFIG_ARCH_DISCONTIGMEM_ENABLE is not set
+CONFIG_SELECT_MEMORY_MODEL=y
+CONFIG_FLATMEM_MANUAL=y
+# CONFIG_DISCONTIGMEM_MANUAL is not set
+# CONFIG_SPARSEMEM_MANUAL is not set
+CONFIG_FLATMEM=y
+CONFIG_FLAT_NODE_MEM_MAP=y
+# CONFIG_SPARSEMEM_STATIC is not set
 CONFIG_ALIGNMENT_TRAP=y
 
 #
@@ -185,6 +198,74 @@ CONFIG_BINFMT_AOUT=y
 CONFIG_PM=y
 CONFIG_APM=y
 
+#
+# Networking
+#
+CONFIG_NET=y
+
+#
+# Networking options
+#
+# CONFIG_PACKET is not set
+CONFIG_UNIX=y
+# CONFIG_NET_KEY is not set
+CONFIG_INET=y
+# CONFIG_IP_MULTICAST is not set
+# CONFIG_IP_ADVANCED_ROUTER is not set
+CONFIG_IP_FIB_HASH=y
+CONFIG_IP_PNP=y
+# CONFIG_IP_PNP_DHCP is not set
+CONFIG_IP_PNP_BOOTP=y
+# CONFIG_IP_PNP_RARP is not set
+# CONFIG_NET_IPIP is not set
+# CONFIG_NET_IPGRE is not set
+# CONFIG_ARPD is not set
+# CONFIG_SYN_COOKIES is not set
+# CONFIG_INET_AH is not set
+# CONFIG_INET_ESP is not set
+# CONFIG_INET_IPCOMP is not set
+# CONFIG_INET_TUNNEL is not set
+CONFIG_INET_DIAG=y
+CONFIG_INET_TCP_DIAG=y
+# CONFIG_TCP_CONG_ADVANCED is not set
+CONFIG_TCP_CONG_BIC=y
+# CONFIG_IPV6 is not set
+# CONFIG_NETFILTER is not set
+
+#
+# DCCP Configuration (EXPERIMENTAL)
+#
+# CONFIG_IP_DCCP is not set
+
+#
+# SCTP Configuration (EXPERIMENTAL)
+#
+# CONFIG_IP_SCTP is not set
+# CONFIG_ATM is not set
+# CONFIG_BRIDGE is not set
+# CONFIG_VLAN_8021Q is not set
+# CONFIG_DECNET is not set
+# CONFIG_LLC2 is not set
+# CONFIG_IPX is not set
+# CONFIG_ATALK is not set
+# CONFIG_X25 is not set
+# CONFIG_LAPB is not set
+# CONFIG_NET_DIVERT is not set
+# CONFIG_ECONET is not set
+# CONFIG_WAN_ROUTER is not set
+# CONFIG_NET_SCHED is not set
+# CONFIG_NET_CLS_ROUTE is not set
+
+#
+# Network testing
+#
+# CONFIG_NET_PKTGEN is not set
+# CONFIG_NETFILTER_NETLINK is not set
+# CONFIG_HAMRADIO is not set
+# CONFIG_IRDA is not set
+# CONFIG_BT is not set
+# CONFIG_IEEE80211 is not set
+
 #
 # Device Drivers
 #
@@ -258,6 +339,7 @@ CONFIG_MTD_ROM=y
 # CONFIG_MTD_IMPA7 is not set
 CONFIG_MTD_BAST=y
 CONFIG_MTD_BAST_MAXSIZE=4
+# CONFIG_MTD_PLATRAM is not set
 
 #
 # Self-contained MTD device drivers
@@ -312,7 +394,6 @@ CONFIG_BLK_DEV_RAM=y
 CONFIG_BLK_DEV_RAM_COUNT=16
 CONFIG_BLK_DEV_RAM_SIZE=4096
 CONFIG_BLK_DEV_INITRD=y
-CONFIG_INITRAMFS_SOURCE=""
 # CONFIG_CDROM_PKTCDVD is not set
 
 #
@@ -354,6 +435,7 @@ CONFIG_BLK_DEV_IDE_BAST=y
 #
 # SCSI device support
 #
+# CONFIG_RAID_ATTRS is not set
 # CONFIG_SCSI is not set
 
 #
@@ -376,76 +458,19 @@ CONFIG_BLK_DEV_IDE_BAST=y
 #
 
 #
-# Networking support
-#
-CONFIG_NET=y
-
-#
-# Networking options
+# Network device support
 #
-# CONFIG_PACKET is not set
-CONFIG_UNIX=y
-# CONFIG_NET_KEY is not set
-CONFIG_INET=y
-CONFIG_IP_FIB_HASH=y
-# CONFIG_IP_FIB_TRIE is not set
-# CONFIG_IP_MULTICAST is not set
-# CONFIG_IP_ADVANCED_ROUTER is not set
-CONFIG_IP_PNP=y
-# CONFIG_IP_PNP_DHCP is not set
-CONFIG_IP_PNP_BOOTP=y
-# CONFIG_IP_PNP_RARP is not set
-# CONFIG_NET_IPIP is not set
-# CONFIG_NET_IPGRE is not set
-# CONFIG_ARPD is not set
-# CONFIG_SYN_COOKIES is not set
-# CONFIG_INET_AH is not set
-# CONFIG_INET_ESP is not set
-# CONFIG_INET_IPCOMP is not set
-# CONFIG_INET_TUNNEL is not set
-CONFIG_IP_TCPDIAG=y
-# CONFIG_IP_TCPDIAG_IPV6 is not set
-# CONFIG_IPV6 is not set
-# CONFIG_NETFILTER is not set
-
-#
-# SCTP Configuration (EXPERIMENTAL)
-#
-# CONFIG_IP_SCTP is not set
-# CONFIG_ATM is not set
-# CONFIG_BRIDGE is not set
-# CONFIG_VLAN_8021Q is not set
-# CONFIG_DECNET is not set
-# CONFIG_LLC2 is not set
-# CONFIG_IPX is not set
-# CONFIG_ATALK is not set
-# CONFIG_X25 is not set
-# CONFIG_LAPB is not set
-# CONFIG_NET_DIVERT 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
-# CONFIG_NET_CLS_ROUTE is not set
-
-#
-# Network testing
-#
-# CONFIG_NET_PKTGEN is not set
-# CONFIG_NETPOLL is not set
-# CONFIG_NET_POLL_CONTROLLER is not set
-# CONFIG_HAMRADIO is not set
-# CONFIG_IRDA is not set
-# CONFIG_BT is not set
 CONFIG_NETDEVICES=y
 # CONFIG_DUMMY is not set
 # CONFIG_BONDING is not set
 # CONFIG_EQUALIZER is not set
 # CONFIG_TUN is not set
 
+#
+# PHY device support
+#
+# CONFIG_PHYLIB is not set
+
 #
 # Ethernet (10 or 100Mbit)
 #
@@ -480,6 +505,8 @@ CONFIG_DM9000=m
 # CONFIG_SLIP is not set
 # CONFIG_SHAPER is not set
 # CONFIG_NETCONSOLE is not set
+# CONFIG_NETPOLL is not set
+# CONFIG_NET_POLL_CONTROLLER is not set
 
 #
 # ISDN subsystem
@@ -562,7 +589,6 @@ CONFIG_SERIAL_8250_EXTENDED=y
 CONFIG_SERIAL_8250_MANY_PORTS=y
 CONFIG_SERIAL_8250_SHARE_IRQ=y
 # CONFIG_SERIAL_8250_DETECT_IRQ is not set
-# CONFIG_SERIAL_8250_MULTIPORT is not set
 # CONFIG_SERIAL_8250_RSA is not set
 
 #
@@ -605,7 +631,6 @@ CONFIG_S3C2410_RTC=y
 #
 # Ftape, the floppy tape device driver
 #
-# CONFIG_DRM is not set
 # CONFIG_RAW_DRIVER is not set
 
 #
@@ -628,7 +653,7 @@ CONFIG_I2C_ALGOBIT=m
 #
 # I2C Hardware Bus support
 #
-# CONFIG_I2C_ISA is not set
+CONFIG_I2C_ISA=m
 # CONFIG_I2C_PARPORT is not set
 # CONFIG_I2C_PARPORT_LIGHT is not set
 CONFIG_I2C_S3C2410=y
@@ -636,14 +661,33 @@ CONFIG_I2C_S3C2410=y
 # CONFIG_I2C_PCA_ISA is not set
 
 #
-# Hardware Sensors Chip support
+# Miscellaneous I2C Chip support
 #
-CONFIG_I2C_SENSOR=m
+# CONFIG_SENSORS_DS1337 is not set
+# CONFIG_SENSORS_DS1374 is not set
+CONFIG_SENSORS_EEPROM=m
+# CONFIG_SENSORS_PCF8574 is not set
+# CONFIG_SENSORS_PCA9539 is not set
+# CONFIG_SENSORS_PCF8591 is not set
+# CONFIG_SENSORS_RTC8564 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
+
+#
+# Hardware Monitoring support
+#
+CONFIG_HWMON=y
+CONFIG_HWMON_VID=m
 # 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_FSCHER is not set
 # CONFIG_SENSORS_FSCPOS is not set
@@ -662,27 +706,21 @@ CONFIG_SENSORS_LM85=m
 # CONFIG_SENSORS_LM92 is not set
 # CONFIG_SENSORS_MAX1619 is not set
 # CONFIG_SENSORS_PC87360 is not set
-# CONFIG_SENSORS_SMSC47B397 is not set
 # CONFIG_SENSORS_SMSC47M1 is not set
+# CONFIG_SENSORS_SMSC47B397 is not set
 # CONFIG_SENSORS_W83781D is not set
+# CONFIG_SENSORS_W83792D 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
 
 #
-# Other I2C Chip support
+# Misc devices
 #
-# CONFIG_SENSORS_DS1337 is not set
-CONFIG_SENSORS_EEPROM=m
-# CONFIG_SENSORS_PCF8574 is not set
-# CONFIG_SENSORS_PCF8591 is not set
-# CONFIG_SENSORS_RTC8564 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
 
 #
-# Misc devices
+# Multimedia Capabilities Port drivers
 #
 
 #
@@ -731,7 +769,7 @@ CONFIG_DUMMY_CONSOLE=y
 # USB support
 #
 CONFIG_USB_ARCH_HAS_HCD=y
-# CONFIG_USB_ARCH_HAS_OHCI is not set
+CONFIG_USB_ARCH_HAS_OHCI=y
 # CONFIG_USB is not set
 
 #
@@ -749,6 +787,7 @@ CONFIG_USB_ARCH_HAS_HCD=y
 #
 CONFIG_EXT2_FS=y
 # CONFIG_EXT2_FS_XATTR is not set
+# CONFIG_EXT2_FS_XIP is not set
 CONFIG_EXT3_FS=y
 CONFIG_EXT3_FS_XATTR=y
 # CONFIG_EXT3_FS_POSIX_ACL is not set
@@ -758,6 +797,7 @@ CONFIG_JBD=y
 CONFIG_FS_MBCACHE=y
 # CONFIG_REISERFS_FS is not set
 # CONFIG_JFS_FS is not set
+# CONFIG_FS_POSIX_ACL is not set
 
 #
 # XFS support
@@ -765,6 +805,7 @@ CONFIG_FS_MBCACHE=y
 # CONFIG_XFS_FS is not set
 # CONFIG_MINIX_FS is not set
 CONFIG_ROMFS_FS=y
+CONFIG_INOTIFY=y
 # CONFIG_QUOTA is not set
 CONFIG_DNOTIFY=y
 # CONFIG_AUTOFS_FS is not set
@@ -791,11 +832,11 @@ CONFIG_FAT_DEFAULT_IOCHARSET="iso8859-1"
 #
 CONFIG_PROC_FS=y
 CONFIG_SYSFS=y
-# CONFIG_DEVPTS_FS_XATTR is not set
 # CONFIG_TMPFS is not set
 # CONFIG_HUGETLBFS is not set
 # CONFIG_HUGETLB_PAGE is not set
 CONFIG_RAMFS=y
+# CONFIG_RELAYFS_FS is not set
 
 #
 # Miscellaneous filesystems
@@ -812,8 +853,7 @@ CONFIG_JFFS_FS_VERBOSE=0
 # CONFIG_JFFS_PROC_FS is not set
 CONFIG_JFFS2_FS=y
 CONFIG_JFFS2_FS_DEBUG=0
-# CONFIG_JFFS2_FS_NAND is not set
-# CONFIG_JFFS2_FS_NOR_ECC is not set
+CONFIG_JFFS2_FS_WRITEBUFFER=y
 # CONFIG_JFFS2_COMPRESSION_OPTIONS is not set
 CONFIG_JFFS2_ZLIB=y
 CONFIG_JFFS2_RTIME=y
@@ -835,6 +875,7 @@ CONFIG_NFS_FS=y
 # CONFIG_NFSD is not set
 CONFIG_ROOT_NFS=y
 CONFIG_LOCKD=y
+CONFIG_NFS_COMMON=y
 CONFIG_SUNRPC=y
 # CONFIG_RPCSEC_GSS_KRB5 is not set
 # CONFIG_RPCSEC_GSS_SPKM3 is not set
@@ -920,6 +961,7 @@ CONFIG_NLS_DEFAULT="iso8859-1"
 CONFIG_DEBUG_KERNEL=y
 # CONFIG_MAGIC_SYSRQ is not set
 CONFIG_LOG_BUF_SHIFT=16
+CONFIG_DETECT_SOFTLOCKUP=y
 # CONFIG_SCHEDSTATS is not set
 # CONFIG_DEBUG_SLAB is not set
 # CONFIG_DEBUG_SPINLOCK is not set
index 112f1d68fb2b10b8be32171ec24dbdac6569af3f..e216ab8b9e8f7c048a83d057c7af36d7575b6826 100644 (file)
@@ -354,7 +354,7 @@ static struct plat_serial8250_port serial_platform_data[] = {
 
 static struct platform_device serial_device = {
        .name                   = "serial8250",
-       .id                     = 0,
+       .id                     = PLAT8250_DEV_PLATFORM,
        .dev                    = {
                .platform_data  = serial_platform_data,
        },
index 23c4da10101bd8e04c2f67b4f3ca5da9d150130f..5aeadfd721431466ba66307c3437a716b7b32b25 100644 (file)
@@ -219,7 +219,7 @@ static struct plat_serial8250_port serial_platform_data[] = {
 
 static struct platform_device serial_device = {
        .name                   = "serial8250",
-       .id                     = 0,
+       .id                     = PLAT8250_DEV_PLATFORM,
        .dev                    = {
                .platform_data  = serial_platform_data,
        },
index 7daa021676d0ac4aa688a8a1c1f546c9ab974000..44c56571d18365ba3b488175a0186444ea3e4da8 100644 (file)
@@ -52,7 +52,7 @@ static struct plat_serial8250_port serial_platform_data[] = {
 
 static struct platform_device serial_device = {
        .name                   = "serial8250",
-       .id                     = 0,
+       .id                     = PLAT8250_DEV_PLATFORM,
        .dev                    = {
                .platform_data  = serial_platform_data,
        },
index aa3a1fef563ee4c6ee780cbb446fdcbc6b72d195..28846c7edaaff3fa628a6f48baac8068ebfb51d1 100644 (file)
@@ -34,7 +34,7 @@ static struct plat_serial8250_port serial_platform_data[] = {
 
 static struct platform_device serial_device = {
        .name                   = "serial8250",
-       .id                     = 0,
+       .id                     = PLAT8250_DEV_PLATFORM,
        .dev                    = {
                .platform_data  = serial_platform_data,
        },
index 4b3199319e68b4c988f4f24edff2ded120405f24..a4a7c0125d030ea3e5482a4f716d05d08f4f5700 100644 (file)
@@ -90,7 +90,7 @@ static struct plat_serial8250_port serial_platform_data[] = {
 
 static struct platform_device serial_device = {
        .name                   = "serial8250",
-       .id                     = 0,
+       .id                     = PLAT8250_DEV_PLATFORM,
        .dev                    = {
                .platform_data  = serial_platform_data,
        },
index 098c817a7fb82a8e6fc7f38c24757ec620f6e47e..74bd2fd602d45181ed333bb3ee7fb9e9cc6aaf5e 100644 (file)
@@ -174,7 +174,7 @@ static struct resource ixp2000_uart_resource = {
 
 static struct platform_device ixp2000_serial_device = {
        .name           = "serial8250",
-       .id             = 0,
+       .id             = PLAT8250_DEV_PLATFORM,
        .dev            = {
                .platform_data          = ixp2000_serial_port,
        },
index 8b2f25322452b2c449ca02296128075e4a09918e..050c92768913b73d542dab88a3a3f883ace1ed38 100644 (file)
@@ -66,7 +66,7 @@ static struct plat_serial8250_port coyote_uart_data[] = {
 
 static struct platform_device coyote_uart = {
        .name           = "serial8250",
-       .id             = 0,
+       .id             = PLAT8250_DEV_PLATFORM,
        .dev                    = {
                .platform_data  = coyote_uart_data,
        },
index 3fd92c5cbaa83e21566595aab80090a93dcdd192..29a6d02fa851d4c19841545830af52788de21fbf 100644 (file)
@@ -93,7 +93,7 @@ static struct plat_serial8250_port gtwx5715_uart_platform_data[] = {
 
 static struct platform_device gtwx5715_uart_device = {
        .name           = "serial8250",
-       .id             = 0,
+       .id             = PLAT8250_DEV_PLATFORM,
        .dev                    = {
                .platform_data  = gtwx5715_uart_platform_data,
        },
index 6c14ff3c23a04706df50f9f8ad38e5179994e21b..ae1fa099d5fa4c965a8f089d8708d1b00b466224 100644 (file)
@@ -96,7 +96,7 @@ static struct plat_serial8250_port ixdp425_uart_data[] = {
 
 static struct platform_device ixdp425_uart = {
        .name                   = "serial8250",
-       .id                     = 0,
+       .id                     = PLAT8250_DEV_PLATFORM,
        .dev.platform_data      = ixdp425_uart_data,
        .num_resources          = 2,
        .resource               = ixdp425_uart_resources
index 7408ac94f771663005b2a52c609aea5c5d7afede..27fc2e8e5fca6d07cfa6659bc9562279de7084ac 100644 (file)
@@ -47,6 +47,14 @@ config MACH_OMAP_OSK
          TI OMAP 5912 OSK (OMAP Starter Kit) board support. Say Y here
           if you have such a board.
 
+config OMAP_OSK_MISTRAL
+       bool "Mistral QVGA board Support"
+       depends on MACH_OMAP_OSK
+       help
+         The OSK supports an optional add-on board with a Quarter-VGA
+         touchscreen, PDA-ish buttons, a resume button, bicolor LED,
+         and camera connector.  Say Y here if you have this board.
+
 config MACH_OMAP_PERSEUS2
        bool "TI Perseus2"
        depends on ARCH_OMAP1 && ARCH_OMAP730
index d386fd913f0c617a890cf88838b739f9c1f53430..181a93deaaee4fa9cca5cbd5fbbca498e0930f3f 100644 (file)
@@ -3,7 +3,7 @@
 #
 
 # Common support
-obj-y := io.o id.o irq.o time.o serial.o
+obj-y := io.o id.o irq.o time.o serial.o devices.o
 led-y := leds.o
 
 # Specific board support
@@ -23,6 +23,7 @@ endif
 
 # LEDs support
 led-$(CONFIG_MACH_OMAP_H2)             += leds-h2p2-debug.o
+led-$(CONFIG_MACH_OMAP_H3)             += leds-h2p2-debug.o
 led-$(CONFIG_MACH_OMAP_INNOVATOR)      += leds-innovator.o
 led-$(CONFIG_MACH_OMAP_PERSEUS2)       += leds-h2p2-debug.o
 led-$(CONFIG_MACH_OMAP_OSK)            += leds-osk.o
index 122796ebe8f5a0b8425748464b756cc83813ef71..c209c7172a9aedf295c725e5ecf79bbb0b8ea02f 100644 (file)
@@ -48,19 +48,43 @@ static struct omap_usb_config generic1510_usb_config __initdata = {
 
 #if defined(CONFIG_ARCH_OMAP16XX)
 static struct omap_usb_config generic1610_usb_config __initdata = {
+#ifdef CONFIG_USB_OTG
+       .otg            = 1,
+#endif
        .register_host  = 1,
        .register_dev   = 1,
        .hmc_mode       = 16,
        .pins[0]        = 6,
 };
+
+static struct omap_mmc_config generic_mmc_config __initdata = {
+       .mmc [0] = {
+               .enabled        = 0,
+               .wire4          = 0,
+               .wp_pin         = -1,
+               .power_pin      = -1,
+               .switch_pin     = -1,
+       },
+       .mmc [1] = {
+               .enabled        = 0,
+               .wire4          = 0,
+               .wp_pin         = -1,
+               .power_pin      = -1,
+               .switch_pin     = -1,
+       },
+};
+
 #endif
 
 static struct omap_board_config_kernel generic_config[] = {
        { OMAP_TAG_USB,           NULL },
+       { OMAP_TAG_MMC,           &generic_mmc_config },
 };
 
 static void __init omap_generic_init(void)
 {
+       const struct omap_uart_config *uart_conf;
+
        /*
         * Make sure the serial ports are muxed on at this point.
         * You have to mux them off in device drivers later on
@@ -76,6 +100,18 @@ static void __init omap_generic_init(void)
                generic_config[0].data = &generic1610_usb_config;
        }
 #endif
+
+       uart_conf = omap_get_config(OMAP_TAG_UART, struct omap_uart_config);
+       if (uart_conf != NULL) {
+               unsigned int enabled_ports, i;
+
+               enabled_ports = uart_conf->enabled_uarts;
+               for (i = 0; i < 3; i++) {
+                       if (!(enabled_ports & (1 << i)))
+                               generic_serial_ports[i] = 0;
+               }
+       }
+
        omap_board_config = generic_config;
        omap_board_config_size = ARRAY_SIZE(generic_config);
        omap_serial_init(generic_serial_ports);
@@ -83,7 +119,7 @@ static void __init omap_generic_init(void)
 
 static void __init omap_generic_map_io(void)
 {
-       omap_map_common_io()
+       omap_map_common_io();
 }
 
 MACHINE_START(OMAP_GENERIC, "Generic OMAP1510/1610/1710")
index f4983ee95ab4e29dbc112c97f7414b76b5e39293..d46a70063b0c61821088ae2c8f483c6a9356454f 100644 (file)
@@ -33,6 +33,7 @@
 #include <asm/mach/map.h>
 
 #include <asm/arch/gpio.h>
+#include <asm/arch/mux.h>
 #include <asm/arch/tc.h>
 #include <asm/arch/usb.h>
 #include <asm/arch/common.h>
@@ -80,8 +81,7 @@ static struct flash_platform_data h2_flash_data = {
 };
 
 static struct resource h2_flash_resource = {
-       .start          = OMAP_CS2B_PHYS,
-       .end            = OMAP_CS2B_PHYS + OMAP_CS2B_SIZE - 1,
+       /* This is on CS3, wherever it's mapped */
        .flags          = IORESOURCE_MEM,
 };
 
@@ -126,10 +126,9 @@ static void __init h2_init_smc91x(void)
                printk("Error requesting gpio 0 for smc91x irq\n");
                return;
        }
-       omap_set_gpio_edge_ctrl(0, OMAP_GPIO_FALLING_EDGE);
 }
 
-void h2_init_irq(void)
+static void __init h2_init_irq(void)
 {
        omap_init_irq();
        omap_gpio_init();
@@ -152,9 +151,13 @@ static struct omap_usb_config h2_usb_config __initdata = {
 };
 
 static struct omap_mmc_config h2_mmc_config __initdata = {
-       .mmc_blocks             = 1,
-       .mmc1_power_pin         = -1,   /* tps65010 gpio3 */
-       .mmc1_switch_pin        = OMAP_MPUIO(1),
+       .mmc [0] = {
+               .enabled        = 1,
+               .wire4          = 1,
+               .wp_pin         = OMAP_MPUIO(3),
+               .power_pin      = -1,   /* tps65010 gpio3 */
+               .switch_pin     = OMAP_MPUIO(1),
+       },
 };
 
 static struct omap_board_config_kernel h2_config[] = {
@@ -164,6 +167,16 @@ static struct omap_board_config_kernel h2_config[] = {
 
 static void __init h2_init(void)
 {
+       /* NOTE: revC boards support NAND-boot, which can put NOR on CS2B
+        * and NAND (either 16bit or 8bit) on CS3.
+        */
+       h2_flash_resource.end = h2_flash_resource.start = omap_cs3_phys();
+       h2_flash_resource.end += SZ_32M - 1;
+
+       /* MMC:  card detect and WP */
+       // omap_cfg_reg(U19_ARMIO1);            /* CD */
+       omap_cfg_reg(BALLOUT_V8_ARMIO3);        /* WP */
+
        platform_add_devices(h2_devices, ARRAY_SIZE(h2_devices));
        omap_board_config = h2_config;
        omap_board_config_size = ARRAY_SIZE(h2_config);
index 7cd419d61b400889c56e39feb64572f888205b6b..2798613696fa7e0781609bb61132858d25089e27 100644 (file)
@@ -82,8 +82,7 @@ static struct flash_platform_data h3_flash_data = {
 };
 
 static struct resource h3_flash_resource = {
-       .start          = OMAP_CS2B_PHYS,
-       .end            = OMAP_CS2B_PHYS + OMAP_CS2B_SIZE - 1,
+       /* This is on CS3, wherever it's mapped */
        .flags          = IORESOURCE_MEM,
 };
 
@@ -161,13 +160,26 @@ static struct omap_usb_config h3_usb_config __initdata = {
        .pins[1]        = 3,
 };
 
+static struct omap_mmc_config h3_mmc_config __initdata = {
+       .mmc[0] = {
+               .enabled        = 1,
+               .power_pin      = -1,   /* tps65010 GPIO4 */
+               .switch_pin     = OMAP_MPUIO(1),
+       },
+};
+
 static struct omap_board_config_kernel h3_config[] = {
        { OMAP_TAG_USB,  &h3_usb_config },
+       { OMAP_TAG_MMC,  &h3_mmc_config },
 };
 
 static void __init h3_init(void)
 {
+       h3_flash_resource.end = h3_flash_resource.start = omap_cs3_phys();
+       h3_flash_resource.end += OMAP_CS3_SIZE - 1;
        (void) platform_add_devices(devices, ARRAY_SIZE(devices));
+       omap_board_config = h3_config;
+       omap_board_config_size = ARRAY_SIZE(h3_config);
 }
 
 static void __init h3_init_smc91x(void)
@@ -177,7 +189,6 @@ static void __init h3_init_smc91x(void)
                printk("Error requesting gpio 40 for smc91x irq\n");
                return;
        }
-       omap_set_gpio_edge_ctrl(40, OMAP_GPIO_FALLING_EDGE);
 }
 
 void h3_init_irq(void)
index 91de60a91ef86a04ae32e3d47a675c32752f33be..df0312b596e484a6e79cf5356c767020e8d55c54 100644 (file)
@@ -29,6 +29,7 @@
 #include <asm/mach/flash.h>
 #include <asm/mach/map.h>
 
+#include <asm/arch/mux.h>
 #include <asm/arch/fpga.h>
 #include <asm/arch/gpio.h>
 #include <asm/arch/tc.h>
@@ -173,7 +174,6 @@ static void __init innovator_init_smc91x(void)
                        printk("Error requesting gpio 0 for smc91x irq\n");
                        return;
                }
-               omap_set_gpio_edge_ctrl(0, OMAP_GPIO_RISING_EDGE);
        }
 }
 
@@ -220,8 +220,19 @@ static struct omap_usb_config h2_usb_config __initdata = {
 };
 #endif
 
+static struct omap_mmc_config innovator_mmc_config __initdata = {
+       .mmc [0] = {
+               .enabled        = 1,
+               .wire4          = 1,
+               .wp_pin         = OMAP_MPUIO(3),
+               .power_pin      = -1,   /* FPGA F3 UIO42 */
+               .switch_pin     = -1,   /* FPGA F4 UIO43 */
+       },
+};
+
 static struct omap_board_config_kernel innovator_config[] = {
        { OMAP_TAG_USB,         NULL },
+       { OMAP_TAG_MMC,         &innovator_mmc_config },
 };
 
 static void __init innovator_init(void)
index 6750b2014092d8ced13f0f28356d2e2ad31a49a8..d904e643f5ec2c30fabf5d8438f5e40cdec82ad1 100644 (file)
@@ -75,16 +75,15 @@ static void __init netstar_init(void)
        mdelay(50);     /* 50ms until PHY ready */
        /* smc91x interrupt pin */
        omap_request_gpio(8);
-       omap_set_gpio_edge_ctrl(8, OMAP_GPIO_RISING_EDGE);
 
        omap_request_gpio(12);
        omap_request_gpio(13);
        omap_request_gpio(14);
        omap_request_gpio(15);
-       omap_set_gpio_edge_ctrl(12, OMAP_GPIO_FALLING_EDGE);
-       omap_set_gpio_edge_ctrl(13, OMAP_GPIO_FALLING_EDGE);
-       omap_set_gpio_edge_ctrl(14, OMAP_GPIO_FALLING_EDGE);
-       omap_set_gpio_edge_ctrl(15, OMAP_GPIO_FALLING_EDGE);
+       set_irq_type(OMAP_GPIO_IRQ(12), IRQT_FALLING);
+       set_irq_type(OMAP_GPIO_IRQ(13), IRQT_FALLING);
+       set_irq_type(OMAP_GPIO_IRQ(14), IRQT_FALLING);
+       set_irq_type(OMAP_GPIO_IRQ(15), IRQT_FALLING);
 
        platform_add_devices(netstar_devices, ARRAY_SIZE(netstar_devices));
 
index 6844e536c698da5820a3b5f05d8ae5e085f67402..21103df50415a7007428f04224b54c8c2127b023 100644 (file)
 #include <linux/kernel.h>
 #include <linux/init.h>
 #include <linux/device.h>
+#include <linux/interrupt.h>
+
+#include <linux/mtd/mtd.h>
+#include <linux/mtd/partitions.h>
 
 #include <asm/hardware.h>
 #include <asm/mach-types.h>
 #include <asm/mach/arch.h>
 #include <asm/mach/map.h>
+#include <asm/mach/flash.h>
 
 #include <asm/arch/gpio.h>
 #include <asm/arch/usb.h>
 #include <asm/arch/tc.h>
 #include <asm/arch/common.h>
 
-static struct map_desc osk5912_io_desc[] __initdata = {
-{ OMAP_OSK_NOR_FLASH_BASE, OMAP_OSK_NOR_FLASH_START, OMAP_OSK_NOR_FLASH_SIZE,
-       MT_DEVICE },
+static int __initdata osk_serial_ports[OMAP_MAX_NR_PORTS] = {1, 0, 0};
+
+static struct mtd_partition osk_partitions[] = {
+       /* bootloader (U-Boot, etc) in first sector */
+       {
+             .name             = "bootloader",
+             .offset           = 0,
+             .size             = SZ_128K,
+             .mask_flags       = MTD_WRITEABLE, /* force read-only */
+       },
+       /* bootloader params in the next sector */
+       {
+             .name             = "params",
+             .offset           = MTDPART_OFS_APPEND,
+             .size             = SZ_128K,
+             .mask_flags       = 0,
+       }, {
+             .name             = "kernel",
+             .offset           = MTDPART_OFS_APPEND,
+             .size             = SZ_2M,
+             .mask_flags       = 0
+       }, {
+             .name             = "filesystem",
+             .offset           = MTDPART_OFS_APPEND,
+             .size             = MTDPART_SIZ_FULL,
+             .mask_flags       = 0
+       }
 };
 
-static int __initdata osk_serial_ports[OMAP_MAX_NR_PORTS] = {1, 0, 0};
+static struct flash_platform_data osk_flash_data = {
+       .map_name       = "cfi_probe",
+       .width          = 2,
+       .parts          = osk_partitions,
+       .nr_parts       = ARRAY_SIZE(osk_partitions),
+};
+
+static struct resource osk_flash_resource = {
+       /* this is on CS3, wherever it's mapped */
+       .flags          = IORESOURCE_MEM,
+};
+
+static struct platform_device osk5912_flash_device = {
+       .name           = "omapflash",
+       .id             = 0,
+       .dev            = {
+               .platform_data  = &osk_flash_data,
+       },
+       .num_resources  = 1,
+       .resource       = &osk_flash_resource,
+};
 
 static struct resource osk5912_smc91x_resources[] = {
        [0] = {
@@ -86,9 +135,16 @@ static struct platform_device osk5912_cf_device = {
        .resource       = osk5912_cf_resources,
 };
 
+static struct platform_device osk5912_mcbsp1_device = {
+       .name           = "omap_mcbsp",
+       .id             = 1,
+};
+
 static struct platform_device *osk5912_devices[] __initdata = {
+       &osk5912_flash_device,
        &osk5912_smc91x_device,
        &osk5912_cf_device,
+       &osk5912_mcbsp1_device,
 };
 
 static void __init osk_init_smc91x(void)
@@ -97,7 +153,6 @@ static void __init osk_init_smc91x(void)
                printk("Error requesting gpio 0 for smc91x irq\n");
                return;
        }
-       omap_set_gpio_edge_ctrl(0, OMAP_GPIO_RISING_EDGE);
 
        /* Check EMIFS wait states to fix errors with SMC_GET_PKT_HDR */
        EMIFS_CCS(1) |= 0x2;
@@ -110,11 +165,11 @@ static void __init osk_init_cf(void)
                printk("Error requesting gpio 62 for CF irq\n");
                return;
        }
-       /* it's really active-low */
-       omap_set_gpio_edge_ctrl(62, OMAP_GPIO_FALLING_EDGE);
+       /* the CF I/O IRQ is really active-low */
+       set_irq_type(OMAP_GPIO_IRQ(62), IRQT_FALLING);
 }
 
-void osk_init_irq(void)
+static void __init osk_init_irq(void)
 {
        omap_init_irq();
        omap_gpio_init();
@@ -142,18 +197,69 @@ static struct omap_board_config_kernel osk_config[] = {
        { OMAP_TAG_USB,           &osk_usb_config },
 };
 
+#ifdef CONFIG_OMAP_OSK_MISTRAL
+
+#ifdef CONFIG_PM
+static irqreturn_t
+osk_mistral_wake_interrupt(int irq, void *ignored, struct pt_regs *regs)
+{
+       return IRQ_HANDLED;
+}
+#endif
+
+static void __init osk_mistral_init(void)
+{
+       /* FIXME here's where to feed in framebuffer, touchpad, and
+        * keyboard setup ...  not in the drivers for those devices!
+        *
+        * NOTE:  we could actually tell if there's a Mistral board
+        * attached, e.g. by trying to read something from the ads7846.
+        * But this is too early for that...
+        */
+
+       /* the sideways button (SW1) is for use as a "wakeup" button */
+       omap_cfg_reg(N15_1610_MPUIO2);
+       if (omap_request_gpio(OMAP_MPUIO(2)) == 0) {
+               int ret = 0;
+               omap_set_gpio_direction(OMAP_MPUIO(2), 1);
+               set_irq_type(OMAP_GPIO_IRQ(OMAP_MPUIO(2)), IRQT_RISING);
+#ifdef CONFIG_PM
+               /* share the IRQ in case someone wants to use the
+                * button for more than wakeup from system sleep.
+                */
+               ret = request_irq(OMAP_GPIO_IRQ(OMAP_MPUIO(2)),
+                               &osk_mistral_wake_interrupt,
+                               SA_SHIRQ, "mistral_wakeup",
+                               &osk_mistral_wake_interrupt);
+               if (ret != 0) {
+                       omap_free_gpio(OMAP_MPUIO(2));
+                       printk(KERN_ERR "OSK+Mistral: no wakeup irq, %d?\n",
+                               ret);
+               } else
+                       enable_irq_wake(OMAP_GPIO_IRQ(OMAP_MPUIO(2)));
+#endif
+       } else
+               printk(KERN_ERR "OSK+Mistral: wakeup button is awol\n");
+}
+#else
+static void __init osk_mistral_init(void) { }
+#endif
+
 static void __init osk_init(void)
 {
+       osk_flash_resource.end = osk_flash_resource.start = omap_cs3_phys();
+       osk_flash_resource.end += SZ_32M - 1;
        platform_add_devices(osk5912_devices, ARRAY_SIZE(osk5912_devices));
        omap_board_config = osk_config;
        omap_board_config_size = ARRAY_SIZE(osk_config);
        USB_TRANSCEIVER_CTRL_REG |= (3 << 1);
+
+       osk_mistral_init();
 }
 
 static void __init osk_map_io(void)
 {
        omap_map_common_io();
-       iotable_init(osk5912_io_desc, ARRAY_SIZE(osk5912_io_desc));
        omap_serial_init(osk_serial_ports);
 }
 
index 213317392d9b1c4066fca07e8cb7bfd1714d9ea9..107c68c8ab54b796fe7f5271adb11a40c52de760 100644 (file)
@@ -24,6 +24,7 @@
 #include <asm/mach/flash.h>
 #include <asm/mach/map.h>
 
+#include <asm/arch/tc.h>
 #include <asm/arch/gpio.h>
 #include <asm/arch/mux.h>
 #include <asm/arch/fpga.h>
@@ -83,8 +84,8 @@ static struct flash_platform_data p2_flash_data = {
 };
 
 static struct resource p2_flash_resource = {
-       .start          = OMAP_FLASH_0_START,
-       .end            = OMAP_FLASH_0_START + OMAP_FLASH_0_SIZE - 1,
+       .start          = OMAP_CS0_PHYS,
+       .end            = OMAP_CS0_PHYS + SZ_32M - 1,
        .flags          = IORESOURCE_MEM,
 };
 
index e422819889904124bf56e84fd577a90ba5c9bca9..bf30b1acda0b97a1c9795a0006622c7db6935265 100644 (file)
 #include <asm/hardware.h>
 #include <asm/mach-types.h>
 #include <asm/mach/arch.h>
+#include <asm/mach/flash.h>
 #include <asm/mach/map.h>
 
+#include <asm/arch/common.h>
 #include <asm/arch/gpio.h>
-#include <asm/arch/tc.h>
 #include <asm/arch/mux.h>
+#include <asm/arch/tc.h>
 #include <asm/arch/usb.h>
-#include <asm/arch/common.h>
 
 extern void omap_init_time(void);
 extern int omap_gpio_init(void);
@@ -74,7 +75,7 @@ static struct plat_serial8250_port voiceblue_ports[] = {
 
 static struct platform_device serial_device = {
        .name                   = "serial8250",
-       .id                     = 1,
+       .id                     = PLAT8250_DEV_PLATFORM1,
        .dev                    = {
                .platform_data  = voiceblue_ports,
        },
@@ -86,6 +87,27 @@ static int __init ext_uart_init(void)
 }
 arch_initcall(ext_uart_init);
 
+static struct flash_platform_data voiceblue_flash_data = {
+       .map_name       = "cfi_probe",
+       .width          = 2,
+};
+
+static struct resource voiceblue_flash_resource = {
+       .start  = OMAP_CS0_PHYS,
+       .end    = OMAP_CS0_PHYS + SZ_32M - 1,
+       .flags  = IORESOURCE_MEM,
+};
+
+static struct platform_device voiceblue_flash_device = {
+       .name           = "omapflash",
+       .id             = 0,
+       .dev            = {
+               .platform_data  = &voiceblue_flash_data,
+       },
+       .num_resources  = 1,
+       .resource       = &voiceblue_flash_resource,
+};
+
 static struct resource voiceblue_smc91x_resources[] = {
        [0] = {
                .start  = OMAP_CS2_PHYS + 0x300,
@@ -107,6 +129,7 @@ static struct platform_device voiceblue_smc91x_device = {
 };
 
 static struct platform_device *voiceblue_devices[] __initdata = {
+       &voiceblue_flash_device,
        &voiceblue_smc91x_device,
 };
 
@@ -119,8 +142,17 @@ static struct omap_usb_config voiceblue_usb_config __initdata = {
        .pins[2]        = 6,
 };
 
+static struct omap_mmc_config voiceblue_mmc_config __initdata = {
+       .mmc[0] = {
+               .enabled        = 1,
+               .power_pin      = 2,
+               .switch_pin     = -1,
+       },
+};
+
 static struct omap_board_config_kernel voiceblue_config[] = {
        { OMAP_TAG_USB, &voiceblue_usb_config },
+       { OMAP_TAG_MMC, &voiceblue_mmc_config },
 };
 
 static void __init voiceblue_init_irq(void)
@@ -131,9 +163,6 @@ static void __init voiceblue_init_irq(void)
 
 static void __init voiceblue_init(void)
 {
-       /* There is a good chance board is going up, so enable Power LED
-        * (it is connected through invertor) */
-       omap_writeb(0x00, OMAP_LPG1_LCR);
        /* Watchdog */
        omap_request_gpio(0);
        /* smc91x reset */
@@ -145,7 +174,6 @@ static void __init voiceblue_init(void)
        mdelay(50);     /* 50ms until PHY ready */
        /* smc91x interrupt pin */
        omap_request_gpio(8);
-       omap_set_gpio_edge_ctrl(8, OMAP_GPIO_RISING_EDGE);
        /* 16C554 reset*/
        omap_request_gpio(6);
        omap_set_gpio_direction(6, 0);
@@ -155,14 +183,19 @@ static void __init voiceblue_init(void)
        omap_request_gpio(13);
        omap_request_gpio(14);
        omap_request_gpio(15);
-       omap_set_gpio_edge_ctrl(12, OMAP_GPIO_RISING_EDGE);
-       omap_set_gpio_edge_ctrl(13, OMAP_GPIO_RISING_EDGE);
-       omap_set_gpio_edge_ctrl(14, OMAP_GPIO_RISING_EDGE);
-       omap_set_gpio_edge_ctrl(15, OMAP_GPIO_RISING_EDGE);
+       set_irq_type(OMAP_GPIO_IRQ(12), IRQT_RISING);
+       set_irq_type(OMAP_GPIO_IRQ(13), IRQT_RISING);
+       set_irq_type(OMAP_GPIO_IRQ(14), IRQT_RISING);
+       set_irq_type(OMAP_GPIO_IRQ(15), IRQT_RISING);
 
        platform_add_devices(voiceblue_devices, ARRAY_SIZE(voiceblue_devices));
        omap_board_config = voiceblue_config;
        omap_board_config_size = ARRAY_SIZE(voiceblue_config);
+
+       /* There is a good chance board is going up, so enable power LED
+        * (it is connected through invertor) */
+       omap_writeb(0x00, OMAP_LPG1_LCR);
+       omap_writeb(0x00, OMAP_LPG1_PMR);       /* Disable clock */
 }
 
 static int __initdata omap_serial_ports[OMAP_MAX_NR_PORTS] = {1, 1, 1};
@@ -184,9 +217,9 @@ static int panic_event(struct notifier_block *this, unsigned long event,
        if (test_and_set_bit(MACHINE_PANICED, &machine_state))
                return NOTIFY_DONE;
 
-       /* Flash Power LED
-        * (TODO: Enable clock right way (enabled in bootloader already)) */
+       /* Flash power LED */
        omap_writeb(0x78, OMAP_LPG1_LCR);
+       omap_writeb(0x01, OMAP_LPG1_PMR);       /* Enable clock */
 
        return NOTIFY_DONE;
 }
@@ -195,15 +228,14 @@ static struct notifier_block panic_block = {
        .notifier_call  = panic_event,
 };
 
-static int __init setup_notifier(void)
+static int __init voiceblue_setup(void)
 {
        /* Setup panic notifier */
        notifier_chain_register(&panic_notifier_list, &panic_block);
 
        return 0;
 }
-
-postcore_initcall(setup_notifier);
+postcore_initcall(voiceblue_setup);
 
 static int wdt_gpio_state;
 
diff --git a/arch/arm/mach-omap1/devices.c b/arch/arm/mach-omap1/devices.c
new file mode 100644 (file)
index 0000000..e8b3981
--- /dev/null
@@ -0,0 +1,351 @@
+/*
+ * linux/arch/arm/mach-omap1/devices.c
+ *
+ * OMAP1 platform device setup/initialization
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ */
+
+#include <linux/config.h>
+#include <linux/module.h>
+#include <linux/kernel.h>
+#include <linux/init.h>
+#include <linux/device.h>
+
+#include <asm/hardware.h>
+#include <asm/io.h>
+#include <asm/mach-types.h>
+#include <asm/mach/map.h>
+
+#include <asm/arch/tc.h>
+#include <asm/arch/board.h>
+#include <asm/arch/mux.h>
+#include <asm/arch/gpio.h>
+
+
+static void omap_nop_release(struct device *dev)
+{
+        /* Nothing */
+}
+
+/*-------------------------------------------------------------------------*/
+
+#if    defined(CONFIG_I2C_OMAP) || defined(CONFIG_I2C_OMAP_MODULE)
+
+#define        OMAP_I2C_BASE           0xfffb3800
+
+static struct resource i2c_resources[] = {
+       {
+               .start          = OMAP_I2C_BASE,
+               .end            = OMAP_I2C_BASE + 0x3f,
+               .flags          = IORESOURCE_MEM,
+       },
+       {
+               .start          = INT_I2C,
+               .flags          = IORESOURCE_IRQ,
+       },
+};
+
+/* DMA not used; works around erratum writing to non-empty i2c fifo */
+
+static struct platform_device omap_i2c_device = {
+        .name           = "i2c_omap",
+        .id             = -1,
+        .dev = {
+                .release        = omap_nop_release,
+        },
+       .num_resources  = ARRAY_SIZE(i2c_resources),
+       .resource       = i2c_resources,
+};
+
+static void omap_init_i2c(void)
+{
+       /* FIXME define and use a boot tag, in case of boards that
+        * either don't wire up I2C, or chips that mux it differently...
+        * it can include clocking and address info, maybe more.
+        */
+       omap_cfg_reg(I2C_SCL);
+       omap_cfg_reg(I2C_SDA);
+
+       (void) platform_device_register(&omap_i2c_device);
+}
+#else
+static inline void omap_init_i2c(void) {}
+#endif
+
+/*-------------------------------------------------------------------------*/
+
+#if    defined(CONFIG_OMAP1610_IR) || defined(CONFIG_OMAP161O_IR_MODULE)
+
+static u64 irda_dmamask = 0xffffffff;
+
+static struct platform_device omap1610ir_device = {
+       .name = "omap1610-ir",
+       .id = -1,
+       .dev = {
+               .release        = omap_nop_release,
+               .dma_mask       = &irda_dmamask,
+       },
+};
+
+static void omap_init_irda(void)
+{
+       /* FIXME define and use a boot tag, members something like:
+        *  u8          uart;           // uart1, or uart3
+        * ... but driver only handles uart3 for now
+        *  s16         fir_sel;        // gpio for SIR vs FIR
+        * ... may prefer a callback for SIR/MIR/FIR mode select;
+        * while h2 uses a GPIO, H3 uses a gpio expander
+        */
+       if (machine_is_omap_h2()
+                       || machine_is_omap_h3())
+               (void) platform_device_register(&omap1610ir_device);
+}
+#else
+static inline void omap_init_irda(void) {}
+#endif
+
+/*-------------------------------------------------------------------------*/
+
+#if    defined(CONFIG_MMC_OMAP) || defined(CONFIG_MMC_OMAP_MODULE)
+
+#define        OMAP_MMC1_BASE          0xfffb7800
+#define        OMAP_MMC2_BASE          0xfffb7c00      /* omap16xx only */
+
+static struct omap_mmc_conf mmc1_conf;
+
+static u64 mmc1_dmamask = 0xffffffff;
+
+static struct resource mmc1_resources[] = {
+       {
+               .start          = IO_ADDRESS(OMAP_MMC1_BASE),
+               .end            = IO_ADDRESS(OMAP_MMC1_BASE) + 0x7f,
+               .flags          = IORESOURCE_MEM,
+       },
+       {
+               .start          = INT_MMC,
+               .flags          = IORESOURCE_IRQ,
+       },
+};
+
+static struct platform_device mmc_omap_device1 = {
+       .name           = "mmci-omap",
+       .id             = 1,
+       .dev = {
+               .release        = omap_nop_release,
+               .dma_mask       = &mmc1_dmamask,
+               .platform_data  = &mmc1_conf,
+       },
+       .num_resources  = ARRAY_SIZE(mmc1_resources),
+       .resource       = mmc1_resources,
+};
+
+#ifdef CONFIG_ARCH_OMAP16XX
+
+static struct omap_mmc_conf mmc2_conf;
+
+static u64 mmc2_dmamask = 0xffffffff;
+
+static struct resource mmc2_resources[] = {
+       {
+               .start          = IO_ADDRESS(OMAP_MMC2_BASE),
+               .end            = IO_ADDRESS(OMAP_MMC2_BASE) + 0x7f,
+               .flags          = IORESOURCE_MEM,
+       },
+       {
+               .start          = INT_1610_MMC2,
+               .flags          = IORESOURCE_IRQ,
+       },
+};
+
+static struct platform_device mmc_omap_device2 = {
+       .name           = "mmci-omap",
+       .id             = 2,
+       .dev = {
+               .release        = omap_nop_release,
+               .dma_mask       = &mmc2_dmamask,
+               .platform_data  = &mmc2_conf,
+       },
+       .num_resources  = ARRAY_SIZE(mmc2_resources),
+       .resource       = mmc2_resources,
+};
+#endif
+
+static void __init omap_init_mmc(void)
+{
+       const struct omap_mmc_config    *mmc_conf;
+       const struct omap_mmc_conf      *mmc;
+
+       /* NOTE:  assumes MMC was never (wrongly) enabled */
+       mmc_conf = omap_get_config(OMAP_TAG_MMC, struct omap_mmc_config);
+       if (!mmc_conf)
+               return;
+
+       /* block 1 is always available and has just one pinout option */
+       mmc = &mmc_conf->mmc[0];
+       if (mmc->enabled) {
+               omap_cfg_reg(MMC_CMD);
+               omap_cfg_reg(MMC_CLK);
+               omap_cfg_reg(MMC_DAT0);
+               if (cpu_is_omap1710()) {
+                     omap_cfg_reg(M15_1710_MMC_CLKI);
+                     omap_cfg_reg(P19_1710_MMC_CMDDIR);
+                     omap_cfg_reg(P20_1710_MMC_DATDIR0);
+               }
+               if (mmc->wire4) {
+                       omap_cfg_reg(MMC_DAT1);
+                       /* NOTE:  DAT2 can be on W10 (here) or M15 */
+                       if (!mmc->nomux)
+                               omap_cfg_reg(MMC_DAT2);
+                       omap_cfg_reg(MMC_DAT3);
+               }
+               mmc1_conf = *mmc;
+               (void) platform_device_register(&mmc_omap_device1);
+       }
+
+#ifdef CONFIG_ARCH_OMAP16XX
+       /* block 2 is on newer chips, and has many pinout options */
+       mmc = &mmc_conf->mmc[1];
+       if (mmc->enabled) {
+               if (!mmc->nomux) {
+                       omap_cfg_reg(Y8_1610_MMC2_CMD);
+                       omap_cfg_reg(Y10_1610_MMC2_CLK);
+                       omap_cfg_reg(R18_1610_MMC2_CLKIN);
+                       omap_cfg_reg(W8_1610_MMC2_DAT0);
+                       if (mmc->wire4) {
+                               omap_cfg_reg(V8_1610_MMC2_DAT1);
+                               omap_cfg_reg(W15_1610_MMC2_DAT2);
+                               omap_cfg_reg(R10_1610_MMC2_DAT3);
+                       }
+
+                       /* These are needed for the level shifter */
+                       omap_cfg_reg(V9_1610_MMC2_CMDDIR);
+                       omap_cfg_reg(V5_1610_MMC2_DATDIR0);
+                       omap_cfg_reg(W19_1610_MMC2_DATDIR1);
+               }
+
+               /* Feedback clock must be set on OMAP-1710 MMC2 */
+               if (cpu_is_omap1710())
+                       omap_writel(omap_readl(MOD_CONF_CTRL_1) | (1 << 24),
+                                    MOD_CONF_CTRL_1);
+               mmc2_conf = *mmc;
+               (void) platform_device_register(&mmc_omap_device2);
+       }
+#endif
+       return;
+}
+#else
+static inline void omap_init_mmc(void) {}
+#endif
+
+#if    defined(CONFIG_OMAP_RTC) || defined(CONFIG_OMAP_RTC)
+
+#define        OMAP_RTC_BASE           0xfffb4800
+
+static struct resource rtc_resources[] = {
+       {
+               .start          = OMAP_RTC_BASE,
+               .end            = OMAP_RTC_BASE + 0x5f,
+               .flags          = IORESOURCE_MEM,
+       },
+       {
+               .start          = INT_RTC_TIMER,
+               .flags          = IORESOURCE_IRQ,
+       },
+       {
+               .start          = INT_RTC_ALARM,
+               .flags          = IORESOURCE_IRQ,
+       },
+};
+
+static struct platform_device omap_rtc_device = {
+       .name           = "omap_rtc",
+       .id             = -1,
+       .dev = {
+               .release        = omap_nop_release,
+       },
+       .num_resources  = ARRAY_SIZE(rtc_resources),
+       .resource       = rtc_resources,
+};
+
+static void omap_init_rtc(void)
+{
+       (void) platform_device_register(&omap_rtc_device);
+}
+#else
+static inline void omap_init_rtc(void) {}
+#endif
+
+/*-------------------------------------------------------------------------*/
+
+#if    defined(CONFIG_OMAP16XX_WATCHDOG) || defined(CONFIG_OMAP16XX_WATCHDOG_MODULE)
+
+#define        OMAP_WDT_BASE           0xfffeb000
+
+static struct resource wdt_resources[] = {
+       {
+               .start          = OMAP_WDT_BASE,
+               .end            = OMAP_WDT_BASE + 0x4f,
+               .flags          = IORESOURCE_MEM,
+       },
+};
+
+static struct platform_device omap_wdt_device = {
+       .name      = "omap1610_wdt",
+       .id          = -1,
+       .dev = {
+               .release        = omap_nop_release,
+       },
+       .num_resources  = ARRAY_SIZE(wdt_resources),
+       .resource       = wdt_resources,
+};
+
+static void omap_init_wdt(void)
+{
+       (void) platform_device_register(&omap_wdt_device);
+}
+#else
+static inline void omap_init_wdt(void) {}
+#endif
+
+
+/*-------------------------------------------------------------------------*/
+
+/*
+ * This gets called after board-specific INIT_MACHINE, and initializes most
+ * on-chip peripherals accessible on this board (except for few like USB):
+ *
+ *  (a) Does any "standard config" pin muxing needed.  Board-specific
+ *     code will have muxed GPIO pins and done "nonstandard" setup;
+ *     that code could live in the boot loader.
+ *  (b) Populating board-specific platform_data with the data drivers
+ *     rely on to handle wiring variations.
+ *  (c) Creating platform devices as meaningful on this board and
+ *     with this kernel configuration.
+ *
+ * Claiming GPIOs, and setting their direction and initial values, is the
+ * responsibility of the device drivers.  So is responding to probe().
+ *
+ * Board-specific knowlege like creating devices or pin setup is to be
+ * kept out of drivers as much as possible.  In particular, pin setup
+ * may be handled by the boot loader, and drivers should expect it will
+ * normally have been done by the time they're probed.
+ */
+static int __init omap_init_devices(void)
+{
+       /* please keep these calls, and their implementations above,
+        * in alphabetical order so they're easier to sort through.
+        */
+       omap_init_i2c();
+       omap_init_irda();
+       omap_init_mmc();
+       omap_init_rtc();
+       omap_init_wdt();
+
+       return 0;
+}
+arch_initcall(omap_init_devices);
+
index c12a7833562570a4e88497c85b5381f3dd0ad080..aca2a120813ae9f95456749a36939d447019a292 100644 (file)
@@ -1,5 +1,5 @@
 /*
- * linux/arch/arm/mach-omap/fpga.c
+ * linux/arch/arm/mach-omap1/fpga.c
  *
  * Interrupt handler for OMAP-1510 Innovator FPGA
  *
@@ -181,7 +181,7 @@ void omap1510_fpga_init_irq(void)
         */
        omap_request_gpio(13);
        omap_set_gpio_direction(13, 1);
-       omap_set_gpio_edge_ctrl(13, OMAP_GPIO_RISING_EDGE);
+       set_irq_type(OMAP_GPIO_IRQ(13), IRQT_RISING);
        set_irq_chained_handler(OMAP1510_INT_FPGA, innovator_fpga_IRQ_demux);
 }
 
index 207df0fe934dacbc3c65a9d6fe8e8a3932837c54..eb8261d7dead9b0eb99ae98887f6a540c79450f8 100644 (file)
@@ -19,6 +19,7 @@
 
 extern int clk_init(void);
 extern void omap_check_revision(void);
+extern void omap_sram_init(void);
 
 /*
  * The machine specific code may provide the extra mapping besides the
@@ -32,7 +33,6 @@ static struct map_desc omap_io_desc[] __initdata = {
 static struct map_desc omap730_io_desc[] __initdata = {
  { OMAP730_DSP_BASE,    OMAP730_DSP_START,    OMAP730_DSP_SIZE,    MT_DEVICE },
  { OMAP730_DSPREG_BASE, OMAP730_DSPREG_START, OMAP730_DSPREG_SIZE, MT_DEVICE },
- { OMAP730_SRAM_BASE,   OMAP730_SRAM_START,   OMAP730_SRAM_SIZE,   MT_DEVICE }
 };
 #endif
 
@@ -40,27 +40,13 @@ static struct map_desc omap730_io_desc[] __initdata = {
 static struct map_desc omap1510_io_desc[] __initdata = {
  { OMAP1510_DSP_BASE,    OMAP1510_DSP_START,    OMAP1510_DSP_SIZE,    MT_DEVICE },
  { OMAP1510_DSPREG_BASE, OMAP1510_DSPREG_START, OMAP1510_DSPREG_SIZE, MT_DEVICE },
- { OMAP1510_SRAM_BASE,   OMAP1510_SRAM_START,   OMAP1510_SRAM_SIZE,   MT_DEVICE }
 };
 #endif
 
 #if defined(CONFIG_ARCH_OMAP16XX)
-static struct map_desc omap1610_io_desc[] __initdata = {
+static struct map_desc omap16xx_io_desc[] __initdata = {
  { OMAP16XX_DSP_BASE,    OMAP16XX_DSP_START,    OMAP16XX_DSP_SIZE,    MT_DEVICE },
  { OMAP16XX_DSPREG_BASE, OMAP16XX_DSPREG_START, OMAP16XX_DSPREG_SIZE, MT_DEVICE },
- { OMAP16XX_SRAM_BASE,   OMAP16XX_SRAM_START,   OMAP1610_SRAM_SIZE,   MT_DEVICE }
-};
-
-static struct map_desc omap5912_io_desc[] __initdata = {
- { OMAP16XX_DSP_BASE,    OMAP16XX_DSP_START,    OMAP16XX_DSP_SIZE,    MT_DEVICE },
- { OMAP16XX_DSPREG_BASE, OMAP16XX_DSPREG_START, OMAP16XX_DSPREG_SIZE, MT_DEVICE },
-/*
- * The OMAP5912 has 250kByte internal SRAM. Because the mapping is baseed on page
- * size (4kByte), it seems that the last 2kByte (=0x800) of the 250kByte are not mapped.
- * Add additional 2kByte (0x800) so that the last page is mapped and the last 2kByte
- * can be used.
- */
- { OMAP16XX_SRAM_BASE,   OMAP16XX_SRAM_START,   OMAP5912_SRAM_SIZE + 0x800,   MT_DEVICE }
 };
 #endif
 
@@ -86,14 +72,13 @@ static void __init _omap_map_io(void)
        }
 #endif
 #if defined(CONFIG_ARCH_OMAP16XX)
-       if (cpu_is_omap1610() || cpu_is_omap1710()) {
-               iotable_init(omap1610_io_desc, ARRAY_SIZE(omap1610_io_desc));
-       }
-       if (cpu_is_omap5912()) {
-               iotable_init(omap5912_io_desc, ARRAY_SIZE(omap5912_io_desc));
+       if (cpu_is_omap16xx()) {
+               iotable_init(omap16xx_io_desc, ARRAY_SIZE(omap16xx_io_desc));
        }
 #endif
 
+       omap_sram_init();
+
        /* REVISIT: Refer to OMAP5910 Errata, Advisory SYS_1: "Timeout Abort
         * on a Posted Write in the TIPB Bridge".
         */
@@ -108,8 +93,9 @@ static void __init _omap_map_io(void)
 /*
  * This should only get called from board specific init
  */
-void omap_map_common_io(void)
+void __init omap_map_common_io(void)
 {
        if (!initialized)
                _omap_map_io();
 }
+
index afd5d67e4ae73625e25a88bcf93ef79b34323602..192ce6055faabb13f31c6e49c6c4b3b05b3dda9e 100644 (file)
@@ -1,5 +1,5 @@
 /*
- * linux/arch/arm/mach-omap/irq.c
+ * linux/arch/arm/mach-omap1/irq.c
  *
  * Interrupt handler for all OMAP boards
  *
index ec0d8285f243dcaf5885130c10cac1108b2ac448..be283cda63dda9f5817c0e9befce16d7e135974c 100644 (file)
@@ -1,5 +1,5 @@
 /*
- * linux/arch/arm/mach-omap/leds-h2p2-debug.c
+ * linux/arch/arm/mach-omap1/leds-h2p2-debug.c
  *
  * Copyright 2003 by Texas Instruments Incorporated
  *
@@ -13,6 +13,7 @@
 #include <linux/init.h>
 #include <linux/kernel_stat.h>
 #include <linux/sched.h>
+#include <linux/version.h>
 
 #include <asm/io.h>
 #include <asm/hardware.h>
index 8043b7d0f66e7008afc755051a959cc80275744d..c8ffd1ddcdedff180bfc682560419236a16568bf 100644 (file)
@@ -1,5 +1,5 @@
 /*
- * linux/arch/arm/mach-omap/leds-innovator.c
+ * linux/arch/arm/mach-omap1/leds-innovator.c
  */
 #include <linux/config.h>
 #include <linux/init.h>
index 4a0e8b9d4fc37d5748e067c01ff0b84a59d1e1d2..2c8bda847c186e3a47ecf8518000bc1d8406dd91 100644 (file)
@@ -1,5 +1,5 @@
 /*
- * linux/arch/arm/mach-omap/leds-osk.c
+ * linux/arch/arm/mach-omap1/leds-osk.c
  *
  * LED driver for OSK, and optionally Mistral QVGA, boards
  */
@@ -64,7 +64,7 @@ static void tps_work(void *unused)
 
 static DECLARE_WORK(work, tps_work, NULL);
 
-#ifdef CONFIG_FB_OMAP
+#ifdef CONFIG_OMAP_OSK_MISTRAL
 
 /* For now, all system indicators require the Mistral board, since that
  * LED can be manipulated without a task context.  This LED is either red,
@@ -127,7 +127,7 @@ void osk_leds_event(led_event_t evt)
                hw_led_state = 0;
                break;
 
-#ifdef CONFIG_FB_OMAP
+#ifdef CONFIG_OMAP_OSK_MISTRAL
 
        case led_timer:
                hw_led_state ^= TIMER_LED;
@@ -144,7 +144,7 @@ void osk_leds_event(led_event_t evt)
                mistral_setled();
                break;
 
-#endif /* CONFIG_FB_OMAP */
+#endif /* CONFIG_OMAP_OSK_MISTRAL */
 
        /* "green" == tps LED1 (leftmost, normally power-good)
         * works only with DC adapter, not on battery power!
index 8ab21fe98e1bc388c0e3a40a4b83bb919a88c622..5c6b1bb6e722deda5bf715e5435498b2846c7228 100644 (file)
@@ -1,5 +1,5 @@
 /*
- * linux/arch/arm/mach-omap/leds.c
+ * linux/arch/arm/mach-omap1/leds.c
  *
  * OMAP LEDs dispatcher
  */
@@ -20,7 +20,9 @@ omap_leds_init(void)
        if (machine_is_omap_innovator())
                leds_event = innovator_leds_event;
 
-       else if (machine_is_omap_h2() || machine_is_omap_perseus2())
+       else if (machine_is_omap_h2()
+                       || machine_is_omap_h3()
+                       || machine_is_omap_perseus2())
                leds_event = h2p2_dbg_leds_event;
 
        else if (machine_is_omap_osk())
@@ -30,8 +32,12 @@ omap_leds_init(void)
                return -1;
 
        if (machine_is_omap_h2()
+                       || machine_is_omap_h3()
                        || machine_is_omap_perseus2()
-                       || machine_is_omap_osk()) {
+#ifdef CONFIG_OMAP_OSK_MISTRAL
+                       || machine_is_omap_osk()
+#endif
+                       ) {
 
                /* LED1/LED2 pins can be used as GPIO (as done here), or by
                 * the LPG (works even in deep sleep!), to drive a bicolor
index 214e5d17c8b56eed98458405885ccaf573c7c318..40c4f7c40e73369d6b7f052ca66e966012b99d67 100644 (file)
 
 #include <asm/arch/board.h>
 #include <asm/arch/mux.h>
+#include <asm/arch/gpio.h>
 #include <asm/arch/fpga.h>
+#ifdef CONFIG_PM
+#include <asm/arch/pm.h>
+#endif
 
 static struct clk * uart1_ck = NULL;
 static struct clk * uart2_ck = NULL;
@@ -94,7 +98,7 @@ static struct plat_serial8250_port serial_platform_data[] = {
 
 static struct platform_device serial_device = {
        .name                   = "serial8250",
-       .id                     = 0,
+       .id                     = PLAT8250_DEV_PLATFORM,
        .dev                    = {
                .platform_data  = serial_platform_data,
        },
@@ -193,6 +197,86 @@ void __init omap_serial_init(int ports[OMAP_MAX_NR_PORTS])
        }
 }
 
+#ifdef CONFIG_OMAP_SERIAL_WAKE
+
+static irqreturn_t omap_serial_wake_interrupt(int irq, void *dev_id,
+                                             struct pt_regs *regs)
+{
+       /* Need to do something with serial port right after wake-up? */
+       return IRQ_HANDLED;
+}
+
+/*
+ * Reroutes serial RX lines to GPIO lines for the duration of
+ * sleep to allow waking up the device from serial port even
+ * in deep sleep.
+ */
+void omap_serial_wake_trigger(int enable)
+{
+       if (!cpu_is_omap16xx())
+               return;
+
+       if (uart1_ck != NULL) {
+               if (enable)
+                       omap_cfg_reg(V14_16XX_GPIO37);
+               else
+                       omap_cfg_reg(V14_16XX_UART1_RX);
+       }
+       if (uart2_ck != NULL) {
+               if (enable)
+                       omap_cfg_reg(R9_16XX_GPIO18);
+               else
+                       omap_cfg_reg(R9_16XX_UART2_RX);
+       }
+       if (uart3_ck != NULL) {
+               if (enable)
+                       omap_cfg_reg(L14_16XX_GPIO49);
+               else
+                       omap_cfg_reg(L14_16XX_UART3_RX);
+       }
+}
+
+static void __init omap_serial_set_port_wakeup(int gpio_nr)
+{
+       int ret;
+
+       ret = omap_request_gpio(gpio_nr);
+       if (ret < 0) {
+               printk(KERN_ERR "Could not request UART wake GPIO: %i\n",
+                      gpio_nr);
+               return;
+       }
+       omap_set_gpio_direction(gpio_nr, 1);
+       set_irq_type(OMAP_GPIO_IRQ(gpio_nr), IRQT_RISING);
+       ret = request_irq(OMAP_GPIO_IRQ(gpio_nr), &omap_serial_wake_interrupt,
+                         0, "serial wakeup", NULL);
+       if (ret) {
+               omap_free_gpio(gpio_nr);
+               printk(KERN_ERR "No interrupt for UART wake GPIO: %i\n",
+                      gpio_nr);
+               return;
+       }
+       enable_irq_wake(OMAP_GPIO_IRQ(gpio_nr));
+}
+
+static int __init omap_serial_wakeup_init(void)
+{
+       if (!cpu_is_omap16xx())
+               return 0;
+
+       if (uart1_ck != NULL)
+               omap_serial_set_port_wakeup(37);
+       if (uart2_ck != NULL)
+               omap_serial_set_port_wakeup(18);
+       if (uart3_ck != NULL)
+               omap_serial_set_port_wakeup(49);
+
+       return 0;
+}
+late_initcall(omap_serial_wakeup_init);
+
+#endif /* CONFIG_OMAP_SERIAL_WAKE */
+
 static int __init omap_init(void)
 {
        return platform_device_register(&serial_device);
index d540539c9bbb7e23fd27e3d4272a481ce21f136a..191a9b1ee9b7168f1ef3b561b08f732e55b4c2bf 100644 (file)
@@ -247,13 +247,6 @@ unsigned long long sched_clock(void)
 #define OMAP_32K_TIMER_TCR             0x04
 
 #define OMAP_32K_TICKS_PER_HZ          (32768 / HZ)
-#if (32768 % HZ) != 0
-/* We cannot ignore modulo.
- * Potential error can be as high as several percent.
- */
-#define OMAP_32K_TICK_MODULO           (32768 % HZ)
-static unsigned modulo_count = 0; /* Counts 1/HZ units */
-#endif
 
 /*
  * TRM says 1 / HZ = ( TVR + 1) / 32768, so TRV = (32768 / HZ) - 1
@@ -296,13 +289,22 @@ static inline void omap_32k_timer_stop(void)
 }
 
 /*
- * Rounds down to nearest usec
+ * Rounds down to nearest usec. Note that this will overflow for larger values.
  */
 static inline unsigned long omap_32k_ticks_to_usecs(unsigned long ticks_32k)
 {
        return (ticks_32k * 5*5*5*5*5*5) >> 9;
 }
 
+/*
+ * Rounds down to nearest nsec.
+ */
+static inline unsigned long long
+omap_32k_ticks_to_nsecs(unsigned long ticks_32k)
+{
+       return (unsigned long long) ticks_32k * 1000 * 5*5*5*5*5*5 >> 9;
+}
+
 static unsigned long omap_32k_last_tick = 0;
 
 /*
@@ -314,6 +316,15 @@ static unsigned long omap_32k_timer_gettimeoffset(void)
        return omap_32k_ticks_to_usecs(now - omap_32k_last_tick);
 }
 
+/*
+ * Returns current time from boot in nsecs. It's OK for this to wrap
+ * around for now, as it's just a relative time stamp.
+ */
+unsigned long long sched_clock(void)
+{
+       return omap_32k_ticks_to_nsecs(omap_32k_sync_timer_read());
+}
+
 /*
  * Timer interrupt for 32KHz timer. When dynamic tick is enabled, this
  * function is also called from other interrupts to remove latency
@@ -330,19 +341,6 @@ static irqreturn_t omap_32k_timer_interrupt(int irq, void *dev_id,
        now = omap_32k_sync_timer_read();
 
        while (now - omap_32k_last_tick >= OMAP_32K_TICKS_PER_HZ) {
-#ifdef OMAP_32K_TICK_MODULO
-               /* Modulo addition may put omap_32k_last_tick ahead of now
-                * and cause unwanted repetition of the while loop.
-                */
-               if (unlikely(now - omap_32k_last_tick == ~0))
-                       break;
-
-               modulo_count += OMAP_32K_TICK_MODULO;
-               if (modulo_count > HZ) {
-                       ++omap_32k_last_tick;
-                       modulo_count -= HZ;
-               }
-#endif
                omap_32k_last_tick += OMAP_32K_TICKS_PER_HZ;
                timer_tick(regs);
        }
index a10268618f7414674e438fb30d9569acf06b2f0c..e3587efec4bf685683d3f1a812e791cd41430f0a 100644 (file)
@@ -140,7 +140,7 @@ static struct plat_serial8250_port serial_platform_data[] = {
 
 static struct platform_device serial_device = {
        .name                   = "serial8250",
-       .id                     = 0,
+       .id                     = PLAT8250_DEV_PLATFORM,
        .dev                    = {
                .platform_data  = serial_platform_data,
        },
index e9182242da95be91ebe9dfc5f389c0a3318d8a5e..1a3367da640897e30acf33118d5fca4073a7fc1a 100644 (file)
@@ -381,7 +381,7 @@ static struct plat_serial8250_port bast_sio_data[] = {
 
 static struct platform_device bast_sio = {
        .name                   = "serial8250",
-       .id                     = 0,
+       .id                     = PLAT8250_DEV_PLATFORM,
        .dev                    = {
                .platform_data  = &bast_sio_data,
        },
index 924e8464c21273b5503d7aa7c96593ba28f281cb..8f9ab2893df4b718bf29613b971ec79cc03ff117 100644 (file)
@@ -221,7 +221,7 @@ static struct plat_serial8250_port serial_platform_data[] = {
 
 static struct platform_device serial_device = {
        .name                   = "serial8250",
-       .id                     = 0,
+       .id                     = PLAT8250_DEV_PLATFORM,
        .dev                    = {
                .platform_data  = serial_platform_data,
        },
index e737eae4521f6fe5b7a8a58abb26c7a9be5b2a6c..946c0d11c73b6d80c0dd8e60c8725ba478dd270b 100644 (file)
@@ -41,7 +41,7 @@ static struct plat_serial8250_port serial_platform_data[] = {
 
 static struct platform_device serial_device = {
        .name                   = "serial8250",
-       .id                     = 0,
+       .id                     = PLAT8250_DEV_PLATFORM,
        .dev                    = {
                .platform_data  = serial_platform_data,
        },
index 191788fb18d13a4f3adad73afd92a649c0c7ff21..b0208c9925764940db06976ec69665b66d7275e0 100644 (file)
 #include <asm/tlbflush.h>
 
 #ifdef CONFIG_CPU_CACHE_VIPT
+
+void flush_cache_mm(struct mm_struct *mm)
+{
+       if (cache_is_vivt()) {
+               if (cpu_isset(smp_processor_id(), mm->cpu_vm_mask))
+                       __cpuc_flush_user_all();
+               return;
+       }
+
+       if (cache_is_vipt_aliasing()) {
+               asm(    "mcr    p15, 0, %0, c7, c14, 0\n"
+               "       mcr     p15, 0, %0, c7, c5, 0\n"
+               "       mcr     p15, 0, %0, c7, c10, 4"
+                   :
+                   : "r" (0)
+                   : "cc");
+       }
+}
+
+void flush_cache_range(struct vm_area_struct *vma, unsigned long start, unsigned long end)
+{
+       if (cache_is_vivt()) {
+               if (cpu_isset(smp_processor_id(), vma->vm_mm->cpu_vm_mask))
+                       __cpuc_flush_user_range(start & PAGE_MASK, PAGE_ALIGN(end),
+                                               vma->vm_flags);
+               return;
+       }
+
+       if (cache_is_vipt_aliasing()) {
+               asm(    "mcr    p15, 0, %0, c7, c14, 0\n"
+               "       mcr     p15, 0, %0, c7, c5, 0\n"
+               "       mcr     p15, 0, %0, c7, c10, 4"
+                   :
+                   : "r" (0)
+                   : "cc");
+       }
+}
+
+void flush_cache_page(struct vm_area_struct *vma, unsigned long user_addr, unsigned long pfn)
+{
+       if (cache_is_vivt()) {
+               if (cpu_isset(smp_processor_id(), vma->vm_mm->cpu_vm_mask)) {
+                       unsigned long addr = user_addr & PAGE_MASK;
+                       __cpuc_flush_user_range(addr, addr + PAGE_SIZE, vma->vm_flags);
+               }
+               return;
+       }
+
+       if (cache_is_vipt_aliasing())
+               flush_pfn_alias(pfn, user_addr);
+}
+
 #define ALIAS_FLUSH_START      0xffff4000
 
 #define TOP_PTE(x)     pte_offset_kernel(top_pmd, x)
index 3cc480998a47d4000013cd093aeb0e26b7a5d2ff..6d6338500c3cac7d0b2a8ae4f32c746346bcc383 100644 (file)
@@ -283,9 +283,9 @@ int pci_mmap_page_range(struct pci_dev *dev, struct vm_area_struct *vma,
        /* Write-combine setting is ignored, it is changed via the mtrr
         * interfaces on this platform.
         */
-       if (remap_pfn_range(vma, vma->vm_start, vma->vm_pgoff,
-                            vma->vm_end - vma->vm_start,
-                            vma->vm_page_prot))
+       if (io_remap_pfn_range(vma, vma->vm_start, vma->vm_pgoff,
+                              vma->vm_end - vma->vm_start,
+                              vma->vm_page_prot))
                return -EAGAIN;
 
        return 0;
index 7b3586a3bf302f22289ab5cf6cbe2e874edeed09..854e45beb387bfdc6bddd6bb9a816d3d9a17f2b8 100644 (file)
@@ -80,7 +80,6 @@ fixup_broken_pcnet32(struct pci_dev* dev)
        if ((dev->class>>8 == PCI_CLASS_NETWORK_ETHERNET)) {
                dev->vendor = PCI_VENDOR_ID_AMD;
                pci_write_config_word(dev, PCI_VENDOR_ID, PCI_VENDOR_ID_AMD);
-               pci_name_device(dev);
        }
 }
 DECLARE_PCI_FIXUP_HEADER(PCI_VENDOR_ID_TRIDENT,        PCI_ANY_ID,                     fixup_broken_pcnet32);
index 87065e2e4c5f726be73b004900a253052980e0cf..3e039706bdbcbc350430d068bd965c65757dd5a2 100644 (file)
@@ -140,12 +140,12 @@ struct platform_device ppc_sys_platform_devices[] = {
        },
        [MPC10X_UART0] = {
                .name = "serial8250",
-               .id     = 0,
+               .id     = PLAT8250_DEV_PLATFORM,
                .dev.platform_data = serial_plat_uart0,
        },
        [MPC10X_UART1] = {
                .name = "serial8250",
-               .id     = 1,
+               .id     = PLAT8250_DEV_PLATFORM1,
                .dev.platform_data = serial_plat_uart1,
        },
 
index 5aaf0e58e1f9d2f7b0b187ed475e98c81c8901de..95b3b8a7f0bae34386bfdbe6409a35253a4250ea 100644 (file)
@@ -165,7 +165,7 @@ struct platform_device ppc_sys_platform_devices[] = {
        },
        [MPC83xx_DUART] = {
                .name = "serial8250",
-               .id     = 0,
+               .id     = PLAT8250_DEV_PLATFORM,
                .dev.platform_data = serial_platform_data,
        },
        [MPC83xx_SEC2] = {
index 8af322dd476a6467cda34d4983d1e589d46f21a4..bbc5ac0de87835f7251fc0980f89166efb2fc6cc 100644 (file)
@@ -282,7 +282,7 @@ struct platform_device ppc_sys_platform_devices[] = {
        },
        [MPC85xx_DUART] = {
                .name = "serial8250",
-               .id     = 0,
+               .id     = PLAT8250_DEV_PLATFORM,
                .dev.platform_data = serial_platform_data,
        },
        [MPC85xx_PERFMON] = {
index af5272fedadf4d8f4a2705edd735479dd9d96751..4c857a6516fc30814bcd4121d2d2c536bf0eaaf5 100644 (file)
@@ -202,10 +202,9 @@ static void pci_addr_cache_print(struct pci_io_addr_cache *cache)
        while (n) {
                struct pci_io_addr_range *piar;
                piar = rb_entry(n, struct pci_io_addr_range, rb_node);
-               printk(KERN_DEBUG "PCI: %s addr range %d [%lx-%lx]: %s %s\n",
+               printk(KERN_DEBUG "PCI: %s addr range %d [%lx-%lx]: %s\n",
                       (piar->flags & IORESOURCE_IO) ? "i/o" : "mem", cnt,
-                      piar->addr_lo, piar->addr_hi, pci_name(piar->pcidev),
-                      pci_pretty_name(piar->pcidev));
+                      piar->addr_lo, piar->addr_hi, pci_name(piar->pcidev));
                cnt++;
                n = rb_next(n);
        }
@@ -260,8 +259,8 @@ static void __pci_addr_cache_insert_device(struct pci_dev *dev)
 
        dn = pci_device_to_OF_node(dev);
        if (!dn) {
-               printk(KERN_WARNING "PCI: no pci dn found for dev=%s %s\n",
-                       pci_name(dev), pci_pretty_name(dev));
+               printk(KERN_WARNING "PCI: no pci dn found for dev=%s\n",
+                       pci_name(dev));
                return;
        }
 
@@ -269,8 +268,8 @@ static void __pci_addr_cache_insert_device(struct pci_dev *dev)
        if (!(dn->eeh_mode & EEH_MODE_SUPPORTED) ||
            dn->eeh_mode & EEH_MODE_NOCHECK) {
 #ifdef DEBUG
-               printk(KERN_INFO "PCI: skip building address cache for=%s %s\n",
-                      pci_name(dev), pci_pretty_name(dev));
+               printk(KERN_INFO "PCI: skip building address cache for=%s\n",
+                      pci_name(dev));
 #endif
                return;
        }
@@ -447,12 +446,12 @@ static void eeh_panic(struct pci_dev *dev, int reset_state)
         * in light of potential corruption, we can use it here.
         */
        if (panic_on_oops)
-               panic("EEH: MMIO failure (%d) on device:%s %s\n", reset_state,
-                     pci_name(dev), pci_pretty_name(dev));
+               panic("EEH: MMIO failure (%d) on device:%s\n", reset_state,
+                     pci_name(dev));
        else {
                __get_cpu_var(ignored_failures)++;
-               printk(KERN_INFO "EEH: Ignored MMIO failure (%d) on device:%s %s\n",
-                      reset_state, pci_name(dev), pci_pretty_name(dev));
+               printk(KERN_INFO "EEH: Ignored MMIO failure (%d) on device:%s\n",
+                      reset_state, pci_name(dev));
        }
 }
 
@@ -482,8 +481,8 @@ static void eeh_event_handler(void *dummy)
                        break;
 
                printk(KERN_INFO "EEH: MMIO failure (%d), notifiying device "
-                      "%s %s\n", event->reset_state,
-                      pci_name(event->dev), pci_pretty_name(event->dev));
+                      "%s\n", event->reset_state,
+                      pci_name(event->dev));
 
                atomic_set(&eeh_fail_count, 0);
                notifier_call_chain (&eeh_notifier_chain,
@@ -851,8 +850,7 @@ void eeh_add_device_late(struct pci_dev *dev)
                return;
 
 #ifdef DEBUG
-       printk(KERN_DEBUG "EEH: adding device %s %s\n", pci_name(dev),
-              pci_pretty_name(dev));
+       printk(KERN_DEBUG "EEH: adding device %s\n", pci_name(dev));
 #endif
 
        pci_addr_cache_insert_device (dev);
@@ -873,8 +871,7 @@ void eeh_remove_device(struct pci_dev *dev)
 
        /* Unregister the device with the EEH/PCI address search system */
 #ifdef DEBUG
-       printk(KERN_DEBUG "EEH: remove device %s %s\n", pci_name(dev),
-              pci_pretty_name(dev));
+       printk(KERN_DEBUG "EEH: remove device %s\n", pci_name(dev));
 #endif
        pci_addr_cache_remove_device(dev);
 }
index d11c732daf816a2a7bed18c58e0a20fa52439c0e..5d921792571f59ee3c64cbfe42caf3f679a6b6b7 100644 (file)
@@ -264,8 +264,5 @@ void __init iSeries_Device_Information(struct pci_dev *PciDev, int count)
        printk("%d. PCI: Bus%3d, Device%3d, Vendor %04X Frame%3d, Card %4s  ",
                        count, bus, PCI_SLOT(PciDev->devfn), PciDev->vendor,
                        frame, card);
-       if (pci_class_name(PciDev->class >> 8) == 0)
-               printk("0x%04X\n", (int)(PciDev->class >> 8));
-       else
-               printk("%s\n", pci_class_name(PciDev->class >> 8));
+       printk("0x%04X\n", (int)(PciDev->class >> 8));
 }
index d0d55c7908efe5a1c2bc5c584e4f9a91873b1c2f..b5ca7d8347e2ec2e9f3838650f437d97d5242871 100644 (file)
@@ -84,7 +84,6 @@ static void fixup_broken_pcnet32(struct pci_dev* dev)
        if ((dev->class>>8 == PCI_CLASS_NETWORK_ETHERNET)) {
                dev->vendor = PCI_VENDOR_ID_AMD;
                pci_write_config_word(dev, PCI_VENDOR_ID, PCI_VENDOR_ID_AMD);
-               pci_name_device(dev);
        }
 }
 DECLARE_PCI_FIXUP_HEADER(PCI_VENDOR_ID_TRIDENT, PCI_ANY_ID, fixup_broken_pcnet32);
index d0bb68af0ea41d48bca4bc945d6e727ffcd2a424..bfa8791c9807f865bb89085f0054759bbd452eaa 100644 (file)
@@ -1283,7 +1283,7 @@ void __init generic_find_legacy_serial_ports(u64 *physport,
 
 static struct platform_device serial_device = {
        .name   = "serial8250",
-       .id     = 0,
+       .id     = PLAT8250_DEV_PLATFORM,
        .dev    = {
                .platform_data = serial_ports,
        },
index ec8bf4012c0c411b66505727387d38a57f43fdc3..2ff7c32ab0ce155efd70e6a75e0f15cf2ecf62b6 100644 (file)
@@ -359,134 +359,17 @@ void pcibios_fixup_bus(struct pci_bus *pbus)
        pbus->resource[1] = &pbm->mem_space;
 }
 
-int pci_claim_resource(struct pci_dev *pdev, int resource)
+struct resource *pcibios_select_root(struct pci_dev *pdev, struct resource *r)
 {
        struct pci_pbm_info *pbm = pdev->bus->sysdata;
-       struct resource *res = &pdev->resource[resource];
-       struct resource *root;
-
-       if (!pbm)
-               return -EINVAL;
+       struct resource *root = NULL;
 
-       if (res->flags & IORESOURCE_IO)
+       if (r->flags & IORESOURCE_IO)
                root = &pbm->io_space;
-       else
+       if (r->flags & IORESOURCE_MEM)
                root = &pbm->mem_space;
 
-       pbm->parent->resource_adjust(pdev, res, root);
-
-       return request_resource(root, res);
-}
-
-/*
- * Given the PCI bus a device resides on, try to
- * find an acceptable resource allocation for a
- * specific device resource..
- */
-static int pci_assign_bus_resource(const struct pci_bus *bus,
-       struct pci_dev *dev,
-       struct resource *res,
-       unsigned long size,
-       unsigned long min,
-       int resno)
-{
-       unsigned int type_mask;
-       int i;
-
-       type_mask = IORESOURCE_IO | IORESOURCE_MEM;
-       for (i = 0 ; i < 4; i++) {
-               struct resource *r = bus->resource[i];
-               if (!r)
-                       continue;
-
-               /* type_mask must match */
-               if ((res->flags ^ r->flags) & type_mask)
-                       continue;
-
-               /* Ok, try it out.. */
-               if (allocate_resource(r, res, size, min, -1, size, NULL, NULL) < 0)
-                       continue;
-
-               /* PCI config space updated by caller.  */
-               return 0;
-       }
-       return -EBUSY;
-}
-
-int pci_assign_resource(struct pci_dev *pdev, int resource)
-{
-       struct pcidev_cookie *pcp = pdev->sysdata;
-       struct pci_pbm_info *pbm = pcp->pbm;
-       struct resource *res = &pdev->resource[resource];
-       unsigned long min, size;
-       int err;
-
-       if (res->flags & IORESOURCE_IO)
-               min = pbm->io_space.start + 0x400UL;
-       else
-               min = pbm->mem_space.start;
-
-       size = res->end - res->start + 1;
-
-       err = pci_assign_bus_resource(pdev->bus, pdev, res, size, min, resource);
-
-       if (err < 0) {
-               printk("PCI: Failed to allocate resource %d for %s\n",
-                      resource, pci_name(pdev));
-       } else {
-               /* Update PCI config space. */
-               pbm->parent->base_address_update(pdev, resource);
-       }
-
-       return err;
-}
-
-/* Sort resources by alignment */
-void pdev_sort_resources(struct pci_dev *dev, struct resource_list *head)
-{
-       int i;
-
-       for (i = 0; i < PCI_NUM_RESOURCES; i++) {
-               struct resource *r;
-               struct resource_list *list, *tmp;
-               unsigned long r_align;
-
-               r = &dev->resource[i];
-               r_align = r->end - r->start;
-               
-               if (!(r->flags) || r->parent)
-                       continue;
-               if (!r_align) {
-                       printk(KERN_WARNING "PCI: Ignore bogus resource %d "
-                                           "[%lx:%lx] of %s\n",
-                                           i, r->start, r->end, pci_name(dev));
-                       continue;
-               }
-               r_align = (i < PCI_BRIDGE_RESOURCES) ? r_align + 1 : r->start;
-               for (list = head; ; list = list->next) {
-                       unsigned long align = 0;
-                       struct resource_list *ln = list->next;
-                       int idx;
-
-                       if (ln) {
-                               idx = ln->res - &ln->dev->resource[0];
-                               align = (idx < PCI_BRIDGE_RESOURCES) ?
-                                       ln->res->end - ln->res->start + 1 :
-                                       ln->res->start;
-                       }
-                       if (r_align > align) {
-                               tmp = kmalloc(sizeof(*tmp), GFP_KERNEL);
-                               if (!tmp)
-                                       panic("pdev_sort_resources(): "
-                                             "kmalloc() failed!\n");
-                               tmp->next = ln;
-                               tmp->res = r;
-                               tmp->dev = dev;
-                               list->next = tmp;
-                               break;
-                       }
-               }
-       }
+       return root;
 }
 
 void pcibios_update_irq(struct pci_dev *pdev, int irq)
index 91ab466d6c66ba7ae9d4aab057b93fd7f1b04bf1..6ed1ef25e0ac6eb4a9b23ca1d8e17f32a4247e96 100644 (file)
@@ -307,7 +307,7 @@ static unsigned char psycho_pil_table[] = {
 /*0x32*/15,            /* Power Management             */
 };
 
-static int __init psycho_ino_to_pil(struct pci_dev *pdev, unsigned int ino)
+static int psycho_ino_to_pil(struct pci_dev *pdev, unsigned int ino)
 {
        int ret;
 
@@ -344,9 +344,9 @@ static int __init psycho_ino_to_pil(struct pci_dev *pdev, unsigned int ino)
        return ret;
 }
 
-static unsigned int __init psycho_irq_build(struct pci_pbm_info *pbm,
-                                           struct pci_dev *pdev,
-                                           unsigned int ino)
+static unsigned int psycho_irq_build(struct pci_pbm_info *pbm,
+                                    struct pci_dev *pdev,
+                                    unsigned int ino)
 {
        struct ino_bucket *bucket;
        unsigned long imap, iclr;
@@ -1024,7 +1024,7 @@ static irqreturn_t psycho_pcierr_intr(int irq, void *dev_id, struct pt_regs *reg
 #define PSYCHO_CE_INO          0x2f
 #define PSYCHO_PCIERR_A_INO    0x30
 #define PSYCHO_PCIERR_B_INO    0x31
-static void __init psycho_register_error_handlers(struct pci_controller_info *p)
+static void psycho_register_error_handlers(struct pci_controller_info *p)
 {
        struct pci_pbm_info *pbm = &p->pbm_A; /* arbitrary */
        unsigned long base = p->pbm_A.controller_regs;
@@ -1091,15 +1091,15 @@ static void __init psycho_register_error_handlers(struct pci_controller_info *p)
 }
 
 /* PSYCHO boot time probing and initialization. */
-static void __init psycho_resource_adjust(struct pci_dev *pdev,
-                                         struct resource *res,
-                                         struct resource *root)
+static void psycho_resource_adjust(struct pci_dev *pdev,
+                                  struct resource *res,
+                                  struct resource *root)
 {
        res->start += root->start;
        res->end += root->start;
 }
 
-static void __init psycho_base_address_update(struct pci_dev *pdev, int resource)
+static void psycho_base_address_update(struct pci_dev *pdev, int resource)
 {
        struct pcidev_cookie *pcp = pdev->sysdata;
        struct pci_pbm_info *pbm = pcp->pbm;
@@ -1144,7 +1144,7 @@ static void __init psycho_base_address_update(struct pci_dev *pdev, int resource
                pci_write_config_dword(pdev, where + 4, 0);
 }
 
-static void __init pbm_config_busmastering(struct pci_pbm_info *pbm)
+static void pbm_config_busmastering(struct pci_pbm_info *pbm)
 {
        u8 *addr;
 
@@ -1161,8 +1161,8 @@ static void __init pbm_config_busmastering(struct pci_pbm_info *pbm)
        pci_config_write8(addr, 64);
 }
 
-static void __init pbm_scan_bus(struct pci_controller_info *p,
-                               struct pci_pbm_info *pbm)
+static void pbm_scan_bus(struct pci_controller_info *p,
+                        struct pci_pbm_info *pbm)
 {
        struct pcidev_cookie *cookie = kmalloc(sizeof(*cookie), GFP_KERNEL);
 
@@ -1189,7 +1189,7 @@ static void __init pbm_scan_bus(struct pci_controller_info *p,
        pci_setup_busmastering(pbm, pbm->pci_bus);
 }
 
-static void __init psycho_scan_bus(struct pci_controller_info *p)
+static void psycho_scan_bus(struct pci_controller_info *p)
 {
        pbm_config_busmastering(&p->pbm_B);
        p->pbm_B.is_66mhz_capable = 0;
@@ -1204,7 +1204,7 @@ static void __init psycho_scan_bus(struct pci_controller_info *p)
        psycho_register_error_handlers(p);
 }
 
-static void __init psycho_iommu_init(struct pci_controller_info *p)
+static void psycho_iommu_init(struct pci_controller_info *p)
 {
        struct pci_iommu *iommu = p->pbm_A.iommu;
        unsigned long tsbbase, i;
@@ -1327,8 +1327,8 @@ static void psycho_controller_hwinit(struct pci_controller_info *p)
        psycho_write(p->pbm_A.controller_regs + PSYCHO_PCIB_DIAG, tmp);
 }
 
-static void __init pbm_register_toplevel_resources(struct pci_controller_info *p,
-                                                  struct pci_pbm_info *pbm)
+static void pbm_register_toplevel_resources(struct pci_controller_info *p,
+                                           struct pci_pbm_info *pbm)
 {
        char *name = pbm->name;
 
@@ -1481,7 +1481,7 @@ static void psycho_pbm_init(struct pci_controller_info *p,
 
 #define PSYCHO_CONFIGSPACE     0x001000000UL
 
-void __init psycho_init(int node, char *model_name)
+void psycho_init(int node, char *model_name)
 {
        struct linux_prom64_registers pr_regs[3];
        struct pci_controller_info *p;
index 52bf3431a42243cc323bfbbe8750a4c3622b4d3c..0ee6bd5b9ac67de368cfb54e7dd52a0f27c4a6ae 100644 (file)
@@ -554,7 +554,7 @@ static unsigned char sabre_pil_table[] = {
 /*0x32*/15,            /* Power Management             */
 };
 
-static int __init sabre_ino_to_pil(struct pci_dev *pdev, unsigned int ino)
+static int sabre_ino_to_pil(struct pci_dev *pdev, unsigned int ino)
 {
        int ret;
 
@@ -612,9 +612,9 @@ static void sabre_wsync_handler(struct ino_bucket *bucket, void *_arg1, void *_a
        sabre_read(sync_reg);
 }
 
-static unsigned int __init sabre_irq_build(struct pci_pbm_info *pbm,
-                                          struct pci_dev *pdev,
-                                          unsigned int ino)
+static unsigned int sabre_irq_build(struct pci_pbm_info *pbm,
+                                   struct pci_dev *pdev,
+                                   unsigned int ino)
 {
        struct ino_bucket *bucket;
        unsigned long imap, iclr;
@@ -1009,7 +1009,7 @@ static irqreturn_t sabre_pcierr_intr(int irq, void *dev_id, struct pt_regs *regs
 #define SABRE_UE_INO           0x2e
 #define SABRE_CE_INO           0x2f
 #define SABRE_PCIERR_INO       0x30
-static void __init sabre_register_error_handlers(struct pci_controller_info *p)
+static void sabre_register_error_handlers(struct pci_controller_info *p)
 {
        struct pci_pbm_info *pbm = &p->pbm_A; /* arbitrary */
        unsigned long base = pbm->controller_regs;
@@ -1056,9 +1056,9 @@ static void __init sabre_register_error_handlers(struct pci_controller_info *p)
        sabre_write(base + SABRE_PCICTRL, tmp);
 }
 
-static void __init sabre_resource_adjust(struct pci_dev *pdev,
-                                        struct resource *res,
-                                        struct resource *root)
+static void sabre_resource_adjust(struct pci_dev *pdev,
+                                 struct resource *res,
+                                 struct resource *root)
 {
        struct pci_pbm_info *pbm = pdev->bus->sysdata;
        unsigned long base;
@@ -1072,7 +1072,7 @@ static void __init sabre_resource_adjust(struct pci_dev *pdev,
        res->end += base;
 }
 
-static void __init sabre_base_address_update(struct pci_dev *pdev, int resource)
+static void sabre_base_address_update(struct pci_dev *pdev, int resource)
 {
        struct pcidev_cookie *pcp = pdev->sysdata;
        struct pci_pbm_info *pbm = pcp->pbm;
@@ -1118,7 +1118,7 @@ static void __init sabre_base_address_update(struct pci_dev *pdev, int resource)
                pci_write_config_dword(pdev, where + 4, 0);
 }
 
-static void __init apb_init(struct pci_controller_info *p, struct pci_bus *sabre_bus)
+static void apb_init(struct pci_controller_info *p, struct pci_bus *sabre_bus)
 {
        struct pci_dev *pdev;
 
@@ -1181,7 +1181,7 @@ static struct pcidev_cookie *alloc_bridge_cookie(struct pci_pbm_info *pbm)
        return cookie;
 }
 
-static void __init sabre_scan_bus(struct pci_controller_info *p)
+static void sabre_scan_bus(struct pci_controller_info *p)
 {
        static int once;
        struct pci_bus *sabre_bus, *pbus;
@@ -1262,9 +1262,9 @@ static void __init sabre_scan_bus(struct pci_controller_info *p)
        sabre_register_error_handlers(p);
 }
 
-static void __init sabre_iommu_init(struct pci_controller_info *p,
-                                   int tsbsize, unsigned long dvma_offset,
-                                   u32 dma_mask)
+static void sabre_iommu_init(struct pci_controller_info *p,
+                            int tsbsize, unsigned long dvma_offset,
+                            u32 dma_mask)
 {
        struct pci_iommu *iommu = p->pbm_A.iommu;
        unsigned long tsbbase, i, order;
@@ -1345,8 +1345,8 @@ static void __init sabre_iommu_init(struct pci_controller_info *p,
        }
 }
 
-static void __init pbm_register_toplevel_resources(struct pci_controller_info *p,
-                                                  struct pci_pbm_info *pbm)
+static void pbm_register_toplevel_resources(struct pci_controller_info *p,
+                                           struct pci_pbm_info *pbm)
 {
        char *name = pbm->name;
        unsigned long ibase = p->pbm_A.controller_regs + SABRE_IOSPACE;
@@ -1415,7 +1415,7 @@ static void __init pbm_register_toplevel_resources(struct pci_controller_info *p
                                            &pbm->mem_space);
 }
 
-static void __init sabre_pbm_init(struct pci_controller_info *p, int sabre_node, u32 dma_begin)
+static void sabre_pbm_init(struct pci_controller_info *p, int sabre_node, u32 dma_begin)
 {
        struct pci_pbm_info *pbm;
        char namebuf[128];
@@ -1552,7 +1552,7 @@ static void __init sabre_pbm_init(struct pci_controller_info *p, int sabre_node,
        }
 }
 
-void __init sabre_init(int pnode, char *model_name)
+void sabre_init(int pnode, char *model_name)
 {
        struct linux_prom64_registers pr_regs[2];
        struct pci_controller_info *p;
index 6a182bb66281f24c0caf721207c5f9370323fd4e..331382e1a75d40d80680206b31b1c3eb26f129d3 100644 (file)
@@ -285,7 +285,7 @@ static unsigned char schizo_pil_table[] = {
 /*0x3f*/0,             /* Reserved for NewLink         */
 };
 
-static int __init schizo_ino_to_pil(struct pci_dev *pdev, unsigned int ino)
+static int schizo_ino_to_pil(struct pci_dev *pdev, unsigned int ino)
 {
        int ret;
 
@@ -1221,7 +1221,7 @@ static irqreturn_t schizo_safarierr_intr(int irq, void *dev_id, struct pt_regs *
  * PCI bus units of the same Tomatillo.  I still have not really
  * figured this out...
  */
-static void __init tomatillo_register_error_handlers(struct pci_controller_info *p)
+static void tomatillo_register_error_handlers(struct pci_controller_info *p)
 {
        struct pci_pbm_info *pbm;
        unsigned int irq;
@@ -1359,7 +1359,7 @@ static void __init tomatillo_register_error_handlers(struct pci_controller_info
                     (SCHIZO_SAFIRQCTRL_EN | (BUS_ERROR_UNMAP)));
 }
 
-static void __init schizo_register_error_handlers(struct pci_controller_info *p)
+static void schizo_register_error_handlers(struct pci_controller_info *p)
 {
        struct pci_pbm_info *pbm;
        unsigned int irq;
@@ -1505,7 +1505,7 @@ static void __init schizo_register_error_handlers(struct pci_controller_info *p)
                     (SCHIZO_SAFIRQCTRL_EN | (BUS_ERROR_UNMAP)));
 }
 
-static void __init pbm_config_busmastering(struct pci_pbm_info *pbm)
+static void pbm_config_busmastering(struct pci_pbm_info *pbm)
 {
        u8 *addr;
 
@@ -1522,8 +1522,8 @@ static void __init pbm_config_busmastering(struct pci_pbm_info *pbm)
        pci_config_write8(addr, 64);
 }
 
-static void __init pbm_scan_bus(struct pci_controller_info *p,
-                               struct pci_pbm_info *pbm)
+static void pbm_scan_bus(struct pci_controller_info *p,
+                        struct pci_pbm_info *pbm)
 {
        struct pcidev_cookie *cookie = kmalloc(sizeof(*cookie), GFP_KERNEL);
 
@@ -1550,8 +1550,8 @@ static void __init pbm_scan_bus(struct pci_controller_info *p,
        pci_setup_busmastering(pbm, pbm->pci_bus);
 }
 
-static void __init __schizo_scan_bus(struct pci_controller_info *p,
-                                    int chip_type)
+static void __schizo_scan_bus(struct pci_controller_info *p,
+                             int chip_type)
 {
        if (!p->pbm_B.prom_node || !p->pbm_A.prom_node) {
                printk("PCI: Only one PCI bus module of controller found.\n");
@@ -1577,17 +1577,17 @@ static void __init __schizo_scan_bus(struct pci_controller_info *p,
                schizo_register_error_handlers(p);
 }
 
-static void __init schizo_scan_bus(struct pci_controller_info *p)
+static void schizo_scan_bus(struct pci_controller_info *p)
 {
        __schizo_scan_bus(p, PBM_CHIP_TYPE_SCHIZO);
 }
 
-static void __init tomatillo_scan_bus(struct pci_controller_info *p)
+static void tomatillo_scan_bus(struct pci_controller_info *p)
 {
        __schizo_scan_bus(p, PBM_CHIP_TYPE_TOMATILLO);
 }
 
-static void __init schizo_base_address_update(struct pci_dev *pdev, int resource)
+static void schizo_base_address_update(struct pci_dev *pdev, int resource)
 {
        struct pcidev_cookie *pcp = pdev->sysdata;
        struct pci_pbm_info *pbm = pcp->pbm;
@@ -1632,9 +1632,9 @@ static void __init schizo_base_address_update(struct pci_dev *pdev, int resource
                pci_write_config_dword(pdev, where + 4, 0);
 }
 
-static void __init schizo_resource_adjust(struct pci_dev *pdev,
-                                         struct resource *res,
-                                         struct resource *root)
+static void schizo_resource_adjust(struct pci_dev *pdev,
+                                  struct resource *res,
+                                  struct resource *root)
 {
        res->start += root->start;
        res->end += root->start;
@@ -1702,8 +1702,8 @@ static void schizo_determine_mem_io_space(struct pci_pbm_info *pbm)
               pbm->mem_space.start);
 }
 
-static void __init pbm_register_toplevel_resources(struct pci_controller_info *p,
-                                                  struct pci_pbm_info *pbm)
+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;
 
@@ -1932,7 +1932,7 @@ static void schizo_pbm_iommu_init(struct pci_pbm_info *pbm)
 #define TOMATILLO_PCI_IOC_TDIAG                (0x2250UL)
 #define TOMATILLO_PCI_IOC_DDIAG                (0x2290UL)
 
-static void __init schizo_pbm_hw_init(struct pci_pbm_info *pbm)
+static void schizo_pbm_hw_init(struct pci_pbm_info *pbm)
 {
        u64 tmp;
 
@@ -1986,9 +1986,9 @@ static void __init schizo_pbm_hw_init(struct pci_pbm_info *pbm)
        }
 }
 
-static void __init schizo_pbm_init(struct pci_controller_info *p,
-                                  int prom_node, u32 portid,
-                                  int chip_type)
+static void schizo_pbm_init(struct pci_controller_info *p,
+                           int prom_node, u32 portid,
+                           int chip_type)
 {
        struct linux_prom64_registers pr_regs[4];
        unsigned int busrange[2];
@@ -2145,7 +2145,7 @@ static inline int portid_compare(u32 x, u32 y, int chip_type)
        return (x == y);
 }
 
-static void __init __schizo_init(int node, char *model_name, int chip_type)
+static void __schizo_init(int node, char *model_name, int chip_type)
 {
        struct pci_controller_info *p;
        struct pci_iommu *iommu;
@@ -2213,17 +2213,17 @@ static void __init __schizo_init(int node, char *model_name, int chip_type)
        schizo_pbm_init(p, node, portid, chip_type);
 }
 
-void __init schizo_init(int node, char *model_name)
+void schizo_init(int node, char *model_name)
 {
        __schizo_init(node, model_name, PBM_CHIP_TYPE_SCHIZO);
 }
 
-void __init schizo_plus_init(int node, char *model_name)
+void schizo_plus_init(int node, char *model_name)
 {
        __schizo_init(node, model_name, PBM_CHIP_TYPE_SCHIZO_PLUS);
 }
 
-void __init tomatillo_init(int node, char *model_name)
+void tomatillo_init(int node, char *model_name)
 {
        __schizo_init(node, model_name, PBM_CHIP_TYPE_TOMATILLO);
 }
index d89fc24808d3eccd137db229c0bef7438b19ec7a..7d9a0f6c437dcc60dba88b30afe33af1dafcc550 100644 (file)
@@ -403,12 +403,3 @@ EXPORT_SYMBOL(xor_vis_4);
 EXPORT_SYMBOL(xor_vis_5);
 
 EXPORT_SYMBOL(prom_palette);
-
-/* memory barriers */
-EXPORT_SYMBOL(mb);
-EXPORT_SYMBOL(rmb);
-EXPORT_SYMBOL(wmb);
-EXPORT_SYMBOL(membar_storeload);
-EXPORT_SYMBOL(membar_storeload_storestore);
-EXPORT_SYMBOL(membar_storeload_loadload);
-EXPORT_SYMBOL(membar_storestore_loadstore);
index 6201f1040982aabde591d28673a4a0d7e2697f95..40dbeec7e5d6a8ed75006dd2873e0d40e019b29e 100644 (file)
@@ -12,7 +12,7 @@ lib-y := PeeCeeI.o copy_page.o clear_page.o strlen.o strncmp.o \
         U1memcpy.o U1copy_from_user.o U1copy_to_user.o \
         U3memcpy.o U3copy_from_user.o U3copy_to_user.o U3patch.o \
         copy_in_user.o user_fixup.o memmove.o \
-        mcount.o ipcsum.o rwsem.o xor.o find_bit.o delay.o mb.o
+        mcount.o ipcsum.o rwsem.o xor.o find_bit.o delay.o
 
 lib-$(CONFIG_DEBUG_SPINLOCK) += debuglocks.o
 lib-$(CONFIG_HAVE_DEC_LOCK) += dec_and_lock.o
diff --git a/arch/sparc64/lib/mb.S b/arch/sparc64/lib/mb.S
deleted file mode 100644 (file)
index 4004f74..0000000
+++ /dev/null
@@ -1,73 +0,0 @@
-/* mb.S: Out of line memory barriers.
- *
- * Copyright (C) 2005 David S. Miller (davem@davemloft.net)
- */
-
-       /* These are here in an effort to more fully work around
-        * Spitfire Errata #51.  Essentially, if a memory barrier
-        * occurs soon after a mispredicted branch, the chip can stop
-        * executing instructions until a trap occurs.  Therefore, if
-        * interrupts are disabled, the chip can hang forever.
-        *
-        * It used to be believed that the memory barrier had to be
-        * right in the delay slot, but a case has been traced
-        * recently wherein the memory barrier was one instruction
-        * after the branch delay slot and the chip still hung.  The
-        * offending sequence was the following in sym_wakeup_done()
-        * of the sym53c8xx_2 driver:
-        *
-        *      call    sym_ccb_from_dsa, 0
-        *       movge  %icc, 0, %l0
-        *      brz,pn  %o0, .LL1303
-        *       mov    %o0, %l2
-        *      membar  #LoadLoad
-        *
-        * The branch has to be mispredicted for the bug to occur.
-        * Therefore, we put the memory barrier explicitly into a
-        * "branch always, predicted taken" delay slot to avoid the
-        * problem case.
-        */
-
-       .text
-
-99:    retl
-        nop
-
-       .globl  mb
-mb:    ba,pt   %xcc, 99b
-        membar #LoadLoad | #LoadStore | #StoreStore | #StoreLoad
-       .size   mb, .-mb
-
-       .globl  rmb
-rmb:   ba,pt   %xcc, 99b
-        membar #LoadLoad
-       .size   rmb, .-rmb
-
-       .globl  wmb
-wmb:   ba,pt   %xcc, 99b
-        membar #StoreStore
-       .size   wmb, .-wmb
-
-       .globl  membar_storeload
-membar_storeload:
-       ba,pt   %xcc, 99b
-        membar #StoreLoad
-       .size   membar_storeload, .-membar_storeload
-
-       .globl  membar_storeload_storestore
-membar_storeload_storestore:
-       ba,pt   %xcc, 99b
-        membar #StoreLoad | #StoreStore
-       .size   membar_storeload_storestore, .-membar_storeload_storestore
-
-       .globl  membar_storeload_loadload
-membar_storeload_loadload:
-       ba,pt   %xcc, 99b
-        membar #StoreLoad | #LoadLoad
-       .size   membar_storeload_loadload, .-membar_storeload_loadload
-
-       .globl  membar_storestore_loadstore
-membar_storestore_loadstore:
-       ba,pt   %xcc, 99b
-        membar #StoreStore | #LoadStore
-       .size   membar_storestore_loadstore, .-membar_storestore_loadstore
index 6f98701dfe15da844eb19aa5e1483f6b73b21a97..121cc85f347e713dbaef7bcbe614cc8dcb48e33e 100644 (file)
@@ -1071,5 +1071,9 @@ extern void *drm_calloc(size_t nmemb, size_t size, int area);
 extern unsigned long drm_core_get_map_ofs(drm_map_t *map);
 extern unsigned long drm_core_get_reg_ofs(struct drm_device *dev);
 
+#ifndef pci_pretty_name
+#define pci_pretty_name(dev) ""
+#endif
+
 #endif /* __KERNEL__ */
 #endif
index 6e9da1372225b73ab74c304824be223c5f078592..8334496a7e0aee02b42ca7b4953a165d2efb91e1 100644 (file)
@@ -144,6 +144,22 @@ config I2C_I810
          This driver can also be built as a module.  If so, the module
          will be called i2c-i810.
 
+config I2C_PXA
+       tristate "Intel PXA2XX I2C adapter (EXPERIMENTAL)"
+       depends on I2C && EXPERIMENTAL && ARCH_PXA
+       help
+         If you have devices in the PXA I2C bus, say yes to this option.
+         This driver can also be built as a module.  If so, the module
+         will be called i2c-pxa.
+
+config I2C_PXA_SLAVE
+       bool "Intel PXA2XX I2C Slave comms support"
+       depends on I2C_PXA
+       help
+         Support I2C slave mode communications on the PXA I2C bus.  This
+         is necessary for systems where the PXA may be a target on the
+         I2C bus.
+
 config I2C_PIIX4
        tristate "Intel PIIX4"
        depends on I2C && PCI
index 42d6d814da726f9445c420c1df801040d3924cb3..980b3e98367040acf2df92baede7212012add7a7 100644 (file)
@@ -28,6 +28,7 @@ obj-$(CONFIG_I2C_PARPORT_LIGHT)       += i2c-parport-light.o
 obj-$(CONFIG_I2C_PCA_ISA)      += i2c-pca-isa.o
 obj-$(CONFIG_I2C_PIIX4)                += i2c-piix4.o
 obj-$(CONFIG_I2C_PROSAVAGE)    += i2c-prosavage.o
+obj-$(CONFIG_I2C_PXA)          += i2c-pxa.o
 obj-$(CONFIG_I2C_RPXLITE)      += i2c-rpx.o
 obj-$(CONFIG_I2C_S3C2410)      += i2c-s3c2410.o
 obj-$(CONFIG_I2C_SAVAGE4)      += i2c-savage4.o
diff --git a/drivers/i2c/busses/i2c-pxa.c b/drivers/i2c/busses/i2c-pxa.c
new file mode 100644 (file)
index 0000000..fdf53ce
--- /dev/null
@@ -0,0 +1,1022 @@
+/*
+ *  i2c_adap_pxa.c
+ *
+ *  I2C adapter for the PXA I2C bus access.
+ *
+ *  Copyright (C) 2002 Intrinsyc Software Inc.
+ *  Copyright (C) 2004-2005 Deep Blue Solutions Ltd.
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License version 2 as
+ *  published by the Free Software Foundation.
+ *
+ *  History:
+ *    Apr 2002: Initial version [CS]
+ *    Jun 2002: Properly seperated algo/adap [FB]
+ *    Jan 2003: Fixed several bugs concerning interrupt handling [Kai-Uwe Bloem]
+ *    Jan 2003: added limited signal handling [Kai-Uwe Bloem]
+ *    Sep 2004: Major rework to ensure efficient bus handling [RMK]
+ *    Dec 2004: Added support for PXA27x and slave device probing [Liam Girdwood]
+ *    Feb 2005: Rework slave mode handling [RMK]
+ */
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/i2c.h>
+#include <linux/i2c-id.h>
+#include <linux/init.h>
+#include <linux/time.h>
+#include <linux/sched.h>
+#include <linux/delay.h>
+#include <linux/errno.h>
+#include <linux/interrupt.h>
+#include <linux/i2c-pxa.h>
+
+#include <asm/hardware.h>
+#include <asm/irq.h>
+#include <asm/arch/i2c.h>
+#include <asm/arch/pxa-regs.h>
+
+struct pxa_i2c {
+       spinlock_t              lock;
+       wait_queue_head_t       wait;
+       struct i2c_msg          *msg;
+       unsigned int            msg_num;
+       unsigned int            msg_idx;
+       unsigned int            msg_ptr;
+       unsigned int            slave_addr;
+
+       struct i2c_adapter      adap;
+#ifdef CONFIG_I2C_PXA_SLAVE
+       struct i2c_slave_client *slave;
+#endif
+
+       unsigned int            irqlogidx;
+       u32                     isrlog[32];
+       u32                     icrlog[32];
+};
+
+/*
+ * I2C Slave mode address
+ */
+#define I2C_PXA_SLAVE_ADDR      0x1
+
+#ifdef DEBUG
+
+struct bits {
+       u32     mask;
+       const char *set;
+       const char *unset;
+};
+#define BIT(m, s, u)   { .mask = m, .set = s, .unset = u }
+
+static inline void
+decode_bits(const char *prefix, const struct bits *bits, int num, u32 val)
+{
+       printk("%s %08x: ", prefix, val);
+       while (num--) {
+               const char *str = val & bits->mask ? bits->set : bits->unset;
+               if (str)
+                       printk("%s ", str);
+               bits++;
+       }
+}
+
+static const struct bits isr_bits[] = {
+       BIT(ISR_RWM,    "RX",           "TX"),
+       BIT(ISR_ACKNAK, "NAK",          "ACK"),
+       BIT(ISR_UB,     "Bsy",          "Rdy"),
+       BIT(ISR_IBB,    "BusBsy",       "BusRdy"),
+       BIT(ISR_SSD,    "SlaveStop",    NULL),
+       BIT(ISR_ALD,    "ALD",          NULL),
+       BIT(ISR_ITE,    "TxEmpty",      NULL),
+       BIT(ISR_IRF,    "RxFull",       NULL),
+       BIT(ISR_GCAD,   "GenCall",      NULL),
+       BIT(ISR_SAD,    "SlaveAddr",    NULL),
+       BIT(ISR_BED,    "BusErr",       NULL),
+};
+
+static void decode_ISR(unsigned int val)
+{
+       decode_bits(KERN_DEBUG "ISR", isr_bits, ARRAY_SIZE(isr_bits), val);
+       printk("\n");
+}
+
+static const struct bits icr_bits[] = {
+       BIT(ICR_START,  "START",        NULL),
+       BIT(ICR_STOP,   "STOP",         NULL),
+       BIT(ICR_ACKNAK, "ACKNAK",       NULL),
+       BIT(ICR_TB,     "TB",           NULL),
+       BIT(ICR_MA,     "MA",           NULL),
+       BIT(ICR_SCLE,   "SCLE",         "scle"),
+       BIT(ICR_IUE,    "IUE",          "iue"),
+       BIT(ICR_GCD,    "GCD",          NULL),
+       BIT(ICR_ITEIE,  "ITEIE",        NULL),
+       BIT(ICR_IRFIE,  "IRFIE",        NULL),
+       BIT(ICR_BEIE,   "BEIE",         NULL),
+       BIT(ICR_SSDIE,  "SSDIE",        NULL),
+       BIT(ICR_ALDIE,  "ALDIE",        NULL),
+       BIT(ICR_SADIE,  "SADIE",        NULL),
+       BIT(ICR_UR,     "UR",           "ur"),
+};
+
+static void decode_ICR(unsigned int val)
+{
+       decode_bits(KERN_DEBUG "ICR", icr_bits, ARRAY_SIZE(icr_bits), val);
+       printk("\n");
+}
+
+static unsigned int i2c_debug = DEBUG;
+
+static void i2c_pxa_show_state(struct pxa_i2c *i2c, int lno, const char *fname)
+{
+       dev_dbg(&i2c->adap.dev, "state:%s:%d: ISR=%08x, ICR=%08x, IBMR=%02x\n", fname, lno, ISR, ICR, IBMR);
+}
+
+#define show_state(i2c) i2c_pxa_show_state(i2c, __LINE__, __FUNCTION__)
+#else
+#define i2c_debug      0
+
+#define show_state(i2c) do { } while (0)
+#define decode_ISR(val) do { } while (0)
+#define decode_ICR(val) do { } while (0)
+#endif
+
+#define eedbg(lvl, x...) do { if ((lvl) < 1) { printk(KERN_DEBUG "" x); } } while(0)
+
+static void i2c_pxa_master_complete(struct pxa_i2c *i2c, int ret);
+
+static void i2c_pxa_scream_blue_murder(struct pxa_i2c *i2c, const char *why)
+{
+       unsigned int i;
+       printk("i2c: error: %s\n", why);
+       printk("i2c: msg_num: %d msg_idx: %d msg_ptr: %d\n",
+               i2c->msg_num, i2c->msg_idx, i2c->msg_ptr);
+       printk("i2c: ICR: %08x ISR: %08x\n"
+              "i2c: log: ", ICR, ISR);
+       for (i = 0; i < i2c->irqlogidx; i++)
+               printk("[%08x:%08x] ", i2c->isrlog[i], i2c->icrlog[i]);
+       printk("\n");
+}
+
+static inline int i2c_pxa_is_slavemode(struct pxa_i2c *i2c)
+{
+       return !(ICR & ICR_SCLE);
+}
+
+static void i2c_pxa_abort(struct pxa_i2c *i2c)
+{
+       unsigned long timeout = jiffies + HZ/4;
+
+       if (i2c_pxa_is_slavemode(i2c)) {
+               dev_dbg(&i2c->adap.dev, "%s: called in slave mode\n", __func__);
+               return;
+       }
+
+       while (time_before(jiffies, timeout) && (IBMR & 0x1) == 0) {
+               unsigned long icr = ICR;
+
+               icr &= ~ICR_START;
+               icr |= ICR_ACKNAK | ICR_STOP | ICR_TB;
+
+               ICR = icr;
+
+               show_state(i2c);
+
+               msleep(1);
+       }
+
+       ICR &= ~(ICR_MA | ICR_START | ICR_STOP);
+}
+
+static int i2c_pxa_wait_bus_not_busy(struct pxa_i2c *i2c)
+{
+       int timeout = DEF_TIMEOUT;
+
+       while (timeout-- && ISR & (ISR_IBB | ISR_UB)) {
+               if ((ISR & ISR_SAD) != 0)
+                       timeout += 4;
+
+               msleep(2);
+               show_state(i2c);
+       }
+
+       if (timeout <= 0)
+               show_state(i2c);
+
+       return timeout <= 0 ? I2C_RETRY : 0;
+}
+
+static int i2c_pxa_wait_master(struct pxa_i2c *i2c)
+{
+       unsigned long timeout = jiffies + HZ*4;
+
+       while (time_before(jiffies, timeout)) {
+               if (i2c_debug > 1)
+                       dev_dbg(&i2c->adap.dev, "%s: %ld: ISR=%08x, ICR=%08x, IBMR=%02x\n",
+                               __func__, (long)jiffies, ISR, ICR, IBMR);
+
+               if (ISR & ISR_SAD) {
+                       if (i2c_debug > 0)
+                               dev_dbg(&i2c->adap.dev, "%s: Slave detected\n", __func__);
+                       goto out;
+               }
+
+               /* wait for unit and bus being not busy, and we also do a
+                * quick check of the i2c lines themselves to ensure they've
+                * gone high...
+                */
+               if ((ISR & (ISR_UB | ISR_IBB)) == 0 && IBMR == 3) {
+                       if (i2c_debug > 0)
+                               dev_dbg(&i2c->adap.dev, "%s: done\n", __func__);
+                       return 1;
+               }
+
+               msleep(1);
+       }
+
+       if (i2c_debug > 0)
+               dev_dbg(&i2c->adap.dev, "%s: did not free\n", __func__);
+ out:
+       return 0;
+}
+
+static int i2c_pxa_set_master(struct pxa_i2c *i2c)
+{
+       if (i2c_debug)
+               dev_dbg(&i2c->adap.dev, "setting to bus master\n");
+
+       if ((ISR & (ISR_UB | ISR_IBB)) != 0) {
+               dev_dbg(&i2c->adap.dev, "%s: unit is busy\n", __func__);
+               if (!i2c_pxa_wait_master(i2c)) {
+                       dev_dbg(&i2c->adap.dev, "%s: error: unit busy\n", __func__);
+                       return I2C_RETRY;
+               }
+       }
+
+       ICR |= ICR_SCLE;
+       return 0;
+}
+
+#ifdef CONFIG_I2C_PXA_SLAVE
+static int i2c_pxa_wait_slave(struct pxa_i2c *i2c)
+{
+       unsigned long timeout = jiffies + HZ*1;
+
+       /* wait for stop */
+
+       show_state(i2c);
+
+       while (time_before(jiffies, timeout)) {
+               if (i2c_debug > 1)
+                       dev_dbg(&i2c->adap.dev, "%s: %ld: ISR=%08x, ICR=%08x, IBMR=%02x\n",
+                               __func__, (long)jiffies, ISR, ICR, IBMR);
+
+               if ((ISR & (ISR_UB|ISR_IBB|ISR_SAD)) == ISR_SAD ||
+                   (ICR & ICR_SCLE) == 0) {
+                       if (i2c_debug > 1)
+                               dev_dbg(&i2c->adap.dev, "%s: done\n", __func__);
+                       return 1;
+               }
+
+               msleep(1);
+       }
+
+       if (i2c_debug > 0)
+               dev_dbg(&i2c->adap.dev, "%s: did not free\n", __func__);
+       return 0;
+}
+
+/*
+ * clear the hold on the bus, and take of anything else
+ * that has been configured
+ */
+static void i2c_pxa_set_slave(struct pxa_i2c *i2c, int errcode)
+{
+       show_state(i2c);
+
+       if (errcode < 0) {
+               udelay(100);   /* simple delay */
+       } else {
+               /* we need to wait for the stop condition to end */
+
+               /* if we where in stop, then clear... */
+               if (ICR & ICR_STOP) {
+                       udelay(100);
+                       ICR &= ~ICR_STOP;
+               }
+
+               if (!i2c_pxa_wait_slave(i2c)) {
+                       dev_err(&i2c->adap.dev, "%s: wait timedout\n",
+                               __func__);
+                       return;
+               }
+       }
+
+       ICR &= ~(ICR_STOP|ICR_ACKNAK|ICR_MA);
+       ICR &= ~ICR_SCLE;
+
+       if (i2c_debug) {
+               dev_dbg(&i2c->adap.dev, "ICR now %08x, ISR %08x\n", ICR, ISR);
+               decode_ICR(ICR);
+       }
+}
+#else
+#define i2c_pxa_set_slave(i2c, err)    do { } while (0)
+#endif
+
+static void i2c_pxa_reset(struct pxa_i2c *i2c)
+{
+       pr_debug("Resetting I2C Controller Unit\n");
+
+       /* abort any transfer currently under way */
+       i2c_pxa_abort(i2c);
+
+       /* reset according to 9.8 */
+       ICR = ICR_UR;
+       ISR = I2C_ISR_INIT;
+       ICR &= ~ICR_UR;
+
+       ISAR = i2c->slave_addr;
+
+       /* set control register values */
+       ICR = I2C_ICR_INIT;
+
+#ifdef CONFIG_I2C_PXA_SLAVE
+       dev_info(&i2c->adap.dev, "Enabling slave mode\n");
+       ICR |= ICR_SADIE | ICR_ALDIE | ICR_SSDIE;
+#endif
+
+       i2c_pxa_set_slave(i2c, 0);
+
+       /* enable unit */
+       ICR |= ICR_IUE;
+       udelay(100);
+}
+
+
+#ifdef CONFIG_I2C_PXA_SLAVE
+/*
+ * I2C EEPROM emulation.
+ */
+static struct i2c_eeprom_emu eeprom = {
+       .size = I2C_EEPROM_EMU_SIZE,
+       .watch = LIST_HEAD_INIT(eeprom.watch),
+};
+
+struct i2c_eeprom_emu *i2c_pxa_get_eeprom(void)
+{
+       return &eeprom;
+}
+
+int i2c_eeprom_emu_addwatcher(struct i2c_eeprom_emu *emu, void *data,
+                             unsigned int addr, unsigned int size,
+                             struct i2c_eeprom_emu_watcher *watcher)
+{
+       struct i2c_eeprom_emu_watch *watch;
+       unsigned long flags;
+
+       if (addr + size > emu->size)
+               return -EINVAL;
+
+       watch = kmalloc(sizeof(struct i2c_eeprom_emu_watch), GFP_KERNEL);
+       if (watch) {
+               watch->start = addr;
+               watch->end = addr + size - 1;
+               watch->ops = watcher;
+               watch->data = data;
+
+               local_irq_save(flags);
+               list_add(&watch->node, &emu->watch);
+               local_irq_restore(flags);
+       }
+
+       return watch ? 0 : -ENOMEM;
+}
+
+void i2c_eeprom_emu_delwatcher(struct i2c_eeprom_emu *emu, void *data,
+                              struct i2c_eeprom_emu_watcher *watcher)
+{
+       struct i2c_eeprom_emu_watch *watch, *n;
+       unsigned long flags;
+
+       list_for_each_entry_safe(watch, n, &emu->watch, node) {
+               if (watch->ops == watcher && watch->data == data) {
+                       local_irq_save(flags);
+                       list_del(&watch->node);
+                       local_irq_restore(flags);
+                       kfree(watch);
+               }
+       }
+}
+
+static void i2c_eeprom_emu_event(void *ptr, i2c_slave_event_t event)
+{
+       struct i2c_eeprom_emu *emu = ptr;
+
+       eedbg(3, "i2c_eeprom_emu_event: %d\n", event);
+
+       switch (event) {
+       case I2C_SLAVE_EVENT_START_WRITE:
+               emu->seen_start = 1;
+               eedbg(2, "i2c_eeprom: write initiated\n");
+               break;
+
+       case I2C_SLAVE_EVENT_START_READ:
+               emu->seen_start = 0;
+               eedbg(2, "i2c_eeprom: read initiated\n");
+               break;
+
+       case I2C_SLAVE_EVENT_STOP:
+               emu->seen_start = 0;
+               eedbg(2, "i2c_eeprom: received stop\n");
+               break;
+
+       default:
+               eedbg(0, "i2c_eeprom: unhandled event\n");
+               break;
+       }
+}
+
+static int i2c_eeprom_emu_read(void *ptr)
+{
+       struct i2c_eeprom_emu *emu = ptr;
+       int ret;
+
+       ret = emu->bytes[emu->ptr];
+       emu->ptr = (emu->ptr + 1) % emu->size;
+
+       return ret;
+}
+
+static void i2c_eeprom_emu_write(void *ptr, unsigned int val)
+{
+       struct i2c_eeprom_emu *emu = ptr;
+       struct i2c_eeprom_emu_watch *watch;
+
+       if (emu->seen_start != 0) {
+               eedbg(2, "i2c_eeprom_emu_write: setting ptr %02x\n", val);
+               emu->ptr = val;
+               emu->seen_start = 0;
+               return;
+       }
+
+       emu->bytes[emu->ptr] = val;
+
+       eedbg(1, "i2c_eeprom_emu_write: ptr=0x%02x, val=0x%02x\n",
+             emu->ptr, val);
+
+       list_for_each_entry(watch, &emu->watch, node) {
+               if (!watch->ops || !watch->ops->write)
+                       continue;
+               if (watch->start <= emu->ptr && watch->end >= emu->ptr)
+                       watch->ops->write(watch->data, emu->ptr, val);
+       }
+
+       emu->ptr = (emu->ptr + 1) % emu->size;
+}
+
+struct i2c_slave_client eeprom_client = {
+       .data   = &eeprom,
+       .event  = i2c_eeprom_emu_event,
+       .read   = i2c_eeprom_emu_read,
+       .write  = i2c_eeprom_emu_write
+};
+
+/*
+ * PXA I2C Slave mode
+ */
+
+static void i2c_pxa_slave_txempty(struct pxa_i2c *i2c, u32 isr)
+{
+       if (isr & ISR_BED) {
+               /* what should we do here? */
+       } else {
+               int ret = i2c->slave->read(i2c->slave->data);
+
+               IDBR = ret;
+               ICR |= ICR_TB;   /* allow next byte */
+       }
+}
+
+static void i2c_pxa_slave_rxfull(struct pxa_i2c *i2c, u32 isr)
+{
+       unsigned int byte = IDBR;
+
+       if (i2c->slave != NULL)
+               i2c->slave->write(i2c->slave->data, byte);
+
+       ICR |= ICR_TB;
+}
+
+static void i2c_pxa_slave_start(struct pxa_i2c *i2c, u32 isr)
+{
+       int timeout;
+
+       if (i2c_debug > 0)
+               dev_dbg(&i2c->adap.dev, "SAD, mode is slave-%cx\n",
+                      (isr & ISR_RWM) ? 'r' : 't');
+
+       if (i2c->slave != NULL)
+               i2c->slave->event(i2c->slave->data,
+                                (isr & ISR_RWM) ? I2C_SLAVE_EVENT_START_READ : I2C_SLAVE_EVENT_START_WRITE);
+
+       /*
+        * slave could interrupt in the middle of us generating a
+        * start condition... if this happens, we'd better back off
+        * and stop holding the poor thing up
+        */
+       ICR &= ~(ICR_START|ICR_STOP);
+       ICR |= ICR_TB;
+
+       timeout = 0x10000;
+
+       while (1) {
+               if ((IBMR & 2) == 2)
+                       break;
+
+               timeout--;
+
+               if (timeout <= 0) {
+                       dev_err(&i2c->adap.dev, "timeout waiting for SCL high\n");
+                       break;
+               }
+       }
+
+       ICR &= ~ICR_SCLE;
+}
+
+static void i2c_pxa_slave_stop(struct pxa_i2c *i2c)
+{
+       if (i2c_debug > 2)
+               dev_dbg(&i2c->adap.dev, "ISR: SSD (Slave Stop)\n");
+
+       if (i2c->slave != NULL)
+               i2c->slave->event(i2c->slave->data, I2C_SLAVE_EVENT_STOP);
+
+       if (i2c_debug > 2)
+               dev_dbg(&i2c->adap.dev, "ISR: SSD (Slave Stop) acked\n");
+
+       /*
+        * If we have a master-mode message waiting,
+        * kick it off now that the slave has completed.
+        */
+       if (i2c->msg)
+               i2c_pxa_master_complete(i2c, I2C_RETRY);
+}
+#else
+static void i2c_pxa_slave_txempty(struct pxa_i2c *i2c, u32 isr)
+{
+       if (isr & ISR_BED) {
+               /* what should we do here? */
+       } else {
+               IDBR = 0;
+               ICR |= ICR_TB;
+       }
+}
+
+static void i2c_pxa_slave_rxfull(struct pxa_i2c *i2c, u32 isr)
+{
+       ICR |= ICR_TB | ICR_ACKNAK;
+}
+
+static void i2c_pxa_slave_start(struct pxa_i2c *i2c, u32 isr)
+{
+       int timeout;
+
+       /*
+        * slave could interrupt in the middle of us generating a
+        * start condition... if this happens, we'd better back off
+        * and stop holding the poor thing up
+        */
+       ICR &= ~(ICR_START|ICR_STOP);
+       ICR |= ICR_TB | ICR_ACKNAK;
+
+       timeout = 0x10000;
+
+       while (1) {
+               if ((IBMR & 2) == 2)
+                       break;
+
+               timeout--;
+
+               if (timeout <= 0) {
+                       dev_err(&i2c->adap.dev, "timeout waiting for SCL high\n");
+                       break;
+               }
+       }
+
+       ICR &= ~ICR_SCLE;
+}
+
+static void i2c_pxa_slave_stop(struct pxa_i2c *i2c)
+{
+       if (i2c->msg)
+               i2c_pxa_master_complete(i2c, I2C_RETRY);
+}
+#endif
+
+/*
+ * PXA I2C Master mode
+ */
+
+static inline unsigned int i2c_pxa_addr_byte(struct i2c_msg *msg)
+{
+       unsigned int addr = (msg->addr & 0x7f) << 1;
+
+       if (msg->flags & I2C_M_RD)
+               addr |= 1;
+
+       return addr;
+}
+
+static inline void i2c_pxa_start_message(struct pxa_i2c *i2c)
+{
+       u32 icr;
+
+       /*
+        * Step 1: target slave address into IDBR
+        */
+       IDBR = i2c_pxa_addr_byte(i2c->msg);
+
+       /*
+        * Step 2: initiate the write.
+        */
+       icr = ICR & ~(ICR_STOP | ICR_ALDIE);
+       ICR = icr | ICR_START | ICR_TB;
+}
+
+/*
+ * We are protected by the adapter bus semaphore.
+ */
+static int i2c_pxa_do_xfer(struct pxa_i2c *i2c, struct i2c_msg *msg, int num)
+{
+       long timeout;
+       int ret;
+
+       /*
+        * Wait for the bus to become free.
+        */
+       ret = i2c_pxa_wait_bus_not_busy(i2c);
+       if (ret) {
+               dev_err(&i2c->adap.dev, "i2c_pxa: timeout waiting for bus free\n");
+               goto out;
+       }
+
+       /*
+        * Set master mode.
+        */
+       ret = i2c_pxa_set_master(i2c);
+       if (ret) {
+               dev_err(&i2c->adap.dev, "i2c_pxa_set_master: error %d\n", ret);
+               goto out;
+       }
+
+       spin_lock_irq(&i2c->lock);
+
+       i2c->msg = msg;
+       i2c->msg_num = num;
+       i2c->msg_idx = 0;
+       i2c->msg_ptr = 0;
+       i2c->irqlogidx = 0;
+
+       i2c_pxa_start_message(i2c);
+
+       spin_unlock_irq(&i2c->lock);
+
+       /*
+        * The rest of the processing occurs in the interrupt handler.
+        */
+       timeout = wait_event_timeout(i2c->wait, i2c->msg_num == 0, HZ * 5);
+
+       /*
+        * We place the return code in i2c->msg_idx.
+        */
+       ret = i2c->msg_idx;
+
+       if (timeout == 0)
+               i2c_pxa_scream_blue_murder(i2c, "timeout");
+
+ out:
+       return ret;
+}
+
+/*
+ * i2c_pxa_master_complete - complete the message and wake up.
+ */
+static void i2c_pxa_master_complete(struct pxa_i2c *i2c, int ret)
+{
+       i2c->msg_ptr = 0;
+       i2c->msg = NULL;
+       i2c->msg_idx ++;
+       i2c->msg_num = 0;
+       if (ret)
+               i2c->msg_idx = ret;
+       wake_up(&i2c->wait);
+}
+
+static void i2c_pxa_irq_txempty(struct pxa_i2c *i2c, u32 isr)
+{
+       u32 icr = ICR & ~(ICR_START|ICR_STOP|ICR_ACKNAK|ICR_TB);
+
+ again:
+       /*
+        * If ISR_ALD is set, we lost arbitration.
+        */
+       if (isr & ISR_ALD) {
+               /*
+                * Do we need to do anything here?  The PXA docs
+                * are vague about what happens.
+                */
+               i2c_pxa_scream_blue_murder(i2c, "ALD set");
+
+               /*
+                * We ignore this error.  We seem to see spurious ALDs
+                * for seemingly no reason.  If we handle them as I think
+                * they should, we end up causing an I2C error, which
+                * is painful for some systems.
+                */
+               return; /* ignore */
+       }
+
+       if (isr & ISR_BED) {
+               int ret = BUS_ERROR;
+
+               /*
+                * I2C bus error - either the device NAK'd us, or
+                * something more serious happened.  If we were NAK'd
+                * on the initial address phase, we can retry.
+                */
+               if (isr & ISR_ACKNAK) {
+                       if (i2c->msg_ptr == 0 && i2c->msg_idx == 0)
+                               ret = I2C_RETRY;
+                       else
+                               ret = XFER_NAKED;
+               }
+               i2c_pxa_master_complete(i2c, ret);
+       } else if (isr & ISR_RWM) {
+               /*
+                * Read mode.  We have just sent the address byte, and
+                * now we must initiate the transfer.
+                */
+               if (i2c->msg_ptr == i2c->msg->len - 1 &&
+                   i2c->msg_idx == i2c->msg_num - 1)
+                       icr |= ICR_STOP | ICR_ACKNAK;
+
+               icr |= ICR_ALDIE | ICR_TB;
+       } else if (i2c->msg_ptr < i2c->msg->len) {
+               /*
+                * Write mode.  Write the next data byte.
+                */
+               IDBR = i2c->msg->buf[i2c->msg_ptr++];
+
+               icr |= ICR_ALDIE | ICR_TB;
+
+               /*
+                * If this is the last byte of the last message, send
+                * a STOP.
+                */
+               if (i2c->msg_ptr == i2c->msg->len &&
+                   i2c->msg_idx == i2c->msg_num - 1)
+                       icr |= ICR_STOP;
+       } else if (i2c->msg_idx < i2c->msg_num - 1) {
+               /*
+                * Next segment of the message.
+                */
+               i2c->msg_ptr = 0;
+               i2c->msg_idx ++;
+               i2c->msg++;
+
+               /*
+                * If we aren't doing a repeated start and address,
+                * go back and try to send the next byte.  Note that
+                * we do not support switching the R/W direction here.
+                */
+               if (i2c->msg->flags & I2C_M_NOSTART)
+                       goto again;
+
+               /*
+                * Write the next address.
+                */
+               IDBR = i2c_pxa_addr_byte(i2c->msg);
+
+               /*
+                * And trigger a repeated start, and send the byte.
+                */
+               icr &= ~ICR_ALDIE;
+               icr |= ICR_START | ICR_TB;
+       } else {
+               if (i2c->msg->len == 0) {
+                       /*
+                        * Device probes have a message length of zero
+                        * and need the bus to be reset before it can
+                        * be used again.
+                        */
+                       i2c_pxa_reset(i2c);
+               }
+               i2c_pxa_master_complete(i2c, 0);
+       }
+
+       i2c->icrlog[i2c->irqlogidx-1] = icr;
+
+       ICR = icr;
+       show_state(i2c);
+}
+
+static void i2c_pxa_irq_rxfull(struct pxa_i2c *i2c, u32 isr)
+{
+       u32 icr = ICR & ~(ICR_START|ICR_STOP|ICR_ACKNAK|ICR_TB);
+
+       /*
+        * Read the byte.
+        */
+       i2c->msg->buf[i2c->msg_ptr++] = IDBR;
+
+       if (i2c->msg_ptr < i2c->msg->len) {
+               /*
+                * If this is the last byte of the last
+                * message, send a STOP.
+                */
+               if (i2c->msg_ptr == i2c->msg->len - 1)
+                       icr |= ICR_STOP | ICR_ACKNAK;
+
+               icr |= ICR_ALDIE | ICR_TB;
+       } else {
+               i2c_pxa_master_complete(i2c, 0);
+       }
+
+       i2c->icrlog[i2c->irqlogidx-1] = icr;
+
+       ICR = icr;
+}
+
+static irqreturn_t i2c_pxa_handler(int this_irq, void *dev_id, struct pt_regs *regs)
+{
+       struct pxa_i2c *i2c = dev_id;
+       u32 isr = ISR;
+
+       if (i2c_debug > 2 && 0) {
+               dev_dbg(&i2c->adap.dev, "%s: ISR=%08x, ICR=%08x, IBMR=%02x\n",
+                       __func__, isr, ICR, IBMR);
+               decode_ISR(isr);
+       }
+
+       if (i2c->irqlogidx < sizeof(i2c->isrlog)/sizeof(u32))
+               i2c->isrlog[i2c->irqlogidx++] = isr;
+
+       show_state(i2c);
+
+       /*
+        * Always clear all pending IRQs.
+        */
+       ISR = isr & (ISR_SSD|ISR_ALD|ISR_ITE|ISR_IRF|ISR_SAD|ISR_BED);
+
+       if (isr & ISR_SAD)
+               i2c_pxa_slave_start(i2c, isr);
+       if (isr & ISR_SSD)
+               i2c_pxa_slave_stop(i2c);
+
+       if (i2c_pxa_is_slavemode(i2c)) {
+               if (isr & ISR_ITE)
+                       i2c_pxa_slave_txempty(i2c, isr);
+               if (isr & ISR_IRF)
+                       i2c_pxa_slave_rxfull(i2c, isr);
+       } else if (i2c->msg) {
+               if (isr & ISR_ITE)
+                       i2c_pxa_irq_txempty(i2c, isr);
+               if (isr & ISR_IRF)
+                       i2c_pxa_irq_rxfull(i2c, isr);
+       } else {
+               i2c_pxa_scream_blue_murder(i2c, "spurious irq");
+       }
+
+       return IRQ_HANDLED;
+}
+
+
+static int i2c_pxa_xfer(struct i2c_adapter *adap, struct i2c_msg msgs[], int num)
+{
+       struct pxa_i2c *i2c = adap->algo_data;
+       int ret, i;
+
+       for (i = adap->retries; i >= 0; i--) {
+               ret = i2c_pxa_do_xfer(i2c, msgs, num);
+               if (ret != I2C_RETRY)
+                       goto out;
+
+               if (i2c_debug)
+                       dev_dbg(&adap->dev, "Retrying transmission\n");
+               udelay(100);
+       }
+       i2c_pxa_scream_blue_murder(i2c, "exhausted retries");
+       ret = -EREMOTEIO;
+ out:
+       i2c_pxa_set_slave(i2c, ret);
+       return ret;
+}
+
+static struct i2c_algorithm i2c_pxa_algorithm = {
+       .name           = "PXA-I2C-Algorithm",
+       .id             = I2C_ALGO_PXA,
+       .master_xfer    = i2c_pxa_xfer,
+};
+
+static struct pxa_i2c i2c_pxa = {
+       .lock   = SPIN_LOCK_UNLOCKED,
+       .wait   = __WAIT_QUEUE_HEAD_INITIALIZER(i2c_pxa.wait),
+       .adap   = {
+               .name           = "pxa2xx-i2c",
+               .id             = I2C_ALGO_PXA,
+               .algo           = &i2c_pxa_algorithm,
+               .retries        = 5,
+       },
+};
+
+static int i2c_pxa_probe(struct device *dev)
+{
+       struct pxa_i2c *i2c = &i2c_pxa;
+       struct i2c_pxa_platform_data *plat = dev->platform_data;
+       int ret;
+
+#ifdef CONFIG_PXA27x
+       pxa_gpio_mode(GPIO117_I2CSCL_MD);
+       pxa_gpio_mode(GPIO118_I2CSDA_MD);
+       udelay(100);
+#endif
+
+       i2c->slave_addr = I2C_PXA_SLAVE_ADDR;
+
+#ifdef CONFIG_I2C_PXA_SLAVE
+       i2c->slave = &eeprom_client;
+       if (plat) {
+               i2c->slave_addr = plat->slave_addr;
+               if (plat->slave)
+                       i2c->slave = plat->slave;
+       }
+#endif
+
+       pxa_set_cken(CKEN14_I2C, 1);
+       ret = request_irq(IRQ_I2C, i2c_pxa_handler, SA_INTERRUPT,
+                         "pxa2xx-i2c", i2c);
+       if (ret)
+               goto out;
+
+       i2c_pxa_reset(i2c);
+
+       i2c->adap.algo_data = i2c;
+       i2c->adap.dev.parent = dev;
+
+       ret = i2c_add_adapter(&i2c->adap);
+       if (ret < 0) {
+               printk(KERN_INFO "I2C: Failed to add bus\n");
+               goto err_irq;
+       }
+
+       dev_set_drvdata(dev, i2c);
+
+#ifdef CONFIG_I2C_PXA_SLAVE
+       printk(KERN_INFO "I2C: %s: PXA I2C adapter, slave address %d\n",
+              i2c->adap.dev.bus_id, i2c->slave_addr);
+#else
+       printk(KERN_INFO "I2C: %s: PXA I2C adapter\n",
+              i2c->adap.dev.bus_id);
+#endif
+       return 0;
+
+ err_irq:
+       free_irq(IRQ_I2C, i2c);
+ out:
+       return ret;
+}
+
+static int i2c_pxa_remove(struct device *dev)
+{
+       struct pxa_i2c *i2c = dev_get_drvdata(dev);
+
+       dev_set_drvdata(dev, NULL);
+
+       i2c_del_adapter(&i2c->adap);
+       free_irq(IRQ_I2C, i2c);
+       pxa_set_cken(CKEN14_I2C, 0);
+
+       return 0;
+}
+
+static struct device_driver i2c_pxa_driver = {
+       .name           = "pxa2xx-i2c",
+       .bus            = &platform_bus_type,
+       .probe          = i2c_pxa_probe,
+       .remove         = i2c_pxa_remove,
+};
+
+static int __init i2c_adap_pxa_init(void)
+{
+       return driver_register(&i2c_pxa_driver);
+}
+
+static void i2c_adap_pxa_exit(void)
+{
+       return driver_unregister(&i2c_pxa_driver);
+}
+
+module_init(i2c_adap_pxa_init);
+module_exit(i2c_adap_pxa_exit);
index 3241d6c9dc11d2f2a959224f22cd58070449d0b5..ffbcd40418d5fd82f8d246e0585fb7bd5ede17c7 100644 (file)
@@ -937,12 +937,12 @@ static int __devinit mthca_init_one(struct pci_dev *pdev,
                ++mthca_version_printed;
        }
 
-       printk(KERN_INFO PFX "Initializing %s (%s)\n",
-              pci_pretty_name(pdev), pci_name(pdev));
+       printk(KERN_INFO PFX "Initializing %s\n",
+              pci_name(pdev));
 
        if (id->driver_data >= ARRAY_SIZE(mthca_hca_table)) {
-               printk(KERN_ERR PFX "%s (%s) has invalid driver data %lx\n",
-                      pci_pretty_name(pdev), pci_name(pdev), id->driver_data);
+               printk(KERN_ERR PFX "%s has invalid driver data %lx\n",
+                      pci_name(pdev), id->driver_data);
                return -ENODEV;
        }
 
index 8ea801271a41581d468c011fd4c65a923d1884ee..4f995391dd1d8176e7ff0cc25f4ac5b049288ae3 100644 (file)
@@ -71,8 +71,8 @@ int mthca_reset(struct mthca_dev *mdev)
                                                bridge)) != NULL) {
                        if (bridge->hdr_type    == PCI_HEADER_TYPE_BRIDGE &&
                            bridge->subordinate == mdev->pdev->bus) {
-                               mthca_dbg(mdev, "Found bridge: %s (%s)\n",
-                                         pci_pretty_name(bridge), pci_name(bridge));
+                               mthca_dbg(mdev, "Found bridge: %s\n",
+                                         pci_name(bridge));
                                break;
                        }
                }
@@ -83,8 +83,8 @@ int mthca_reset(struct mthca_dev *mdev)
                         * assume we're in no-bridge mode and hope for
                         * the best.
                         */
-                       mthca_warn(mdev, "No bridge found for %s (%s)\n",
-                                 pci_pretty_name(mdev->pdev), pci_name(mdev->pdev));
+                       mthca_warn(mdev, "No bridge found for %s\n",
+                                 pci_name(mdev->pdev));
                }
 
        }
index 0a117c61cd1809e4f2ee6d924ac716810c8c848e..ceae379a4d4c56227541582affc855785fc248c5 100644 (file)
@@ -1079,13 +1079,17 @@ static void mmc_setup(struct mmc_host *host)
 /**
  *     mmc_detect_change - process change of state on a MMC socket
  *     @host: host which changed state.
+ *     @delay: optional delay to wait before detection (jiffies)
  *
  *     All we know is that card(s) have been inserted or removed
  *     from the socket(s).  We don't know which socket or cards.
  */
-void mmc_detect_change(struct mmc_host *host)
+void mmc_detect_change(struct mmc_host *host, unsigned long delay)
 {
-       schedule_work(&host->detect);
+       if (delay)
+               schedule_delayed_work(&host->detect, delay);
+       else
+               schedule_work(&host->detect);
 }
 
 EXPORT_SYMBOL(mmc_detect_change);
@@ -1189,7 +1193,7 @@ int mmc_add_host(struct mmc_host *host)
        ret = mmc_add_host_sysfs(host);
        if (ret == 0) {
                mmc_power_off(host);
-               mmc_detect_change(host);
+               mmc_detect_change(host, 0);
        }
 
        return ret;
@@ -1259,7 +1263,7 @@ EXPORT_SYMBOL(mmc_suspend_host);
  */
 int mmc_resume_host(struct mmc_host *host)
 {
-       mmc_detect_change(host);
+       mmc_detect_change(host, 0);
 
        return 0;
 }
index 716c4ef4faf6f8c46c9582d5211d5fba3a332255..91c74843dc0d8c54c88bec1973a44eda18b0866b 100644 (file)
@@ -442,7 +442,7 @@ static void mmci_check_status(unsigned long data)
 
        status = host->plat->status(mmc_dev(host->mmc));
        if (status ^ host->oldstat)
-               mmc_detect_change(host->mmc);
+               mmc_detect_change(host->mmc, 0);
 
        host->oldstat = status;
        mod_timer(&host->timer, jiffies + HZ);
index e99a53b09e321390d683362cf483923774d535a7..b53af57074e3296b5bf994c105f37a42b3a8398a 100644 (file)
@@ -423,7 +423,9 @@ static void pxamci_dma_irq(int dma, void *devid, struct pt_regs *regs)
 
 static irqreturn_t pxamci_detect_irq(int irq, void *devid, struct pt_regs *regs)
 {
-       mmc_detect_change(devid);
+       struct pxamci_host *host = mmc_priv(devid);
+
+       mmc_detect_change(devid, host->pdata->detect_delay);
        return IRQ_HANDLED;
 }
 
index dec01d38c782fce5935ffb575ca90122934260e7..a62c86fef5ccc094f8a5e65ee0375837d14548e2 100644 (file)
@@ -1122,7 +1122,7 @@ static void wbsd_detect_card(unsigned long data)
        
        DBG("Executing card detection\n");
        
-       mmc_detect_change(host->mmc);   
+       mmc_detect_change(host->mmc, 0);        
 }
 
 /*
@@ -1198,7 +1198,7 @@ static void wbsd_tasklet_card(unsigned long param)
                 */
                spin_unlock(&host->lock);
 
-               mmc_detect_change(host->mmc);
+               mmc_detect_change(host->mmc, 0);
        }
        else
                spin_unlock(&host->lock);
index 55a72c7ad001a20ae03b4c3ebf3fe61281688884..83598e32179cee8c1f81b851e37c67f8fc736f87 100644 (file)
@@ -14,8 +14,8 @@
 
 #define DRV_MODULE_NAME                "bnx2"
 #define PFX DRV_MODULE_NAME    ": "
-#define DRV_MODULE_VERSION     "1.2.20"
-#define DRV_MODULE_RELDATE     "August 22, 2005"
+#define DRV_MODULE_VERSION     "1.2.21"
+#define DRV_MODULE_RELDATE     "September 7, 2005"
 
 #define RUN_AT(x) (jiffies + (x))
 
@@ -1533,6 +1533,7 @@ bnx2_msi(int irq, void *dev_instance, struct pt_regs *regs)
        struct net_device *dev = dev_instance;
        struct bnx2 *bp = dev->priv;
 
+       prefetch(bp->status_blk);
        REG_WR(bp, BNX2_PCICFG_INT_ACK_CMD,
                BNX2_PCICFG_INT_ACK_CMD_USE_INT_HC_PARAM |
                BNX2_PCICFG_INT_ACK_CMD_MASK_INT);
@@ -1558,7 +1559,7 @@ bnx2_interrupt(int irq, void *dev_instance, struct pt_regs *regs)
         * When using MSI, the MSI message will always complete after
         * the status block write.
         */
-       if ((bp->status_blk->status_idx == bp->last_status_idx) ||
+       if ((bp->status_blk->status_idx == bp->last_status_idx) &&
            (REG_RD(bp, BNX2_PCICFG_MISC_STATUS) &
             BNX2_PCICFG_MISC_STATUS_INTA_VALUE))
                return IRQ_NONE;
index 9ad3f5740cd8ee450a3aa96b2996b4d8c8882fca..62857b6a6ee41ea7bb086904a68f75f71abc4469 100644 (file)
@@ -50,6 +50,7 @@
 #endif
 #include <linux/workqueue.h>
 #include <linux/crc32.h>
+#include <linux/prefetch.h>
 
 /* Hardware data structures and register definitions automatically
  * generated from RTL code. Do not modify.
index 414694abf588fe8eed1d6a10908fe075c74a87f3..741aecc655dfe7d9da06d610c77a1eb8e4a60618 100644 (file)
@@ -69,14 +69,8 @@ typedef void irqreturn_t;
 
 #else /* 2.5 or later */
 
-/* recent 2.5/2.6 stores pci device names at varying places ;-) */
-#ifdef CONFIG_PCI_NAMES
-/* human readable name */
-#define PCIDEV_NAME(pdev)      ((pdev)->pretty_name)
-#else
 /* whatever we get from the associated struct device - bus:slot:dev.fn id */
 #define PCIDEV_NAME(pdev)      (pci_name(pdev))
-#endif
 
 #endif
 
index 97f723179f621d15ed3f9283a8a80446aa4a2cb0..1b938bb9be3cc0a985c8b22d80fbdac97344e33a 100644 (file)
@@ -3010,7 +3010,7 @@ static int __init parport_pc_init_superio (int autoirq, int autodma)
        struct pci_dev *pdev = NULL;
        int ret = 0;
 
-       while ((pdev = pci_find_device(PCI_ANY_ID, PCI_ANY_ID, pdev)) != NULL) {
+       for_each_pci_dev(pdev) {
                id = pci_match_id(parport_pc_pci_tbl, pdev);
                if (id == NULL || id->driver_data >= last_sio)
                        continue;
index 7f31991772ea4b0b2c51966479642f6e63c66490..f187fd8aeed6483d72c3b07ae72c49f2333fdbd9 100644 (file)
@@ -30,23 +30,6 @@ config PCI_LEGACY_PROC
 
          When in doubt, say N.
 
-config PCI_NAMES
-       bool "PCI device name database"
-       depends on PCI
-       ---help---
-         By default, the kernel contains a database of all known PCI device
-         names to make the information in /proc/pci, /proc/ioports and
-         similar files comprehensible to the user. 
-
-         This database increases size of the kernel image by about 80KB. This 
-         memory is freed after the system boots up if CONFIG_HOTPLUG is not set.
-
-         Anyway, if you are building an installation floppy or kernel for an 
-         embedded system where kernel image size really matters, you can disable 
-         this feature and you'll get device ID numbers instead of names.
-
-         When in doubt, say Y.
-
 config PCI_DEBUG
        bool "PCI Debugging"
        depends on PCI && DEBUG_KERNEL
index 3657f6199c48f8e579a8d1f49b91c0217f1ce0d7..716df015f8d017b4a5216f1e34e345bc5b813dd1 100644 (file)
@@ -3,14 +3,9 @@
 #
 
 obj-y          += access.o bus.o probe.o remove.o pci.o quirks.o \
-                       names.o pci-driver.o search.o pci-sysfs.o \
-                       rom.o
+                       pci-driver.o search.o pci-sysfs.o rom.o setup-res.o
 obj-$(CONFIG_PROC_FS) += proc.o
 
-ifndef CONFIG_SPARC64
-obj-y += setup-res.o
-endif
-
 obj-$(CONFIG_HOTPLUG) += hotplug.o
 
 # Build the PCI Hotplug drivers if we were asked to
@@ -46,21 +41,6 @@ ifeq ($(CONFIG_PCI_DEBUG),y)
 EXTRA_CFLAGS += -DDEBUG
 endif
 
-hostprogs-y := gen-devlist
-
-# Dependencies on generated files need to be listed explicitly
-$(obj)/names.o: $(obj)/devlist.h $(obj)/classlist.h
-$(obj)/classlist.h: $(obj)/devlist.h
-
-# And that's how to generate them
-quiet_cmd_devlist = DEVLIST $@
-      cmd_devlist = ( cd $(obj); ./gen-devlist ) < $<
-$(obj)/devlist.h: $(src)/pci.ids $(obj)/gen-devlist
-       $(call cmd,devlist)
-
-# Files generated that shall be removed upon make clean
-clean-files := devlist.h classlist.h
-
 # Build PCI Express stuff if needed
 obj-$(CONFIG_PCIEPORTBUS) += pcie/
 
index fb9a11243d2a1fbff876749a997617cfb4013670..eed67d9e73bcd6e3e9ac684342d460a1ac77c62b 100644 (file)
@@ -140,16 +140,65 @@ void __devinit pci_bus_add_devices(struct pci_bus *bus)
 void pci_enable_bridges(struct pci_bus *bus)
 {
        struct pci_dev *dev;
+       int retval;
 
        list_for_each_entry(dev, &bus->devices, bus_list) {
                if (dev->subordinate) {
-                       pci_enable_device(dev);
+                       retval = pci_enable_device(dev);
                        pci_set_master(dev);
                        pci_enable_bridges(dev->subordinate);
                }
        }
 }
 
+/** pci_walk_bus - walk devices on/under bus, calling callback.
+ *  @top      bus whose devices should be walked
+ *  @cb       callback to be called for each device found
+ *  @userdata arbitrary pointer to be passed to callback.
+ *
+ *  Walk the given bus, including any bridged devices
+ *  on buses under this bus.  Call the provided callback
+ *  on each device found.
+ */
+void pci_walk_bus(struct pci_bus *top, void (*cb)(struct pci_dev *, void *),
+                 void *userdata)
+{
+       struct pci_dev *dev;
+       struct pci_bus *bus;
+       struct list_head *next;
+
+       bus = top;
+       spin_lock(&pci_bus_lock);
+       next = top->devices.next;
+       for (;;) {
+               if (next == &bus->devices) {
+                       /* end of this bus, go up or finish */
+                       if (bus == top)
+                               break;
+                       next = bus->self->bus_list.next;
+                       bus = bus->self->bus;
+                       continue;
+               }
+               dev = list_entry(next, struct pci_dev, bus_list);
+               pci_dev_get(dev);
+               if (dev->subordinate) {
+                       /* this is a pci-pci bridge, do its devices next */
+                       next = dev->subordinate->devices.next;
+                       bus = dev->subordinate;
+               } else
+                       next = dev->bus_list.next;
+               spin_unlock(&pci_bus_lock);
+
+               /* Run device routines with the bus unlocked */
+               cb(dev, userdata);
+
+               spin_lock(&pci_bus_lock);
+               pci_dev_put(dev);
+       }
+       spin_unlock(&pci_bus_lock);
+}
+EXPORT_SYMBOL_GPL(pci_walk_bus);
+
 EXPORT_SYMBOL(pci_bus_alloc_resource);
 EXPORT_SYMBOL_GPL(pci_bus_add_device);
 EXPORT_SYMBOL(pci_bus_add_devices);
diff --git a/drivers/pci/gen-devlist.c b/drivers/pci/gen-devlist.c
deleted file mode 100644 (file)
index 8abfc49..0000000
+++ /dev/null
@@ -1,132 +0,0 @@
-/*
- *     Generate devlist.h and classlist.h from the PCI ID file.
- *
- *     (c) 1999--2002 Martin Mares <mj@ucw.cz>
- */
-
-#include <stdio.h>
-#include <string.h>
-
-#define MAX_NAME_SIZE 200
-
-static void
-pq(FILE *f, const char *c, int len)
-{
-       int i = 1;
-       while (*c && i != len) {
-               if (*c == '"')
-                       fprintf(f, "\\\"");
-               else {
-                       fputc(*c, f);
-                       if (*c == '?' && c[1] == '?') {
-                               /* Avoid trigraphs */
-                               fprintf(f, "\" \"");
-                       }
-               }
-               c++;
-               i++;
-       }
-}
-
-int
-main(void)
-{
-       char line[1024], *c, *bra, vend[8];
-       int vendors = 0;
-       int mode = 0;
-       int lino = 0;
-       int vendor_len = 0;
-       FILE *devf, *clsf;
-
-       devf = fopen("devlist.h", "w");
-       clsf = fopen("classlist.h", "w");
-       if (!devf || !clsf) {
-               fprintf(stderr, "Cannot create output file!\n");
-               return 1;
-       }
-
-       while (fgets(line, sizeof(line)-1, stdin)) {
-               lino++;
-               if ((c = strchr(line, '\n')))
-                       *c = 0;
-               if (!line[0] || line[0] == '#')
-                       continue;
-               if (line[1] == ' ') {
-                       if (line[0] == 'C' && strlen(line) > 4 && line[4] == ' ') {
-                               vend[0] = line[2];
-                               vend[1] = line[3];
-                               vend[2] = 0;
-                               mode = 2;
-                       } else goto err;
-               }
-               else if (line[0] == '\t') {
-                       if (line[1] == '\t')
-                               continue;
-                       switch (mode) {
-                       case 1:
-                               if (strlen(line) > 5 && line[5] == ' ') {
-                                       c = line + 5;
-                                       while (*c == ' ')
-                                               *c++ = 0;
-                                       if (vendor_len + strlen(c) + 1 > MAX_NAME_SIZE) {
-                                               /* Too long, try cutting off long description */
-                                               bra = strchr(c, '[');
-                                               if (bra && bra > c && bra[-1] == ' ')
-                                                       bra[-1] = 0;
-                                               if (vendor_len + strlen(c) + 1 > MAX_NAME_SIZE) {
-                                                       fprintf(stderr, "Line %d: Device name too long. Name truncated.\n", lino);
-                                                       fprintf(stderr, "%s\n", c);
-                                                       /*return 1;*/
-                                               }
-                                       }
-                                       fprintf(devf, "\tDEVICE(%s,%s,\"", vend, line+1);
-                                       pq(devf, c, MAX_NAME_SIZE - vendor_len - 1);
-                                       fputs("\")\n", devf);
-                               } else goto err;
-                               break;
-                       case 2:
-                               if (strlen(line) > 3 && line[3] == ' ') {
-                                       c = line + 3;
-                                       while (*c == ' ')
-                                               *c++ = 0;
-                                       fprintf(clsf, "CLASS(%s%s, \"%s\")\n", vend, line+1, c);
-                               } else goto err;
-                               break;
-                       default:
-                               goto err;
-                       }
-               } else if (strlen(line) > 4 && line[4] == ' ') {
-                       c = line + 4;
-                       while (*c == ' ')
-                               *c++ = 0;
-                       if (vendors)
-                               fputs("ENDVENDOR()\n\n", devf);
-                       vendors++;
-                       strcpy(vend, line);
-                       vendor_len = strlen(c);
-                       if (vendor_len + 24 > MAX_NAME_SIZE) {
-                               fprintf(stderr, "Line %d: Vendor name too long\n", lino);
-                               return 1;
-                       }
-                       fprintf(devf, "VENDOR(%s,\"", vend);
-                       pq(devf, c, 0);
-                       fputs("\")\n", devf);
-                       mode = 1;
-               } else {
-               err:
-                       fprintf(stderr, "Line %d: Syntax error in mode %d: %s\n", lino, mode, line);
-                       return 1;
-               }
-       }
-       fputs("ENDVENDOR()\n\
-\n\
-#undef VENDOR\n\
-#undef DEVICE\n\
-#undef ENDVENDOR\n", devf);
-       fputs("\n#undef CLASS\n", clsf);
-
-       fclose(devf);
-       fclose(clsf);
-
-       return 0;
-}
index 246586a3d91a1bf5d9343ecae8ebbf749f3fcda2..3c71e3077ff1dd9b5cbbc1f5b0c18df022a84451 100644 (file)
@@ -41,8 +41,7 @@ acpiphp-objs          :=      acpiphp_core.o  \
 
 rpaphp-objs            :=      rpaphp_core.o   \
                                rpaphp_pci.o    \
-                               rpaphp_slot.o   \
-                               rpaphp_vio.o
+                               rpaphp_slot.o
 
 rpadlpar_io-objs       :=      rpadlpar_core.o \
                                rpadlpar_sysfs.o
index 2b92b9e8c910a34ddf9e118e292c583ec84b2b37..061ead21ef1467bab23c390ec1604b2d3a78ccf5 100644 (file)
@@ -302,7 +302,7 @@ static inline void return_resource(struct pci_resource **head, struct pci_resour
 
 static inline void make_slot_name(char *buffer, int buffer_size, struct slot *slot)
 {
-       snprintf(buffer, buffer_size, "%d", slot->number);
+       snprintf(buffer, buffer_size, "%04d_%04d", slot->bus, slot->number);
 }
 
 enum php_ctlr_type {
index 86b384e427178e91a59911df426f60342343f808..4ada15111af0849fafd69769d31d189942ab43c1 100644 (file)
 #include <asm/pci-bridge.h>
 #include <asm/semaphore.h>
 #include <asm/rtas.h>
+#include <asm/vio.h>
 #include "../pci.h"
 #include "rpaphp.h"
 #include "rpadlpar.h"
 
 static DECLARE_MUTEX(rpadlpar_sem);
 
+#define DLPAR_MODULE_NAME "rpadlpar_io"
+
 #define NODE_TYPE_VIO  1
 #define NODE_TYPE_SLOT 2
 #define NODE_TYPE_PHB  3
 
-static struct device_node *find_php_slot_vio_node(char *drc_name)
+static struct device_node *find_vio_slot_node(char *drc_name)
 {
-       struct device_node *child;
        struct device_node *parent = of_find_node_by_name(NULL, "vdevice");
-       char *loc_code;
+       struct device_node *dn = NULL;
+       char *name;
+       int rc;
 
        if (!parent)
                return NULL;
 
-       for (child = of_get_next_child(parent, NULL);
-               child; child = of_get_next_child(parent, child)) {
-               loc_code = get_property(child, "ibm,loc-code", NULL);
-               if (loc_code && !strncmp(loc_code, drc_name, strlen(drc_name)))
-                       return child;
+       while ((dn = of_get_next_child(parent, dn))) {
+               rc = rpaphp_get_drc_props(dn, NULL, &name, NULL, NULL);
+               if ((rc == 0) && (!strcmp(drc_name, name)))
+                       break;
        }
 
-       return NULL;
+       return dn;
 }
 
 /* Find dlpar-capable pci node that contains the specified name and type */
@@ -67,7 +70,7 @@ static struct device_node *find_php_slot_pci_node(char *drc_name,
        return np;
 }
 
-static struct device_node *find_newly_added_node(char *drc_name, int *node_type)
+static struct device_node *find_dlpar_node(char *drc_name, int *node_type)
 {
        struct device_node *dn;
 
@@ -83,7 +86,7 @@ static struct device_node *find_newly_added_node(char *drc_name, int *node_type)
                return dn;
        }
 
-       dn = find_php_slot_vio_node(drc_name);
+       dn = find_vio_slot_node(drc_name);
        if (dn) {
                *node_type = NODE_TYPE_VIO;
                return dn;
@@ -92,14 +95,14 @@ static struct device_node *find_newly_added_node(char *drc_name, int *node_type)
        return NULL;
 }
 
-static struct slot *find_slot(char *drc_name)
+static struct slot *find_slot(struct device_node *dn)
 {
        struct list_head *tmp, *n;
        struct slot *slot;
 
         list_for_each_safe(tmp, n, &rpaphp_slot_head) {
                 slot = list_entry(tmp, struct slot, rpaphp_slot_list);
-                if (strcmp(slot->location, drc_name) == 0)
+                if (slot->dn == dn)
                         return slot;
         }
 
@@ -164,6 +167,20 @@ static int pci_add_secondary_bus(struct device_node *dn,
        return 0;
 }
 
+static struct pci_dev *dlpar_find_new_dev(struct pci_bus *parent,
+                                       struct device_node *dev_dn)
+{
+       struct pci_dev *tmp = NULL;
+       struct device_node *child_dn;
+
+       list_for_each_entry(tmp, &parent->devices, bus_list) {
+               child_dn = pci_device_to_OF_node(tmp);
+               if (child_dn == dev_dn)
+                       return tmp;
+       }
+       return NULL;
+}
+
 static struct pci_dev *dlpar_pci_add_bus(struct device_node *dn)
 {
        struct pci_controller *hose = dn->phb;
@@ -179,49 +196,28 @@ static struct pci_dev *dlpar_pci_add_bus(struct device_node *dn)
        pci_bus_add_devices(hose->bus);
 
        /* Confirm new bridge dev was created */
-       dev = rpaphp_find_pci_dev(dn);
-       if (!dev) {
-               printk(KERN_ERR "%s: failed to add pci device\n", __FUNCTION__);
-               return NULL;
-       }
+       dev = dlpar_find_new_dev(hose->bus, dn);
+       if (dev) {
+               if (dev->hdr_type != PCI_HEADER_TYPE_BRIDGE) {
+                       printk(KERN_ERR "%s: unexpected header type %d\n",
+                               __FUNCTION__, dev->hdr_type);
+                       return NULL;
+               }
 
-       if (dev->hdr_type != PCI_HEADER_TYPE_BRIDGE) {
-               printk(KERN_ERR "%s: unexpected header type %d\n",
-                       __FUNCTION__, dev->hdr_type);
-               return NULL;
+               if (pci_add_secondary_bus(dn, dev))
+                       return NULL;
        }
 
-       if (pci_add_secondary_bus(dn, dev))
-               return NULL;
-
        return dev;
 }
 
-static int dlpar_pci_remove_bus(struct pci_dev *bridge_dev)
+static int dlpar_add_pci_slot(char *drc_name, struct device_node *dn)
 {
-       struct pci_bus *secondary_bus;
+       struct pci_dev *dev;
+       int rc;
 
-       if (!bridge_dev) {
-               printk(KERN_ERR "%s: unexpected null device\n",
-                       __FUNCTION__);
+       if (rpaphp_find_pci_bus(dn))
                return -EINVAL;
-       }
-
-       secondary_bus = bridge_dev->subordinate;
-
-       if (unmap_bus_range(secondary_bus)) {
-               printk(KERN_ERR "%s: failed to unmap bus range\n",
-                       __FUNCTION__);
-               return -ERANGE;
-       }
-
-       pci_remove_bus_device(bridge_dev);
-       return 0;
-}
-
-static inline int dlpar_add_pci_slot(char *drc_name, struct device_node *dn)
-{
-       struct pci_dev *dev;
 
        /* Add pci bus */
        dev = dlpar_pci_add_bus(dn);
@@ -231,6 +227,21 @@ static inline int dlpar_add_pci_slot(char *drc_name, struct device_node *dn)
                return -EIO;
        }
 
+       if (dn->child) {
+               rc = rpaphp_config_pci_adapter(dev->subordinate);
+               if (rc < 0) {
+                       printk(KERN_ERR "%s: unable to enable slot %s\n",
+                               __FUNCTION__, drc_name);
+                       return -EIO;
+               }
+       }
+
+       /* Add hotplug slot */
+       if (rpaphp_add_slot(dn)) {
+               printk(KERN_ERR "%s: unable to add hotplug slot %s\n",
+                       __FUNCTION__, drc_name);
+               return -EIO;
+       }
        return 0;
 }
 
@@ -255,47 +266,67 @@ static int dlpar_remove_root_bus(struct pci_controller *phb)
        return 0;
 }
 
-static int dlpar_remove_phb(struct slot *slot)
+static int dlpar_remove_phb(char *drc_name, struct device_node *dn)
 {
-       struct pci_controller *phb;
-       struct device_node *dn;
+       struct slot *slot;
        int rc = 0;
 
-       dn = slot->dn;
-       if (!dn) {
-               printk(KERN_ERR "%s: unexpected NULL slot device node\n",
-                               __FUNCTION__);
-               return -EIO;
-       }
-
-       phb = dn->phb;
-       if (!phb) {
-               printk(KERN_ERR "%s: unexpected NULL phb pointer\n",
-                               __FUNCTION__);
-               return -EIO;
-       }
+       if (!rpaphp_find_pci_bus(dn))
+               return -EINVAL;
 
-       if (rpaphp_remove_slot(slot)) {
-               printk(KERN_ERR "%s: unable to remove hotplug slot %s\n",
-                       __FUNCTION__, slot->location);
-               return -EIO;
+       slot = find_slot(dn);
+       if (slot) {
+               /* Remove hotplug slot */
+               if (rpaphp_remove_slot(slot)) {
+                       printk(KERN_ERR
+                               "%s: unable to remove hotplug slot %s\n",
+                               __FUNCTION__, drc_name);
+                       return -EIO;
+               }
        }
 
-       rc = dlpar_remove_root_bus(phb);
+       BUG_ON(!dn->phb);
+       rc = dlpar_remove_root_bus(dn->phb);
        if (rc < 0)
                return rc;
 
+       dn->phb = NULL;
+
        return 0;
 }
 
-static int dlpar_add_phb(struct device_node *dn)
+static int dlpar_add_phb(char *drc_name, struct device_node *dn)
 {
        struct pci_controller *phb;
 
+       if (dn->phb) {
+               /* PHB already exists */
+               return -EINVAL;
+       }
+
        phb = init_phb_dynamic(dn);
        if (!phb)
+               return -EIO;
+
+       if (rpaphp_add_slot(dn)) {
+               printk(KERN_ERR "%s: unable to add hotplug slot %s\n",
+                       __FUNCTION__, drc_name);
+               return -EIO;
+       }
+       return 0;
+}
+
+static int dlpar_add_vio_slot(char *drc_name, struct device_node *dn)
+{
+       if (vio_find_node(dn))
                return -EINVAL;
 
+       if (!vio_register_device_node(dn)) {
+               printk(KERN_ERR
+                       "%s: failed to register vio node %s\n",
+                       __FUNCTION__, drc_name);
+               return -EIO;
+       }
        return 0;
 }
 
@@ -316,18 +347,13 @@ int dlpar_add_slot(char *drc_name)
 {
        struct device_node *dn = NULL;
        int node_type;
-       int rc = 0;
+       int rc = -EIO;
 
        if (down_interruptible(&rpadlpar_sem))
                return -ERESTARTSYS;
 
-       /* Check for existing hotplug slot */
-       if (find_slot(drc_name)) {
-               rc = -EINVAL;
-               goto exit;
-       }
-
-       dn = find_newly_added_node(drc_name, &node_type);
+       /* Find newly added node */
+       dn = find_dlpar_node(drc_name, &node_type);
        if (!dn) {
                rc = -ENODEV;
                goto exit;
@@ -335,24 +361,17 @@ int dlpar_add_slot(char *drc_name)
 
        switch (node_type) {
                case NODE_TYPE_VIO:
-                       /* Just add hotplug slot */
+                       rc = dlpar_add_vio_slot(drc_name, dn);
                        break;
                case NODE_TYPE_SLOT:
                        rc = dlpar_add_pci_slot(drc_name, dn);
                        break;
                case NODE_TYPE_PHB:
-                       rc = dlpar_add_phb(dn);
+                       rc = dlpar_add_phb(drc_name, dn);
                        break;
-               default:
-                       printk("%s: unexpected node type\n", __FUNCTION__);
-                       return -EIO;
        }
 
-       if (!rc && rpaphp_add_slot(dn)) {
-               printk(KERN_ERR "%s: unable to add hotplug slot %s\n",
-                       __FUNCTION__, drc_name);
-               rc = -EIO;
-       }
+       printk(KERN_INFO "%s: slot %s added\n", DLPAR_MODULE_NAME, drc_name);
 exit:
        up(&rpadlpar_sem);
        return rc;
@@ -366,17 +385,17 @@ exit:
  * of an I/O Slot.
  * Return Codes:
  * 0                   Success
- * -EIO                        Internal  Error
+ * -EINVAL             Vio dev doesn't exist
  */
-int dlpar_remove_vio_slot(struct slot *slot, char *drc_name)
+static int dlpar_remove_vio_slot(char *drc_name, struct device_node *dn)
 {
-       /* Remove hotplug slot */
+       struct vio_dev *vio_dev;
 
-       if (rpaphp_remove_slot(slot)) {
-               printk(KERN_ERR "%s: unable to remove hotplug slot %s\n",
-                       __FUNCTION__, drc_name);
-               return -EIO;
-       }
+       vio_dev = vio_find_node(dn);
+       if (!vio_dev)
+               return -EINVAL;
+
+       vio_unregister_device(vio_dev);
        return 0;
 }
 
@@ -391,31 +410,34 @@ int dlpar_remove_vio_slot(struct slot *slot, char *drc_name)
  * -ENODEV             Not a valid drc_name
  * -EIO                        Internal PCI Error
  */
-int dlpar_remove_pci_slot(struct slot *slot, char *drc_name)
+int dlpar_remove_pci_slot(char *drc_name, struct device_node *dn)
 {
-       struct pci_dev *bridge_dev;
+       struct pci_bus *bus;
+       struct slot *slot;
 
-       bridge_dev = slot->bridge;
-       if (!bridge_dev) {
-               printk(KERN_ERR "%s: unexpected null bridge device\n",
-                       __FUNCTION__);
-               return -EIO;
-       }
+       bus = rpaphp_find_pci_bus(dn);
+       if (!bus)
+               return -EINVAL;
 
-       /* Remove hotplug slot */
-       if (rpaphp_remove_slot(slot)) {
-               printk(KERN_ERR "%s: unable to remove hotplug slot %s\n",
-                       __FUNCTION__, drc_name);
-               return -EIO;
+       slot = find_slot(dn);
+       if (slot) {
+               /* Remove hotplug slot */
+               if (rpaphp_remove_slot(slot)) {
+                       printk(KERN_ERR
+                               "%s: unable to remove hotplug slot %s\n",
+                               __FUNCTION__, drc_name);
+                       return -EIO;
+               }
        }
 
-       /* Remove pci bus */
-
-       if (dlpar_pci_remove_bus(bridge_dev)) {
-               printk(KERN_ERR "%s: unable to remove pci bus %s\n",
-                       __FUNCTION__, drc_name);
-               return -EIO;
+       if (unmap_bus_range(bus)) {
+               printk(KERN_ERR "%s: failed to unmap bus range\n",
+                       __FUNCTION__);
+               return -ERANGE;
        }
+
+       BUG_ON(!bus->self);
+       pci_remove_bus_device(bus->self);
        return 0;
 }
 
@@ -434,38 +456,31 @@ int dlpar_remove_pci_slot(struct slot *slot, char *drc_name)
  */
 int dlpar_remove_slot(char *drc_name)
 {
-       struct slot *slot;
+       struct device_node *dn;
+       int node_type;
        int rc = 0;
 
        if (down_interruptible(&rpadlpar_sem))
                return -ERESTARTSYS;
 
-       if (!find_php_slot_vio_node(drc_name) &&
-           !find_php_slot_pci_node(drc_name, "SLOT") &&
-           !find_php_slot_pci_node(drc_name, "PHB")) {
+       dn = find_dlpar_node(drc_name, &node_type);
+       if (!dn) {
                rc = -ENODEV;
                goto exit;
        }
 
-       slot = find_slot(drc_name);
-       if (!slot) {
-               rc = -EINVAL;
-               goto exit;
-       }
-       
-       if (slot->type == PHB) {
-               rc = dlpar_remove_phb(slot);
-       } else {
-               switch (slot->dev_type) {
-                       case PCI_DEV:
-                               rc = dlpar_remove_pci_slot(slot, drc_name);
-                               break;
-
-                       case VIO_DEV:
-                               rc = dlpar_remove_vio_slot(slot, drc_name);
-                               break;
-               }
+       switch (node_type) {
+               case NODE_TYPE_VIO:
+                       rc = dlpar_remove_vio_slot(drc_name, dn);
+                       break;
+               case NODE_TYPE_PHB:
+                       rc = dlpar_remove_phb(drc_name, dn);
+                       break;
+               case NODE_TYPE_SLOT:
+                       rc = dlpar_remove_pci_slot(drc_name, dn);
+                       break;
        }
+       printk(KERN_INFO "%s: slot %s removed\n", DLPAR_MODULE_NAME, drc_name);
 exit:
        up(&rpadlpar_sem);
        return rc;
index 81746e6e0e0fefdcbe13be108364f123eab10365..61d94d1e29cbaeb063ba437b44180c1066fabe5a 100644 (file)
 #include <linux/pci.h>
 #include "pci_hotplug.h"
 
-#define        PHB     2
-#define        HOTPLUG 1
-#define        EMBEDDED 0
-
 #define DR_INDICATOR 9002
 #define DR_ENTITY_SENSE 9003
 
@@ -61,10 +57,6 @@ extern int debug;
 #define info(format, arg...) printk(KERN_INFO "%s: " format, MY_NAME , ## arg)
 #define warn(format, arg...) printk(KERN_WARNING "%s: " format, MY_NAME , ## arg)
 
-/* slot types */
-#define VIO_DEV        1
-#define PCI_DEV        2
-
 /* slot states */
 
 #define        NOT_VALID       3
@@ -72,11 +64,6 @@ extern int debug;
 #define        CONFIGURED      1
 #define        EMPTY           0
 
-struct rpaphp_pci_func {
-       struct pci_dev *pci_dev;
-       struct list_head sibling;
-};
-
 /*
  * struct slot - slot information for each *physical* slot
  */
@@ -88,15 +75,9 @@ struct slot {
        u32 power_domain;
        char *name;
        char *location;
-       u8 removable;
-       u8 dev_type;            /* VIO or PCI */
-       struct device_node *dn; /* slot's device_node in OFDT */
-                               /* dn has phb info */
-       struct pci_dev *bridge; /* slot's pci_dev in pci_devices */
-       union {
-               struct list_head *pci_devs; /* pci_devs in PCI slot */
-               struct vio_dev *vio_dev; /* vio_dev in VIO slot */
-       } dev;
+       struct device_node *dn;
+       struct pci_bus *bus;
+       struct list_head *pci_devs;
        struct hotplug_slot *hotplug_slot;
 };
 
@@ -107,13 +88,13 @@ extern int num_slots;
 /* function prototypes */
 
 /* rpaphp_pci.c */
-extern struct pci_dev *rpaphp_find_pci_dev(struct device_node *dn);
+extern struct pci_bus *rpaphp_find_pci_bus(struct device_node *dn);
 extern int rpaphp_claim_resource(struct pci_dev *dev, int resource);
 extern int rpaphp_enable_pci_slot(struct slot *slot);
 extern int register_pci_slot(struct slot *slot);
 extern int rpaphp_unconfig_pci_adapter(struct slot *slot);
 extern int rpaphp_get_pci_adapter_status(struct slot *slot, int is_init, u8 * value);
-extern struct hotplug_slot *rpaphp_find_hotplug_slot(struct pci_dev *dev);
+extern int rpaphp_config_pci_adapter(struct pci_bus *bus);
 
 /* rpaphp_core.c */
 extern int rpaphp_add_slot(struct device_node *dn);
@@ -121,12 +102,6 @@ extern int rpaphp_remove_slot(struct slot *slot);
 extern int rpaphp_get_drc_props(struct device_node *dn, int *drc_index,
                char **drc_name, char **drc_type, int *drc_power_domain);
 
-/* rpaphp_vio.c */
-extern int rpaphp_get_vio_adapter_status(struct slot *slot, int is_init, u8 * value);
-extern int rpaphp_unconfig_vio_adapter(struct slot *slot);
-extern int register_vio_slot(struct device_node *dn);
-extern int rpaphp_enable_vio_slot(struct slot *slot);
-
 /* rpaphp_slot.c */
 extern void dealloc_slot_struct(struct slot *slot);
 extern struct slot *alloc_slot_struct(struct device_node *dn, int drc_index, char *drc_name, int power_domain);
index 29117a3a32874194f72805d4530c2416fbe2eb1e..c830ff0acdc3471202414943dac2b8d2c818d7e6 100644 (file)
@@ -152,17 +152,7 @@ static int get_adapter_status(struct hotplug_slot *hotplug_slot, u8 * value)
        int retval = 0;
 
        down(&rpaphp_sem);
-       /*  have to go through this */
-       switch (slot->dev_type) {
-       case PCI_DEV:
-               retval = rpaphp_get_pci_adapter_status(slot, 0, value);
-               break;
-       case VIO_DEV:
-               retval = rpaphp_get_vio_adapter_status(slot, 0, value);
-               break;
-       default:
-               retval = -EINVAL;
-       }
+       retval = rpaphp_get_pci_adapter_status(slot, 0, value);
        up(&rpaphp_sem);
        return retval;
 }
@@ -317,34 +307,6 @@ static int is_php_dn(struct device_node *dn, int **indexes, int **names,
        return 0;
 }
 
-static int is_dr_dn(struct device_node *dn, int **indexes, int **names,
-               int **types, int **power_domains, int **my_drc_index)
-{
-       int rc;
-
-       *my_drc_index = (int *) get_property(dn, "ibm,my-drc-index", NULL);
-       if(!*my_drc_index)
-               return (0);
-
-       if (!dn->parent)
-               return (0);
-
-       rc = get_children_props(dn->parent, indexes, names, types,
-                               power_domains);
-       return (rc >= 0);
-}
-
-static inline int is_vdevice_root(struct device_node *dn)
-{
-       return !strcmp(dn->name, "vdevice");
-}
-
-int is_dlpar_type(const char *type_str)
-{
-       /* Only register DLPAR-capable nodes of drc-type PHB or SLOT */
-       return (!strcmp(type_str, "PHB") || !strcmp(type_str, "SLOT"));
-}
-
 /****************************************************************
  *     rpaphp not only registers PCI hotplug slots(HOTPLUG), 
  *     but also logical DR slots(EMBEDDED).
@@ -356,54 +318,33 @@ int rpaphp_add_slot(struct device_node *dn)
 {
        struct slot *slot;
        int retval = 0;
-       int i, *my_drc_index, slot_type;
+       int i;
        int *indexes, *names, *types, *power_domains;
        char *name, *type;
 
        dbg("Entry %s: dn->full_name=%s\n", __FUNCTION__, dn->full_name);
 
-       if (dn->parent && is_vdevice_root(dn->parent)) {
-               /* register a VIO device */
-               retval = register_vio_slot(dn);
-               goto exit;
-       }
-
        /* register PCI devices */
        if (dn->name != 0 && strcmp(dn->name, "pci") == 0) {
-               if (is_php_dn(dn, &indexes, &names, &types, &power_domains))  
-                       slot_type = HOTPLUG;
-               else if (is_dr_dn(dn, &indexes, &names, &types, &power_domains, &my_drc_index)) 
-                       slot_type = EMBEDDED;
-               else goto exit;
+               if (!is_php_dn(dn, &indexes, &names, &types, &power_domains))
+                       goto exit;
 
                name = (char *) &names[1];
                type = (char *) &types[1];
                for (i = 0; i < indexes[0]; i++,
-                       name += (strlen(name) + 1), type += (strlen(type) + 1)) {
-
-                       if (slot_type == HOTPLUG ||
-                           (slot_type == EMBEDDED &&
-                            indexes[i + 1] == my_drc_index[0] &&
-                            is_dlpar_type(type))) {
-                               if (!(slot = alloc_slot_struct(dn, indexes[i + 1], name,
-                                              power_domains[i + 1]))) {
-                                       retval = -ENOMEM;
-                                       goto exit;
-                               }
-                               if (!strcmp(type, "PHB"))
-                                       slot->type = PHB;
-                               else if (slot_type == EMBEDDED)
-                                       slot->type = EMBEDDED;
-                               else
-                                       slot->type = simple_strtoul(type, NULL, 10);
+                       name += (strlen(name) + 1), type += (strlen(type) + 1))                 {
+
+                       if (!(slot = alloc_slot_struct(dn, indexes[i + 1], name,
+                                      power_domains[i + 1]))) {
+                               retval = -ENOMEM;
+                               goto exit;
+                       }
+                       slot->type = simple_strtoul(type, NULL, 10);
                                
-                               dbg("    Found drc-index:0x%x drc-name:%s drc-type:%s\n",
+                       dbg("Found drc-index:0x%x drc-name:%s drc-type:%s\n",
                                        indexes[i + 1], name, type);
 
-                               retval = register_pci_slot(slot);
-                               if (slot_type == EMBEDDED)
-                                       goto exit;
-                       }
+                       retval = register_pci_slot(slot);
                }
        }
 exit:
@@ -412,31 +353,6 @@ exit:
        return retval;
 }
 
-/*
- * init_slots - initialize 'struct slot' structures for each slot
- *
- */
-static void init_slots(void)
-{
-       struct device_node *dn;
-
-       for (dn = find_all_nodes(); dn; dn = dn->next)
-               rpaphp_add_slot(dn);
-}
-
-static int __init init_rpa(void)
-{
-
-       init_MUTEX(&rpaphp_sem);
-
-       /* initialize internal data structure etc. */
-       init_slots();
-       if (!num_slots)
-               return -ENODEV;
-
-       return 0;
-}
-
 static void __exit cleanup_slots(void)
 {
        struct list_head *tmp, *n;
@@ -458,10 +374,18 @@ static void __exit cleanup_slots(void)
 
 static int __init rpaphp_init(void)
 {
+       struct device_node *dn = NULL;
+
        info(DRIVER_DESC " version: " DRIVER_VERSION "\n");
+       init_MUTEX(&rpaphp_sem);
 
-       /* read all the PRA info from the system */
-       return init_rpa();
+       while ((dn = of_find_node_by_type(dn, "pci")))
+               rpaphp_add_slot(dn);
+
+       if (!num_slots)
+               return -ENODEV;
+
+       return 0;
 }
 
 static void __exit rpaphp_exit(void)
@@ -481,16 +405,7 @@ static int enable_slot(struct hotplug_slot *hotplug_slot)
 
        dbg("ENABLING SLOT %s\n", slot->name);
        down(&rpaphp_sem);
-       switch (slot->dev_type) {
-       case PCI_DEV:
-               retval = rpaphp_enable_pci_slot(slot);
-               break;
-       case VIO_DEV:
-               retval = rpaphp_enable_vio_slot(slot);
-               break;
-       default:
-               retval = -EINVAL;
-       }
+       retval = rpaphp_enable_pci_slot(slot);
        up(&rpaphp_sem);
 exit:
        dbg("%s - Exit: rc[%d]\n", __FUNCTION__, retval);
@@ -511,16 +426,7 @@ static int disable_slot(struct hotplug_slot *hotplug_slot)
 
        dbg("DISABLING SLOT %s\n", slot->name);
        down(&rpaphp_sem);
-       switch (slot->dev_type) {
-       case PCI_DEV:
-               retval = rpaphp_unconfig_pci_adapter(slot);
-               break;
-       case VIO_DEV:
-               retval = rpaphp_unconfig_vio_adapter(slot);
-               break;
-       default:
-               retval = -ENODEV;
-       }
+       retval = rpaphp_unconfig_pci_adapter(slot);
        up(&rpaphp_sem);
 exit:
        dbg("%s - Exit: rc[%d]\n", __FUNCTION__, retval);
index d8305a935aab12d2471dd8de7253ba21e19b4136..17a0279ebcb9faf0e3b0c42229d145392aa4cd4c 100644 (file)
 
 #include "rpaphp.h"
 
-struct pci_dev *rpaphp_find_pci_dev(struct device_node *dn)
+static struct pci_bus *find_bus_among_children(struct pci_bus *bus,
+                                       struct device_node *dn)
 {
-       struct pci_dev *dev = NULL;
-       char bus_id[BUS_ID_SIZE];
+       struct pci_bus *child = NULL;
+       struct list_head *tmp;
+       struct device_node *busdn;
+
+       busdn = pci_bus_to_OF_node(bus);
+       if (busdn == dn)
+               return bus;
 
-       sprintf(bus_id, "%04x:%02x:%02x.%d", dn->phb->global_number,
-               dn->busno, PCI_SLOT(dn->devfn), PCI_FUNC(dn->devfn));
-       for_each_pci_dev(dev) {
-               if (!strcmp(pci_name(dev), bus_id)) {
+       list_for_each(tmp, &bus->children) {
+               child = find_bus_among_children(pci_bus_b(tmp), dn);
+               if (child)
                        break;
-               }
        }
-       return dev;
+       return child;
 }
 
-EXPORT_SYMBOL_GPL(rpaphp_find_pci_dev);
+struct pci_bus *rpaphp_find_pci_bus(struct device_node *dn)
+{
+       if (!dn->phb || !dn->phb->bus)
+               return NULL;
+
+       return find_bus_among_children(dn->phb->bus, dn);
+}
+EXPORT_SYMBOL_GPL(rpaphp_find_pci_bus);
 
 int rpaphp_claim_resource(struct pci_dev *dev, int resource)
 {
@@ -69,11 +80,6 @@ int rpaphp_claim_resource(struct pci_dev *dev, int resource)
 
 EXPORT_SYMBOL_GPL(rpaphp_claim_resource);
 
-static struct pci_dev *rpaphp_find_bridge_pdev(struct slot *slot)
-{
-       return rpaphp_find_pci_dev(slot->dn);
-}
-
 static int rpaphp_get_sensor_state(struct slot *slot, int *state)
 {
        int rc;
@@ -116,39 +122,27 @@ static int rpaphp_get_sensor_state(struct slot *slot, int *state)
  */
 int rpaphp_get_pci_adapter_status(struct slot *slot, int is_init, u8 * value)
 {
+       struct pci_bus *bus;
        int state, rc;
-       struct device_node *child_dn;
-       struct pci_dev *child_dev = NULL;
 
        *value = NOT_VALID;
        rc = rpaphp_get_sensor_state(slot, &state);
        if (rc)
                goto exit;
 
-       if ((state == EMPTY) || (slot->type == PHB)) {
-               dbg("slot is empty\n");
+       if (state == EMPTY)
                *value = EMPTY;
-       }
        else if (state == PRESENT) {
                if (!is_init) {
                        /* at run-time slot->state can be changed by */
                        /* config/unconfig adapter */
                        *value = slot->state;
                } else {
-                       child_dn = slot->dn->child;
-                       if (child_dn)
-                               child_dev = rpaphp_find_pci_dev(child_dn);
-
-                       if (child_dev)
-                               *value = CONFIGURED;
-                       else if (!child_dn)
-                               dbg("%s: %s is not valid OFDT node\n",
-                                   __FUNCTION__, slot->dn->full_name);
-                       else {
-                               err("%s: can't find pdev of adapter in slot[%s]\n", 
-                                       __FUNCTION__, slot->dn->full_name);
+                       bus = rpaphp_find_pci_bus(slot->dn);
+                       if (bus && !list_empty(&bus->devices))
+                               *value = CONFIGURED;
+                       else
                                *value = NOT_CONFIGURED;
-                       }
                }
        }
 exit:
@@ -186,39 +180,6 @@ rpaphp_fixup_new_pci_devices(struct pci_bus *bus, int fix_bus)
        }
 }
 
-static int rpaphp_pci_config_bridge(struct pci_dev *dev);
-
-/*****************************************************************************
- rpaphp_pci_config_slot() will  configure all devices under the 
- given slot->dn and return the the first pci_dev.
- *****************************************************************************/
-static struct pci_dev *
-rpaphp_pci_config_slot(struct device_node *dn, struct pci_bus *bus)
-{
-       struct device_node *eads_first_child = dn->child;
-       struct pci_dev *dev = NULL;
-       int num;
-       
-       dbg("Enter %s: dn=%s bus=%s\n", __FUNCTION__, dn->full_name, bus->name);
-
-       if (eads_first_child) {
-               /* pci_scan_slot should find all children of EADs */
-               num = pci_scan_slot(bus, PCI_DEVFN(PCI_SLOT(eads_first_child->devfn), 0));
-               if (num) {
-                       rpaphp_fixup_new_pci_devices(bus, 1); 
-                       pci_bus_add_devices(bus);
-               }
-               dev = rpaphp_find_pci_dev(eads_first_child);
-               if (!dev) {
-                       err("No new device found\n");
-                       return NULL;
-               }
-               if (dev->hdr_type == PCI_HEADER_TYPE_BRIDGE) 
-                       rpaphp_pci_config_bridge(dev);
-       }
-       return dev;
-}
-
 static int rpaphp_pci_config_bridge(struct pci_dev *dev)
 {
        u8 sec_busno;
@@ -252,6 +213,42 @@ static int rpaphp_pci_config_bridge(struct pci_dev *dev)
        return 0;
 }
 
+/*****************************************************************************
+ rpaphp_pci_config_slot() will  configure all devices under the
+ given slot->dn and return the the first pci_dev.
+ *****************************************************************************/
+static struct pci_dev *
+rpaphp_pci_config_slot(struct pci_bus *bus)
+{
+       struct device_node *dn = pci_bus_to_OF_node(bus);
+       struct pci_dev *dev = NULL;
+       int slotno;
+       int num;
+
+       dbg("Enter %s: dn=%s bus=%s\n", __FUNCTION__, dn->full_name, bus->name);
+       if (!dn || !dn->child)
+               return NULL;
+
+       slotno = PCI_SLOT(dn->child->devfn);
+
+       /* pci_scan_slot should find all children */
+       num = pci_scan_slot(bus, PCI_DEVFN(slotno, 0));
+       if (num) {
+               rpaphp_fixup_new_pci_devices(bus, 1);
+               pci_bus_add_devices(bus);
+       }
+       if (list_empty(&bus->devices)) {
+               err("%s: No new device found\n", __FUNCTION__);
+               return NULL;
+       }
+       list_for_each_entry(dev, &bus->devices, bus_list) {
+               if (dev->hdr_type == PCI_HEADER_TYPE_BRIDGE)
+                       rpaphp_pci_config_bridge(dev);
+       }
+
+       return dev;
+}
+
 static void enable_eeh(struct device_node *dn)
 {
        struct device_node *sib;
@@ -263,49 +260,44 @@ static void enable_eeh(struct device_node *dn)
        
 }
 
-static void print_slot_pci_funcs(struct slot *slot)
+static void print_slot_pci_funcs(struct pci_bus *bus)
 {
+       struct device_node *dn;
        struct pci_dev *dev;
 
-       if (slot->dev_type == PCI_DEV) {
-               dbg("%s: pci_devs of slot[%s]\n", __FUNCTION__, slot->name);
-               list_for_each_entry (dev, slot->dev.pci_devs, bus_list)
-                       dbg("\t%s\n", pci_name(dev));
-       }
+       dn = pci_bus_to_OF_node(bus);
+       if (!dn)
+               return;
+
+       dbg("%s: pci_devs of slot[%s]\n", __FUNCTION__, dn->full_name);
+       list_for_each_entry (dev, &bus->devices, bus_list)
+               dbg("\t%s\n", pci_name(dev));
        return;
 }
 
-static int rpaphp_config_pci_adapter(struct slot *slot)
+int rpaphp_config_pci_adapter(struct pci_bus *bus)
 {
-       struct pci_bus *pci_bus;
+       struct device_node *dn = pci_bus_to_OF_node(bus);
        struct pci_dev *dev;
        int rc = -ENODEV;
 
-       dbg("Entry %s: slot[%s]\n", __FUNCTION__, slot->name);
-
-       if (slot->bridge) {
+       dbg("Entry %s: slot[%s]\n", __FUNCTION__, dn->full_name);
+       if (!dn)
+               goto exit;
 
-               pci_bus = slot->bridge->subordinate;
-               if (!pci_bus) {
-                       err("%s: can't find bus structure\n", __FUNCTION__);
-                       goto exit;
-               }
-               enable_eeh(slot->dn);
-               dev = rpaphp_pci_config_slot(slot->dn, pci_bus);
-               if (!dev) {
-                       err("%s: can't find any devices.\n", __FUNCTION__);
-                       goto exit;
-               }
-               print_slot_pci_funcs(slot);
-               rc = 0;
-       } else {
-               /* slot is not enabled */
-               err("slot doesn't have pci_dev structure\n");
+       enable_eeh(dn);
+       dev = rpaphp_pci_config_slot(bus);
+       if (!dev) {
+               err("%s: can't find any devices.\n", __FUNCTION__);
+               goto exit;
        }
+       print_slot_pci_funcs(bus);
+       rc = 0;
 exit:
        dbg("Exit %s:  rc=%d\n", __FUNCTION__, rc);
        return rc;
 }
+EXPORT_SYMBOL_GPL(rpaphp_config_pci_adapter);
 
 static void rpaphp_eeh_remove_bus_device(struct pci_dev *dev)
 {
@@ -327,13 +319,14 @@ static void rpaphp_eeh_remove_bus_device(struct pci_dev *dev)
 
 int rpaphp_unconfig_pci_adapter(struct slot *slot)
 {
-       struct pci_dev *dev;
+       struct pci_dev *dev, *tmp;
        int retval = 0;
 
-       list_for_each_entry(dev, slot->dev.pci_devs, bus_list)
+       list_for_each_entry_safe(dev, tmp, slot->pci_devs, bus_list) {
                rpaphp_eeh_remove_bus_device(dev);
+               pci_remove_bus_device(dev);
+       }
 
-       pci_remove_behind_bridge(slot->bridge);
        slot->state = NOT_CONFIGURED;
        info("%s: devices in slot[%s] unconfigured.\n", __FUNCTION__,
             slot->name);
@@ -356,66 +349,41 @@ static int setup_pci_hotplug_slot_info(struct slot *slot)
        return 0;
 }
 
-static int set_phb_slot_name(struct slot *slot)
+static void set_slot_name(struct slot *slot)
 {
-       struct device_node *dn;
-       struct pci_controller *phb;
-       struct pci_bus *bus;
-
-       dn = slot->dn;
-       if (!dn) {
-               return -EINVAL;
-       }
-       phb = dn->phb;
-       if (!phb) {
-               return -EINVAL;
-       }
-       bus = phb->bus;
-       if (!bus) {
-               return -EINVAL;
-       }
+       struct pci_bus *bus = slot->bus;
+       struct pci_dev *bridge;
 
-       sprintf(slot->name, "%04x:%02x:%02x.%x", pci_domain_nr(bus),
-                       bus->number, 0, 0);
-       return 0;
+       bridge = bus->self;
+       if (bridge)
+               strcpy(slot->name, pci_name(bridge));
+       else
+               sprintf(slot->name, "%04x:%02x:00.0", pci_domain_nr(bus),
+                       bus->number);
 }
 
 static int setup_pci_slot(struct slot *slot)
 {
+       struct device_node *dn = slot->dn;
        struct pci_bus *bus;
-       int rc;
 
-       if (slot->type == PHB) {
-               rc = set_phb_slot_name(slot);
-               if (rc < 0) {
-                       err("%s: failed to set phb slot name\n", __FUNCTION__);
-                       goto exit_rc;
-               }
-       } else {
-               slot->bridge = rpaphp_find_bridge_pdev(slot);
-               if (!slot->bridge) {
-                       /* slot being added doesn't have pci_dev yet */
-                       err("%s: no pci_dev for bridge dn %s\n",
-                                       __FUNCTION__, slot->name);
-                       goto exit_rc;
-               }
-
-               bus = slot->bridge->subordinate;
-               if (!bus)
-                       goto exit_rc;
-               slot->dev.pci_devs = &bus->devices;
-
-               dbg("%s set slot->name to %s\n",  __FUNCTION__,
-                               pci_name(slot->bridge));
-               strcpy(slot->name, pci_name(slot->bridge));
+       BUG_ON(!dn);
+       bus = rpaphp_find_pci_bus(dn);
+       if (!bus) {
+               err("%s: no pci_bus for dn %s\n", __FUNCTION__, dn->full_name);
+               goto exit_rc;
        }
 
+       slot->bus = bus;
+       slot->pci_devs = &bus->devices;
+       set_slot_name(slot);
+
        /* find slot's pci_dev if it's not empty */
        if (slot->hotplug_slot->info->adapter_status == EMPTY) {
                slot->state = EMPTY;    /* slot is empty */
        } else {
                /* slot is occupied */
-               if (!(slot->dn->child)) {
+               if (!dn->child) {
                        /* non-empty slot has to have child */
                        err("%s: slot[%s]'s device_node doesn't have child for adapter\n", 
                                __FUNCTION__, slot->name);
@@ -425,7 +393,7 @@ static int setup_pci_slot(struct slot *slot)
                if (slot->hotplug_slot->info->adapter_status == NOT_CONFIGURED) {
                        dbg("%s CONFIGURING pci adapter in slot[%s]\n",  
                                __FUNCTION__, slot->name);
-                       if (rpaphp_config_pci_adapter(slot)) {
+                       if (rpaphp_config_pci_adapter(slot->bus)) {
                                err("%s: CONFIG pci adapter failed\n", __FUNCTION__);
                                goto exit_rc;           
                        }
@@ -435,8 +403,8 @@ static int setup_pci_slot(struct slot *slot)
                                __FUNCTION__, slot->name);
                        goto exit_rc;
                }
-               print_slot_pci_funcs(slot);
-               if (!list_empty(slot->dev.pci_devs)) {
+               print_slot_pci_funcs(slot->bus);
+               if (!list_empty(slot->pci_devs)) {
                        slot->state = CONFIGURED;
                } else {
                        /* DLPAR add as opposed to 
@@ -454,11 +422,6 @@ int register_pci_slot(struct slot *slot)
 {
        int rc = -EINVAL;
 
-       slot->dev_type = PCI_DEV;
-       if ((slot->type == EMBEDDED) || (slot->type == PHB))
-               slot->removable = 0;
-       else
-               slot->removable = 1;
        if (setup_pci_hotplug_slot_info(slot))
                goto exit_rc;
        if (setup_pci_slot(slot))
@@ -479,7 +442,7 @@ int rpaphp_enable_pci_slot(struct slot *slot)
        /* if slot is not empty, enable the adapter */
        if (state == PRESENT) {
                dbg("%s : slot[%s] is occupied.\n", __FUNCTION__, slot->name);
-               retval = rpaphp_config_pci_adapter(slot);
+               retval = rpaphp_config_pci_adapter(slot->bus);
                if (!retval) {
                        slot->state = CONFIGURED;
                        dbg("%s: PCI devices in slot[%s] has been configured\n", 
@@ -502,37 +465,3 @@ exit:
        dbg("%s - Exit: rc[%d]\n", __FUNCTION__, retval);
        return retval;
 }
-
-struct hotplug_slot *rpaphp_find_hotplug_slot(struct pci_dev *dev)
-{
-       struct list_head        *tmp, *n;
-       struct slot             *slot;
-
-       list_for_each_safe(tmp, n, &rpaphp_slot_head) {
-               struct pci_bus *bus;
-               struct list_head *ln;
-
-               slot = list_entry(tmp, struct slot, rpaphp_slot_list);
-               if (slot->bridge == NULL) {
-                       if (slot->dev_type == PCI_DEV) {
-                               printk(KERN_WARNING "PCI slot missing bridge %s %s \n", 
-                                                   slot->name, slot->location);
-                       }
-                       continue;
-               }
-
-               bus = slot->bridge->subordinate;
-               if (!bus) {
-                       continue;  /* should never happen? */
-               }
-               for (ln = bus->devices.next; ln != &bus->devices; ln = ln->next) {
-                                struct pci_dev *pdev = pci_dev_b(ln);
-                               if (pdev == dev)
-                                       return slot->hotplug_slot;
-               }
-       }
-
-       return NULL;
-}
-
-EXPORT_SYMBOL_GPL(rpaphp_find_hotplug_slot);
index ff2cbf0652d83879509fa45ed59d1d1c7f4c60b4..0e88154950838fa770e5cd21d172102b7272993f 100644 (file)
 #include <asm/rtas.h>
 #include "rpaphp.h"
 
-static ssize_t removable_read_file (struct hotplug_slot *php_slot, char *buf)
-{
-       u8 value;
-       int retval = -ENOENT;
-       struct slot *slot = (struct slot *)php_slot->private;
-
-       if (!slot)
-               return retval;
-
-       value = slot->removable;
-       retval = sprintf (buf, "%d\n", value);
-       return retval;
-}
-
-static struct hotplug_slot_attribute hotplug_slot_attr_removable = {
-       .attr = {.name = "phy_removable", .mode = S_IFREG | S_IRUGO},
-       .show = removable_read_file,
-};
-
-static void rpaphp_sysfs_add_attr_removable (struct hotplug_slot *slot)
-{
-       sysfs_create_file(&slot->kobj, &hotplug_slot_attr_removable.attr);
-}
-
-static void rpaphp_sysfs_remove_attr_removable (struct hotplug_slot *slot)
-{
-       sysfs_remove_file(&slot->kobj, &hotplug_slot_attr_removable.attr);
-}
-
 static ssize_t location_read_file (struct hotplug_slot *php_slot, char *buf)
 {
         char *value;
@@ -176,9 +147,6 @@ int deregister_slot(struct slot *slot)
        /* remove "phy_location" file */
        rpaphp_sysfs_remove_attr_location(php_slot);
 
-       /* remove "phy_removable" file */
-       rpaphp_sysfs_remove_attr_removable(php_slot);
-
        retval = pci_hp_deregister(php_slot);
        if (retval)
                err("Problem unregistering a slot %s\n", slot->name);
@@ -212,21 +180,13 @@ int register_slot(struct slot *slot)
        /* create "phy_locatoin" file */
        rpaphp_sysfs_add_attr_location(slot->hotplug_slot);     
 
-       /* create "phy_removable" file */
-       rpaphp_sysfs_add_attr_removable(slot->hotplug_slot);    
-
        /* add slot to our internal list */
        dbg("%s adding slot[%s] to rpaphp_slot_list\n",
            __FUNCTION__, slot->name);
 
        list_add(&slot->rpaphp_slot_list, &rpaphp_slot_head);
-
-       if (slot->dev_type == VIO_DEV)
-               info("Slot [%s](VIO location=%s) registered\n",
-                    slot->name, slot->location);
-       else
-               info("Slot [%s](PCI location=%s) registered\n",
-                    slot->name, slot->location);
+       info("Slot [%s](PCI location=%s) registered\n", slot->name,
+                       slot->location);
        num_slots++;
        return 0;
 }
@@ -235,21 +195,17 @@ int rpaphp_get_power_status(struct slot *slot, u8 * value)
 {
        int rc = 0, level;
        
-       if (slot->type == HOTPLUG) {
-               rc = rtas_get_power_level(slot->power_domain, &level);
-               if (!rc) {
-                       dbg("%s the power level of slot %s(pwd-domain:0x%x) is %d\n",
-                               __FUNCTION__, slot->name, slot->power_domain, level);
-                       *value = level;
-               } else
-                       err("failed to get power-level for slot(%s), rc=0x%x\n",
-                               slot->location, rc);
-       } else {
-               dbg("%s report POWER_ON for EMBEDDED or PHB slot %s\n",
-                       __FUNCTION__, slot->location);
-               *value = (u8) POWER_ON;
+       rc = rtas_get_power_level(slot->power_domain, &level);
+       if (rc < 0) {
+               err("failed to get power-level for slot(%s), rc=0x%x\n",
+                       slot->location, rc);
+               return rc;
        }
 
+       dbg("%s the power level of slot %s(pwd-domain:0x%x) is %d\n",
+               __FUNCTION__, slot->name, slot->power_domain, level);
+       *value = level;
+
        return rc;
 }
 
diff --git a/drivers/pci/hotplug/rpaphp_vio.c b/drivers/pci/hotplug/rpaphp_vio.c
deleted file mode 100644 (file)
index 74df6a3..0000000
+++ /dev/null
@@ -1,129 +0,0 @@
-/*
- * RPA Hot Plug Virtual I/O device functions 
- * Copyright (C) 2004 Linda Xie <lxie@us.ibm.com>
- *
- * All rights reserved.
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or (at
- * your option) any later version.
- *
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE, GOOD TITLE or
- * NON INFRINGEMENT.  See the GNU General Public License for more
- * details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- *
- * Send feedback to <lxie@us.ibm.com>
- *
- */
-#include <asm/vio.h>
-#include "rpaphp.h"
-
-/*
- * get_vio_adapter_status - get  the status of a slot
- * 
- * status:
- * 
- * 1-- adapter is configured
- * 2-- adapter is not configured
- * 3-- not valid
- */
-inline int rpaphp_get_vio_adapter_status(struct slot *slot, int is_init, u8 *value)
-{
-       *value = slot->state;
-       return 0;
-}
-
-int rpaphp_unconfig_vio_adapter(struct slot *slot)
-{
-       int retval = 0;
-
-       dbg("Entry %s: slot[%s]\n", __FUNCTION__, slot->name);
-       if (!slot->dev.vio_dev) {
-               info("%s: no VIOA in slot[%s]\n", __FUNCTION__, slot->name);
-               retval = -EINVAL;
-               goto exit;
-       }
-       /* remove the device from the vio core */
-       vio_unregister_device(slot->dev.vio_dev);
-       slot->state = NOT_CONFIGURED;
-       info("%s: adapter in slot[%s] unconfigured.\n", __FUNCTION__, slot->name);
-exit:
-       dbg("Exit %s, rc=0x%x\n", __FUNCTION__, retval);
-       return retval;
-}
-
-static int setup_vio_hotplug_slot_info(struct slot *slot)
-{
-       slot->hotplug_slot->info->power_status = 1;
-       rpaphp_get_vio_adapter_status(slot, 1,
-               &slot->hotplug_slot->info->adapter_status); 
-       return 0;
-}
-
-int register_vio_slot(struct device_node *dn)
-{
-       u32 *index;
-       char *name;
-       int rc = -EINVAL;
-       struct slot *slot = NULL;
-       
-       rc = rpaphp_get_drc_props(dn, NULL, &name, NULL, NULL);
-       if (rc < 0)
-               goto exit_rc;
-       index = (u32 *) get_property(dn, "ibm,my-drc-index", NULL);
-       if (!index)
-               goto exit_rc;
-       if (!(slot = alloc_slot_struct(dn, *index, name, 0))) {
-               rc = -ENOMEM;
-               goto exit_rc;
-       }
-       slot->dev_type = VIO_DEV;
-       slot->dev.vio_dev = vio_find_node(dn);
-       if (slot->dev.vio_dev) {
-               /*
-                * rpaphp is the only owner of vio devices and
-                * does not need extra reference taken by
-                * vio_find_node
-                */
-               put_device(&slot->dev.vio_dev->dev);
-       } else
-               slot->dev.vio_dev = vio_register_device_node(dn);
-       if (slot->dev.vio_dev)
-               slot->state = CONFIGURED;
-       else
-               slot->state = NOT_CONFIGURED;
-       if (setup_vio_hotplug_slot_info(slot))
-               goto exit_rc;
-       strcpy(slot->name, slot->dev.vio_dev->dev.bus_id);
-       info("%s: registered VIO device[name=%s vio_dev=%p]\n",
-               __FUNCTION__, slot->name, slot->dev.vio_dev); 
-       rc = register_slot(slot);
-exit_rc:
-       if (rc && slot)
-               dealloc_slot_struct(slot);
-       return (rc);
-}
-
-int rpaphp_enable_vio_slot(struct slot *slot)
-{
-       int retval = 0;
-
-       if ((slot->dev.vio_dev = vio_register_device_node(slot->dn))) {
-               info("%s: VIO adapter %s in slot[%s] has been configured\n",
-                       __FUNCTION__, slot->dn->name, slot->name);
-               slot->state = CONFIGURED;
-       } else {
-               info("%s: no vio_dev struct for adapter in slot[%s]\n",
-                       __FUNCTION__, slot->name);
-               slot->state = NOT_CONFIGURED;
-       }
-       
-       return retval;
-}
index 323041fd41dc19c20ce88e4ae370272cbe09ea97..b1409441c1cde52a605e6daf4e6d40ec173e5e52 100644 (file)
@@ -32,14 +32,15 @@ MODULE_LICENSE("GPL");
 MODULE_AUTHOR("SGI (prarit@sgi.com, dickie@sgi.com, habeck@sgi.com)");
 MODULE_DESCRIPTION("SGI Altix Hot Plug PCI Controller Driver");
 
-#define PCIIO_ASIC_TYPE_TIOCA     4
-#define PCI_SLOT_ALREADY_UP       2     /* slot already up */
-#define PCI_SLOT_ALREADY_DOWN     3     /* slot already down */
-#define PCI_L1_ERR                7     /* L1 console command error */
-#define PCI_EMPTY_33MHZ          15     /* empty 33 MHz bus */
-#define PCI_L1_QSIZE            128     /* our L1 message buffer size */
-#define SN_MAX_HP_SLOTS                 32     /* max number of hotplug slots */
-#define SGI_HOTPLUG_PROM_REV   0x0420  /* Min. required PROM version */
+#define PCIIO_ASIC_TYPE_TIOCA          4
+#define PCI_SLOT_ALREADY_UP            2       /* slot already up */
+#define PCI_SLOT_ALREADY_DOWN          3       /* slot already down */
+#define PCI_L1_ERR                     7       /* L1 console command error */
+#define PCI_EMPTY_33MHZ                        15      /* empty 33 MHz bus */
+#define PCI_L1_QSIZE                   128     /* our L1 message buffer size */
+#define SN_MAX_HP_SLOTS                        32      /* max hotplug slots */
+#define SGI_HOTPLUG_PROM_REV           0x0430  /* Min. required PROM version */
+#define SN_SLOT_NAME_SIZE              33      /* size of name string */
 
 /* internal list head */
 static struct list_head sn_hp_list;
@@ -51,6 +52,7 @@ struct slot {
        /* this struct for glue internal only */
        struct hotplug_slot *hotplug_slot;
        struct list_head hp_list;
+       char physical_path[SN_SLOT_NAME_SIZE];
 };
 
 struct pcibr_slot_enable_resp {
@@ -70,7 +72,7 @@ enum sn_pci_req_e {
 
 static int enable_slot(struct hotplug_slot *slot);
 static int disable_slot(struct hotplug_slot *slot);
-static int get_power_status(struct hotplug_slot *slot, u8 *value);
+static inline int get_power_status(struct hotplug_slot *slot, u8 *value);
 
 static struct hotplug_slot_ops sn_hotplug_slot_ops = {
        .owner                  = THIS_MODULE,
@@ -81,6 +83,21 @@ static struct hotplug_slot_ops sn_hotplug_slot_ops = {
 
 static DECLARE_MUTEX(sn_hotplug_sem);
 
+static ssize_t path_show (struct hotplug_slot *bss_hotplug_slot,
+                         char *buf)
+{
+       int retval = -ENOENT;
+       struct slot *slot = bss_hotplug_slot->private;
+
+       if (!slot)
+               return retval;
+
+       retval = sprintf (buf, "%s\n", slot->physical_path);
+       return retval;
+}
+
+static struct hotplug_slot_attribute sn_slot_path_attr = __ATTR_RO(path);
+
 static int sn_pci_slot_valid(struct pci_bus *pci_bus, int device)
 {
        struct pcibus_info *pcibus_info;
@@ -120,15 +137,15 @@ static int sn_pci_bus_valid(struct pci_bus *pci_bus)
        /* Only register slots in I/O Bricks that support hotplug */
        bricktype = MODULE_GET_BTYPE(pcibus_info->pbi_moduleid);
        switch (bricktype) {
-       case L1_BRICKTYPE_IX:
-       case L1_BRICKTYPE_PX:
-       case L1_BRICKTYPE_IA:
-       case L1_BRICKTYPE_PA:
-               return 1;
-               break;
-       default:
-               return -EPERM;
-               break;
+               case L1_BRICKTYPE_IX:
+               case L1_BRICKTYPE_PX:
+               case L1_BRICKTYPE_IA:
+               case L1_BRICKTYPE_PA:
+                       return 1;
+                       break;
+               default:
+                       return -EPERM;
+                       break;
        }
 
        return -EIO;
@@ -142,13 +159,12 @@ static int sn_hp_slot_private_alloc(struct hotplug_slot *bss_hotplug_slot,
 
        pcibus_info = SN_PCIBUS_BUSSOFT_INFO(pci_bus);
 
-       bss_hotplug_slot->private = kcalloc(1, sizeof(struct slot),
-                                           GFP_KERNEL);
-       if (!bss_hotplug_slot->private)
+       slot = kcalloc(1, sizeof(*slot), GFP_KERNEL);
+       if (!slot)
                return -ENOMEM;
-       slot = (struct slot *)bss_hotplug_slot->private;
+       bss_hotplug_slot->private = slot;
 
-       bss_hotplug_slot->name = kmalloc(33, GFP_KERNEL);
+       bss_hotplug_slot->name = kmalloc(SN_SLOT_NAME_SIZE, GFP_KERNEL);
        if (!bss_hotplug_slot->name) {
                kfree(bss_hotplug_slot->private);
                return -ENOMEM;
@@ -156,16 +172,16 @@ static int sn_hp_slot_private_alloc(struct hotplug_slot *bss_hotplug_slot,
 
        slot->device_num = device;
        slot->pci_bus = pci_bus;
-
-       sprintf(bss_hotplug_slot->name, "module_%c%c%c%c%.2d_b_%d_s_%d",
+       sprintf(bss_hotplug_slot->name, "%04x:%02x:%02x",
+               pci_domain_nr(pci_bus),
+               ((int)pcibus_info->pbi_buscommon.bs_persist_busnum) & 0xf,
+               device + 1);
+       sprintf(slot->physical_path, "module_%c%c%c%c%.2d",
                '0'+RACK_GET_CLASS(MODULE_GET_RACK(pcibus_info->pbi_moduleid)),
                '0'+RACK_GET_GROUP(MODULE_GET_RACK(pcibus_info->pbi_moduleid)),
                '0'+RACK_GET_NUM(MODULE_GET_RACK(pcibus_info->pbi_moduleid)),
                MODULE_GET_BTCHAR(pcibus_info->pbi_moduleid),
-               MODULE_GET_BPOS(pcibus_info->pbi_moduleid),
-               ((int)pcibus_info->pbi_buscommon.bs_persist_busnum) & 0xf,
-               device + 1);
-
+               MODULE_GET_BPOS(pcibus_info->pbi_moduleid));
        slot->hotplug_slot = bss_hotplug_slot;
        list_add(&slot->hp_list, &sn_hp_list);
 
@@ -175,14 +191,14 @@ static int sn_hp_slot_private_alloc(struct hotplug_slot *bss_hotplug_slot,
 static struct hotplug_slot * sn_hp_destroy(void)
 {
        struct slot *slot;
-       struct list_head *list;
        struct hotplug_slot *bss_hotplug_slot = NULL;
 
-       list_for_each(list, &sn_hp_list) {
-               slot = list_entry(list, struct slot, hp_list);
+       list_for_each_entry(slot, &sn_hp_list, hp_list) {
                bss_hotplug_slot = slot->hotplug_slot;
                list_del(&((struct slot *)bss_hotplug_slot->private)->
                         hp_list);
+               sysfs_remove_file(&bss_hotplug_slot->kobj,
+                                 &sn_slot_path_attr.attr);
                break;
        }
        return bss_hotplug_slot;
@@ -190,7 +206,6 @@ static struct hotplug_slot * sn_hp_destroy(void)
 
 static void sn_bus_alloc_data(struct pci_dev *dev)
 {
-       struct list_head *node;
        struct pci_bus *subordinate_bus;
        struct pci_dev *child;
 
@@ -199,66 +214,29 @@ static void sn_bus_alloc_data(struct pci_dev *dev)
        /* Recursively sets up the sn_irq_info structs */
        if (dev->subordinate) {
                subordinate_bus = dev->subordinate;
-               list_for_each(node, &subordinate_bus->devices) {
-                       child = list_entry(node, struct pci_dev, bus_list);
+               list_for_each_entry(child, &subordinate_bus->devices, bus_list)
                        sn_bus_alloc_data(child);
-               }
        }
 }
 
 static void sn_bus_free_data(struct pci_dev *dev)
 {
-       struct list_head *node;
        struct pci_bus *subordinate_bus;
        struct pci_dev *child;
 
        /* Recursively clean up sn_irq_info structs */
        if (dev->subordinate) {
                subordinate_bus = dev->subordinate;
-               list_for_each(node, &subordinate_bus->devices) {
-                       child = list_entry(node, struct pci_dev, bus_list);
+               list_for_each_entry(child, &subordinate_bus->devices, bus_list)
                        sn_bus_free_data(child);
-               }
        }
        sn_pci_unfixup_slot(dev);
 }
 
-static u8 sn_power_status_get(struct hotplug_slot *bss_hotplug_slot)
-{
-       struct slot *slot = (struct slot *)bss_hotplug_slot->private;
-       struct pcibus_info *pcibus_info;
-       u8 retval;
-
-       pcibus_info = SN_PCIBUS_BUSSOFT_INFO(slot->pci_bus);
-       retval = pcibus_info->pbi_enabled_devices & (1 << slot->device_num);
-
-       return retval ? 1 : 0;
-}
-
-static void sn_slot_mark_enable(struct hotplug_slot *bss_hotplug_slot,
-                               int device_num)
-{
-       struct slot *slot = (struct slot *)bss_hotplug_slot->private;
-       struct pcibus_info *pcibus_info;
-
-       pcibus_info = SN_PCIBUS_BUSSOFT_INFO(slot->pci_bus);
-       pcibus_info->pbi_enabled_devices |= (1 << device_num);
-}
-
-static void sn_slot_mark_disable(struct hotplug_slot *bss_hotplug_slot,
-                                int device_num)
-{
-       struct slot *slot = (struct slot *)bss_hotplug_slot->private;
-       struct pcibus_info *pcibus_info;
-
-       pcibus_info = SN_PCIBUS_BUSSOFT_INFO(slot->pci_bus);
-       pcibus_info->pbi_enabled_devices &= ~(1 << device_num);
-}
-
 static int sn_slot_enable(struct hotplug_slot *bss_hotplug_slot,
                          int device_num)
 {
-       struct slot *slot = (struct slot *)bss_hotplug_slot->private;
+       struct slot *slot = bss_hotplug_slot->private;
        struct pcibus_info *pcibus_info;
        struct pcibr_slot_enable_resp resp;
        int rc;
@@ -273,7 +251,7 @@ static int sn_slot_enable(struct hotplug_slot *bss_hotplug_slot,
 
        if (rc == PCI_SLOT_ALREADY_UP) {
                dev_dbg(slot->pci_bus->self, "is already active\n");
-               return -EPERM;
+               return 1; /* return 1 to user */
        }
 
        if (rc == PCI_L1_ERR) {
@@ -290,7 +268,8 @@ static int sn_slot_enable(struct hotplug_slot *bss_hotplug_slot,
                return -EIO;
        }
 
-       sn_slot_mark_enable(bss_hotplug_slot, device_num);
+       pcibus_info = SN_PCIBUS_BUSSOFT_INFO(slot->pci_bus);
+       pcibus_info->pbi_enabled_devices |= (1 << device_num);
 
        return 0;
 }
@@ -298,7 +277,7 @@ static int sn_slot_enable(struct hotplug_slot *bss_hotplug_slot,
 static int sn_slot_disable(struct hotplug_slot *bss_hotplug_slot,
                           int device_num, int action)
 {
-       struct slot *slot = (struct slot *)bss_hotplug_slot->private;
+       struct slot *slot = bss_hotplug_slot->private;
        struct pcibus_info *pcibus_info;
        struct pcibr_slot_disable_resp resp;
        int rc;
@@ -307,43 +286,44 @@ static int sn_slot_disable(struct hotplug_slot *bss_hotplug_slot,
 
        rc = sal_pcibr_slot_disable(pcibus_info, device_num, action, &resp);
 
-       if (action == PCI_REQ_SLOT_ELIGIBLE && rc == PCI_SLOT_ALREADY_DOWN) {
+       if ((action == PCI_REQ_SLOT_ELIGIBLE) &&
+           (rc == PCI_SLOT_ALREADY_DOWN)) {
                dev_dbg(slot->pci_bus->self, "Slot %s already inactive\n");
-               return -ENODEV;
+               return 1; /* return 1 to user */
        }
 
-       if (action == PCI_REQ_SLOT_ELIGIBLE && rc == PCI_EMPTY_33MHZ) {
+       if ((action == PCI_REQ_SLOT_ELIGIBLE) && (rc == PCI_EMPTY_33MHZ)) {
                dev_dbg(slot->pci_bus->self,
                        "Cannot remove last 33MHz card\n");
                return -EPERM;
        }
 
-       if (action == PCI_REQ_SLOT_ELIGIBLE && rc == PCI_L1_ERR) {
+       if ((action == PCI_REQ_SLOT_ELIGIBLE) && (rc == PCI_L1_ERR)) {
                dev_dbg(slot->pci_bus->self,
                        "L1 failure %d with message \n%s\n",
                        resp.resp_sub_errno, resp.resp_l1_msg);
                return -EPERM;
        }
 
-       if (action == PCI_REQ_SLOT_ELIGIBLE && rc) {
+       if ((action == PCI_REQ_SLOT_ELIGIBLE) && rc) {
                dev_dbg(slot->pci_bus->self,
                        "remove failed with error %d sub-error %d\n",
                        rc, resp.resp_sub_errno);
                return -EIO;
        }
 
-       if (action == PCI_REQ_SLOT_ELIGIBLE && !rc)
+       if ((action == PCI_REQ_SLOT_ELIGIBLE) && !rc)
                return 0;
 
-       if (action == PCI_REQ_SLOT_DISABLE && !rc) {
-               sn_slot_mark_disable(bss_hotplug_slot, device_num);
+       if ((action == PCI_REQ_SLOT_DISABLE) && !rc) {
+               pcibus_info = SN_PCIBUS_BUSSOFT_INFO(slot->pci_bus);
+               pcibus_info->pbi_enabled_devices &= ~(1 << device_num);
                dev_dbg(slot->pci_bus->self, "remove successful\n");
                return 0;
        }
 
-       if (action == PCI_REQ_SLOT_DISABLE && rc) {
+       if ((action == PCI_REQ_SLOT_DISABLE) && rc) {
                dev_dbg(slot->pci_bus->self,"remove failed rc = %d\n", rc);
-               return rc;
        }
 
        return rc;
@@ -351,7 +331,7 @@ static int sn_slot_disable(struct hotplug_slot *bss_hotplug_slot,
 
 static int enable_slot(struct hotplug_slot *bss_hotplug_slot)
 {
-       struct slot *slot = (struct slot *)bss_hotplug_slot->private;
+       struct slot *slot = bss_hotplug_slot->private;
        struct pci_bus *new_bus = NULL;
        struct pci_dev *dev;
        int func, num_funcs;
@@ -371,8 +351,8 @@ static int enable_slot(struct hotplug_slot *bss_hotplug_slot)
                return rc;
        }
 
-       num_funcs = pci_scan_slot(slot->pci_bus, PCI_DEVFN(slot->device_num+1,
-                                                          PCI_FUNC(0)));
+       num_funcs = pci_scan_slot(slot->pci_bus,
+                                 PCI_DEVFN(slot->device_num + 1, 0));
        if (!num_funcs) {
                dev_dbg(slot->pci_bus->self, "no device in slot\n");
                up(&sn_hotplug_sem);
@@ -391,8 +371,6 @@ static int enable_slot(struct hotplug_slot *bss_hotplug_slot)
                dev = pci_get_slot(slot->pci_bus,
                                   PCI_DEVFN(slot->device_num + 1,
                                             PCI_FUNC(func)));
-
-
                if (dev) {
                        if (dev->hdr_type == PCI_HEADER_TYPE_BRIDGE) {
                                unsigned char sec_bus;
@@ -431,7 +409,7 @@ static int enable_slot(struct hotplug_slot *bss_hotplug_slot)
 
 static int disable_slot(struct hotplug_slot *bss_hotplug_slot)
 {
-       struct slot *slot = (struct slot *)bss_hotplug_slot->private;
+       struct slot *slot = bss_hotplug_slot->private;
        struct pci_dev *dev;
        int func;
        int rc;
@@ -448,7 +426,7 @@ static int disable_slot(struct hotplug_slot *bss_hotplug_slot)
        /* Free the SN resources assigned to the Linux device.*/
        for (func = 0; func < 8;  func++) {
                dev = pci_get_slot(slot->pci_bus,
-                                  PCI_DEVFN(slot->device_num+1,
+                                  PCI_DEVFN(slot->device_num + 1,
                                             PCI_FUNC(func)));
                if (dev) {
                        /*
@@ -477,10 +455,15 @@ static int disable_slot(struct hotplug_slot *bss_hotplug_slot)
        return rc;
 }
 
-static int get_power_status(struct hotplug_slot *bss_hotplug_slot, u8 *value)
+static inline int get_power_status(struct hotplug_slot *bss_hotplug_slot,
+                                  u8 *value)
 {
+       struct slot *slot = bss_hotplug_slot->private;
+       struct pcibus_info *pcibus_info;
+
+       pcibus_info = SN_PCIBUS_BUSSOFT_INFO(slot->pci_bus);
        down(&sn_hotplug_sem);
-       *value = sn_power_status_get(bss_hotplug_slot);
+       *value = pcibus_info->pbi_enabled_devices & (1 << slot->device_num);
        up(&sn_hotplug_sem);
        return 0;
 }
@@ -508,7 +491,7 @@ static int sn_hotplug_slot_register(struct pci_bus *pci_bus)
                if (sn_pci_slot_valid(pci_bus, device) != 1)
                        continue;
 
-               bss_hotplug_slot = kcalloc(1,sizeof(struct hotplug_slot),
+               bss_hotplug_slot = kcalloc(1, sizeof(*bss_hotplug_slot),
                                           GFP_KERNEL);
                if (!bss_hotplug_slot) {
                        rc = -ENOMEM;
@@ -516,7 +499,7 @@ static int sn_hotplug_slot_register(struct pci_bus *pci_bus)
                }
 
                bss_hotplug_slot->info =
-                       kcalloc(1,sizeof(struct hotplug_slot_info),
+                       kcalloc(1, sizeof(struct hotplug_slot_info),
                                GFP_KERNEL);
                if (!bss_hotplug_slot->info) {
                        rc = -ENOMEM;
@@ -535,6 +518,11 @@ static int sn_hotplug_slot_register(struct pci_bus *pci_bus)
                rc = pci_hp_register(bss_hotplug_slot);
                if (rc)
                        goto register_err;
+
+               rc = sysfs_create_file(&bss_hotplug_slot->kobj,
+                                      &sn_slot_path_attr.attr);
+               if (rc)
+                       goto register_err;
        }
        dev_dbg(pci_bus->self, "Registered bus with hotplug\n");
        return rc;
@@ -564,14 +552,14 @@ static int sn_pci_hotplug_init(void)
        int rc;
        int registered = 0;
 
-       INIT_LIST_HEAD(&sn_hp_list);
-
        if (sn_sal_rev() < SGI_HOTPLUG_PROM_REV) {
-               printk(KERN_ERR "%s: PROM version must be greater than 4.05\n",
+               printk(KERN_ERR "%s: PROM version must be greater than 4.30\n",
                       __FUNCTION__);
                return -EPERM;
        }
 
+       INIT_LIST_HEAD(&sn_hp_list);
+
        while ((pci_bus = pci_find_next_bus(pci_bus))) {
                if (!pci_bus->sysdata)
                        continue;
@@ -584,9 +572,9 @@ static int sn_pci_hotplug_init(void)
                dev_dbg(pci_bus->self, "valid hotplug bus\n");
 
                rc = sn_hotplug_slot_register(pci_bus);
-               if (!rc)
+               if (!rc) {
                        registered = 1;
-               else {
+               else {
                        registered = 0;
                        break;
                }
@@ -599,9 +587,8 @@ static void sn_pci_hotplug_exit(void)
 {
        struct hotplug_slot *bss_hotplug_slot;
 
-       while ((bss_hotplug_slot = sn_hp_destroy())) {
+       while ((bss_hotplug_slot = sn_hp_destroy()))
                pci_hp_deregister(bss_hotplug_slot);
-       }
 
        if (!list_empty(&sn_hp_list))
                printk(KERN_ERR "%s: internal list is not empty\n", __FILE__);
index fe4d653da18849f9a7793b62630c45ec009e2139..b7d1c61d6bbbe8aa30674a6fdea8790e527e8a67 100644 (file)
@@ -411,7 +411,7 @@ static inline void return_resource(struct pci_resource **head, struct pci_resour
 
 static inline void make_slot_name(char *buffer, int buffer_size, struct slot *slot)
 {
-       snprintf(buffer, buffer_size, "%d", slot->number);
+       snprintf(buffer, buffer_size, "%04d_%04d", slot->bus, slot->number);
 }
 
 enum php_ctlr_type {
index 532f73bb2224af802af190aa0a38ea66242aa188..ee8677bda950e5c95b7b73fe4cb3386b50e41a05 100644 (file)
@@ -439,10 +439,7 @@ static void enable_msi_mode(struct pci_dev *dev, int pos, int type)
        }
        if (pci_find_capability(dev, PCI_CAP_ID_EXP)) {
                /* PCI Express Endpoint device detected */
-               u16 cmd;
-               pci_read_config_word(dev, PCI_COMMAND, &cmd);
-               cmd |= PCI_COMMAND_INTX_DISABLE;
-               pci_write_config_word(dev, PCI_COMMAND, cmd);
+               pci_intx(dev, 0);  /* disable intx */
        }
 }
 
@@ -461,10 +458,7 @@ void disable_msi_mode(struct pci_dev *dev, int pos, int type)
        }
        if (pci_find_capability(dev, PCI_CAP_ID_EXP)) {
                /* PCI Express Endpoint device detected */
-               u16 cmd;
-               pci_read_config_word(dev, PCI_COMMAND, &cmd);
-               cmd &= ~PCI_COMMAND_INTX_DISABLE;
-               pci_write_config_word(dev, PCI_COMMAND, cmd);
+               pci_intx(dev, 1);  /* enable intx */
        }
 }
 
diff --git a/drivers/pci/names.c b/drivers/pci/names.c
deleted file mode 100644 (file)
index ad224aa..0000000
+++ /dev/null
@@