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

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

arch/s390/include/asm/ccwgroup.h

+0 −10
Original line number Diff line number Diff line
@@ -36,11 +36,6 @@ struct ccwgroup_device { 
 * @set_online: function called when device is set online

 * @set_offline: function called when device is set offline

 * @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

 * @ccw_driver: supported ccw_driver (optional)

 */
@@ -50,11 +45,6 @@ struct ccwgroup_driver { 
	int (*set_online) (struct ccwgroup_device *);

	int (*set_offline) (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 ccw_driver *ccw_driver;

drivers/s390/net/ctcm_main.c

+0 −40
Original line number Diff line number Diff line
@@ -1698,43 +1698,6 @@ static void ctcm_remove_device(struct ccwgroup_device *cgdev) 
	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[] = {

	{CCW_DEVICE(0x3088, 0x08), .driver_info = ctcm_channel_type_parallel},

	{CCW_DEVICE(0x3088, 0x1e), .driver_info = ctcm_channel_type_ficon},
@@ -1764,9 +1727,6 @@ static struct ccwgroup_driver ctcm_group_driver = { 
	.remove      = ctcm_remove_device,

	.set_online  = ctcm_new_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,

drivers/s390/net/lcs.c

+0 −59
Original line number Diff line number Diff line
@@ -2296,60 +2296,6 @@ lcs_remove_device(struct ccwgroup_device *ccwgdev) 
	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[] = {

	{CCW_DEVICE(0x3088, 0x08), .driver_info = lcs_channel_type_parallel},

	{CCW_DEVICE(0x3088, 0x1f), .driver_info = lcs_channel_type_2216},
@@ -2382,11 +2328,6 @@ static struct ccwgroup_driver lcs_group_driver = { 
	.remove      = lcs_remove_device,

	.set_online  = lcs_new_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,

drivers/s390/net/netiucv.c

+1 −103
Original line number Diff line number Diff line
@@ -112,27 +112,10 @@ DECLARE_PER_CPU(char[256], iucv_dbf_txt_buf); 
 */

#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 = {

	.owner = THIS_MODULE,

	.name = "netiucv",

	.bus  = &iucv_bus,

	.pm = &netiucv_pm_ops,

};



static int netiucv_callback_connreq(struct iucv_path *, u8 *, u8 *);
@@ -213,7 +196,6 @@ struct netiucv_priv { 
	fsm_instance            *fsm;

        struct iucv_connection  *conn;

	struct device           *dev;

	int			 pm_state;

};



/**
@@ -1275,72 +1257,6 @@ static int netiucv_close(struct net_device *dev) 
	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.

 * Called from generic network device layer.
@@ -2156,7 +2072,6 @@ static void __exit netiucv_exit(void) 
		netiucv_unregister_device(dev);

	}



	device_unregister(netiucv_dev);

	driver_unregister(&netiucv_driver);

	iucv_unregister(&netiucv_handler, 1);

	iucv_unregister_dbf_views();
@@ -2182,27 +2097,10 @@ static int __init netiucv_init(void) 
		IUCV_DBF_TEXT_(setup, 2, "ret %d from driver_register\n", rc);

		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();

	return rc;



out_driver:

	driver_unregister(&netiucv_driver);

out_iucv:

	iucv_unregister(&netiucv_handler, 1);

out_dbf:

drivers/s390/net/qeth_core_main.c

+0 −31
Original line number Diff line number Diff line
@@ -6434,32 +6434,6 @@ static void qeth_core_shutdown(struct ccwgroup_device *gdev) 
	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,

			   size_t count)

{
@@ -6496,11 +6470,6 @@ static struct ccwgroup_driver qeth_core_ccwgroup_driver = { 
	.set_online = qeth_core_set_online,

	.set_offline = qeth_core_set_offline,

	.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)