2018-01-26 20:22:04 +00:00
|
|
|
/* SPDX-License-Identifier: GPL-2.0+ */
|
2005-04-16 22:20:36 +00:00
|
|
|
/*
|
|
|
|
|
* PCI Express Hot Plug Controller Driver
|
|
|
|
|
*
|
|
|
|
|
* Copyright (C) 1995,2001 Compaq Computer Corporation
|
|
|
|
|
* Copyright (C) 2001 Greg Kroah-Hartman (greg@kroah.com)
|
|
|
|
|
* Copyright (C) 2001 IBM Corp.
|
|
|
|
|
* Copyright (C) 2003-2004 Intel Corporation
|
|
|
|
|
*
|
|
|
|
|
* All rights reserved.
|
|
|
|
|
*
|
2005-08-16 22:16:10 +00:00
|
|
|
* Send feedback to <greg@kroah.com>, <kristen.c.accardi@intel.com>
|
2005-04-16 22:20:36 +00:00
|
|
|
*
|
|
|
|
|
*/
|
|
|
|
|
#ifndef _PCIEHP_H
|
|
|
|
|
#define _PCIEHP_H
|
|
|
|
|
|
|
|
|
|
#include <linux/types.h>
|
|
|
|
|
#include <linux/pci.h>
|
2006-10-14 03:05:19 +00:00
|
|
|
#include <linux/pci_hotplug.h>
|
2005-04-16 22:20:36 +00:00
|
|
|
#include <linux/delay.h>
|
2017-02-02 18:15:33 +00:00
|
|
|
#include <linux/sched/signal.h> /* signal_pending() */
|
2006-01-13 15:02:15 +00:00
|
|
|
#include <linux/mutex.h>
|
2018-07-28 05:18:00 +00:00
|
|
|
#include <linux/rwsem.h>
|
2010-10-18 06:31:02 +00:00
|
|
|
#include <linux/workqueue.h>
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2018-03-09 17:42:01 +00:00
|
|
|
#include "../pcie/portdrv.h"
|
2018-02-14 03:52:18 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
#define MY_NAME "pciehp"
|
|
|
|
|
|
2012-01-12 23:02:20 +00:00
|
|
|
extern bool pciehp_poll_mode;
|
2005-04-16 22:20:36 +00:00
|
|
|
extern int pciehp_poll_time;
|
2012-01-12 23:02:20 +00:00
|
|
|
extern bool pciehp_debug;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2006-12-22 01:01:07 +00:00
|
|
|
#define dbg(format, arg...) \
|
2009-02-06 09:23:36 +00:00
|
|
|
do { \
|
|
|
|
|
if (pciehp_debug) \
|
2015-12-27 21:21:11 +00:00
|
|
|
printk(KERN_DEBUG "%s: " format, MY_NAME, ## arg); \
|
2009-02-06 09:23:36 +00:00
|
|
|
} while (0)
|
2006-12-22 01:01:07 +00:00
|
|
|
#define err(format, arg...) \
|
2015-12-27 21:21:11 +00:00
|
|
|
printk(KERN_ERR "%s: " format, MY_NAME, ## arg)
|
2006-12-22 01:01:07 +00:00
|
|
|
#define info(format, arg...) \
|
2015-12-27 21:21:11 +00:00
|
|
|
printk(KERN_INFO "%s: " format, MY_NAME, ## arg)
|
2006-12-22 01:01:07 +00:00
|
|
|
#define warn(format, arg...) \
|
2015-12-27 21:21:11 +00:00
|
|
|
printk(KERN_WARNING "%s: " format, MY_NAME, ## arg)
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2008-09-05 03:11:26 +00:00
|
|
|
#define ctrl_dbg(ctrl, format, arg...) \
|
|
|
|
|
do { \
|
|
|
|
|
if (pciehp_debug) \
|
2009-02-06 09:23:36 +00:00
|
|
|
dev_printk(KERN_DEBUG, &ctrl->pcie->device, \
|
2008-09-05 03:11:26 +00:00
|
|
|
format, ## arg); \
|
|
|
|
|
} while (0)
|
|
|
|
|
#define ctrl_err(ctrl, format, arg...) \
|
|
|
|
|
dev_err(&ctrl->pcie->device, format, ## arg)
|
|
|
|
|
#define ctrl_info(ctrl, format, arg...) \
|
|
|
|
|
dev_info(&ctrl->pcie->device, format, ## arg)
|
|
|
|
|
#define ctrl_warn(ctrl, format, arg...) \
|
|
|
|
|
dev_warn(&ctrl->pcie->device, format, ## arg)
|
|
|
|
|
|
2006-12-22 01:01:02 +00:00
|
|
|
#define SLOT_NAME_SIZE 10
|
2018-07-19 22:27:36 +00:00
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* struct slot - PCIe hotplug slot
|
|
|
|
|
* @state: current state machine position
|
|
|
|
|
* @ctrl: pointer to the slot's controller structure
|
|
|
|
|
* @hotplug_slot: pointer to the structure registered with the PCI hotplug core
|
|
|
|
|
* @work: work item to turn the slot on or off after 5 seconds in response to
|
|
|
|
|
* an Attention Button press
|
|
|
|
|
* @lock: protects reads and writes of @state;
|
|
|
|
|
* protects scheduling, execution and cancellation of @work
|
|
|
|
|
*/
|
2005-04-16 22:20:36 +00:00
|
|
|
struct slot {
|
|
|
|
|
u8 state;
|
|
|
|
|
struct controller *ctrl;
|
|
|
|
|
struct hotplug_slot *hotplug_slot;
|
2018-07-19 22:27:36 +00:00
|
|
|
struct delayed_work work;
|
2007-03-06 23:02:26 +00:00
|
|
|
struct mutex lock;
|
2005-04-16 22:20:36 +00:00
|
|
|
};
|
|
|
|
|
|
2018-07-19 22:27:36 +00:00
|
|
|
/**
|
|
|
|
|
* struct controller - PCIe hotplug controller
|
|
|
|
|
* @ctrl_lock: serializes writes to the Slot Control register
|
|
|
|
|
* @pcie: pointer to the controller's PCIe port service device
|
2018-07-28 05:18:00 +00:00
|
|
|
* @reset_lock: prevents access to the Data Link Layer Link Active bit in the
|
|
|
|
|
* Link Status register and to the Presence Detect State bit in the Slot
|
|
|
|
|
* Status register during a slot reset which may cause them to flap
|
2018-07-19 22:27:36 +00:00
|
|
|
* @slot: pointer to the controller's slot structure
|
|
|
|
|
* @queue: wait queue to wake up on reception of a Command Completed event,
|
|
|
|
|
* used for synchronous writes to the Slot Control register
|
|
|
|
|
* @slot_cap: cached copy of the Slot Capabilities register
|
|
|
|
|
* @slot_ctrl: cached copy of the Slot Control register
|
2018-07-19 22:27:39 +00:00
|
|
|
* @poll_thread: thread to poll for slot events if no IRQ is available,
|
2018-07-19 22:27:36 +00:00
|
|
|
* enabled with pciehp_poll_mode module parameter
|
|
|
|
|
* @cmd_started: jiffies when the Slot Control register was last written;
|
|
|
|
|
* the next write is allowed 1 second later, absent a Command Completed
|
|
|
|
|
* interrupt (PCIe r4.0, sec 6.7.3.2)
|
|
|
|
|
* @cmd_busy: flag set on Slot Control register write, cleared by IRQ handler
|
|
|
|
|
* on reception of a Command Completed event
|
|
|
|
|
* @link_active_reporting: cached copy of Data Link Layer Link Active Reporting
|
|
|
|
|
* Capable bit in Link Capabilities register; if this bit is zero, the
|
|
|
|
|
* Data Link Layer Link Active bit in the Link Status register will never
|
|
|
|
|
* be set and the driver is thus confined to wait 1 second before assuming
|
|
|
|
|
* the link to a hotplugged device is up and accessing it
|
|
|
|
|
* @notification_enabled: whether the IRQ was requested successfully
|
|
|
|
|
* @power_fault_detected: whether a power fault was detected by the hardware
|
|
|
|
|
* that has not yet been cleared by the user
|
PCI: pciehp: Convert to threaded IRQ
pciehp's IRQ handler queues up a work item for each event signaled by
the hardware. A more modern alternative is to let a long running
kthread service the events. The IRQ handler's sole job is then to check
whether the IRQ originated from the device in question, acknowledge its
receipt to the hardware to quiesce the interrupt and wake up the kthread.
One benefit is reduced latency to handle the IRQ, which is a necessity
for realtime environments. Another benefit is that we can make pciehp
simpler and more robust by handling events synchronously in process
context, rather than asynchronously by queueing up work items. pciehp's
usage of work items is a historic artifact, it predates the introduction
of threaded IRQ handlers by two years. (The former was introduced in
2007 with commit 5d386e1ac402 ("pciehp: Event handling rework"), the
latter in 2009 with commit 3aa551c9b4c4 ("genirq: add threaded interrupt
handler support").)
Convert pciehp to threaded IRQ handling by retrieving the pending events
in pciehp_isr(), saving them for later consumption by the thread handler
pciehp_ist() and clearing them in the Slot Status register.
By clearing the Slot Status (and thereby acknowledging the events) in
pciehp_isr(), we can avoid requesting the IRQ with IRQF_ONESHOT, which
would have the unpleasant side effect of starving devices sharing the
IRQ until pciehp_ist() has finished.
pciehp_isr() does not count how many times each event occurred, but
merely records the fact *that* an event occurred. If the same event
occurs a second time before pciehp_ist() is woken, that second event
will not be recorded separately, which is problematic according to
commit fad214b0aa72 ("PCI: pciehp: Process all hotplug events before
looking for new ones") because we may miss removal of a card in-between
two back-to-back insertions. We're about to make pciehp_ist() resilient
to missed events. The present commit regresses the driver's behavior
temporarily in order to separate the changes into reviewable chunks.
This doesn't affect regular slow-motion hotplug, only plug-unplug-plug
operations that happen in a timespan shorter than wakeup of the IRQ
thread.
Signed-off-by: Lukas Wunner <lukas@wunner.de>
Signed-off-by: Bjorn Helgaas <bhelgaas@google.com>
Cc: Thomas Gleixner <tglx@linutronix.de>
Cc: Mayurkumar Patel <mayurkumar.patel@intel.com>
Cc: Kenji Kaneshige <kaneshige.kenji@jp.fujitsu.com>
2018-07-19 22:27:38 +00:00
|
|
|
* @pending_events: used by the IRQ handler to save events retrieved from the
|
|
|
|
|
* Slot Status register for later consumption by the IRQ thread
|
PCI: pciehp: Enable/disable exclusively from IRQ thread
Besides the IRQ thread, there are several other places in the driver
which enable or disable the slot:
- pciehp_probe() enables the slot if it's occupied and the pciehp_force
module parameter is used.
- pciehp_resume() enables or disables the slot after system sleep.
- pciehp_queue_pushbutton_work() enables or disables the slot after the
5 second delay following an Attention Button press.
- pciehp_sysfs_enable_slot() and pciehp_sysfs_disable_slot() enable or
disable the slot on sysfs write.
This requires locking and complicates pciehp's state machine.
A simplification can be achieved by enabling and disabling the slot
exclusively from the IRQ thread.
Amend the functions listed above to request slot enable/disablement from
the IRQ thread by either synthesizing a Presence Detect Changed event or,
in the case of a disable user request (via sysfs or an Attention Button
press), submitting a newly introduced force disable request. The latter
is needed because the slot shall be forced off despite being occupied.
For this force disable request, avoid colliding with Slot Status register
bits by using a bit number greater than 16.
For synchronous execution of requests (on sysfs write), wait for the
request to finish and retrieve the result. There can only ever be one
sysfs write in flight due to the locking in kernfs_fop_write(), hence
there is no risk of returning the result of a different sysfs request to
user space.
The POWERON_STATE and POWEROFF_STATE is now no longer entered by the
above-listed functions, but solely by the IRQ thread when it begins a
power transition. Afterwards, it moves to STATIC_STATE. The same
applies to canceling the Attention Button work, it likewise becomes an
IRQ thread only operation.
An immediate consequence is that the POWERON_STATE and POWEROFF_STATE is
never observed by the IRQ thread itself, only by functions called in a
different context, such as pciehp_sysfs_enable_slot(). So remove
handling of these states from pciehp_handle_button_press() and
pciehp_handle_link_change() which are exclusively called from the IRQ
thread.
Signed-off-by: Lukas Wunner <lukas@wunner.de>
Signed-off-by: Bjorn Helgaas <bhelgaas@google.com>
2018-07-19 22:27:46 +00:00
|
|
|
* @request_result: result of last user request submitted to the IRQ thread
|
|
|
|
|
* @requester: wait queue to wake up on completion of user request,
|
|
|
|
|
* used for synchronous slot enable/disable request via sysfs
|
2018-07-19 22:27:36 +00:00
|
|
|
*/
|
2005-04-16 22:20:36 +00:00
|
|
|
struct controller {
|
2018-07-19 22:27:36 +00:00
|
|
|
struct mutex ctrl_lock;
|
|
|
|
|
struct pcie_device *pcie;
|
2018-07-28 05:18:00 +00:00
|
|
|
struct rw_semaphore reset_lock;
|
2009-09-15 08:24:46 +00:00
|
|
|
struct slot *slot;
|
2018-07-19 22:27:36 +00:00
|
|
|
wait_queue_head_t queue;
|
2008-04-25 21:39:06 +00:00
|
|
|
u32 slot_cap;
|
2014-08-15 23:18:44 +00:00
|
|
|
u16 slot_ctrl;
|
2018-07-19 22:27:39 +00:00
|
|
|
struct task_struct *poll_thread;
|
PCI: pciehp: Compute timeout from hotplug command start time
If we issue a hotplug command, go do something else, then come back and
wait for the command to complete, we don't have to wait the whole timeout
period, because some of it elapsed while we were doing something else.
Keep track of the time we issued the command, and wait only until the
timeout period from that point has elapsed.
For controllers with errata like Intel CF118, we previously timed out
before issuing the second hotplug command:
At time T1 (during boot):
- Write DLLSCE, ABPE, PDCE, etc. to Slot Control
At time T2 (hotplug event):
- Wait for command completion (CC) in Slot Status
- Timeout at T2 + 1 second because CC is never set in Slot Status
- Write PCC, PIC, etc. to Slot Control
With this change, we wait until T1 + 1 second instead of T2 + 1 second.
If the hotplug event is more than 1 second after the boot-time
initialization, we won't wait for the timeout at all.
We still emit a "Timeout on hotplug command" message if it timed out; we
should see this on the first hotplug event on every controller with this
erratum, as well as on real errors on controllers without the erratum.
Link: http://www.intel.com/content/www/us/en/processors/xeon/xeon-e7-v2-spec-update.html
Tested-by: Rajat Jain <rajatxjain@gmail.com> (IDT 807a controller)
Signed-off-by: Bjorn Helgaas <bhelgaas@google.com>
Acked-by: Yinghai Lu <yinghai@kernel.org>
2014-06-14 15:55:49 +00:00
|
|
|
unsigned long cmd_started; /* jiffies */
|
2009-02-03 06:06:18 +00:00
|
|
|
unsigned int cmd_busy:1;
|
2008-10-22 05:31:44 +00:00
|
|
|
unsigned int link_active_reporting:1;
|
2009-01-29 03:31:18 +00:00
|
|
|
unsigned int notification_enabled:1;
|
2009-02-03 06:06:16 +00:00
|
|
|
unsigned int power_fault_detected;
|
PCI: pciehp: Convert to threaded IRQ
pciehp's IRQ handler queues up a work item for each event signaled by
the hardware. A more modern alternative is to let a long running
kthread service the events. The IRQ handler's sole job is then to check
whether the IRQ originated from the device in question, acknowledge its
receipt to the hardware to quiesce the interrupt and wake up the kthread.
One benefit is reduced latency to handle the IRQ, which is a necessity
for realtime environments. Another benefit is that we can make pciehp
simpler and more robust by handling events synchronously in process
context, rather than asynchronously by queueing up work items. pciehp's
usage of work items is a historic artifact, it predates the introduction
of threaded IRQ handlers by two years. (The former was introduced in
2007 with commit 5d386e1ac402 ("pciehp: Event handling rework"), the
latter in 2009 with commit 3aa551c9b4c4 ("genirq: add threaded interrupt
handler support").)
Convert pciehp to threaded IRQ handling by retrieving the pending events
in pciehp_isr(), saving them for later consumption by the thread handler
pciehp_ist() and clearing them in the Slot Status register.
By clearing the Slot Status (and thereby acknowledging the events) in
pciehp_isr(), we can avoid requesting the IRQ with IRQF_ONESHOT, which
would have the unpleasant side effect of starving devices sharing the
IRQ until pciehp_ist() has finished.
pciehp_isr() does not count how many times each event occurred, but
merely records the fact *that* an event occurred. If the same event
occurs a second time before pciehp_ist() is woken, that second event
will not be recorded separately, which is problematic according to
commit fad214b0aa72 ("PCI: pciehp: Process all hotplug events before
looking for new ones") because we may miss removal of a card in-between
two back-to-back insertions. We're about to make pciehp_ist() resilient
to missed events. The present commit regresses the driver's behavior
temporarily in order to separate the changes into reviewable chunks.
This doesn't affect regular slow-motion hotplug, only plug-unplug-plug
operations that happen in a timespan shorter than wakeup of the IRQ
thread.
Signed-off-by: Lukas Wunner <lukas@wunner.de>
Signed-off-by: Bjorn Helgaas <bhelgaas@google.com>
Cc: Thomas Gleixner <tglx@linutronix.de>
Cc: Mayurkumar Patel <mayurkumar.patel@intel.com>
Cc: Kenji Kaneshige <kaneshige.kenji@jp.fujitsu.com>
2018-07-19 22:27:38 +00:00
|
|
|
atomic_t pending_events;
|
PCI: pciehp: Enable/disable exclusively from IRQ thread
Besides the IRQ thread, there are several other places in the driver
which enable or disable the slot:
- pciehp_probe() enables the slot if it's occupied and the pciehp_force
module parameter is used.
- pciehp_resume() enables or disables the slot after system sleep.
- pciehp_queue_pushbutton_work() enables or disables the slot after the
5 second delay following an Attention Button press.
- pciehp_sysfs_enable_slot() and pciehp_sysfs_disable_slot() enable or
disable the slot on sysfs write.
This requires locking and complicates pciehp's state machine.
A simplification can be achieved by enabling and disabling the slot
exclusively from the IRQ thread.
Amend the functions listed above to request slot enable/disablement from
the IRQ thread by either synthesizing a Presence Detect Changed event or,
in the case of a disable user request (via sysfs or an Attention Button
press), submitting a newly introduced force disable request. The latter
is needed because the slot shall be forced off despite being occupied.
For this force disable request, avoid colliding with Slot Status register
bits by using a bit number greater than 16.
For synchronous execution of requests (on sysfs write), wait for the
request to finish and retrieve the result. There can only ever be one
sysfs write in flight due to the locking in kernfs_fop_write(), hence
there is no risk of returning the result of a different sysfs request to
user space.
The POWERON_STATE and POWEROFF_STATE is now no longer entered by the
above-listed functions, but solely by the IRQ thread when it begins a
power transition. Afterwards, it moves to STATIC_STATE. The same
applies to canceling the Attention Button work, it likewise becomes an
IRQ thread only operation.
An immediate consequence is that the POWERON_STATE and POWEROFF_STATE is
never observed by the IRQ thread itself, only by functions called in a
different context, such as pciehp_sysfs_enable_slot(). So remove
handling of these states from pciehp_handle_button_press() and
pciehp_handle_link_change() which are exclusively called from the IRQ
thread.
Signed-off-by: Lukas Wunner <lukas@wunner.de>
Signed-off-by: Bjorn Helgaas <bhelgaas@google.com>
2018-07-19 22:27:46 +00:00
|
|
|
int request_result;
|
|
|
|
|
wait_queue_head_t requester;
|
2005-04-16 22:20:36 +00:00
|
|
|
};
|
|
|
|
|
|
2018-07-19 22:27:45 +00:00
|
|
|
/**
|
|
|
|
|
* DOC: Slot state
|
|
|
|
|
*
|
|
|
|
|
* @OFF_STATE: slot is powered off, no subordinate devices are enumerated
|
|
|
|
|
* @BLINKINGON_STATE: slot will be powered on after the 5 second delay,
|
|
|
|
|
* green led is blinking
|
|
|
|
|
* @BLINKINGOFF_STATE: slot will be powered off after the 5 second delay,
|
|
|
|
|
* green led is blinking
|
|
|
|
|
* @POWERON_STATE: slot is currently powering on
|
|
|
|
|
* @POWEROFF_STATE: slot is currently powering off
|
|
|
|
|
* @ON_STATE: slot is powered on, subordinate devices have been enumerated
|
|
|
|
|
*/
|
|
|
|
|
#define OFF_STATE 0
|
2005-04-16 22:20:36 +00:00
|
|
|
#define BLINKINGON_STATE 1
|
|
|
|
|
#define BLINKINGOFF_STATE 2
|
|
|
|
|
#define POWERON_STATE 3
|
|
|
|
|
#define POWEROFF_STATE 4
|
2018-07-19 22:27:45 +00:00
|
|
|
#define ON_STATE 5
|
2005-04-16 22:20:36 +00:00
|
|
|
|
PCI: pciehp: Enable/disable exclusively from IRQ thread
Besides the IRQ thread, there are several other places in the driver
which enable or disable the slot:
- pciehp_probe() enables the slot if it's occupied and the pciehp_force
module parameter is used.
- pciehp_resume() enables or disables the slot after system sleep.
- pciehp_queue_pushbutton_work() enables or disables the slot after the
5 second delay following an Attention Button press.
- pciehp_sysfs_enable_slot() and pciehp_sysfs_disable_slot() enable or
disable the slot on sysfs write.
This requires locking and complicates pciehp's state machine.
A simplification can be achieved by enabling and disabling the slot
exclusively from the IRQ thread.
Amend the functions listed above to request slot enable/disablement from
the IRQ thread by either synthesizing a Presence Detect Changed event or,
in the case of a disable user request (via sysfs or an Attention Button
press), submitting a newly introduced force disable request. The latter
is needed because the slot shall be forced off despite being occupied.
For this force disable request, avoid colliding with Slot Status register
bits by using a bit number greater than 16.
For synchronous execution of requests (on sysfs write), wait for the
request to finish and retrieve the result. There can only ever be one
sysfs write in flight due to the locking in kernfs_fop_write(), hence
there is no risk of returning the result of a different sysfs request to
user space.
The POWERON_STATE and POWEROFF_STATE is now no longer entered by the
above-listed functions, but solely by the IRQ thread when it begins a
power transition. Afterwards, it moves to STATIC_STATE. The same
applies to canceling the Attention Button work, it likewise becomes an
IRQ thread only operation.
An immediate consequence is that the POWERON_STATE and POWEROFF_STATE is
never observed by the IRQ thread itself, only by functions called in a
different context, such as pciehp_sysfs_enable_slot(). So remove
handling of these states from pciehp_handle_button_press() and
pciehp_handle_link_change() which are exclusively called from the IRQ
thread.
Signed-off-by: Lukas Wunner <lukas@wunner.de>
Signed-off-by: Bjorn Helgaas <bhelgaas@google.com>
2018-07-19 22:27:46 +00:00
|
|
|
/**
|
|
|
|
|
* DOC: Flags to request an action from the IRQ thread
|
|
|
|
|
*
|
|
|
|
|
* These are stored together with events read from the Slot Status register,
|
|
|
|
|
* hence must be greater than its 16-bit width.
|
|
|
|
|
*
|
|
|
|
|
* %DISABLE_SLOT: Disable the slot in response to a user request via sysfs or
|
|
|
|
|
* an Attention Button press after the 5 second delay
|
|
|
|
|
*/
|
|
|
|
|
#define DISABLE_SLOT (1 << 16)
|
|
|
|
|
|
2009-09-15 08:34:05 +00:00
|
|
|
#define ATTN_BUTTN(ctrl) ((ctrl)->slot_cap & PCI_EXP_SLTCAP_ABP)
|
|
|
|
|
#define POWER_CTRL(ctrl) ((ctrl)->slot_cap & PCI_EXP_SLTCAP_PCP)
|
|
|
|
|
#define MRL_SENS(ctrl) ((ctrl)->slot_cap & PCI_EXP_SLTCAP_MRLSP)
|
|
|
|
|
#define ATTN_LED(ctrl) ((ctrl)->slot_cap & PCI_EXP_SLTCAP_AIP)
|
|
|
|
|
#define PWR_LED(ctrl) ((ctrl)->slot_cap & PCI_EXP_SLTCAP_PIP)
|
|
|
|
|
#define HP_SUPR_RM(ctrl) ((ctrl)->slot_cap & PCI_EXP_SLTCAP_HPS)
|
|
|
|
|
#define EMI(ctrl) ((ctrl)->slot_cap & PCI_EXP_SLTCAP_EIP)
|
|
|
|
|
#define NO_CMD_CMPL(ctrl) ((ctrl)->slot_cap & PCI_EXP_SLTCAP_NCCS)
|
2014-04-05 21:05:07 +00:00
|
|
|
#define PSN(ctrl) (((ctrl)->slot_cap & PCI_EXP_SLTCAP_PSN) >> 19)
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2013-04-12 18:02:59 +00:00
|
|
|
int pciehp_sysfs_enable_slot(struct slot *slot);
|
|
|
|
|
int pciehp_sysfs_disable_slot(struct slot *slot);
|
PCI: pciehp: Enable/disable exclusively from IRQ thread
Besides the IRQ thread, there are several other places in the driver
which enable or disable the slot:
- pciehp_probe() enables the slot if it's occupied and the pciehp_force
module parameter is used.
- pciehp_resume() enables or disables the slot after system sleep.
- pciehp_queue_pushbutton_work() enables or disables the slot after the
5 second delay following an Attention Button press.
- pciehp_sysfs_enable_slot() and pciehp_sysfs_disable_slot() enable or
disable the slot on sysfs write.
This requires locking and complicates pciehp's state machine.
A simplification can be achieved by enabling and disabling the slot
exclusively from the IRQ thread.
Amend the functions listed above to request slot enable/disablement from
the IRQ thread by either synthesizing a Presence Detect Changed event or,
in the case of a disable user request (via sysfs or an Attention Button
press), submitting a newly introduced force disable request. The latter
is needed because the slot shall be forced off despite being occupied.
For this force disable request, avoid colliding with Slot Status register
bits by using a bit number greater than 16.
For synchronous execution of requests (on sysfs write), wait for the
request to finish and retrieve the result. There can only ever be one
sysfs write in flight due to the locking in kernfs_fop_write(), hence
there is no risk of returning the result of a different sysfs request to
user space.
The POWERON_STATE and POWEROFF_STATE is now no longer entered by the
above-listed functions, but solely by the IRQ thread when it begins a
power transition. Afterwards, it moves to STATIC_STATE. The same
applies to canceling the Attention Button work, it likewise becomes an
IRQ thread only operation.
An immediate consequence is that the POWERON_STATE and POWEROFF_STATE is
never observed by the IRQ thread itself, only by functions called in a
different context, such as pciehp_sysfs_enable_slot(). So remove
handling of these states from pciehp_handle_button_press() and
pciehp_handle_link_change() which are exclusively called from the IRQ
thread.
Signed-off-by: Lukas Wunner <lukas@wunner.de>
Signed-off-by: Bjorn Helgaas <bhelgaas@google.com>
2018-07-19 22:27:46 +00:00
|
|
|
void pciehp_request(struct controller *ctrl, int action);
|
2018-07-19 22:27:41 +00:00
|
|
|
void pciehp_handle_button_press(struct slot *slot);
|
PCI: pciehp: Enable/disable exclusively from IRQ thread
Besides the IRQ thread, there are several other places in the driver
which enable or disable the slot:
- pciehp_probe() enables the slot if it's occupied and the pciehp_force
module parameter is used.
- pciehp_resume() enables or disables the slot after system sleep.
- pciehp_queue_pushbutton_work() enables or disables the slot after the
5 second delay following an Attention Button press.
- pciehp_sysfs_enable_slot() and pciehp_sysfs_disable_slot() enable or
disable the slot on sysfs write.
This requires locking and complicates pciehp's state machine.
A simplification can be achieved by enabling and disabling the slot
exclusively from the IRQ thread.
Amend the functions listed above to request slot enable/disablement from
the IRQ thread by either synthesizing a Presence Detect Changed event or,
in the case of a disable user request (via sysfs or an Attention Button
press), submitting a newly introduced force disable request. The latter
is needed because the slot shall be forced off despite being occupied.
For this force disable request, avoid colliding with Slot Status register
bits by using a bit number greater than 16.
For synchronous execution of requests (on sysfs write), wait for the
request to finish and retrieve the result. There can only ever be one
sysfs write in flight due to the locking in kernfs_fop_write(), hence
there is no risk of returning the result of a different sysfs request to
user space.
The POWERON_STATE and POWEROFF_STATE is now no longer entered by the
above-listed functions, but solely by the IRQ thread when it begins a
power transition. Afterwards, it moves to STATIC_STATE. The same
applies to canceling the Attention Button work, it likewise becomes an
IRQ thread only operation.
An immediate consequence is that the POWERON_STATE and POWEROFF_STATE is
never observed by the IRQ thread itself, only by functions called in a
different context, such as pciehp_sysfs_enable_slot(). So remove
handling of these states from pciehp_handle_button_press() and
pciehp_handle_link_change() which are exclusively called from the IRQ
thread.
Signed-off-by: Lukas Wunner <lukas@wunner.de>
Signed-off-by: Bjorn Helgaas <bhelgaas@google.com>
2018-07-19 22:27:46 +00:00
|
|
|
void pciehp_handle_disable_request(struct slot *slot);
|
PCI: pciehp: Become resilient to missed events
A hotplug port's Slot Status register does not count how often each type
of event occurred, it only records the fact *that* an event has occurred.
Previously pciehp queued a work item for each event. But if it missed
an event, e.g. removal of a card in-between two back-to-back insertions,
it queued up the wrong work item or no work item at all. Commit
fad214b0aa72 ("PCI: pciehp: Process all hotplug events before looking
for new ones") sought to improve the situation by shrinking the window
during which events may be missed.
But Stefan Roese reports unbalanced Card present and Link Up events,
suggesting that we're still missing events if they occur very rapidly.
Bjorn Helgaas responds that he considers pciehp's event handling
"baroque" and calls for its simplification and rationalization:
https://lkml.kernel.org/r/20180202192045.GA53759@bhelgaas-glaptop.roam.corp.google.com
It gets worse once a hotplug port is runtime suspended: The port can
signal an interrupt while it and its parents are in D3hot, i.e. while
it is inaccessible. By the time we've runtime resumed all parents to D0
and read the port's Slot Status register, we may have missed an arbitrary
number of events. Event handling therefore needs to be reworked to
become resilient to missed events.
Assume that a Presence Detect Changed event has occurred.
Consider the following truth table:
- Slot is in OFF_STATE and is currently empty. => Do nothing.
(The event is trailing a Link Down or we've
missed an insertion and subsequent removal.)
- Slot is in OFF_STATE and is currently occupied. => Turn the slot on.
- Slot is in ON_STATE and is currently empty. => Turn the slot off.
- Slot is in ON_STATE and is currently occupied. => Turn the slot off,
(Be cautious and assume the card in then back on.
the slot isn't the same as before.)
This leads to the following simple algorithm:
1 If the slot is in ON_STATE, turn it off unconditionally.
2 If the slot is currently occupied, turn it on.
Because those actions are now carried out synchronously, rather than by
scheduled work items, pciehp reacts to the *current* situation and
missed events no longer matter.
Data Link Layer State Changed events can be handled identically to
Presence Detect Changed events. Note that in the above truth table,
a Link Up trailing a Card present event didn't have to be accounted for:
It is filtered out by pciehp_check_link_status().
As for Attention Button Pressed events, PCIe r4.0, sec 6.7.1.5 says:
"Once the Power Indicator begins blinking, a 5-second abort interval
exists during which a second depression of the Attention Button cancels
the operation." In other words, the user can only expect the system to
react to a button press after it starts blinking. Missed button presses
that occur in-between are irrelevant.
Signed-off-by: Lukas Wunner <lukas@wunner.de>
Signed-off-by: Bjorn Helgaas <bhelgaas@google.com>
Cc: Stefan Roese <sr@denx.de>
Cc: Mayurkumar Patel <mayurkumar.patel@intel.com>
Cc: Mika Westerberg <mika.westerberg@linux.intel.com>
Cc: Kenji Kaneshige <kaneshige.kenji@jp.fujitsu.com>
2018-07-19 22:27:49 +00:00
|
|
|
void pciehp_handle_presence_or_link_change(struct slot *slot, u32 events);
|
2013-04-12 18:02:59 +00:00
|
|
|
int pciehp_configure_device(struct slot *p_slot);
|
2018-07-19 22:27:36 +00:00
|
|
|
void pciehp_unconfigure_device(struct slot *p_slot);
|
2013-04-12 18:02:59 +00:00
|
|
|
void pciehp_queue_pushbutton_work(struct work_struct *work);
|
2008-06-20 03:07:08 +00:00
|
|
|
struct controller *pcie_init(struct pcie_device *dev);
|
2009-01-29 03:31:18 +00:00
|
|
|
int pcie_init_notification(struct controller *ctrl);
|
2018-07-19 22:27:32 +00:00
|
|
|
void pcie_shutdown_notification(struct controller *ctrl);
|
2018-05-23 22:14:39 +00:00
|
|
|
void pcie_reenable_notification(struct controller *ctrl);
|
2009-09-15 08:30:48 +00:00
|
|
|
int pciehp_power_on_slot(struct slot *slot);
|
2013-12-14 20:06:16 +00:00
|
|
|
void pciehp_power_off_slot(struct slot *slot);
|
|
|
|
|
void pciehp_get_power_status(struct slot *slot, u8 *status);
|
|
|
|
|
void pciehp_get_attention_status(struct slot *slot, u8 *status);
|
2009-09-15 08:30:48 +00:00
|
|
|
|
2013-12-14 20:06:16 +00:00
|
|
|
void pciehp_set_attention_status(struct slot *slot, u8 status);
|
|
|
|
|
void pciehp_get_latch_status(struct slot *slot, u8 *status);
|
|
|
|
|
void pciehp_get_adapter_status(struct slot *slot, u8 *status);
|
2009-09-15 08:30:48 +00:00
|
|
|
int pciehp_query_power_fault(struct slot *slot);
|
|
|
|
|
void pciehp_green_led_on(struct slot *slot);
|
|
|
|
|
void pciehp_green_led_off(struct slot *slot);
|
|
|
|
|
void pciehp_green_led_blink(struct slot *slot);
|
|
|
|
|
int pciehp_check_link_status(struct controller *ctrl);
|
2014-02-05 02:28:43 +00:00
|
|
|
bool pciehp_check_link_active(struct controller *ctrl);
|
2009-09-15 08:30:48 +00:00
|
|
|
void pciehp_release_ctrl(struct controller *ctrl);
|
2013-08-08 20:09:37 +00:00
|
|
|
int pciehp_reset_slot(struct slot *slot, int probe);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
PCI: pciehp: Allow exclusive userspace control of indicators
PCIe hotplug supports optional Attention and Power Indicators, which are
used internally by pciehp. Users can't control the Power Indicator, but
they can control the Attention Indicator by writing to a sysfs "attention"
file.
The Slot Control register has two bits for each indicator, and the PCIe
spec defines the encodings for each as (Reserved/On/Blinking/Off). For
sysfs "attention" writes, pciehp_set_attention_status() maps into these
encodings, so the only useful write values are 0 (Off), 1 (On), and 2
(Blinking).
However, some platforms use all four bits for platform-specific indicators,
and they need to allow direct user control of them while preventing pciehp
from using them at all.
Add a "hotplug_user_indicators" flag to the pci_dev structure. When set,
pciehp does not use either the Attention Indicator or the Power Indicator,
and the low four bits (values 0x0 - 0xf) of sysfs "attention" write values
are written directly to the Attention Indicator Control and Power Indicator
Control fields.
[bhelgaas: changelog, rename flag and accessors to s/attention/indicator/]
Signed-off-by: Keith Busch <keith.busch@intel.com>
Signed-off-by: Bjorn Helgaas <bhelgaas@google.com>
2016-09-13 16:31:59 +00:00
|
|
|
int pciehp_set_raw_indicator_status(struct hotplug_slot *h_slot, u8 status);
|
|
|
|
|
int pciehp_get_raw_indicator_status(struct hotplug_slot *h_slot, u8 *status);
|
|
|
|
|
|
2008-10-20 23:41:38 +00:00
|
|
|
static inline const char *slot_name(struct slot *slot)
|
|
|
|
|
{
|
|
|
|
|
return hotplug_slot_name(slot->hotplug_slot);
|
|
|
|
|
}
|
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
#endif /* _PCIEHP_H */
|
