PCI Hotplug: cpqphp: fix comment style (427438c6) · Commits · e / devices / android_kernel_fairphone_FP3

drivers/pci/hotplug/cpqphp.h

+11 −11

Original line number	Diff line number	Diff line
		@@ -190,7 +190,9 @@ struct hrt {
		u32 reserved2;
		} __attribute__ ((packed));

		/* offsets to the hotplug resource table registers based on the above structure layout */
		/* offsets to the hotplug resource table registers based on the above
		* structure layout
		*/
		enum hrt_offsets {
		SIG0 = offsetof(struct hrt, sig0),
		SIG1 = offsetof(struct hrt, sig1),
		@@ -217,7 +219,9 @@ struct slot_rt {
		u16 pre_mem_length;
		} __attribute__ ((packed));

		/* offsets to the hotplug slot resource table registers based on the above structure layout */
		/* offsets to the hotplug slot resource table registers based on the above
		* structure layout
		*/
		enum slot_rt_offsets {
		DEV_FUNC = offsetof(struct slot_rt, dev_func),
		PRIMARY_BUS = offsetof(struct slot_rt, primary_bus),
		@@ -458,7 +462,6 @@ static inline char slot_name(struct slot slot)
		* return_resource
		*
		* Puts node back in the resource list pointed to by head
		*
		*/
		static inline void return_resource(struct pci_resource *head, struct pci_resource node)
		{
		@@ -575,13 +578,12 @@ static inline u8 read_slot_enable(struct controller *ctrl)
		}


		/*
		/**
		* get_controller_speed - find the current frequency/mode of controller.
		*
		* @ctrl: controller to get frequency/mode for.
		*
		* Returns controller speed.
		*
		*/
		static inline u8 get_controller_speed(struct controller *ctrl)
		{
		@@ -607,14 +609,13 @@ static inline u8 get_controller_speed(struct controller *ctrl)
		}


		/*
		/**
		* get_adapter_speed - find the max supported frequency/mode of adapter.
		*
		* @ctrl: hotplug controller.
		* @hp_slot: hotplug slot where adapter is installed.
		*
		* Returns adapter speed.
		*
		*/
		static inline u8 get_adapter_speed(struct controller *ctrl, u8 hp_slot)
		{
		@@ -719,4 +720,3 @@ static inline int wait_for_ctrl_irq(struct controller *ctrl)
		}

		#endif

drivers/pci/hotplug/cpqphp_core.c

+84 −73

Original line number	Diff line number	Diff line
		@@ -26,7 +26,6 @@
		*
		* Jan 12, 2003 - Added 66/100/133MHz PCI-X support,
		* Torben Mathiasen <torben.mathiasen@hp.com>
		*
		*/

		#include <linux/module.h>
		@@ -171,7 +170,7 @@ static int init_SERR(struct controller * ctrl)
		tempdword = ctrl->first_slot;

		number_of_slots = readb(ctrl->hpc_reg + SLOT_MASK) & 0x0F;
		// Loop through slots
		/* Loop through slots */
		while (number_of_slots) {
		physical_slot = tempdword;
		writeb(0, ctrl->hpc_reg + SLOT_SERR);
		@@ -200,7 +199,7 @@ static int pci_print_IRQ_route (void)

		len = (routing_table->size - sizeof(struct irq_routing_table)) /
		sizeof(struct irq_info);
		// Make sure I got at least one entry
		/* Make sure I got at least one entry */
		if (len == 0) {
		kfree(routing_table);
		return -1;
		@@ -244,7 +243,7 @@ static void __iomem get_subsequent_smbios_entry(void __iomem smbios_start,
		if (!smbios_table \|\| !curr)
		return(NULL);

		// set p_max to the end of the table
		/* set p_max to the end of the table */
		p_max = smbios_start + readw(smbios_table + ST_LENGTH);

		p_temp = curr;
		@@ -253,7 +252,8 @@ static void __iomem get_subsequent_smbios_entry(void __iomem smbios_start,
		while ((p_temp < p_max) && !bail) {
		/* Look for the double NULL terminator
		* The first condition is the previous byte
		* and the second is the curr */
		* and the second is the curr
		*/
		if (!previous_byte && !(readb(p_temp))) {
		bail = 1;
		}
		@@ -387,8 +387,9 @@ static int ctrl_slot_setup(struct controller *ctrl,
		slot->task_event.expires = jiffies + 5 * HZ;
		slot->task_event.function = cpqhp_pushbutton_thread;

		//FIXME: these capabilities aren't used but if they are
		// they need to be correctly implemented
		/*FIXME: these capabilities aren't used but if they are
		* they need to be correctly implemented
		*/
		slot->capabilities \|= PCISLOT_REPLACE_SUPPORTED;
		slot->capabilities \|= PCISLOT_INTERLOCK_SUPPORTED;

		@@ -402,14 +403,14 @@ static int ctrl_slot_setup(struct controller *ctrl,
		ctrl_slot =
		slot_device - (readb(ctrl->hpc_reg + SLOT_MASK) >> 4);

		// Check presence
		/* Check presence */
		slot->capabilities \|=
		((((~tempdword) >> 23) \|
		((~tempdword) >> 15)) >> ctrl_slot) & 0x02;
		// Check the switch state
		/* Check the switch state */
		slot->capabilities \|=
		((~tempdword & 0xFF) >> ctrl_slot) & 0x01;
		// Check the slot enable
		/* Check the slot enable */
		slot->capabilities \|=
		((read_slot_enable(ctrl) << 2) >> ctrl_slot) & 0x04;

		@@ -476,11 +477,11 @@ static int ctrl_slot_cleanup (struct controller * ctrl)

		cpqhp_remove_debugfs_files(ctrl);

		//Free IRQ associated with hot plug device
		/* Free IRQ associated with hot plug device */
		free_irq(ctrl->interrupt, ctrl);
		//Unmap the memory
		/* Unmap the memory */
		iounmap(ctrl->hpc_reg);
		//Finally reclaim PCI mem
		/* Finally reclaim PCI mem */
		release_mem_region(pci_resource_start(ctrl->pci_dev, 0),
		pci_resource_len(ctrl->pci_dev, 0));

		@@ -488,20 +489,17 @@ static int ctrl_slot_cleanup (struct controller * ctrl)
		}


		//============================================================================
		// function: get_slot_mapping
		//
		// Description: Attempts to determine a logical slot mapping for a PCI
		// device. Won't work for more than one PCI-PCI bridge
		// in a slot.
		//
		// Input: u8 bus_num - bus number of PCI device
		// u8 dev_num - device number of PCI device
		// u8 *slot - Pointer to u8 where slot number will
		// be returned
		//
		// Output: SUCCESS or FAILURE
		//=============================================================================
		/**
		* get_slot_mapping - determine logical slot mapping for PCI device
		*
		* Won't work for more than one PCI-PCI bridge in a slot.
		*
		* @bus_num - bus number of PCI device
		* @dev_num - device number of PCI device
		* @slot - Pointer to u8 where slot number will be returned
		*
		* Output: SUCCESS or FAILURE
		*/
		static int
		get_slot_mapping(struct pci_bus bus, u8 bus_num, u8 dev_num, u8 slot)
		{
		@@ -522,7 +520,7 @@ get_slot_mapping(struct pci_bus bus, u8 bus_num, u8 dev_num, u8 slot)

		len = (PCIIRQRoutingInfoLength->size -
		sizeof(struct irq_routing_table)) / sizeof(struct irq_info);
		// Make sure I got at least one entry
		/* Make sure I got at least one entry */
		if (len == 0) {
		kfree(PCIIRQRoutingInfoLength);
		return -1;
		@@ -539,13 +537,14 @@ get_slot_mapping(struct pci_bus bus, u8 bus_num, u8 dev_num, u8 slot)
		return 0;
		} else {
		/* Did not get a match on the target PCI device. Check
		* if the current IRQ table entry is a PCI-to-PCI bridge
		* device. If so, and it's secondary bus matches the
		* bus number for the target device, I need to save the
		* bridge's slot number. If I can not find an entry for
		* the target device, I will have to assume it's on the
		* other side of the bridge, and assign it the bridge's
		* slot. */
		* if the current IRQ table entry is a PCI-to-PCI
		* bridge device. If so, and it's secondary bus
		* matches the bus number for the target device, I need
		* to save the bridge's slot number. If I can not find
		* an entry for the target device, I will have to
		* assume it's on the other side of the bridge, and
		* assign it the bridge's slot.
		*/
		bus->number = tbus;
		pci_bus_read_config_dword(bus, PCI_DEVFN(tdevice, 0),
		PCI_CLASS_REVISION, &work);
		@@ -563,17 +562,18 @@ get_slot_mapping(struct pci_bus bus, u8 bus_num, u8 dev_num, u8 slot)

		}

		// If we got here, we didn't find an entry in the IRQ mapping table
		// for the target PCI device. If we did determine that the target
		// device is on the other side of a PCI-to-PCI bridge, return the
		// slot number for the bridge.
		/* If we got here, we didn't find an entry in the IRQ mapping table for
		* the target PCI device. If we did determine that the target device
		* is on the other side of a PCI-to-PCI bridge, return the slot number
		* for the bridge.
		*/
		if (bridgeSlot != 0xFF) {
		*slot = bridgeSlot;
		kfree(PCIIRQRoutingInfoLength);
		return 0;
		}
		kfree(PCIIRQRoutingInfoLength);
		// Couldn't find an entry in the routing table for this PCI device
		/* Couldn't find an entry in the routing table for this PCI device */
		return -1;
		}

		@@ -595,7 +595,7 @@ cpqhp_set_attention_status(struct controller ctrl, struct pci_func func,

		hp_slot = func->device - ctrl->slot_device_offset;

		// Wait for exclusive access to hardware
		/* Wait for exclusive access to hardware */
		mutex_lock(&ctrl->crit_sect);

		if (status == 1) {
		@@ -603,17 +603,17 @@ cpqhp_set_attention_status(struct controller ctrl, struct pci_func func,
		} else if (status == 0) {
		amber_LED_off (ctrl, hp_slot);
		} else {
		// Done with exclusive hardware access
		/* Done with exclusive hardware access */
		mutex_unlock(&ctrl->crit_sect);
		return(1);
		}

		set_SOGO(ctrl);

		// Wait for SOBS to be unset
		/* Wait for SOBS to be unset */
		wait_for_ctrl_irq (ctrl);

		// Done with exclusive hardware access
		/* Done with exclusive hardware access */
		mutex_unlock(&ctrl->crit_sect);

		return(0);
		@@ -815,7 +815,9 @@ static int cpqhpc_probe(struct pci_dev pdev, const struct pci_device_id ent)
		return err;
		}

		// Need to read VID early b/c it's used to differentiate CPQ and INTC discovery
		/* Need to read VID early b/c it's used to differentiate CPQ and INTC
		* discovery
		*/
		rc = pci_read_config_word(pdev, PCI_VENDOR_ID, &vendor_id);
		if (rc \|\| ((vendor_id != PCI_VENDOR_ID_COMPAQ) && (vendor_id != PCI_VENDOR_ID_INTEL))) {
		err(msg_HPC_non_compaq_or_intel);
		@@ -837,7 +839,9 @@ static int cpqhpc_probe(struct pci_dev pdev, const struct pci_device_id ent)
		* Also Intel HPC's may have RID=0.
		*/
		if ((pdev->revision > 2) \|\| (vendor_id == PCI_VENDOR_ID_INTEL)) {
		// TODO: This code can be made to support non-Compaq or Intel subsystem IDs
		/* TODO: This code can be made to support non-Compaq or Intel
		* subsystem IDs
		*/
		rc = pci_read_config_word(pdev, PCI_SUBSYSTEM_VENDOR_ID, &subsystem_vid);
		if (rc) {
		err("%s : pci_read_config_word failed\n", __func__);
		@@ -865,7 +869,9 @@ static int cpqhpc_probe(struct pci_dev pdev, const struct pci_device_id ent)

		info("Hot Plug Subsystem Device ID: %x\n", subsystem_deviceid);

		/* Set Vendor ID, so it can be accessed later from other functions */
		/* Set Vendor ID, so it can be accessed later from other
		* functions
		*/
		ctrl->vendor_id = vendor_id;

		switch (subsystem_vid) {
		@@ -992,23 +998,23 @@ static int cpqhpc_probe(struct pci_dev pdev, const struct pci_device_id ent)

		/* PHP Status (0=De-feature PHP, 1=Normal operation) */
		if (subsystem_deviceid & 0x0008) {
		ctrl->defeature_PHP = 1; // PHP supported
		ctrl->defeature_PHP = 1; /* PHP supported */
		} else {
		ctrl->defeature_PHP = 0; // PHP not supported
		ctrl->defeature_PHP = 0; /* PHP not supported */
		}

		/* Alternate Base Address Register Interface (0=not supported, 1=supported) */
		if (subsystem_deviceid & 0x0010) {
		ctrl->alternate_base_address = 1; // supported
		ctrl->alternate_base_address = 1; /* supported */
		} else {
		ctrl->alternate_base_address = 0; // not supported
		ctrl->alternate_base_address = 0; /* not supported */
		}

		/* PCI Config Space Index (0=not supported, 1=supported) */
		if (subsystem_deviceid & 0x0020) {
		ctrl->pci_config_space = 1; // supported
		ctrl->pci_config_space = 1; /* supported */
		} else {
		ctrl->pci_config_space = 0; // not supported
		ctrl->pci_config_space = 0; /* not supported */
		}

		/* PCI-X support */
		@@ -1042,7 +1048,7 @@ static int cpqhpc_probe(struct pci_dev pdev, const struct pci_device_id ent)
		return -ENODEV;
		}

		// Tell the user that we found one.
		/* Tell the user that we found one. */
		info("Initializing the PCI hot plug controller residing on PCI bus %d\n",
		pdev->bus->number);

		@@ -1120,7 +1126,7 @@ static int cpqhpc_probe(struct pci_dev pdev, const struct pci_device_id ent)
		*
		********************************************************/

		// find the physical slot number of the first hot plug slot
		/* find the physical slot number of the first hot plug slot */

		/* Get slot won't work for devices behind bridges, but
		* in this case it will always be called for the "base"
		@@ -1137,7 +1143,7 @@ static int cpqhpc_probe(struct pci_dev pdev, const struct pci_device_id ent)
		goto err_iounmap;
		}

		// Store PCI Config Space for all devices on this bus
		/* Store PCI Config Space for all devices on this bus */
		rc = cpqhp_save_config(ctrl, ctrl->bus, readb(ctrl->hpc_reg + SLOT_MASK));
		if (rc) {
		err("%s: unable to save PCI configuration data, error %d\n",
		@@ -1148,7 +1154,7 @@ static int cpqhpc_probe(struct pci_dev pdev, const struct pci_device_id ent)
		/*
		* Get IO, memory, and IRQ resources for new devices
		*/
		// The next line is required for cpqhp_find_available_resources
		/* The next line is required for cpqhp_find_available_resources */
		ctrl->interrupt = pdev->irq;
		if (ctrl->interrupt < 0x10) {
		cpqhp_legacy_mode = 1;
		@@ -1196,12 +1202,14 @@ static int cpqhpc_probe(struct pci_dev pdev, const struct pci_device_id ent)
		goto err_iounmap;
		}

		/* Enable Shift Out interrupt and clear it, also enable SERR on power fault */
		/* Enable Shift Out interrupt and clear it, also enable SERR on power
		* fault
		*/
		temp_word = readw(ctrl->hpc_reg + MISC);
		temp_word \|= 0x4006;
		writew(temp_word, ctrl->hpc_reg + MISC);

		// Changed 05/05/97 to clear all interrupts at start
		/* Changed 05/05/97 to clear all interrupts at start */
		writel(0xFFFFFFFFL, ctrl->hpc_reg + INT_INPUT_CLEAR);

		ctrl->ctrl_int_comp = readl(ctrl->hpc_reg + INT_INPUT_CLEAR);
		@@ -1216,13 +1224,14 @@ static int cpqhpc_probe(struct pci_dev pdev, const struct pci_device_id ent)
		cpqhp_ctrl_list = ctrl;
		}

		// turn off empty slots here unless command line option "ON" set
		// Wait for exclusive access to hardware
		/* turn off empty slots here unless command line option "ON" set
		* Wait for exclusive access to hardware
		*/
		mutex_lock(&ctrl->crit_sect);

		num_of_slots = readb(ctrl->hpc_reg + SLOT_MASK) & 0x0F;

		// find first device number for the ctrl
		/* find first device number for the ctrl */
		device = readb(ctrl->hpc_reg + SLOT_MASK) >> 4;

		while (num_of_slots) {
		@@ -1234,7 +1243,7 @@ static int cpqhpc_probe(struct pci_dev pdev, const struct pci_device_id ent)
		hp_slot = func->device - ctrl->slot_device_offset;
		dbg("hp_slot: %d\n", hp_slot);

		// We have to save the presence info for these slots
		/* We have to save the presence info for these slots */
		temp_word = ctrl->ctrl_int_comp >> 16;
		func->presence_save = (temp_word >> hp_slot) & 0x01;
		func->presence_save \|= (temp_word >> (hp_slot + 7)) & 0x02;
		@@ -1258,7 +1267,7 @@ static int cpqhpc_probe(struct pci_dev pdev, const struct pci_device_id ent)

		if (!power_mode) {
		set_SOGO(ctrl);
		// Wait for SOBS to be unset
		/* Wait for SOBS to be unset */
		wait_for_ctrl_irq(ctrl);
		}

		@@ -1269,7 +1278,7 @@ static int cpqhpc_probe(struct pci_dev pdev, const struct pci_device_id ent)
		goto err_free_irq;
		}

		// Done with exclusive hardware access
		/* Done with exclusive hardware access */
		mutex_unlock(&ctrl->crit_sect);

		cpqhp_create_debugfs_files(ctrl);
		@@ -1316,11 +1325,11 @@ static int one_time_init(void)
		cpqhp_slot_list[loop] = NULL;
		}

		// FIXME: We also need to hook the NMI handler eventually.
		// this also needs to be worked with Christoph
		// register_NMI_handler();

		// Map rom address
		/* FIXME: We also need to hook the NMI handler eventually.
		* this also needs to be worked with Christoph
		* register_NMI_handler();
		*/
		/* Map rom address */
		cpqhp_rom_start = ioremap(ROM_PHY_ADDR, ROM_PHY_LEN);
		if (!cpqhp_rom_start) {
		err ("Could not ioremap memory region for ROM\n");
		@@ -1328,7 +1337,9 @@ static int one_time_init(void)
		goto error;
		}

		/* Now, map the int15 entry point if we are on compaq specific hardware */
		/* Now, map the int15 entry point if we are on compaq specific
		* hardware
		*/
		compaq_nvram_init(cpqhp_rom_start);

		/* Map smbios table entry point structure */
		@@ -1462,11 +1473,11 @@ static void __exit unload_cpqphpd(void)
		}
		}

		// Stop the notification mechanism
		/* Stop the notification mechanism */
		if (initialized)
		cpqhp_event_stop_thread();

		//unmap the rom address
		/* unmap the rom address */
		if (cpqhp_rom_start)
		iounmap(cpqhp_rom_start);
		if (smbios_start)

drivers/pci/hotplug/cpqphp_ctrl.c

+77 −54

Original line number	Diff line number	Diff line
		@@ -81,14 +81,15 @@ static u8 handle_switch_change(u8 change, struct controller * ctrl)

		for (hp_slot = 0; hp_slot < 6; hp_slot++) {
		if (change & (0x1L << hp_slot)) {
		/**********************************
		/*
		* this one changed.
		**********************************/
		*/
		func = cpqhp_slot_find(ctrl->bus,
		(hp_slot + ctrl->slot_device_offset), 0);

		/* this is the structure that tells the worker thread
		what to do /
		* what to do
		*/
		taskInfo = &(ctrl->event_queue[ctrl->next_event]);
		ctrl->next_event = (ctrl->next_event + 1) % 10;
		taskInfo->hp_slot = hp_slot;
		@@ -100,17 +101,17 @@ static u8 handle_switch_change(u8 change, struct controller * ctrl)
		func->presence_save \|= (temp_word >> (hp_slot + 7)) & 0x02;

		if (ctrl->ctrl_int_comp & (0x1L << hp_slot)) {
		/**********************************
		/*
		* Switch opened
		**********************************/
		*/

		func->switch_save = 0;

		taskInfo->event_type = INT_SWITCH_OPEN;
		} else {
		/**********************************
		/*
		* Switch closed
		**********************************/
		*/

		func->switch_save = 0x10;

		@@ -152,17 +153,17 @@ static u8 handle_presence_change(u16 change, struct controller * ctrl)
		if (!change)
		return 0;

		/**********************************
		/*
		* Presence Change
		**********************************/
		*/
		dbg("cpqsbd: Presence/Notify input change.\n");
		dbg(" Changed bits are 0x%4.4x\n", change );

		for (hp_slot = 0; hp_slot < 6; hp_slot++) {
		if (change & (0x0101 << hp_slot)) {
		/**********************************
		/*
		* this one changed.
		**********************************/
		*/
		func = cpqhp_slot_find(ctrl->bus,
		(hp_slot + ctrl->slot_device_offset), 0);

		@@ -177,22 +178,23 @@ static u8 handle_presence_change(u16 change, struct controller * ctrl)
		return 0;

		/* If the switch closed, must be a button
		* If not in button mode, nevermind */
		* If not in button mode, nevermind
		*/
		if (func->switch_save && (ctrl->push_button == 1)) {
		temp_word = ctrl->ctrl_int_comp >> 16;
		temp_byte = (temp_word >> hp_slot) & 0x01;
		temp_byte \|= (temp_word >> (hp_slot + 7)) & 0x02;

		if (temp_byte != func->presence_save) {
		/**************************************
		/*
		* button Pressed (doesn't do anything)
		**************************************/
		*/
		dbg("hp_slot %d button pressed\n", hp_slot);
		taskInfo->event_type = INT_BUTTON_PRESS;
		} else {
		/**********************************
		/*
		* button Released - TAKE ACTION!!!!
		**********************************/
		*/
		dbg("hp_slot %d button released\n", hp_slot);
		taskInfo->event_type = INT_BUTTON_RELEASE;

		@@ -210,7 +212,8 @@ static u8 handle_presence_change(u16 change, struct controller * ctrl)
		}
		} else {
		/* Switch is open, assume a presence change
		* Save the presence state */
		* Save the presence state
		*/
		temp_word = ctrl->ctrl_int_comp >> 16;
		func->presence_save = (temp_word >> hp_slot) & 0x01;
		func->presence_save \|= (temp_word >> (hp_slot + 7)) & 0x02;
		@@ -241,17 +244,17 @@ static u8 handle_power_fault(u8 change, struct controller * ctrl)
		if (!change)
		return 0;

		/**********************************
		/*
		* power fault
		**********************************/
		*/

		info("power fault interrupt\n");

		for (hp_slot = 0; hp_slot < 6; hp_slot++) {
		if (change & (0x01 << hp_slot)) {
		/**********************************
		/*
		* this one changed.
		**********************************/
		*/
		func = cpqhp_slot_find(ctrl->bus,
		(hp_slot + ctrl->slot_device_offset), 0);

		@@ -262,16 +265,16 @@ static u8 handle_power_fault(u8 change, struct controller * ctrl)
		rc++;

		if (ctrl->ctrl_int_comp & (0x00000100 << hp_slot)) {
		/**********************************
		/*
		* power fault Cleared
		**********************************/
		*/
		func->status = 0x00;

		taskInfo->event_type = INT_POWER_FAULT_CLEAR;
		} else {
		/**********************************
		/*
		* power fault
		**********************************/
		*/
		taskInfo->event_type = INT_POWER_FAULT;

		if (ctrl->rev < 4) {
		@@ -432,13 +435,15 @@ static struct pci_resource do_pre_bridge_resource_split(struct pci_resource *h


		/* If we got here, there the bridge requires some of the resource, but
		* we may be able to split some off of the front */
		* we may be able to split some off of the front
		*/

		node = *head;

		if (node->length & (alignment -1)) {
		/* this one isn't an aligned length, so we'll make a new entry
		* and split it up. */
		* and split it up.
		*/
		split_node = kmalloc(sizeof(*split_node), GFP_KERNEL);

		if (!split_node)
		@@ -556,7 +561,8 @@ static struct pci_resource get_io_resource(struct pci_resource *head, u32 size

		if (node->base & (size - 1)) {
		/* this one isn't base aligned properly
		* so we'll make a new entry and split it up */
		* so we'll make a new entry and split it up
		*/
		temp_dword = (node->base \| (size-1)) + 1;

		/* Short circuit if adjusted size is too small */
		@@ -581,7 +587,8 @@ static struct pci_resource get_io_resource(struct pci_resource *head, u32 size
		/* Don't need to check if too small since we already did */
		if (node->length > size) {
		/* this one is longer than we need
		* so we'll make a new entry and split it up */
		* so we'll make a new entry and split it up
		*/
		split_node = kmalloc(sizeof(*split_node), GFP_KERNEL);

		if (!split_node)
		@@ -601,7 +608,8 @@ static struct pci_resource get_io_resource(struct pci_resource *head, u32 size
		continue;

		/* If we got here, then it is the right size
		* Now take it out of the list and break */
		* Now take it out of the list and break
		*/
		if (*head == node) {
		*head = node->next;
		} else {
		@@ -643,13 +651,15 @@ static struct pci_resource get_max_resource(struct pci_resource *head, u32 siz

		for (max = *head; max; max = max->next) {
		/* If not big enough we could probably just bail,
		* instead we'll continue to the next. */
		* instead we'll continue to the next.
		*/
		if (max->length < size)
		continue;

		if (max->base & (size - 1)) {
		/* this one isn't base aligned properly
		* so we'll make a new entry and split it up */
		* so we'll make a new entry and split it up
		*/
		temp_dword = (max->base \| (size-1)) + 1;

		/* Short circuit if adjusted size is too small */
		@@ -672,7 +682,8 @@ static struct pci_resource get_max_resource(struct pci_resource *head, u32 siz

		if ((max->base + max->length) & (size - 1)) {
		/* this one isn't end aligned properly at the top
		* so we'll make a new entry and split it up */
		* so we'll make a new entry and split it up
		*/
		split_node = kmalloc(sizeof(*split_node), GFP_KERNEL);

		if (!split_node)
		@@ -744,7 +755,8 @@ static struct pci_resource get_resource(struct pci_resource *head, u32 size)
		if (node->base & (size - 1)) {
		dbg("%s: not aligned\n", __func__);
		/* this one isn't base aligned properly
		* so we'll make a new entry and split it up */
		* so we'll make a new entry and split it up
		*/
		temp_dword = (node->base \| (size-1)) + 1;

		/* Short circuit if adjusted size is too small */
		@@ -769,7 +781,8 @@ static struct pci_resource get_resource(struct pci_resource *head, u32 size)
		if (node->length > size) {
		dbg("%s: too big\n", __func__);
		/* this one is longer than we need
		* so we'll make a new entry and split it up */
		* so we'll make a new entry and split it up
		*/
		split_node = kmalloc(sizeof(*split_node), GFP_KERNEL);

		if (!split_node)
		@@ -888,17 +901,17 @@ irqreturn_t cpqhp_ctrl_intr(int IRQ, void *data)


		misc = readw(ctrl->hpc_reg + MISC);
		/***************************************
		/*
		* Check to see if it was our interrupt
		***************************************/
		*/
		if (!(misc & 0x000C)) {
		return IRQ_NONE;
		}

		if (misc & 0x0004) {
		/**********************************
		/*
		* Serial Output interrupt Pending
		**********************************/
		*/

		/* Clear the interrupt */
		misc \|= 0x0004;
		@@ -963,7 +976,8 @@ struct pci_func *cpqhp_slot_create(u8 busnumber)
		new_slot = kzalloc(sizeof(*new_slot), GFP_KERNEL);
		if (new_slot == NULL) {
		/* I'm not dead yet!
		* You will be. */
		* You will be.
		*/
		return new_slot;
		}

		@@ -1135,7 +1149,8 @@ static u8 set_controller_speed(struct controller *ctrl, u8 adapter_speed, u8 hp_
		return 0;

		/* We don't allow freq/mode changes if we find another adapter running
		* in another slot on this controller */
		* in another slot on this controller
		*/
		for(slot = ctrl->slot; slot; slot = slot->next) {
		if (slot->device == (hp_slot + ctrl->slot_device_offset))
		continue;
		@@ -1145,7 +1160,8 @@ static u8 set_controller_speed(struct controller *ctrl, u8 adapter_speed, u8 hp_
		continue;
		/* If another adapter is running on the same segment but at a
		* lower speed/mode, we allow the new adapter to function at
		* this rate if supported */
		* this rate if supported
		*/
		if (ctrl->speed < adapter_speed)
		return 0;

		@@ -1153,7 +1169,8 @@ static u8 set_controller_speed(struct controller *ctrl, u8 adapter_speed, u8 hp_
		}

		/* If the controller doesn't support freq/mode changes and the
		* controller is running at a higher mode, we bail */
		* controller is running at a higher mode, we bail
		*/
		if ((ctrl->speed > adapter_speed) && (!ctrl->pcix_speed_capability))
		return 1;

		@@ -1162,7 +1179,8 @@ static u8 set_controller_speed(struct controller *ctrl, u8 adapter_speed, u8 hp_
		return 0;

		/* We try to set the max speed supported by both the adapter and
		* controller */
		* controller
		*/
		if (ctrl->speed_capability < adapter_speed) {
		if (ctrl->speed == ctrl->speed_capability)
		return 0;
		@@ -1244,7 +1262,7 @@ static u8 set_controller_speed(struct controller *ctrl, u8 adapter_speed, u8 hp_
		}

		/* the following routines constitute the bulk of the
		hotplug controller logic
		* hotplug controller logic
		*/


		@@ -1269,14 +1287,14 @@ static u32 board_replaced(struct pci_func func, struct controller ctrl)
		hp_slot = func->device - ctrl->slot_device_offset;

		if (readl(ctrl->hpc_reg + INT_INPUT_CLEAR) & (0x01L << hp_slot)) {
		/**********************************
		/*
		* The switch is open.
		**********************************/
		*/
		rc = INTERLOCK_OPEN;
		} else if (is_slot_enabled (ctrl, hp_slot)) {
		/**********************************
		/*
		* The board is already on
		**********************************/
		*/
		rc = CARD_FUNCTIONING;
		} else {
		mutex_lock(&ctrl->crit_sect);
		@@ -1352,7 +1370,8 @@ static u32 board_replaced(struct pci_func func, struct controller ctrl)
		* Get slot won't work for devices behind
		* bridges, but in this case it will always be
		* called for the "base" bus/dev/func of an
		* adapter. */
		* adapter.
		*/

		mutex_lock(&ctrl->crit_sect);

		@@ -1377,7 +1396,8 @@ static u32 board_replaced(struct pci_func func, struct controller ctrl)

		* Get slot won't work for devices behind bridges, but
		* in this case it will always be called for the "base"
		* bus/dev/func of an adapter. */
		* bus/dev/func of an adapter.
		*/

		mutex_lock(&ctrl->crit_sect);

		@@ -1434,7 +1454,8 @@ static u32 board_added(struct pci_func func, struct controller ctrl)
		wait_for_ctrl_irq (ctrl);

		/* Change bits in slot power register to force another shift out
		* NOTE: this is to work around the timer bug */
		* NOTE: this is to work around the timer bug
		*/
		temp_byte = readb(ctrl->hpc_reg + SLOT_POWER);
		writeb(0x00, ctrl->hpc_reg + SLOT_POWER);
		writeb(temp_byte, ctrl->hpc_reg + SLOT_POWER);
		@@ -2484,7 +2505,8 @@ static int configure_new_function(struct controller ctrl, struct pci_func func
		temp_resources.irqs = &irqs;

		/* Make copies of the nodes we are going to pass down so that
		* if there is a problem,we can just use these to free resources */
		* if there is a problem,we can just use these to free resources
		*/
		hold_bus_node = kmalloc(sizeof(*hold_bus_node), GFP_KERNEL);
		hold_IO_node = kmalloc(sizeof(*hold_IO_node), GFP_KERNEL);
		hold_mem_node = kmalloc(sizeof(*hold_mem_node), GFP_KERNEL);
		@@ -2556,7 +2578,8 @@ static int configure_new_function(struct controller ctrl, struct pci_func func
		temp_word = (p_mem_node->base + p_mem_node->length - 1) >> 16;
		rc = pci_bus_write_config_word (pci_bus, devfn, PCI_PREF_MEMORY_LIMIT, temp_word);

		/* Adjust this to compensate for extra adjustment in first loop */
		/* Adjust this to compensate for extra adjustment in first loop
		*/
		irqs.barber_pole--;

		rc = 0;

drivers/pci/hotplug/cpqphp_nvram.c

+42 −37

File changed.

Preview size limit exceeded, changes collapsed.

drivers/pci/hotplug/cpqphp_pci.c

+173 −140

File changed.

Preview size limit exceeded, changes collapsed.