---

yaml
---
r: 9159
b: refs/heads/master
c: 972d512
h: refs/heads/master
i:
  9157: 382271a
  9155: 13ba446
  9151: 8640aa5
v: v3

[refs]

@@ -1,2 +1,2 @@
 ---
-refs/heads/master: 62a36c43c898d45efcfe3376ea1da6a9a182e1ad
+refs/heads/master: 972d512a17c1bb7c4b784a9da2ca75745fcc6989

trunk/Documentation/DocBook/kernel-hacking.tmpl

@@ -1105,7 +1105,7 @@ static struct block_device_operations opt_fops = {
     </listitem>
     <listitem>
      <para>
-      Function names as strings (__FUNCTION__).
+      Function names as strings (__func__).
      </para>
     </listitem>
     <listitem>

trunk/MAINTAINERS

@@ -2266,12 +2266,6 @@ M:	kristen.c.accardi@intel.com
 L:	pcihpd-discuss@lists.sourceforge.net
 S:	Maintained
 
-SKGE, SKY2 10/100/1000 GIGABIT ETHERNET DRIVERS
-P:	Stephen Hemminger
-M:	shemminger@osdl.org
-L:	netdev@vger.kernel.org
-S:	Maintained
-
 SPARC (sparc32):
 P:	William L. Irwin
 M:	wli@holomorphy.com

trunk/README

@@ -149,9 +149,6 @@ CONFIGURING the kernel:
 	"make gconfig"     X windows (Gtk) based configuration tool.
 	"make oldconfig"   Default all questions based on the contents of
 			   your existing ./.config file.
-	"make silentoldconfig"
-			   Like above, but avoids cluttering the screen
-			   with question already answered.
 
 	NOTES on "make config":
 	- having unnecessary drivers will make the kernel bigger, and can
@@ -172,6 +169,9 @@ CONFIGURING the kernel:
 	  should probably answer 'n' to the questions for
           "development", "experimental", or "debugging" features.
 
+ - Check the top Makefile for further site-dependent configuration
+   (default SVGA mode etc). 
+
 COMPILING the kernel:
 
  - Make sure you have gcc 2.95.3 available.
@@ -199,9 +199,6 @@ COMPILING the kernel:
    are installing a new kernel with the same version number as your
    working kernel, make a backup of your modules directory before you
    do a "make modules_install".
-   In alternative, before compiling, edit your Makefile and change the
-   "EXTRAVERSION" line - its content is appended to the regular kernel
-   version.
 
  - In order to boot your new kernel, you'll need to copy the kernel
    image (e.g. .../linux/arch/i386/boot/bzImage after compilation)

trunk/arch/ppc64/Makefile

@@ -107,7 +107,7 @@ install: vmlinux
 	$(Q)$(MAKE) $(build)=$(boot) BOOTIMAGE=$(BOOTIMAGE) $@
 
 defaultimage-$(CONFIG_PPC_PSERIES) := zImage
-defaultimage-$(CONFIG_PPC_PMAC) := zImage.vmode
+defaultimage-$(CONFIG_PPC_PMAC) := vmlinux
 defaultimage-$(CONFIG_PPC_MAPLE) := zImage
 defaultimage-$(CONFIG_PPC_ISERIES) := vmlinux
 KBUILD_IMAGE := $(defaultimage-y)

trunk/arch/ppc64/kernel/pSeries_iommu.c

@@ -265,10 +265,8 @@ static void iommu_table_setparms(struct pci_controller *phb,
 	tbl->it_offset = phb->dma_window_base_cur >> PAGE_SHIFT;
 
 	/* Test if we are going over 2GB of DMA space */
-	if (phb->dma_window_base_cur + phb->dma_window_size > 0x80000000ul) {
-		udbg_printf("PCI_DMA: Unexpected number of IOAs under this PHB.\n");
+	if (phb->dma_window_base_cur + phb->dma_window_size > (1L << 31))
 		panic("PCI_DMA: Unexpected number of IOAs under this PHB.\n"); 
-	}
 
 	phb->dma_window_base_cur += phb->dma_window_size;
 
@@ -312,84 +310,92 @@ static void iommu_table_setparms_lpar(struct pci_controller *phb,
 
 static void iommu_bus_setup_pSeries(struct pci_bus *bus)
 {
-	struct device_node *dn;
-	struct iommu_table *tbl;
-	struct device_node *isa_dn, *isa_dn_orig;
-	struct device_node *tmp;
+	struct device_node *dn, *pdn;
 	struct pci_dn *pci;
-	int children;
+	struct iommu_table *tbl;
 
 	DBG("iommu_bus_setup_pSeries, bus %p, bus->self %p\n", bus, bus->self);
 
-	dn = pci_bus_to_OF_node(bus);
-	pci = PCI_DN(dn);
-
-	if (bus->self) {
-		/* This is not a root bus, any setup will be done for the
-		 * device-side of the bridge in iommu_dev_setup_pSeries().
-		 */
-		return;
-	}
-
-	/* Check if the ISA bus on the system is under
-	 * this PHB.
-	 */
-	isa_dn = isa_dn_orig = of_find_node_by_type(NULL, "isa");
-
-	while (isa_dn && isa_dn != dn)
-		isa_dn = isa_dn->parent;
-
-	if (isa_dn_orig)
-		of_node_put(isa_dn_orig);
-
-	/* Count number of direct PCI children of the PHB.
-	 * All PCI device nodes have class-code property, so it's
-	 * an easy way to find them.
-	 */
-	for (children = 0, tmp = dn->child; tmp; tmp = tmp->sibling)
-		if (get_property(tmp, "class-code", NULL))
-			children++;
-
-	DBG("Children: %d\n", children);
-
-	/* Calculate amount of DMA window per slot. Each window must be
-	 * a power of two (due to pci_alloc_consistent requirements).
+	/* For each (root) bus, we carve up the available DMA space in 256MB
+	 * pieces. Since each piece is used by one (sub) bus/device, that would
+	 * give a maximum of 7 devices per PHB. In most cases, this is plenty.
 	 *
-	 * Keep 256MB aside for PHBs with ISA.
+	 * The exception is on Python PHBs (pre-POWER4). Here we don't have EADS
+	 * bridges below the PHB to allocate the sectioned tables to, so instead
+	 * we allocate a 1GB table at the PHB level.
 	 */
 
-	if (!isa_dn) {
-		/* No ISA/IDE - just set window size and return */
-		pci->phb->dma_window_size = 0x80000000ul; /* To be divided */
-
-		while (pci->phb->dma_window_size * children > 0x80000000ul)
-			pci->phb->dma_window_size >>= 1;
-		DBG("No ISA/IDE, window size is %x\n", pci->phb->dma_window_size);
-		pci->phb->dma_window_base_cur = 0;
-
-		return;
-	}
-
-	/* If we have ISA, then we probably have an IDE
-	 * controller too. Allocate a 128MB table but
-	 * skip the first 128MB to avoid stepping on ISA
-	 * space.
-	 */
-	pci->phb->dma_window_size = 0x8000000ul;
-	pci->phb->dma_window_base_cur = 0x8000000ul;
-
-	tbl = kmalloc(sizeof(struct iommu_table), GFP_KERNEL);
+	dn = pci_bus_to_OF_node(bus);
+	pci = dn->data;
+
+	if (!bus->self) {
+		/* Root bus */
+		if (is_python(dn)) {
+			unsigned int *iohole;
+
+			DBG("Python root bus %s\n", bus->name);
+
+			iohole = (unsigned int *)get_property(dn, "io-hole", 0);
+
+			if (iohole) {
+				/* On first bus we need to leave room for the
+				 * ISA address space. Just skip the first 256MB
+				 * alltogether. This leaves 768MB for the window.
+				 */
+				DBG("PHB has io-hole, reserving 256MB\n");
+				pci->phb->dma_window_size = 3 << 28;
+				pci->phb->dma_window_base_cur = 1 << 28;
+			} else {
+				/* 1GB window by default */
+				pci->phb->dma_window_size = 1 << 30;
+				pci->phb->dma_window_base_cur = 0;
+			}
+
+			tbl = kmalloc(sizeof(struct iommu_table), GFP_KERNEL);
+
+			iommu_table_setparms(pci->phb, dn, tbl);
+			pci->iommu_table = iommu_init_table(tbl);
+		} else {
+			/* Do a 128MB table at root. This is used for the IDE
+			 * controller on some SMP-mode POWER4 machines. It
+			 * doesn't hurt to allocate it on other machines
+			 * -- it'll just be unused since new tables are
+			 * allocated on the EADS level.
+			 *
+			 * Allocate at offset 128MB to avoid having to deal
+			 * with ISA holes; 128MB table for IDE is plenty.
+			 */
+			pci->phb->dma_window_size = 1 << 27;
+			pci->phb->dma_window_base_cur = 1 << 27;
+
+			tbl = kmalloc(sizeof(struct iommu_table), GFP_KERNEL);
+
+			iommu_table_setparms(pci->phb, dn, tbl);
+			pci->iommu_table = iommu_init_table(tbl);
+
+			/* All child buses have 256MB tables */
+			pci->phb->dma_window_size = 1 << 28;
+		}
+	} else {
+		pdn = pci_bus_to_OF_node(bus->parent);
 
-	iommu_table_setparms(pci->phb, dn, tbl);
-	pci->iommu_table = iommu_init_table(tbl);
+		if (!bus->parent->self && !is_python(pdn)) {
+			struct iommu_table *tbl;
+			/* First child and not python means this is the EADS
+			 * level. Allocate new table for this slot with 256MB
+			 * window.
+			 */
 
-	/* Divide the rest (1.75GB) among the children */
-	pci->phb->dma_window_size = 0x80000000ul;
-	while (pci->phb->dma_window_size * children > 0x70000000ul)
-		pci->phb->dma_window_size >>= 1;
+			tbl = kmalloc(sizeof(struct iommu_table), GFP_KERNEL);
 
-	DBG("ISA/IDE, window size is %x\n", pci->phb->dma_window_size);
+			iommu_table_setparms(pci->phb, dn, tbl);
 
+			pci->iommu_table = iommu_init_table(tbl);
+		} else {
+			/* Lower than first child or under python, use parent table */
+			pci->iommu_table = PCI_DN(pdn)->iommu_table;
+		}
+	}
 }
 
 
@@ -440,28 +446,13 @@ static void iommu_bus_setup_pSeriesLP(struct pci_bus *bus)
 static void iommu_dev_setup_pSeries(struct pci_dev *dev)
 {
 	struct device_node *dn, *mydn;
-	struct iommu_table *tbl;
 
 	DBG("iommu_dev_setup_pSeries, dev %p (%s)\n", dev, dev->pretty_name);
-
-	mydn = dn = pci_device_to_OF_node(dev);
-
-	/* If we're the direct child of a root bus, then we need to allocate
-	 * an iommu table ourselves. The bus setup code should have setup
-	 * the window sizes already.
-	 */
-	if (!dev->bus->self) {
-		DBG(" --> first child, no bridge. Allocating iommu table.\n");
-		tbl = kmalloc(sizeof(struct iommu_table), GFP_KERNEL);
-		iommu_table_setparms(PCI_DN(dn)->phb, dn, tbl);
-		PCI_DN(mydn)->iommu_table = iommu_init_table(tbl);
-
-		return;
-	}
-
-	/* If this device is further down the bus tree, search upwards until
-	 * an already allocated iommu table is found and use that.
+	/* Now copy the iommu_table ptr from the bus device down to the
+	 * pci device_node.  This means get_iommu_table() won't need to search
+	 * up the device tree to find it.
 	 */
+	mydn = dn = pci_device_to_OF_node(dev);
 
 	while (dn && dn->data && PCI_DN(dn)->iommu_table == NULL)
 		dn = dn->parent;

trunk/arch/ppc64/kernel/pci.c

@@ -246,14 +246,11 @@ static unsigned int pci_parse_of_flags(u32 addr0)
 	unsigned int flags = 0;
 
 	if (addr0 & 0x02000000) {
-		flags = IORESOURCE_MEM | PCI_BASE_ADDRESS_SPACE_MEMORY;
-		flags |= (addr0 >> 22) & PCI_BASE_ADDRESS_MEM_TYPE_64;
-		flags |= (addr0 >> 28) & PCI_BASE_ADDRESS_MEM_TYPE_1M;
+		flags |= IORESOURCE_MEM;
 		if (addr0 & 0x40000000)
-			flags |= IORESOURCE_PREFETCH
-				 | PCI_BASE_ADDRESS_MEM_PREFETCH;
+			flags |= IORESOURCE_PREFETCH;
 	} else if (addr0 & 0x01000000)
-		flags = IORESOURCE_IO | PCI_BASE_ADDRESS_SPACE_IO;
+		flags |= IORESOURCE_IO;
 	return flags;
 }
 

trunk/arch/ppc64/kernel/prom_init.c

@@ -1711,7 +1711,6 @@ static void __init flatten_device_tree(void)
 	unsigned long offset = reloc_offset();
 	unsigned long mem_start, mem_end, room;
 	struct boot_param_header *hdr;
-	struct prom_t *_prom = PTRRELOC(&prom);
 	char *namep;
 	u64 *rsvmap;
 
@@ -1766,7 +1765,6 @@ static void __init flatten_device_tree(void)
 	RELOC(dt_struct_end) = PAGE_ALIGN(mem_start);
 
 	/* Finish header */
-	hdr->boot_cpuid_phys = _prom->cpu;
 	hdr->magic = OF_DT_HEADER;
 	hdr->totalsize = RELOC(dt_struct_end) - RELOC(dt_header_start);
 	hdr->off_dt_struct = RELOC(dt_struct_start) - RELOC(dt_header_start);
@@ -1856,6 +1854,7 @@ static void __init prom_find_boot_cpu(void)
 
 	cpu_pkg = call_prom("instance-to-package", 1, 1, prom_cpu);
 
+	prom_setprop(cpu_pkg, "linux,boot-cpu", NULL, 0);
 	prom_getprop(cpu_pkg, "reg", &getprop_rval, sizeof(getprop_rval));
 	_prom->cpu = getprop_rval;
 

trunk/arch/x86_64/Kconfig

@@ -308,7 +308,7 @@ config HPET_TIMER
 	  present.  The HPET provides a stable time base on SMP
 	  systems, unlike the TSC, but it is more expensive to access,
 	  as it is off-chip.  You can find the HPET spec at
-	  <http://www.intel.com/hardwaredesign/hpetspec.htm>.
+	  <http://www.intel.com/labs/platcomp/hpet/hpetspec.htm>.
 
 config X86_PM_TIMER
 	bool "PM timer"

trunk/drivers/block/cciss.c

@@ -483,6 +483,9 @@ static int cciss_open(struct inode *inode, struct file *filep)
 	printk(KERN_DEBUG "cciss_open %s\n", inode->i_bdev->bd_disk->disk_name);
 #endif /* CCISS_DEBUG */ 
 
+	if (host->busy_initializing)
+		return -EBUSY;
+
 	if (host->busy_initializing || drv->busy_configuring)
 		return -EBUSY;
 	/*
@@ -2988,7 +2991,6 @@ static int __devinit cciss_init_one(struct pci_dev *pdev,
 	hba[i]->access.set_intr_mask(hba[i], CCISS_INTR_ON);
 
 	cciss_procinit(i);
-	hba[i]->busy_initializing = 0;
 
 	for(j=0; j < NWD; j++) { /* mfm */
 		drive_info_struct *drv = &(hba[i]->drv[j]);
@@ -3031,6 +3033,7 @@ static int __devinit cciss_init_one(struct pci_dev *pdev,
 		add_disk(disk);
 	}
 
+	hba[i]->busy_initializing = 0;
 	return(1);
 
 clean4:

trunk/drivers/block/ll_rw_blk.c

@@ -2373,6 +2373,44 @@ int blkdev_issue_flush(struct block_device *bdev, sector_t *error_sector)
 
 EXPORT_SYMBOL(blkdev_issue_flush);
 
+/**
+ * blkdev_scsi_issue_flush_fn - issue flush for SCSI devices
+ * @q:		device queue
+ * @disk:	gendisk
+ * @error_sector:	error offset
+ *
+ * Description:
+ *    Devices understanding the SCSI command set, can use this function as
+ *    a helper for issuing a cache flush. Note: driver is required to store
+ *    the error offset (in case of error flushing) in ->sector of struct
+ *    request.
+ */
+int blkdev_scsi_issue_flush_fn(request_queue_t *q, struct gendisk *disk,
+			       sector_t *error_sector)
+{
+	struct request *rq = blk_get_request(q, WRITE, __GFP_WAIT);
+	int ret;
+
+	rq->flags |= REQ_BLOCK_PC | REQ_SOFTBARRIER;
+	rq->sector = 0;
+	memset(rq->cmd, 0, sizeof(rq->cmd));
+	rq->cmd[0] = 0x35;
+	rq->cmd_len = 12;
+	rq->data = NULL;
+	rq->data_len = 0;
+	rq->timeout = 60 * HZ;
+
+	ret = blk_execute_rq(q, disk, rq, 0);
+
+	if (ret && error_sector)
+		*error_sector = rq->sector;
+
+	blk_put_request(rq);
+	return ret;
+}
+
+EXPORT_SYMBOL(blkdev_scsi_issue_flush_fn);
+
 static void drive_stat_acct(struct request *rq, int nr_sectors, int new_io)
 {
 	int rw = rq_data_dir(rq);