github-mirror/linux
1
0
Fork 0
mirror of https://github.com/torvalds/linux.git synced 2026-05-28 00:53:34 +02:00
Code Issues Actions Packages Projects Releases Wiki Activity Graph

Merge branch 'qlogic-use-generic-power-management'

Browse Source 
Vaibhav Gupta says:

====================
qlogic: use generic power management

Linux Kernel Mentee: Remove Legacy Power Management.

The purpose of this patch series is to remove legacy power management callbacks
from qlogic ethernet drivers.

The callbacks performing suspend() and resume() operations are still calling
pci_save_state(), pci_set_power_state(), etc. and handling the power management
themselves, which is not recommended.

The conversion requires the removal of the those function calls and change the
callback definition accordingly and make use of dev_pm_ops structure.

All patches are compile-tested only.

V2: Fix unused variable warning in v1.
====================

Signed-off-by: David S. Miller <davem@davemloft.net>
This commit is contained in:
David S. Miller 2020-07-04 18:02:06 -07:00
commit e1f0467044
3 changed files with 37 additions and 66 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

59
drivers/net/ethernet/qlogic/netxen/netxen_nic_main.c
View File

@ -1695,19 +1695,13 @@ static void netxen_nic_detach_func(struct netxen_adapter *adapter)
clear_bit(__NX_RESETTING, &adapter->state);
}
static int netxen_nic_attach_func(struct pci_dev *pdev)
static int netxen_nic_attach_late_func(struct pci_dev *pdev)
{
struct netxen_adapter *adapter = pci_get_drvdata(pdev);
struct net_device *netdev = adapter->netdev;
int err;
err = pci_enable_device(pdev);
if (err)
return err;
pci_set_power_state(pdev, PCI_D0);
pci_set_master(pdev);
pci_restore_state(pdev);
adapter->ahw.crb_win = -1;
adapter->ahw.ocm_win = -1;
@ -1741,6 +1735,20 @@ static int netxen_nic_attach_func(struct pci_dev *pdev)
return err;
}
static int netxen_nic_attach_func(struct pci_dev *pdev)
{
int err;
err = pci_enable_device(pdev);
if (err)
return err;
pci_set_power_state(pdev, PCI_D0);
pci_restore_state(pdev);
return netxen_nic_attach_late_func(pdev);
}
static pci_ers_result_t netxen_io_error_detected(struct pci_dev *pdev,
pci_channel_state_t state)
{
@ -1785,36 +1793,24 @@ static void netxen_nic_shutdown(struct pci_dev *pdev)
pci_disable_device(pdev);
}
#ifdef CONFIG_PM
static int
netxen_nic_suspend(struct pci_dev *pdev, pm_message_t state)
static int __maybe_unused
netxen_nic_suspend(struct device *dev_d)
{
struct netxen_adapter *adapter = pci_get_drvdata(pdev);
int retval;
struct netxen_adapter *adapter = dev_get_drvdata(dev_d);
netxen_nic_detach_func(adapter);
retval = pci_save_state(pdev);
if (retval)
return retval;
if (netxen_nic_wol_supported(adapter)) {
pci_enable_wake(pdev, PCI_D3cold, 1);
pci_enable_wake(pdev, PCI_D3hot, 1);
}
pci_disable_device(pdev);
pci_set_power_state(pdev, pci_choose_state(pdev, state));
if (netxen_nic_wol_supported(adapter))
device_wakeup_enable(dev_d);
return 0;
}
static int
netxen_nic_resume(struct pci_dev *pdev)
static int __maybe_unused
netxen_nic_resume(struct device *dev_d)
{
return netxen_nic_attach_func(pdev);
return netxen_nic_attach_late_func(to_pci_dev(dev_d));
}
#endif
static int netxen_nic_open(struct net_device *netdev)
{
@ -3448,15 +3444,16 @@ static const struct pci_error_handlers netxen_err_handler = {
.slot_reset = netxen_io_slot_reset,
};
static SIMPLE_DEV_PM_OPS(netxen_nic_pm_ops,
netxen_nic_suspend,
netxen_nic_resume);
static struct pci_driver netxen_driver = {
.name = netxen_nic_driver_name,
.id_table = netxen_pci_tbl,
.probe = netxen_nic_probe,
.remove = netxen_nic_remove,
#ifdef CONFIG_PM
.suspend = netxen_nic_suspend,
.resume = netxen_nic_resume,
#endif
.driver.pm = &netxen_nic_pm_ops,
.shutdown = netxen_nic_shutdown,
.err_handler = &netxen_err_handler
};

11
drivers/net/ethernet/qlogic/qlcnic/qlcnic_hw.c
View File

@ -1649,7 +1649,6 @@ int qlcnic_82xx_shutdown(struct pci_dev *pdev)
{
struct qlcnic_adapter *adapter = pci_get_drvdata(pdev);
struct net_device *netdev = adapter->netdev;
int retval;
netif_device_detach(netdev);
@ -1662,14 +1661,8 @@ int qlcnic_82xx_shutdown(struct pci_dev *pdev)
clear_bit(__QLCNIC_RESETTING, &adapter->state);
retval = pci_save_state(pdev);
if (retval)
return retval;
if (qlcnic_wol_supported(adapter)) {
pci_enable_wake(pdev, PCI_D3cold, 1);
pci_enable_wake(pdev, PCI_D3hot, 1);
}
if (qlcnic_wol_supported(adapter))
device_wakeup_enable(&pdev->dev);
return 0;
}

33
drivers/net/ethernet/qlogic/qlcnic/qlcnic_main.c
View File

@ -2811,35 +2811,17 @@ static void qlcnic_shutdown(struct pci_dev *pdev)
pci_disable_device(pdev);
}
#ifdef CONFIG_PM
static int qlcnic_suspend(struct pci_dev *pdev, pm_message_t state)
static int __maybe_unused qlcnic_suspend(struct device *dev_d)
{
int retval;
retval = __qlcnic_shutdown(pdev);
if (retval)
return retval;
pci_set_power_state(pdev, pci_choose_state(pdev, state));
return 0;
return __qlcnic_shutdown(to_pci_dev(dev_d));
}
static int qlcnic_resume(struct pci_dev *pdev)
static int __maybe_unused qlcnic_resume(struct device *dev_d)
{
struct qlcnic_adapter *adapter = pci_get_drvdata(pdev);
int err;
err = pci_enable_device(pdev);
if (err)
return err;
pci_set_power_state(pdev, PCI_D0);
pci_set_master(pdev);
pci_restore_state(pdev);
struct qlcnic_adapter *adapter = dev_get_drvdata(dev_d);
return __qlcnic_resume(adapter);
}
#endif
static int qlcnic_open(struct net_device *netdev)
{
@ -4258,15 +4240,14 @@ static const struct pci_error_handlers qlcnic_err_handler = {
.resume = qlcnic_io_resume,
};
static SIMPLE_DEV_PM_OPS(qlcnic_pm_ops, qlcnic_suspend, qlcnic_resume);
static struct pci_driver qlcnic_driver = {
.name = qlcnic_driver_name,
.id_table = qlcnic_pci_tbl,
.probe = qlcnic_probe,
.remove = qlcnic_remove,
#ifdef CONFIG_PM
.suspend = qlcnic_suspend,
.resume = qlcnic_resume,
#endif
.driver.pm = &qlcnic_pm_ops,
.shutdown = qlcnic_shutdown,
.err_handler = &qlcnic_err_handler,
#ifdef CONFIG_QLCNIC_SRIOV