PCI hotplug: shpchp: replace printk with dev_printk (f98ca311) · Commits · e / devices / android_kernel_xiaomi_markw

drivers/pci/hotplug/shpchp.h

+20 −3

Original line number	Original line	Diff line number	Diff line
	@@ -59,6 +59,20 @@ extern struct workqueue_struct *shpchp_wq;
	#define warn(format, arg...) \		#define warn(format, arg...) \
	printk(KERN_WARNING "%s: " format, MY_NAME , ## arg)		printk(KERN_WARNING "%s: " format, MY_NAME , ## arg)

			#define ctrl_dbg(ctrl, format, arg...) \
			do { \
			if (shpchp_debug) \
			dev_printk(, &ctrl->pci_dev->dev, \
			format, ## arg); \
			} while (0)
			#define ctrl_err(ctrl, format, arg...) \
			dev_err(&ctrl->pci_dev->dev, format, ## arg)
			#define ctrl_info(ctrl, format, arg...) \
			dev_info(&ctrl->pci_dev->dev, format, ## arg)
			#define ctrl_warn(ctrl, format, arg...) \
			dev_warn(&ctrl->pci_dev->dev, format, ## arg)


	#define SLOT_NAME_SIZE 10		#define SLOT_NAME_SIZE 10
	struct slot {		struct slot {
	u8 bus;		u8 bus;
	@@ -239,7 +253,7 @@ static inline struct slot shpchp_find_slot(struct controller ctrl, u8 device)
	return slot;		return slot;
	}		}

	err("%s: slot (device=0x%x) not found\n", __func__, device);		ctrl_err(ctrl, "%s: slot (device=0x%x) not found\n", __func__, device);
	return NULL;		return NULL;
	}		}

	@@ -273,7 +287,9 @@ static inline void amd_pogo_errata_restore_misc_reg(struct slot *p_slot)
	pci_read_config_dword(p_slot->ctrl->pci_dev, PCIX_MISC_BRIDGE_ERRORS_OFFSET, &pcix_bridge_errors_reg);		pci_read_config_dword(p_slot->ctrl->pci_dev, PCIX_MISC_BRIDGE_ERRORS_OFFSET, &pcix_bridge_errors_reg);
	perr_set = pcix_bridge_errors_reg & PERR_OBSERVED_MASK;		perr_set = pcix_bridge_errors_reg & PERR_OBSERVED_MASK;
	if (perr_set) {		if (perr_set) {
	dbg ("%s W1C: Bridge_Errors[ PERR_OBSERVED = %08X]\n",__func__ , perr_set);		ctrl_dbg(p_slot->ctrl,
			"%s W1C: Bridge_Errors[ PERR_OBSERVED = %08X]\n",
			__func__ , perr_set);

	pci_write_config_dword(p_slot->ctrl->pci_dev, PCIX_MISC_BRIDGE_ERRORS_OFFSET, perr_set);		pci_write_config_dword(p_slot->ctrl->pci_dev, PCIX_MISC_BRIDGE_ERRORS_OFFSET, perr_set);
	}		}
	@@ -282,7 +298,8 @@ static inline void amd_pogo_errata_restore_misc_reg(struct slot *p_slot)
	pci_read_config_dword(p_slot->ctrl->pci_dev, PCIX_MEM_BASE_LIMIT_OFFSET, &pcix_mem_base_reg);		pci_read_config_dword(p_slot->ctrl->pci_dev, PCIX_MEM_BASE_LIMIT_OFFSET, &pcix_mem_base_reg);
	rse_set = pcix_mem_base_reg & RSE_MASK;		rse_set = pcix_mem_base_reg & RSE_MASK;
	if (rse_set) {		if (rse_set) {
	dbg ("%s W1C: Memory_Base_Limit[ RSE ]\n",__func__ );		ctrl_dbg(p_slot->ctrl, "%s W1C: Memory_Base_Limit[ RSE ]\n",
			__func__);

	pci_write_config_dword(p_slot->ctrl->pci_dev, PCIX_MEM_BASE_LIMIT_OFFSET, rse_set);		pci_write_config_dword(p_slot->ctrl->pci_dev, PCIX_MEM_BASE_LIMIT_OFFSET, rse_set);
	}		}

drivers/pci/hotplug/shpchp_core.c

+28 −18

Original line number	Original line	Diff line number	Diff line
	@@ -89,7 +89,8 @@ static void release_slot(struct hotplug_slot *hotplug_slot)
	{		{
	struct slot *slot = hotplug_slot->private;		struct slot *slot = hotplug_slot->private;

	dbg("%s - physical_slot = %s\n", __func__, slot_name(slot));		ctrl_dbg(slot->ctrl, "%s - physical_slot = %s\n",
			__func__, slot_name(slot));

	kfree(slot->hotplug_slot->info);		kfree(slot->hotplug_slot->info);
	kfree(slot->hotplug_slot);		kfree(slot->hotplug_slot);
	@@ -135,13 +136,14 @@ static int init_slots(struct controller *ctrl)
	snprintf(name, SLOT_NAME_SIZE, "%d", slot->number);		snprintf(name, SLOT_NAME_SIZE, "%d", slot->number);
	hotplug_slot->ops = &shpchp_hotplug_slot_ops;		hotplug_slot->ops = &shpchp_hotplug_slot_ops;

	dbg("Registering bus=%x dev=%x hp_slot=%x sun=%x "		ctrl_dbg(ctrl, "Registering bus=%x dev=%x hp_slot=%x sun=%x "
	"slot_device_offset=%x\n", slot->bus, slot->device,		"slot_device_offset=%x\n", slot->bus, slot->device,
	slot->hp_slot, slot->number, ctrl->slot_device_offset);		slot->hp_slot, slot->number, ctrl->slot_device_offset);
	retval = pci_hp_register(slot->hotplug_slot,		retval = pci_hp_register(slot->hotplug_slot,
	ctrl->pci_dev->subordinate, slot->device, name);		ctrl->pci_dev->subordinate, slot->device, name);
	if (retval) {		if (retval) {
	err("pci_hp_register failed with error %d\n", retval);		ctrl_err(ctrl, "pci_hp_register failed with error %d\n",
			retval);
	goto error_info;		goto error_info;
	}		}

	@@ -187,7 +189,8 @@ static int set_attention_status (struct hotplug_slot *hotplug_slot, u8 status)
	{		{
	struct slot *slot = get_slot(hotplug_slot);		struct slot *slot = get_slot(hotplug_slot);

	dbg("%s - physical_slot = %s\n", __func__, slot_name(slot));		ctrl_dbg(slot->ctrl, "%s - physical_slot = %s\n",
			__func__, slot_name(slot));

	hotplug_slot->info->attention_status = status;		hotplug_slot->info->attention_status = status;
	slot->hpc_ops->set_attention_status(slot, status);		slot->hpc_ops->set_attention_status(slot, status);
	@@ -199,7 +202,8 @@ static int enable_slot (struct hotplug_slot *hotplug_slot)
	{		{
	struct slot *slot = get_slot(hotplug_slot);		struct slot *slot = get_slot(hotplug_slot);

	dbg("%s - physical_slot = %s\n", __func__, slot_name(slot));		ctrl_dbg(slot->ctrl, "%s - physical_slot = %s\n",
			__func__, slot_name(slot));

	return shpchp_sysfs_enable_slot(slot);		return shpchp_sysfs_enable_slot(slot);
	}		}
	@@ -208,7 +212,8 @@ static int disable_slot (struct hotplug_slot *hotplug_slot)
	{		{
	struct slot *slot = get_slot(hotplug_slot);		struct slot *slot = get_slot(hotplug_slot);

	dbg("%s - physical_slot = %s\n", __func__, slot_name(slot));		ctrl_dbg(slot->ctrl, "%s - physical_slot = %s\n",
			__func__, slot_name(slot));

	return shpchp_sysfs_disable_slot(slot);		return shpchp_sysfs_disable_slot(slot);
	}		}
	@@ -218,7 +223,8 @@ static int get_power_status (struct hotplug_slot hotplug_slot, u8 value)
	struct slot *slot = get_slot(hotplug_slot);		struct slot *slot = get_slot(hotplug_slot);
	int retval;		int retval;

	dbg("%s - physical_slot = %s\n", __func__, slot_name(slot));		ctrl_dbg(slot->ctrl, "%s - physical_slot = %s\n",
			__func__, slot_name(slot));

	retval = slot->hpc_ops->get_power_status(slot, value);		retval = slot->hpc_ops->get_power_status(slot, value);
	if (retval < 0)		if (retval < 0)
	@@ -232,7 +238,8 @@ static int get_attention_status (struct hotplug_slot hotplug_slot, u8 value)
	struct slot *slot = get_slot(hotplug_slot);		struct slot *slot = get_slot(hotplug_slot);
	int retval;		int retval;

	dbg("%s - physical_slot = %s\n", __func__, slot_name(slot));		ctrl_dbg(slot->ctrl, "%s - physical_slot = %s\n",
			__func__, slot_name(slot));

	retval = slot->hpc_ops->get_attention_status(slot, value);		retval = slot->hpc_ops->get_attention_status(slot, value);
	if (retval < 0)		if (retval < 0)
	@@ -246,7 +253,8 @@ static int get_latch_status (struct hotplug_slot hotplug_slot, u8 value)
	struct slot *slot = get_slot(hotplug_slot);		struct slot *slot = get_slot(hotplug_slot);
	int retval;		int retval;

	dbg("%s - physical_slot = %s\n", __func__, slot_name(slot));		ctrl_dbg(slot->ctrl, "%s - physical_slot = %s\n",
			__func__, slot_name(slot));

	retval = slot->hpc_ops->get_latch_status(slot, value);		retval = slot->hpc_ops->get_latch_status(slot, value);
	if (retval < 0)		if (retval < 0)
	@@ -260,7 +268,8 @@ static int get_adapter_status (struct hotplug_slot hotplug_slot, u8 value)
	struct slot *slot = get_slot(hotplug_slot);		struct slot *slot = get_slot(hotplug_slot);
	int retval;		int retval;

	dbg("%s - physical_slot = %s\n", __func__, slot_name(slot));		ctrl_dbg(slot->ctrl, "%s - physical_slot = %s\n",
			__func__, slot_name(slot));

	retval = slot->hpc_ops->get_adapter_status(slot, value);		retval = slot->hpc_ops->get_adapter_status(slot, value);
	if (retval < 0)		if (retval < 0)
	@@ -275,7 +284,8 @@ static int get_max_bus_speed(struct hotplug_slot *hotplug_slot,
	struct slot *slot = get_slot(hotplug_slot);		struct slot *slot = get_slot(hotplug_slot);
	int retval;		int retval;

	dbg("%s - physical_slot = %s\n", __func__, slot_name(slot));		ctrl_dbg(slot->ctrl, "%s - physical_slot = %s\n",
			__func__, slot_name(slot));

	retval = slot->hpc_ops->get_max_bus_speed(slot, value);		retval = slot->hpc_ops->get_max_bus_speed(slot, value);
	if (retval < 0)		if (retval < 0)
	@@ -289,7 +299,8 @@ static int get_cur_bus_speed (struct hotplug_slot *hotplug_slot, enum pci_bus_sp
	struct slot *slot = get_slot(hotplug_slot);		struct slot *slot = get_slot(hotplug_slot);
	int retval;		int retval;

	dbg("%s - physical_slot = %s\n", __func__, slot_name(slot));		ctrl_dbg(slot->ctrl, "%s - physical_slot = %s\n",
			__func__, slot_name(slot));

	retval = slot->hpc_ops->get_cur_bus_speed(slot, value);		retval = slot->hpc_ops->get_cur_bus_speed(slot, value);
	if (retval < 0)		if (retval < 0)
	@@ -320,15 +331,14 @@ static int shpc_probe(struct pci_dev pdev, const struct pci_device_id ent)

	ctrl = kzalloc(sizeof(*ctrl), GFP_KERNEL);		ctrl = kzalloc(sizeof(*ctrl), GFP_KERNEL);
	if (!ctrl) {		if (!ctrl) {
	err("%s : out of memory\n", __func__);		dev_err(&pdev->dev, "%s : out of memory\n", __func__);
	goto err_out_none;		goto err_out_none;
	}		}
	INIT_LIST_HEAD(&ctrl->slot_list);		INIT_LIST_HEAD(&ctrl->slot_list);

	rc = shpc_init(ctrl, pdev);		rc = shpc_init(ctrl, pdev);
	if (rc) {		if (rc) {
	dbg("%s: controller initialization failed\n",		ctrl_dbg(ctrl, "controller initialization failed\n");
	SHPC_MODULE_NAME);
	goto err_out_free_ctrl;		goto err_out_free_ctrl;
	}		}

	@@ -337,7 +347,7 @@ static int shpc_probe(struct pci_dev pdev, const struct pci_device_id ent)
	/* Setup the slot information structures */		/* Setup the slot information structures */
	rc = init_slots(ctrl);		rc = init_slots(ctrl);
	if (rc) {		if (rc) {
	err("%s: slot initialization failed\n", SHPC_MODULE_NAME);		ctrl_err(ctrl, "slot initialization failed\n");
	goto err_out_release_ctlr;		goto err_out_release_ctlr;
	}		}

drivers/pci/hotplug/shpchp_ctrl.c

+93 −69

Original line number	Original line	Diff line number	Diff line
	@@ -62,7 +62,7 @@ u8 shpchp_handle_attention_button(u8 hp_slot, struct controller *ctrl)
	u32 event_type;		u32 event_type;

	/* Attention Button Change */		/* Attention Button Change */
	dbg("shpchp: Attention button interrupt received.\n");		ctrl_dbg(ctrl, "Attention button interrupt received.\n");

	p_slot = shpchp_find_slot(ctrl, hp_slot + ctrl->slot_device_offset);		p_slot = shpchp_find_slot(ctrl, hp_slot + ctrl->slot_device_offset);
	p_slot->hpc_ops->get_adapter_status(p_slot, &(p_slot->presence_save));		p_slot->hpc_ops->get_adapter_status(p_slot, &(p_slot->presence_save));
	@@ -70,7 +70,7 @@ u8 shpchp_handle_attention_button(u8 hp_slot, struct controller *ctrl)
	/*		/*
	* Button pressed - See if need to TAKE ACTION!!!		* Button pressed - See if need to TAKE ACTION!!!
	*/		*/
	info("Button pressed on Slot(%s)\n", slot_name(p_slot));		ctrl_info(ctrl, "Button pressed on Slot(%s)\n", slot_name(p_slot));
	event_type = INT_BUTTON_PRESS;		event_type = INT_BUTTON_PRESS;

	queue_interrupt_event(p_slot, event_type);		queue_interrupt_event(p_slot, event_type);
	@@ -86,29 +86,29 @@ u8 shpchp_handle_switch_change(u8 hp_slot, struct controller *ctrl)
	u32 event_type;		u32 event_type;

	/* Switch Change */		/* Switch Change */
	dbg("shpchp: Switch interrupt received.\n");		ctrl_dbg(ctrl, "Switch interrupt received.\n");

	p_slot = shpchp_find_slot(ctrl, hp_slot + ctrl->slot_device_offset);		p_slot = shpchp_find_slot(ctrl, hp_slot + ctrl->slot_device_offset);
	p_slot->hpc_ops->get_adapter_status(p_slot, &(p_slot->presence_save));		p_slot->hpc_ops->get_adapter_status(p_slot, &(p_slot->presence_save));
	p_slot->hpc_ops->get_latch_status(p_slot, &getstatus);		p_slot->hpc_ops->get_latch_status(p_slot, &getstatus);
	dbg("%s: Card present %x Power status %x\n", __func__,		ctrl_dbg(ctrl, "%s: Card present %x Power status %x\n",
	p_slot->presence_save, p_slot->pwr_save);		__func__, p_slot->presence_save, p_slot->pwr_save);

	if (getstatus) {		if (getstatus) {
	/*		/*
	* Switch opened		* Switch opened
	*/		*/
	info("Latch open on Slot(%s)\n", slot_name(p_slot));		ctrl_info(ctrl, "Latch open on Slot(%s)\n", slot_name(p_slot));
	event_type = INT_SWITCH_OPEN;		event_type = INT_SWITCH_OPEN;
	if (p_slot->pwr_save && p_slot->presence_save) {		if (p_slot->pwr_save && p_slot->presence_save) {
	event_type = INT_POWER_FAULT;		event_type = INT_POWER_FAULT;
	err("Surprise Removal of card\n");		ctrl_err(ctrl, "Surprise Removal of card\n");
	}		}
	} else {		} else {
	/*		/*
	* Switch closed		* Switch closed
	*/		*/
	info("Latch close on Slot(%s)\n", slot_name(p_slot));		ctrl_info(ctrl, "Latch close on Slot(%s)\n", slot_name(p_slot));
	event_type = INT_SWITCH_CLOSE;		event_type = INT_SWITCH_CLOSE;
	}		}

	@@ -123,7 +123,7 @@ u8 shpchp_handle_presence_change(u8 hp_slot, struct controller *ctrl)
	u32 event_type;		u32 event_type;

	/* Presence Change */		/* Presence Change */
	dbg("shpchp: Presence/Notify input change.\n");		ctrl_dbg(ctrl, "Presence/Notify input change.\n");

	p_slot = shpchp_find_slot(ctrl, hp_slot + ctrl->slot_device_offset);		p_slot = shpchp_find_slot(ctrl, hp_slot + ctrl->slot_device_offset);

	@@ -135,13 +135,15 @@ u8 shpchp_handle_presence_change(u8 hp_slot, struct controller *ctrl)
	/*		/*
	* Card Present		* Card Present
	*/		*/
	info("Card present on Slot(%s)\n", slot_name(p_slot));		ctrl_info(ctrl, "Card present on Slot(%s)\n",
			slot_name(p_slot));
	event_type = INT_PRESENCE_ON;		event_type = INT_PRESENCE_ON;
	} else {		} else {
	/*		/*
	* Not Present		* Not Present
	*/		*/
	info("Card not present on Slot(%s)\n", slot_name(p_slot));		ctrl_info(ctrl, "Card not present on Slot(%s)\n",
			slot_name(p_slot));
	event_type = INT_PRESENCE_OFF;		event_type = INT_PRESENCE_OFF;
	}		}

	@@ -156,7 +158,7 @@ u8 shpchp_handle_power_fault(u8 hp_slot, struct controller *ctrl)
	u32 event_type;		u32 event_type;

	/* Power fault */		/* Power fault */
	dbg("shpchp: Power fault interrupt received.\n");		ctrl_dbg(ctrl, "Power fault interrupt received.\n");

	p_slot = shpchp_find_slot(ctrl, hp_slot + ctrl->slot_device_offset);		p_slot = shpchp_find_slot(ctrl, hp_slot + ctrl->slot_device_offset);

	@@ -164,18 +166,19 @@ u8 shpchp_handle_power_fault(u8 hp_slot, struct controller *ctrl)
	/*		/*
	* Power fault Cleared		* Power fault Cleared
	*/		*/
	info("Power fault cleared on Slot(%s)\n", slot_name(p_slot));		ctrl_info(ctrl, "Power fault cleared on Slot(%s)\n",
			slot_name(p_slot));
	p_slot->status = 0x00;		p_slot->status = 0x00;
	event_type = INT_POWER_FAULT_CLEAR;		event_type = INT_POWER_FAULT_CLEAR;
	} else {		} else {
	/*		/*
	* Power fault		* Power fault
	*/		*/
	info("Power fault on Slot(%s)\n", slot_name(p_slot));		ctrl_info(ctrl, "Power fault on Slot(%s)\n", slot_name(p_slot));
	event_type = INT_POWER_FAULT;		event_type = INT_POWER_FAULT;
	/* set power fault status for this board */		/* set power fault status for this board */
	p_slot->status = 0xFF;		p_slot->status = 0xFF;
	info("power fault bit %x set\n", hp_slot);		ctrl_info(ctrl, "power fault bit %x set\n", hp_slot);
	}		}

	queue_interrupt_event(p_slot, event_type);		queue_interrupt_event(p_slot, event_type);
	@@ -191,10 +194,10 @@ static int change_bus_speed(struct controller ctrl, struct slot p_slot,
	{		{
	int rc = 0;		int rc = 0;

	dbg("%s: change to speed %d\n", __func__, speed);		ctrl_dbg(ctrl, "%s: change to speed %d\n", __func__, speed);
	if ((rc = p_slot->hpc_ops->set_bus_speed_mode(p_slot, speed))) {		if ((rc = p_slot->hpc_ops->set_bus_speed_mode(p_slot, speed))) {
	err("%s: Issue of set bus speed mode command failed\n",		ctrl_err(ctrl, "%s: Issue of set bus speed mode command "
	__func__);		"failed\n", __func__);
	return WRONG_BUS_FREQUENCY;		return WRONG_BUS_FREQUENCY;
	}		}
	return rc;		return rc;
	@@ -212,8 +215,8 @@ static int fix_bus_speed(struct controller ctrl, struct slot pslot,
	*/		*/
	if (flag) {		if (flag) {
	if (asp < bsp) {		if (asp < bsp) {
	err("%s: speed of bus %x and adapter %x mismatch\n",		ctrl_err(ctrl, "%s: speed of bus %x and adapter %x "
	__func__, bsp, asp);		"mismatch\n", __func__, bsp, asp);
	rc = WRONG_BUS_FREQUENCY;		rc = WRONG_BUS_FREQUENCY;
	}		}
	return rc;		return rc;
	@@ -246,14 +249,14 @@ static int board_added(struct slot *p_slot)

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

	dbg("%s: p_slot->device, slot_offset, hp_slot = %d, %d ,%d\n",		ctrl_dbg(ctrl,
	__func__, p_slot->device,		"%s: p_slot->device, slot_offset, hp_slot = %d, %d ,%d\n",
	ctrl->slot_device_offset, hp_slot);		__func__, p_slot->device, ctrl->slot_device_offset, hp_slot);

	/* Power on slot without connecting to bus */		/* Power on slot without connecting to bus */
	rc = p_slot->hpc_ops->power_on_slot(p_slot);		rc = p_slot->hpc_ops->power_on_slot(p_slot);
	if (rc) {		if (rc) {
	err("%s: Failed to power on slot\n", __func__);		ctrl_err(ctrl, "%s: Failed to power on slot\n", __func__);
	return -1;		return -1;
	}		}

	@@ -262,33 +265,36 @@ static int board_added(struct slot *p_slot)
	return WRONG_BUS_FREQUENCY;		return WRONG_BUS_FREQUENCY;

	if ((rc = p_slot->hpc_ops->set_bus_speed_mode(p_slot, PCI_SPEED_33MHz))) {		if ((rc = p_slot->hpc_ops->set_bus_speed_mode(p_slot, PCI_SPEED_33MHz))) {
	err("%s: Issue of set bus speed mode command failed\n", __func__);		ctrl_err(ctrl, "%s: Issue of set bus speed mode command"
			" failed\n", __func__);
	return WRONG_BUS_FREQUENCY;		return WRONG_BUS_FREQUENCY;
	}		}

	/* turn on board, blink green LED, turn off Amber LED */		/* turn on board, blink green LED, turn off Amber LED */
	if ((rc = p_slot->hpc_ops->slot_enable(p_slot))) {		if ((rc = p_slot->hpc_ops->slot_enable(p_slot))) {
	err("%s: Issue of Slot Enable command failed\n", __func__);		ctrl_err(ctrl, "%s: Issue of Slot Enable command"
			" failed\n", __func__);
	return rc;		return rc;
	}		}
	}		}

	rc = p_slot->hpc_ops->get_adapter_speed(p_slot, &asp);		rc = p_slot->hpc_ops->get_adapter_speed(p_slot, &asp);
	if (rc) {		if (rc) {
	err("%s: Can't get adapter speed or bus mode mismatch\n",		ctrl_err(ctrl, "%s: Can't get adapter speed or bus mode "
	__func__);		"mismatch\n", __func__);
	return WRONG_BUS_FREQUENCY;		return WRONG_BUS_FREQUENCY;
	}		}

	rc = p_slot->hpc_ops->get_cur_bus_speed(p_slot, &bsp);		rc = p_slot->hpc_ops->get_cur_bus_speed(p_slot, &bsp);
	if (rc) {		if (rc) {
	err("%s: Can't get bus operation speed\n", __func__);		ctrl_err(ctrl, "%s: Can't get bus operation speed\n", __func__);
	return WRONG_BUS_FREQUENCY;		return WRONG_BUS_FREQUENCY;
	}		}

	rc = p_slot->hpc_ops->get_max_bus_speed(p_slot, &msp);		rc = p_slot->hpc_ops->get_max_bus_speed(p_slot, &msp);
	if (rc) {		if (rc) {
	err("%s: Can't get max bus operation speed\n", __func__);		ctrl_err(ctrl, "%s: Can't get max bus operation speed\n",
			__func__);
	msp = bsp;		msp = bsp;
	}		}

	@@ -296,7 +302,7 @@ static int board_added(struct slot *p_slot)
	if (!list_empty(&ctrl->pci_dev->subordinate->devices))		if (!list_empty(&ctrl->pci_dev->subordinate->devices))
	slots_not_empty = 1;		slots_not_empty = 1;

	dbg("%s: slots_not_empty %d, adapter_speed %d, bus_speed %d, "		ctrl_dbg(ctrl, "%s: slots_not_empty %d, adapter_speed %d, bus_speed %d,"
	" max_bus_speed %d\n", __func__, slots_not_empty, asp,		" max_bus_speed %d\n", __func__, slots_not_empty, asp,
	bsp, msp);		bsp, msp);

	@@ -306,26 +312,27 @@ static int board_added(struct slot *p_slot)

	/* turn on board, blink green LED, turn off Amber LED */		/* turn on board, blink green LED, turn off Amber LED */
	if ((rc = p_slot->hpc_ops->slot_enable(p_slot))) {		if ((rc = p_slot->hpc_ops->slot_enable(p_slot))) {
	err("%s: Issue of Slot Enable command failed\n", __func__);		ctrl_err(ctrl, "%s: Issue of Slot Enable command failed\n",
			__func__);
	return rc;		return rc;
	}		}

	/* Wait for ~1 second */		/* Wait for ~1 second */
	msleep(1000);		msleep(1000);

	dbg("%s: slot status = %x\n", __func__, p_slot->status);		ctrl_dbg(ctrl, "%s: slot status = %x\n", __func__, p_slot->status);
	/* Check for a power fault */		/* Check for a power fault */
	if (p_slot->status == 0xFF) {		if (p_slot->status == 0xFF) {
	/* power fault occurred, but it was benign */		/* power fault occurred, but it was benign */
	dbg("%s: power fault\n", __func__);		ctrl_dbg(ctrl, "%s: power fault\n", __func__);
	rc = POWER_FAILURE;		rc = POWER_FAILURE;
	p_slot->status = 0;		p_slot->status = 0;
	goto err_exit;		goto err_exit;
	}		}

	if (shpchp_configure_device(p_slot)) {		if (shpchp_configure_device(p_slot)) {
	err("Cannot add device at 0x%x:0x%x\n", p_slot->bus,		ctrl_err(ctrl, "Cannot add device at 0x%x:0x%x\n",
	p_slot->device);		p_slot->bus, p_slot->device);
	goto err_exit;		goto err_exit;
	}		}

	@@ -341,7 +348,8 @@ err_exit:
	/* turn off slot, turn on Amber LED, turn off Green LED */		/* turn off slot, turn on Amber LED, turn off Green LED */
	rc = p_slot->hpc_ops->slot_disable(p_slot);		rc = p_slot->hpc_ops->slot_disable(p_slot);
	if (rc) {		if (rc) {
	err("%s: Issue of Slot Disable command failed\n", __func__);		ctrl_err(ctrl, "%s: Issue of Slot Disable command failed\n",
			__func__);
	return rc;		return rc;
	}		}

	@@ -365,7 +373,7 @@ static int remove_board(struct slot *p_slot)
	hp_slot = p_slot->device - ctrl->slot_device_offset;		hp_slot = p_slot->device - ctrl->slot_device_offset;
	p_slot = shpchp_find_slot(ctrl, hp_slot + ctrl->slot_device_offset);		p_slot = shpchp_find_slot(ctrl, hp_slot + ctrl->slot_device_offset);

	dbg("In %s, hp_slot = %d\n", __func__, hp_slot);		ctrl_dbg(ctrl, "In %s, hp_slot = %d\n", __func__, hp_slot);

	/* Change status to shutdown */		/* Change status to shutdown */
	if (p_slot->is_a_board)		if (p_slot->is_a_board)
	@@ -374,13 +382,15 @@ static int remove_board(struct slot *p_slot)
	/* turn off slot, turn on Amber LED, turn off Green LED */		/* turn off slot, turn on Amber LED, turn off Green LED */
	rc = p_slot->hpc_ops->slot_disable(p_slot);		rc = p_slot->hpc_ops->slot_disable(p_slot);
	if (rc) {		if (rc) {
	err("%s: Issue of Slot Disable command failed\n", __func__);		ctrl_err(ctrl, "%s: Issue of Slot Disable command failed\n",
			__func__);
	return rc;		return rc;
	}		}

	rc = p_slot->hpc_ops->set_attention_status(p_slot, 0);		rc = p_slot->hpc_ops->set_attention_status(p_slot, 0);
	if (rc) {		if (rc) {
	err("%s: Issue of Set Attention command failed\n", __func__);		ctrl_err(ctrl, "%s: Issue of Set Attention command failed\n",
			__func__);
	return rc;		return rc;
	}		}

	@@ -439,7 +449,8 @@ void shpchp_queue_pushbutton_work(struct work_struct *work)

	info = kmalloc(sizeof(*info), GFP_KERNEL);		info = kmalloc(sizeof(*info), GFP_KERNEL);
	if (!info) {		if (!info) {
	err("%s: Cannot allocate memory\n", __func__);		ctrl_err(p_slot->ctrl, "%s: Cannot allocate memory\n",
			__func__);
	return;		return;
	}		}
	info->p_slot = p_slot;		info->p_slot = p_slot;
	@@ -486,18 +497,19 @@ static int update_slot_info (struct slot *slot)
	static void handle_button_press_event(struct slot *p_slot)		static void handle_button_press_event(struct slot *p_slot)
	{		{
	u8 getstatus;		u8 getstatus;
			struct controller *ctrl = p_slot->ctrl;

	switch (p_slot->state) {		switch (p_slot->state) {
	case STATIC_STATE:		case STATIC_STATE:
	p_slot->hpc_ops->get_power_status(p_slot, &getstatus);		p_slot->hpc_ops->get_power_status(p_slot, &getstatus);
	if (getstatus) {		if (getstatus) {
	p_slot->state = BLINKINGOFF_STATE;		p_slot->state = BLINKINGOFF_STATE;
	info("PCI slot #%s - powering off due to button "		ctrl_info(ctrl, "PCI slot #%s - powering off due to "
	"press.\n", slot_name(p_slot));		"button press.\n", slot_name(p_slot));
	} else {		} else {
	p_slot->state = BLINKINGON_STATE;		p_slot->state = BLINKINGON_STATE;
	info("PCI slot #%s - powering on due to button "		ctrl_info(ctrl, "PCI slot #%s - powering on due to "
	"press.\n", slot_name(p_slot));		"button press.\n", slot_name(p_slot));
	}		}
	/* blink green LED and turn off amber */		/* blink green LED and turn off amber */
	p_slot->hpc_ops->green_led_blink(p_slot);		p_slot->hpc_ops->green_led_blink(p_slot);
	@@ -512,16 +524,17 @@ static void handle_button_press_event(struct slot *p_slot)
	* press the attention again before the 5 sec. limit		* press the attention again before the 5 sec. limit
	* expires to cancel hot-add or hot-remove		* expires to cancel hot-add or hot-remove
	*/		*/
	info("Button cancel on Slot(%s)\n", slot_name(p_slot));		ctrl_info(ctrl, "Button cancel on Slot(%s)\n",
	dbg("%s: button cancel\n", __func__);		slot_name(p_slot));
			ctrl_dbg(ctrl, "%s: button cancel\n", __func__);
	cancel_delayed_work(&p_slot->work);		cancel_delayed_work(&p_slot->work);
	if (p_slot->state == BLINKINGOFF_STATE)		if (p_slot->state == BLINKINGOFF_STATE)
	p_slot->hpc_ops->green_led_on(p_slot);		p_slot->hpc_ops->green_led_on(p_slot);
	else		else
	p_slot->hpc_ops->green_led_off(p_slot);		p_slot->hpc_ops->green_led_off(p_slot);
	p_slot->hpc_ops->set_attention_status(p_slot, 0);		p_slot->hpc_ops->set_attention_status(p_slot, 0);
	info("PCI slot #%s - action canceled due to button press\n",		ctrl_info(ctrl, "PCI slot #%s - action canceled due to "
	slot_name(p_slot));		"button press\n", slot_name(p_slot));
	p_slot->state = STATIC_STATE;		p_slot->state = STATIC_STATE;
	break;		break;
	case POWEROFF_STATE:		case POWEROFF_STATE:
	@@ -531,11 +544,12 @@ static void handle_button_press_event(struct slot *p_slot)
	* this means that the previous attention button action		* this means that the previous attention button action
	* to hot-add or hot-remove is undergoing		* to hot-add or hot-remove is undergoing
	*/		*/
	info("Button ignore on Slot(%s)\n", slot_name(p_slot));		ctrl_info(ctrl, "Button ignore on Slot(%s)\n",
			slot_name(p_slot));
	update_slot_info(p_slot);		update_slot_info(p_slot);
	break;		break;
	default:		default:
	warn("Not a valid state\n");		ctrl_warn(ctrl, "Not a valid state\n");
	break;		break;
	}		}
	}		}
	@@ -551,7 +565,7 @@ static void interrupt_event_handler(struct work_struct *work)
	handle_button_press_event(p_slot);		handle_button_press_event(p_slot);
	break;		break;
	case INT_POWER_FAULT:		case INT_POWER_FAULT:
	dbg("%s: power fault\n", __func__);		ctrl_dbg(p_slot->ctrl, "%s: power fault\n", __func__);
	p_slot->hpc_ops->set_attention_status(p_slot, 1);		p_slot->hpc_ops->set_attention_status(p_slot, 1);
	p_slot->hpc_ops->green_led_off(p_slot);		p_slot->hpc_ops->green_led_off(p_slot);
	break;		break;
	@@ -569,22 +583,24 @@ static int shpchp_enable_slot (struct slot *p_slot)
	{		{
	u8 getstatus = 0;		u8 getstatus = 0;
	int rc, retval = -ENODEV;		int rc, retval = -ENODEV;
			struct controller *ctrl = p_slot->ctrl;

	/* Check to see if (latch closed, card present, power off) */		/* Check to see if (latch closed, card present, power off) */
	mutex_lock(&p_slot->ctrl->crit_sect);		mutex_lock(&p_slot->ctrl->crit_sect);
	rc = p_slot->hpc_ops->get_adapter_status(p_slot, &getstatus);		rc = p_slot->hpc_ops->get_adapter_status(p_slot, &getstatus);
	if (rc \|\| !getstatus) {		if (rc \|\| !getstatus) {
	info("No adapter on slot(%s)\n", slot_name(p_slot));		ctrl_info(ctrl, "No adapter on slot(%s)\n", slot_name(p_slot));
	goto out;		goto out;
	}		}
	rc = p_slot->hpc_ops->get_latch_status(p_slot, &getstatus);		rc = p_slot->hpc_ops->get_latch_status(p_slot, &getstatus);
	if (rc \|\| getstatus) {		if (rc \|\| getstatus) {
	info("Latch open on slot(%s)\n", slot_name(p_slot));		ctrl_info(ctrl, "Latch open on slot(%s)\n", slot_name(p_slot));
	goto out;		goto out;
	}		}
	rc = p_slot->hpc_ops->get_power_status(p_slot, &getstatus);		rc = p_slot->hpc_ops->get_power_status(p_slot, &getstatus);
	if (rc \|\| getstatus) {		if (rc \|\| getstatus) {
	info("Already enabled on slot(%s)\n", slot_name(p_slot));		ctrl_info(ctrl, "Already enabled on slot(%s)\n",
			slot_name(p_slot));
	goto out;		goto out;
	}		}

	@@ -593,7 +609,7 @@ static int shpchp_enable_slot (struct slot *p_slot)
	/* We have to save the presence info for these slots */		/* We have to save the presence info for these slots */
	p_slot->hpc_ops->get_adapter_status(p_slot, &(p_slot->presence_save));		p_slot->hpc_ops->get_adapter_status(p_slot, &(p_slot->presence_save));
	p_slot->hpc_ops->get_power_status(p_slot, &(p_slot->pwr_save));		p_slot->hpc_ops->get_power_status(p_slot, &(p_slot->pwr_save));
	dbg("%s: p_slot->pwr_save %x\n", __func__, p_slot->pwr_save);		ctrl_dbg(ctrl, "%s: p_slot->pwr_save %x\n", __func__, p_slot->pwr_save);
	p_slot->hpc_ops->get_latch_status(p_slot, &getstatus);		p_slot->hpc_ops->get_latch_status(p_slot, &getstatus);

	if(((p_slot->ctrl->pci_dev->vendor == PCI_VENDOR_ID_AMD) \|\|		if(((p_slot->ctrl->pci_dev->vendor == PCI_VENDOR_ID_AMD) \|\|
	@@ -624,6 +640,7 @@ static int shpchp_disable_slot (struct slot *p_slot)
	{		{
	u8 getstatus = 0;		u8 getstatus = 0;
	int rc, retval = -ENODEV;		int rc, retval = -ENODEV;
			struct controller *ctrl = p_slot->ctrl;

	if (!p_slot->ctrl)		if (!p_slot->ctrl)
	return -ENODEV;		return -ENODEV;
	@@ -633,17 +650,18 @@ static int shpchp_disable_slot (struct slot *p_slot)

	rc = p_slot->hpc_ops->get_adapter_status(p_slot, &getstatus);		rc = p_slot->hpc_ops->get_adapter_status(p_slot, &getstatus);
	if (rc \|\| !getstatus) {		if (rc \|\| !getstatus) {
	info("No adapter on slot(%s)\n", slot_name(p_slot));		ctrl_info(ctrl, "No adapter on slot(%s)\n", slot_name(p_slot));
	goto out;		goto out;
	}		}
	rc = p_slot->hpc_ops->get_latch_status(p_slot, &getstatus);		rc = p_slot->hpc_ops->get_latch_status(p_slot, &getstatus);
	if (rc \|\| getstatus) {		if (rc \|\| getstatus) {
	info("Latch open on slot(%s)\n", slot_name(p_slot));		ctrl_info(ctrl, "Latch open on slot(%s)\n", slot_name(p_slot));
	goto out;		goto out;
	}		}
	rc = p_slot->hpc_ops->get_power_status(p_slot, &getstatus);		rc = p_slot->hpc_ops->get_power_status(p_slot, &getstatus);
	if (rc \|\| !getstatus) {		if (rc \|\| !getstatus) {
	info("Already disabled slot(%s)\n", slot_name(p_slot));		ctrl_info(ctrl, "Already disabled slot(%s)\n",
			slot_name(p_slot));
	goto out;		goto out;
	}		}

	@@ -657,6 +675,7 @@ static int shpchp_disable_slot (struct slot *p_slot)
	int shpchp_sysfs_enable_slot(struct slot *p_slot)		int shpchp_sysfs_enable_slot(struct slot *p_slot)
	{		{
	int retval = -ENODEV;		int retval = -ENODEV;
			struct controller *ctrl = p_slot->ctrl;

	mutex_lock(&p_slot->lock);		mutex_lock(&p_slot->lock);
	switch (p_slot->state) {		switch (p_slot->state) {
	@@ -670,15 +689,17 @@ int shpchp_sysfs_enable_slot(struct slot *p_slot)
	p_slot->state = STATIC_STATE;		p_slot->state = STATIC_STATE;
	break;		break;
	case POWERON_STATE:		case POWERON_STATE:
	info("Slot %s is already in powering on state\n",		ctrl_info(ctrl, "Slot %s is already in powering on state\n",
	slot_name(p_slot));		slot_name(p_slot));
	break;		break;
	case BLINKINGOFF_STATE:		case BLINKINGOFF_STATE:
	case POWEROFF_STATE:		case POWEROFF_STATE:
	info("Already enabled on slot %s\n", slot_name(p_slot));		ctrl_info(ctrl, "Already enabled on slot %s\n",
			slot_name(p_slot));
	break;		break;
	default:		default:
	err("Not a valid state on slot %s\n", slot_name(p_slot));		ctrl_err(ctrl, "Not a valid state on slot %s\n",
			slot_name(p_slot));
	break;		break;
	}		}
	mutex_unlock(&p_slot->lock);		mutex_unlock(&p_slot->lock);
	@@ -689,6 +710,7 @@ int shpchp_sysfs_enable_slot(struct slot *p_slot)
	int shpchp_sysfs_disable_slot(struct slot *p_slot)		int shpchp_sysfs_disable_slot(struct slot *p_slot)
	{		{
	int retval = -ENODEV;		int retval = -ENODEV;
			struct controller *ctrl = p_slot->ctrl;

	mutex_lock(&p_slot->lock);		mutex_lock(&p_slot->lock);
	switch (p_slot->state) {		switch (p_slot->state) {
	@@ -702,15 +724,17 @@ int shpchp_sysfs_disable_slot(struct slot *p_slot)
	p_slot->state = STATIC_STATE;		p_slot->state = STATIC_STATE;
	break;		break;
	case POWEROFF_STATE:		case POWEROFF_STATE:
	info("Slot %s is already in powering off state\n",		ctrl_info(ctrl, "Slot %s is already in powering off state\n",
	slot_name(p_slot));		slot_name(p_slot));
	break;		break;
	case BLINKINGON_STATE:		case BLINKINGON_STATE:
	case POWERON_STATE:		case POWERON_STATE:
	info("Already disabled on slot %s\n", slot_name(p_slot));		ctrl_info(ctrl, "Already disabled on slot %s\n",
			slot_name(p_slot));
	break;		break;
	default:		default:
	err("Not a valid state on slot %s\n", slot_name(p_slot));		ctrl_err(ctrl, "Not a valid state on slot %s\n",
			slot_name(p_slot));
	break;		break;
	}		}
	mutex_unlock(&p_slot->lock);		mutex_unlock(&p_slot->lock);

drivers/pci/hotplug/shpchp_hpc.c

+64 −56

File changed.

Preview size limit exceeded, changes collapsed.

drivers/pci/hotplug/shpchp_pci.c

+19 −13

Original line number	Original line	Diff line number	Diff line
	@@ -101,10 +101,12 @@ int __ref shpchp_configure_device(struct slot *p_slot)
	struct pci_dev *dev;		struct pci_dev *dev;
	struct pci_bus *parent = p_slot->ctrl->pci_dev->subordinate;		struct pci_bus *parent = p_slot->ctrl->pci_dev->subordinate;
	int num, fn;		int num, fn;
			struct controller *ctrl = p_slot->ctrl;

	dev = pci_get_slot(parent, PCI_DEVFN(p_slot->device, 0));		dev = pci_get_slot(parent, PCI_DEVFN(p_slot->device, 0));
	if (dev) {		if (dev) {
	err("Device %s already exists at %x:%x, cannot hot-add\n",		ctrl_err(ctrl,
			"Device %s already exists at %x:%x, cannot hot-add\n",
	pci_name(dev), p_slot->bus, p_slot->device);		pci_name(dev), p_slot->bus, p_slot->device);
	pci_dev_put(dev);		pci_dev_put(dev);
	return -EINVAL;		return -EINVAL;
	@@ -112,7 +114,7 @@ int __ref shpchp_configure_device(struct slot *p_slot)

	num = pci_scan_slot(parent, PCI_DEVFN(p_slot->device, 0));		num = pci_scan_slot(parent, PCI_DEVFN(p_slot->device, 0));
	if (num == 0) {		if (num == 0) {
	err("No new device found\n");		ctrl_err(ctrl, "No new device found\n");
	return -ENODEV;		return -ENODEV;
	}		}

	@@ -121,7 +123,7 @@ int __ref shpchp_configure_device(struct slot *p_slot)
	if (!dev)		if (!dev)
	continue;		continue;
	if ((dev->class >> 16) == PCI_BASE_CLASS_DISPLAY) {		if ((dev->class >> 16) == PCI_BASE_CLASS_DISPLAY) {
	err("Cannot hot-add display device %s\n",		ctrl_err(ctrl, "Cannot hot-add display device %s\n",
	pci_name(dev));		pci_name(dev));
	pci_dev_put(dev);		pci_dev_put(dev);
	continue;		continue;
	@@ -138,13 +140,14 @@ int __ref shpchp_configure_device(struct slot *p_slot)
	break;		break;
	}		}
	if (busnr >= end) {		if (busnr >= end) {
	err("No free bus for hot-added bridge\n");		ctrl_err(ctrl,
			"No free bus for hot-added bridge\n");
	pci_dev_put(dev);		pci_dev_put(dev);
	continue;		continue;
	}		}
	child = pci_add_new_bus(parent, dev, busnr);		child = pci_add_new_bus(parent, dev, busnr);
	if (!child) {		if (!child) {
	err("Cannot add new bus for %s\n",		ctrl_err(ctrl, "Cannot add new bus for %s\n",
	pci_name(dev));		pci_name(dev));
	pci_dev_put(dev);		pci_dev_put(dev);
	continue;		continue;
	@@ -168,8 +171,10 @@ int shpchp_unconfigure_device(struct slot *p_slot)
	int j;		int j;
	u8 bctl = 0;		u8 bctl = 0;
	struct pci_bus *parent = p_slot->ctrl->pci_dev->subordinate;		struct pci_bus *parent = p_slot->ctrl->pci_dev->subordinate;
			struct controller *ctrl = p_slot->ctrl;

	dbg("%s: bus/dev = %x/%x\n", __func__, p_slot->bus, p_slot->device);		ctrl_dbg(ctrl, "%s: bus/dev = %x/%x\n",
			__func__, p_slot->bus, p_slot->device);

	for (j=0; j<8 ; j++) {		for (j=0; j<8 ; j++) {
	struct pci_dev* temp = pci_get_slot(parent,		struct pci_dev* temp = pci_get_slot(parent,
	@@ -177,7 +182,7 @@ int shpchp_unconfigure_device(struct slot *p_slot)
	if (!temp)		if (!temp)
	continue;		continue;
	if ((temp->class >> 16) == PCI_BASE_CLASS_DISPLAY) {		if ((temp->class >> 16) == PCI_BASE_CLASS_DISPLAY) {
	err("Cannot remove display device %s\n",		ctrl_err(ctrl, "Cannot remove display device %s\n",
	pci_name(temp));		pci_name(temp));
	pci_dev_put(temp);		pci_dev_put(temp);
	continue;		continue;
	@@ -185,7 +190,8 @@ int shpchp_unconfigure_device(struct slot *p_slot)
	if (temp->hdr_type == PCI_HEADER_TYPE_BRIDGE) {		if (temp->hdr_type == PCI_HEADER_TYPE_BRIDGE) {
	pci_read_config_byte(temp, PCI_BRIDGE_CONTROL, &bctl);		pci_read_config_byte(temp, PCI_BRIDGE_CONTROL, &bctl);
	if (bctl & PCI_BRIDGE_CTL_VGA) {		if (bctl & PCI_BRIDGE_CTL_VGA) {
	err("Cannot remove display device %s\n",		ctrl_err(ctrl,
			"Cannot remove display device %s\n",
	pci_name(temp));		pci_name(temp));
	pci_dev_put(temp);		pci_dev_put(temp);
	continue;		continue;