Commit 2de49925 authored by David S. Miller's avatar David S. Miller

Merge branch 's390-next'

Julian Wiedmann says:

====================
s390/net: updates 2020-05-19

please apply the following patch series to netdev's net-next tree.

s390 dropped its support for power management, this removes the relevant
code from the s390 network drivers.
====================
Signed-off-by: default avatarDavid S. Miller <davem@davemloft.net>
parents fa14b9b0 97ccf6f9
...@@ -36,11 +36,6 @@ struct ccwgroup_device { ...@@ -36,11 +36,6 @@ struct ccwgroup_device {
* @set_online: function called when device is set online * @set_online: function called when device is set online
* @set_offline: function called when device is set offline * @set_offline: function called when device is set offline
* @shutdown: function called when device is shut down * @shutdown: function called when device is shut down
* @prepare: prepare for pm state transition
* @complete: undo work done in @prepare
* @freeze: callback for freezing during hibernation snapshotting
* @thaw: undo work done in @freeze
* @restore: callback for restoring after hibernation
* @driver: embedded driver structure * @driver: embedded driver structure
* @ccw_driver: supported ccw_driver (optional) * @ccw_driver: supported ccw_driver (optional)
*/ */
...@@ -50,11 +45,6 @@ struct ccwgroup_driver { ...@@ -50,11 +45,6 @@ struct ccwgroup_driver {
int (*set_online) (struct ccwgroup_device *); int (*set_online) (struct ccwgroup_device *);
int (*set_offline) (struct ccwgroup_device *); int (*set_offline) (struct ccwgroup_device *);
void (*shutdown)(struct ccwgroup_device *); void (*shutdown)(struct ccwgroup_device *);
int (*prepare) (struct ccwgroup_device *);
void (*complete) (struct ccwgroup_device *);
int (*freeze)(struct ccwgroup_device *);
int (*thaw) (struct ccwgroup_device *);
int (*restore)(struct ccwgroup_device *);
struct device_driver driver; struct device_driver driver;
struct ccw_driver *ccw_driver; struct ccw_driver *ccw_driver;
......
...@@ -1698,43 +1698,6 @@ static void ctcm_remove_device(struct ccwgroup_device *cgdev) ...@@ -1698,43 +1698,6 @@ static void ctcm_remove_device(struct ccwgroup_device *cgdev)
put_device(&cgdev->dev); put_device(&cgdev->dev);
} }
static int ctcm_pm_suspend(struct ccwgroup_device *gdev)
{
struct ctcm_priv *priv = dev_get_drvdata(&gdev->dev);
if (gdev->state == CCWGROUP_OFFLINE)
return 0;
netif_device_detach(priv->channel[CTCM_READ]->netdev);
ctcm_close(priv->channel[CTCM_READ]->netdev);
if (!wait_event_timeout(priv->fsm->wait_q,
fsm_getstate(priv->fsm) == DEV_STATE_STOPPED, CTCM_TIME_5_SEC)) {
netif_device_attach(priv->channel[CTCM_READ]->netdev);
return -EBUSY;
}
ccw_device_set_offline(gdev->cdev[1]);
ccw_device_set_offline(gdev->cdev[0]);
return 0;
}
static int ctcm_pm_resume(struct ccwgroup_device *gdev)
{
struct ctcm_priv *priv = dev_get_drvdata(&gdev->dev);
int rc;
if (gdev->state == CCWGROUP_OFFLINE)
return 0;
rc = ccw_device_set_online(gdev->cdev[1]);
if (rc)
goto err_out;
rc = ccw_device_set_online(gdev->cdev[0]);
if (rc)
goto err_out;
ctcm_open(priv->channel[CTCM_READ]->netdev);
err_out:
netif_device_attach(priv->channel[CTCM_READ]->netdev);
return rc;
}
static struct ccw_device_id ctcm_ids[] = { static struct ccw_device_id ctcm_ids[] = {
{CCW_DEVICE(0x3088, 0x08), .driver_info = ctcm_channel_type_parallel}, {CCW_DEVICE(0x3088, 0x08), .driver_info = ctcm_channel_type_parallel},
{CCW_DEVICE(0x3088, 0x1e), .driver_info = ctcm_channel_type_ficon}, {CCW_DEVICE(0x3088, 0x1e), .driver_info = ctcm_channel_type_ficon},
...@@ -1764,9 +1727,6 @@ static struct ccwgroup_driver ctcm_group_driver = { ...@@ -1764,9 +1727,6 @@ static struct ccwgroup_driver ctcm_group_driver = {
.remove = ctcm_remove_device, .remove = ctcm_remove_device,
.set_online = ctcm_new_device, .set_online = ctcm_new_device,
.set_offline = ctcm_shutdown_device, .set_offline = ctcm_shutdown_device,
.freeze = ctcm_pm_suspend,
.thaw = ctcm_pm_resume,
.restore = ctcm_pm_resume,
}; };
static ssize_t group_store(struct device_driver *ddrv, const char *buf, static ssize_t group_store(struct device_driver *ddrv, const char *buf,
......
...@@ -2296,60 +2296,6 @@ lcs_remove_device(struct ccwgroup_device *ccwgdev) ...@@ -2296,60 +2296,6 @@ lcs_remove_device(struct ccwgroup_device *ccwgdev)
put_device(&ccwgdev->dev); put_device(&ccwgdev->dev);
} }
static int lcs_pm_suspend(struct lcs_card *card)
{
if (card->dev)
netif_device_detach(card->dev);
lcs_set_allowed_threads(card, 0);
lcs_wait_for_threads(card, 0xffffffff);
if (card->state != DEV_STATE_DOWN)
__lcs_shutdown_device(card->gdev, 1);
return 0;
}
static int lcs_pm_resume(struct lcs_card *card)
{
int rc = 0;
if (card->state == DEV_STATE_RECOVER)
rc = lcs_new_device(card->gdev);
if (card->dev)
netif_device_attach(card->dev);
if (rc) {
dev_warn(&card->gdev->dev, "The lcs device driver "
"failed to recover the device\n");
}
return rc;
}
static int lcs_prepare(struct ccwgroup_device *gdev)
{
return 0;
}
static void lcs_complete(struct ccwgroup_device *gdev)
{
return;
}
static int lcs_freeze(struct ccwgroup_device *gdev)
{
struct lcs_card *card = dev_get_drvdata(&gdev->dev);
return lcs_pm_suspend(card);
}
static int lcs_thaw(struct ccwgroup_device *gdev)
{
struct lcs_card *card = dev_get_drvdata(&gdev->dev);
return lcs_pm_resume(card);
}
static int lcs_restore(struct ccwgroup_device *gdev)
{
struct lcs_card *card = dev_get_drvdata(&gdev->dev);
return lcs_pm_resume(card);
}
static struct ccw_device_id lcs_ids[] = { static struct ccw_device_id lcs_ids[] = {
{CCW_DEVICE(0x3088, 0x08), .driver_info = lcs_channel_type_parallel}, {CCW_DEVICE(0x3088, 0x08), .driver_info = lcs_channel_type_parallel},
{CCW_DEVICE(0x3088, 0x1f), .driver_info = lcs_channel_type_2216}, {CCW_DEVICE(0x3088, 0x1f), .driver_info = lcs_channel_type_2216},
...@@ -2382,11 +2328,6 @@ static struct ccwgroup_driver lcs_group_driver = { ...@@ -2382,11 +2328,6 @@ static struct ccwgroup_driver lcs_group_driver = {
.remove = lcs_remove_device, .remove = lcs_remove_device,
.set_online = lcs_new_device, .set_online = lcs_new_device,
.set_offline = lcs_shutdown_device, .set_offline = lcs_shutdown_device,
.prepare = lcs_prepare,
.complete = lcs_complete,
.freeze = lcs_freeze,
.thaw = lcs_thaw,
.restore = lcs_restore,
}; };
static ssize_t group_store(struct device_driver *ddrv, const char *buf, static ssize_t group_store(struct device_driver *ddrv, const char *buf,
......
...@@ -112,27 +112,10 @@ DECLARE_PER_CPU(char[256], iucv_dbf_txt_buf); ...@@ -112,27 +112,10 @@ DECLARE_PER_CPU(char[256], iucv_dbf_txt_buf);
*/ */
#define PRINTK_HEADER " iucv: " /* for debugging */ #define PRINTK_HEADER " iucv: " /* for debugging */
/* dummy device to make sure netiucv_pm functions are called */
static struct device *netiucv_dev;
static int netiucv_pm_prepare(struct device *);
static void netiucv_pm_complete(struct device *);
static int netiucv_pm_freeze(struct device *);
static int netiucv_pm_restore_thaw(struct device *);
static const struct dev_pm_ops netiucv_pm_ops = {
.prepare = netiucv_pm_prepare,
.complete = netiucv_pm_complete,
.freeze = netiucv_pm_freeze,
.thaw = netiucv_pm_restore_thaw,
.restore = netiucv_pm_restore_thaw,
};
static struct device_driver netiucv_driver = { static struct device_driver netiucv_driver = {
.owner = THIS_MODULE, .owner = THIS_MODULE,
.name = "netiucv", .name = "netiucv",
.bus = &iucv_bus, .bus = &iucv_bus,
.pm = &netiucv_pm_ops,
}; };
static int netiucv_callback_connreq(struct iucv_path *, u8 *, u8 *); static int netiucv_callback_connreq(struct iucv_path *, u8 *, u8 *);
...@@ -213,7 +196,6 @@ struct netiucv_priv { ...@@ -213,7 +196,6 @@ struct netiucv_priv {
fsm_instance *fsm; fsm_instance *fsm;
struct iucv_connection *conn; struct iucv_connection *conn;
struct device *dev; struct device *dev;
int pm_state;
}; };
/** /**
...@@ -1275,72 +1257,6 @@ static int netiucv_close(struct net_device *dev) ...@@ -1275,72 +1257,6 @@ static int netiucv_close(struct net_device *dev)
return 0; return 0;
} }
static int netiucv_pm_prepare(struct device *dev)
{
IUCV_DBF_TEXT(trace, 3, __func__);
return 0;
}
static void netiucv_pm_complete(struct device *dev)
{
IUCV_DBF_TEXT(trace, 3, __func__);
return;
}
/**
* netiucv_pm_freeze() - Freeze PM callback
* @dev: netiucv device
*
* close open netiucv interfaces
*/
static int netiucv_pm_freeze(struct device *dev)
{
struct netiucv_priv *priv = dev_get_drvdata(dev);
struct net_device *ndev = NULL;
int rc = 0;
IUCV_DBF_TEXT(trace, 3, __func__);
if (priv && priv->conn)
ndev = priv->conn->netdev;
if (!ndev)
goto out;
netif_device_detach(ndev);
priv->pm_state = fsm_getstate(priv->fsm);
rc = netiucv_close(ndev);
out:
return rc;
}
/**
* netiucv_pm_restore_thaw() - Thaw and restore PM callback
* @dev: netiucv device
*
* re-open netiucv interfaces closed during freeze
*/
static int netiucv_pm_restore_thaw(struct device *dev)
{
struct netiucv_priv *priv = dev_get_drvdata(dev);
struct net_device *ndev = NULL;
int rc = 0;
IUCV_DBF_TEXT(trace, 3, __func__);
if (priv && priv->conn)
ndev = priv->conn->netdev;
if (!ndev)
goto out;
switch (priv->pm_state) {
case DEV_STATE_RUNNING:
case DEV_STATE_STARTWAIT:
rc = netiucv_open(ndev);
break;
default:
break;
}
netif_device_attach(ndev);
out:
return rc;
}
/** /**
* Start transmission of a packet. * Start transmission of a packet.
* Called from generic network device layer. * Called from generic network device layer.
...@@ -2156,7 +2072,6 @@ static void __exit netiucv_exit(void) ...@@ -2156,7 +2072,6 @@ static void __exit netiucv_exit(void)
netiucv_unregister_device(dev); netiucv_unregister_device(dev);
} }
device_unregister(netiucv_dev);
driver_unregister(&netiucv_driver); driver_unregister(&netiucv_driver);
iucv_unregister(&netiucv_handler, 1); iucv_unregister(&netiucv_handler, 1);
iucv_unregister_dbf_views(); iucv_unregister_dbf_views();
...@@ -2182,27 +2097,10 @@ static int __init netiucv_init(void) ...@@ -2182,27 +2097,10 @@ static int __init netiucv_init(void)
IUCV_DBF_TEXT_(setup, 2, "ret %d from driver_register\n", rc); IUCV_DBF_TEXT_(setup, 2, "ret %d from driver_register\n", rc);
goto out_iucv; goto out_iucv;
} }
/* establish dummy device */
netiucv_dev = kzalloc(sizeof(struct device), GFP_KERNEL);
if (!netiucv_dev) {
rc = -ENOMEM;
goto out_driver;
}
dev_set_name(netiucv_dev, "netiucv");
netiucv_dev->bus = &iucv_bus;
netiucv_dev->parent = iucv_root;
netiucv_dev->release = (void (*)(struct device *))kfree;
netiucv_dev->driver = &netiucv_driver;
rc = device_register(netiucv_dev);
if (rc) {
put_device(netiucv_dev);
goto out_driver;
}
netiucv_banner(); netiucv_banner();
return rc; return rc;
out_driver:
driver_unregister(&netiucv_driver);
out_iucv: out_iucv:
iucv_unregister(&netiucv_handler, 1); iucv_unregister(&netiucv_handler, 1);
out_dbf: out_dbf:
......
...@@ -6434,32 +6434,6 @@ static void qeth_core_shutdown(struct ccwgroup_device *gdev) ...@@ -6434,32 +6434,6 @@ static void qeth_core_shutdown(struct ccwgroup_device *gdev)
qdio_free(CARD_DDEV(card)); qdio_free(CARD_DDEV(card));
} }
static int qeth_suspend(struct ccwgroup_device *gdev)
{
struct qeth_card *card = dev_get_drvdata(&gdev->dev);
qeth_set_allowed_threads(card, 0, 1);
wait_event(card->wait_q, qeth_threads_running(card, 0xffffffff) == 0);
if (gdev->state == CCWGROUP_OFFLINE)
return 0;
qeth_set_offline(card, false);
return 0;
}
static int qeth_resume(struct ccwgroup_device *gdev)
{
struct qeth_card *card = dev_get_drvdata(&gdev->dev);
int rc;
rc = qeth_set_online(card);
qeth_set_allowed_threads(card, 0xffffffff, 0);
if (rc)
dev_warn(&card->gdev->dev, "The qeth device driver failed to recover an error on the device\n");
return rc;
}
static ssize_t group_store(struct device_driver *ddrv, const char *buf, static ssize_t group_store(struct device_driver *ddrv, const char *buf,
size_t count) size_t count)
{ {
...@@ -6496,11 +6470,6 @@ static struct ccwgroup_driver qeth_core_ccwgroup_driver = { ...@@ -6496,11 +6470,6 @@ static struct ccwgroup_driver qeth_core_ccwgroup_driver = {
.set_online = qeth_core_set_online, .set_online = qeth_core_set_online,
.set_offline = qeth_core_set_offline, .set_offline = qeth_core_set_offline,
.shutdown = qeth_core_shutdown, .shutdown = qeth_core_shutdown,
.prepare = NULL,
.complete = NULL,
.freeze = qeth_suspend,
.thaw = qeth_resume,
.restore = qeth_resume,
}; };
struct qeth_card *qeth_get_card_by_busid(char *bus_id) struct qeth_card *qeth_get_card_by_busid(char *bus_id)
......
...@@ -29,12 +29,9 @@ MODULE_AUTHOR ...@@ -29,12 +29,9 @@ MODULE_AUTHOR
MODULE_DESCRIPTION ("Linux for S/390 IUCV special message driver"); MODULE_DESCRIPTION ("Linux for S/390 IUCV special message driver");
static struct iucv_path *smsg_path; static struct iucv_path *smsg_path;
/* dummy device used as trigger for PM functions */
static struct device *smsg_dev;
static DEFINE_SPINLOCK(smsg_list_lock); static DEFINE_SPINLOCK(smsg_list_lock);
static LIST_HEAD(smsg_list); static LIST_HEAD(smsg_list);
static int iucv_path_connected;
static int smsg_path_pending(struct iucv_path *, u8 *, u8 *); static int smsg_path_pending(struct iucv_path *, u8 *, u8 *);
static void smsg_message_pending(struct iucv_path *, struct iucv_message *); static void smsg_message_pending(struct iucv_path *, struct iucv_message *);
...@@ -124,60 +121,15 @@ void smsg_unregister_callback(const char *prefix, ...@@ -124,60 +121,15 @@ void smsg_unregister_callback(const char *prefix,
kfree(cb); kfree(cb);
} }
static int smsg_pm_freeze(struct device *dev)
{
#ifdef CONFIG_PM_DEBUG
printk(KERN_WARNING "smsg_pm_freeze\n");
#endif
if (smsg_path && iucv_path_connected) {
iucv_path_sever(smsg_path, NULL);
iucv_path_connected = 0;
}
return 0;
}
static int smsg_pm_restore_thaw(struct device *dev)
{
int rc;
#ifdef CONFIG_PM_DEBUG
printk(KERN_WARNING "smsg_pm_restore_thaw\n");
#endif
if (smsg_path && !iucv_path_connected) {
memset(smsg_path, 0, sizeof(*smsg_path));
smsg_path->msglim = 255;
smsg_path->flags = 0;
rc = iucv_path_connect(smsg_path, &smsg_handler, "*MSG ",
NULL, NULL, NULL);
#ifdef CONFIG_PM_DEBUG
if (rc)
printk(KERN_ERR
"iucv_path_connect returned with rc %i\n", rc);
#endif
if (!rc)
iucv_path_connected = 1;
cpcmd("SET SMSG IUCV", NULL, 0, NULL);
}
return 0;
}
static const struct dev_pm_ops smsg_pm_ops = {
.freeze = smsg_pm_freeze,
.thaw = smsg_pm_restore_thaw,
.restore = smsg_pm_restore_thaw,
};
static struct device_driver smsg_driver = { static struct device_driver smsg_driver = {
.owner = THIS_MODULE, .owner = THIS_MODULE,
.name = SMSGIUCV_DRV_NAME, .name = SMSGIUCV_DRV_NAME,
.bus = &iucv_bus, .bus = &iucv_bus,
.pm = &smsg_pm_ops,
}; };
static void __exit smsg_exit(void) static void __exit smsg_exit(void)
{ {
cpcmd("SET SMSG OFF", NULL, 0, NULL); cpcmd("SET SMSG OFF", NULL, 0, NULL);
device_unregister(smsg_dev);
iucv_unregister(&smsg_handler, 1); iucv_unregister(&smsg_handler, 1);
driver_unregister(&smsg_driver); driver_unregister(&smsg_driver);
} }
...@@ -205,27 +157,10 @@ static int __init smsg_init(void) ...@@ -205,27 +157,10 @@ static int __init smsg_init(void)
NULL, NULL, NULL); NULL, NULL, NULL);
if (rc) if (rc)
goto out_free_path; goto out_free_path;
else
iucv_path_connected = 1;
smsg_dev = kzalloc(sizeof(struct device), GFP_KERNEL);
if (!smsg_dev) {
rc = -ENOMEM;
goto out_free_path;
}
dev_set_name(smsg_dev, "smsg_iucv");
smsg_dev->bus = &iucv_bus;
smsg_dev->parent = iucv_root;
smsg_dev->release = (void (*)(struct device *))kfree;
smsg_dev->driver = &smsg_driver;
rc = device_register(smsg_dev);
if (rc)
goto out_put;
cpcmd("SET SMSG IUCV", NULL, 0, NULL); cpcmd("SET SMSG IUCV", NULL, 0, NULL);
return 0; return 0;
out_put:
put_device(smsg_dev);
out_free_path: out_free_path:
iucv_path_free(smsg_path); iucv_path_free(smsg_path);
smsg_path = NULL; smsg_path = NULL;
......
Markdown is supported
0%
or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment