Commit 2f7e5208 authored by Peter Oberparleiter's avatar Peter Oberparleiter Committed by Vasily Gorbik
Browse files

s390/sclp: Remove sclp base power management support 



Power management support was removed for s390 with
commit 39421627 ("s390: remove broken hibernate / power management
support").

Remove leftover sclp base-related power management code. Note that we
keep the registration of the sclp platform driver since it is used to
externalize non-PM related attributes in sysfs.

Acked-by: default avatarHeiko Carstens <hca@linux.ibm.com>
Signed-off-by: default avatarPeter Oberparleiter <oberpar@linux.ibm.com>
Signed-off-by: default avatarVasily Gorbik <gor@linux.ibm.com>
parent 9b357ccd

drivers/s390/char/sclp.c

+1 −173
Original line number Diff line number Diff line
@@ -17,8 +17,6 @@ 
#include <linux/reboot.h>

#include <linux/jiffies.h>

#include <linux/init.h>

#include <linux/suspend.h>

#include <linux/completion.h>

#include <linux/platform_device.h>

#include <asm/types.h>

#include <asm/irq.h>
@@ -48,9 +46,6 @@ static struct sclp_req sclp_init_req; 
static void *sclp_read_sccb;

static struct init_sccb *sclp_init_sccb;



/* Suspend request */

static DECLARE_COMPLETION(sclp_request_queue_flushed);



/* Number of console pages to allocate, used by sclp_con.c and sclp_vt220.c */

int sclp_console_pages = SCLP_CONSOLE_PAGES;

/* Flag to indicate if buffer pages are dropped on buffer full condition */
@@ -58,11 +53,6 @@ int sclp_console_drop = 1; 
/* Number of times the console dropped buffer pages */

unsigned long sclp_console_full;



static void sclp_suspend_req_cb(struct sclp_req *req, void *data)

{

	complete(&sclp_request_queue_flushed);

}



static int __init sclp_setup_console_pages(char *str)

{

	int pages, rc;
@@ -87,8 +77,6 @@ static int __init sclp_setup_console_drop(char *str) 


__setup("sclp_con_drop=", sclp_setup_console_drop);



static struct sclp_req sclp_suspend_req;



/* Timer for request retries. */

static struct timer_list sclp_request_timer;
@@ -122,12 +110,6 @@ static volatile enum sclp_mask_state_t { 
	sclp_mask_state_initializing

} sclp_mask_state = sclp_mask_state_idle;



/* Internal state: is the driver suspended? */

static enum sclp_suspend_state_t {

	sclp_suspend_state_running,

	sclp_suspend_state_suspended,

} sclp_suspend_state = sclp_suspend_state_running;



/* Maximum retry counts */

#define SCLP_INIT_RETRY		3

#define SCLP_MASK_RETRY		3
@@ -313,8 +295,6 @@ sclp_process_queue(void) 
	del_timer(&sclp_request_timer);

	while (!list_empty(&sclp_req_queue)) {

		req = list_entry(sclp_req_queue.next, struct sclp_req, list);

		if (!req->sccb)

			goto do_post;

		rc = __sclp_start_request(req);

		if (rc == 0)

			break;
@@ -326,7 +306,6 @@ sclp_process_queue(void) 
						 sclp_request_timeout_normal);

			break;

		}

do_post:

		/* Post-processing for aborted request */

		list_del(&req->list);

		if (req->callback) {
@@ -340,10 +319,8 @@ sclp_process_queue(void) 


static int __sclp_can_add_request(struct sclp_req *req)

{

	if (req == &sclp_suspend_req || req == &sclp_init_req)

	if (req == &sclp_init_req)

		return 1;

	if (sclp_suspend_state != sclp_suspend_state_running)

		return 0;

	if (sclp_init_state != sclp_init_state_initialized)

		return 0;

	if (sclp_activation_state != sclp_activation_state_active)
@@ -377,16 +354,10 @@ sclp_add_request(struct sclp_req *req) 
	/* Start if request is first in list */

	if (sclp_running_state == sclp_running_state_idle &&

	    req->list.prev == &sclp_req_queue) {

		if (!req->sccb) {

			list_del(&req->list);

			rc = -ENODATA;

			goto out;

		}

		rc = __sclp_start_request(req);

		if (rc)

			list_del(&req->list);

	}

out:

	spin_unlock_irqrestore(&sclp_lock, flags);

	return rc;

}
@@ -692,7 +663,6 @@ sclp_register(struct sclp_register *reg) 
	/* Trigger initial state change callback */

	reg->sclp_receive_mask = 0;

	reg->sclp_send_mask = 0;

	reg->pm_event_posted = 0;

	list_add(&reg->list, &sclp_reg_list);

	spin_unlock_irqrestore(&sclp_lock, flags);

	rc = sclp_init_mask(1);
@@ -1010,112 +980,6 @@ static struct notifier_block sclp_reboot_notifier = { 
	.notifier_call = sclp_reboot_event

};



/*

 * Suspend/resume SCLP notifier implementation

 */



static void sclp_pm_event(enum sclp_pm_event sclp_pm_event, int rollback)

{

	struct sclp_register *reg;

	unsigned long flags;



	if (!rollback) {

		spin_lock_irqsave(&sclp_lock, flags);

		list_for_each_entry(reg, &sclp_reg_list, list)

			reg->pm_event_posted = 0;

		spin_unlock_irqrestore(&sclp_lock, flags);

	}

	do {

		spin_lock_irqsave(&sclp_lock, flags);

		list_for_each_entry(reg, &sclp_reg_list, list) {

			if (rollback && reg->pm_event_posted)

				goto found;

			if (!rollback && !reg->pm_event_posted)

				goto found;

		}

		spin_unlock_irqrestore(&sclp_lock, flags);

		return;

found:

		spin_unlock_irqrestore(&sclp_lock, flags);

		if (reg->pm_event_fn)

			reg->pm_event_fn(reg, sclp_pm_event);

		reg->pm_event_posted = rollback ? 0 : 1;

	} while (1);

}



/*

 * Susend/resume callbacks for platform device

 */



static int sclp_freeze(struct device *dev)

{

	unsigned long flags;

	int rc;



	sclp_pm_event(SCLP_PM_EVENT_FREEZE, 0);



	spin_lock_irqsave(&sclp_lock, flags);

	sclp_suspend_state = sclp_suspend_state_suspended;

	spin_unlock_irqrestore(&sclp_lock, flags);



	/* Init supend data */

	memset(&sclp_suspend_req, 0, sizeof(sclp_suspend_req));

	sclp_suspend_req.callback = sclp_suspend_req_cb;

	sclp_suspend_req.status = SCLP_REQ_FILLED;

	init_completion(&sclp_request_queue_flushed);



	rc = sclp_add_request(&sclp_suspend_req);

	if (rc == 0)

		wait_for_completion(&sclp_request_queue_flushed);

	else if (rc != -ENODATA)

		goto fail_thaw;



	rc = sclp_deactivate();

	if (rc)

		goto fail_thaw;

	return 0;



fail_thaw:

	spin_lock_irqsave(&sclp_lock, flags);

	sclp_suspend_state = sclp_suspend_state_running;

	spin_unlock_irqrestore(&sclp_lock, flags);

	sclp_pm_event(SCLP_PM_EVENT_THAW, 1);

	return rc;

}



static int sclp_undo_suspend(enum sclp_pm_event event)

{

	unsigned long flags;

	int rc;



	rc = sclp_reactivate();

	if (rc)

		return rc;



	spin_lock_irqsave(&sclp_lock, flags);

	sclp_suspend_state = sclp_suspend_state_running;

	spin_unlock_irqrestore(&sclp_lock, flags);



	sclp_pm_event(event, 0);

	return 0;

}



static int sclp_thaw(struct device *dev)

{

	return sclp_undo_suspend(SCLP_PM_EVENT_THAW);

}



static int sclp_restore(struct device *dev)

{

	return sclp_undo_suspend(SCLP_PM_EVENT_RESTORE);

}



static const struct dev_pm_ops sclp_pm_ops = {

	.freeze		= sclp_freeze,

	.thaw		= sclp_thaw,

	.restore	= sclp_restore,

};



static ssize_t con_pages_show(struct device_driver *dev, char *buf)

{

	return sprintf(buf, "%i\n", sclp_console_pages);
@@ -1154,13 +1018,10 @@ static const struct attribute_group *sclp_drv_attr_groups[] = { 
static struct platform_driver sclp_pdrv = {

	.driver = {

		.name	= "sclp",

		.pm	= &sclp_pm_ops,

		.groups = sclp_drv_attr_groups,

	},

};



static struct platform_device *sclp_pdev;



/* Initialize SCLP driver. Return zero if driver is operational, non-zero

 * otherwise. */

static int
@@ -1214,23 +1075,6 @@ sclp_init(void) 
	return rc;

}



/*

 * SCLP panic notifier: If we are suspended, we thaw SCLP in order to be able

 * to print the panic message.

 */

static int sclp_panic_notify(struct notifier_block *self,

			     unsigned long event, void *data)

{

	if (sclp_suspend_state == sclp_suspend_state_suspended)

		sclp_undo_suspend(SCLP_PM_EVENT_THAW);

	return NOTIFY_OK;

}



static struct notifier_block sclp_on_panic_nb = {

	.notifier_call = sclp_panic_notify,

	.priority = SCLP_PANIC_PRIO,

};



static __init int sclp_initcall(void)

{

	int rc;
@@ -1239,23 +1083,7 @@ static __init int sclp_initcall(void) 
	if (rc)

		return rc;



	sclp_pdev = platform_device_register_simple("sclp", -1, NULL, 0);

	rc = PTR_ERR_OR_ZERO(sclp_pdev);

	if (rc)

		goto fail_platform_driver_unregister;



	rc = atomic_notifier_chain_register(&panic_notifier_list,

					    &sclp_on_panic_nb);

	if (rc)

		goto fail_platform_device_unregister;



	return sclp_init();



fail_platform_device_unregister:

	platform_device_unregister(sclp_pdev);

fail_platform_driver_unregister:

	platform_driver_unregister(&sclp_pdrv);

	return rc;

}



arch_initcall(sclp_initcall);

drivers/s390/char/sclp.h

+0 −13
Original line number Diff line number Diff line
@@ -81,15 +81,6 @@ typedef unsigned int sclp_cmdw_t; 


#define GDS_KEY_SELFDEFTEXTMSG	0x31



enum sclp_pm_event {

	SCLP_PM_EVENT_FREEZE,

	SCLP_PM_EVENT_THAW,

	SCLP_PM_EVENT_RESTORE,

};



#define SCLP_PANIC_PRIO		1

#define SCLP_PANIC_PRIO_CLIENT	0



typedef u64 sccb_mask_t;



struct sccb_header {
@@ -293,10 +284,6 @@ struct sclp_register { 
	void (*state_change_fn)(struct sclp_register *);

	/* called for events in cp_receive_mask/sclp_receive_mask */

	void (*receiver_fn)(struct evbuf_header *);

	/* called for power management events */

	void (*pm_event_fn)(struct sclp_register *, enum sclp_pm_event);

	/* pm event posted flag */

	int pm_event_posted;

};



/* externals from sclp.c */

drivers/s390/char/sclp_ftp.c

+0 −1
Original line number Diff line number Diff line
@@ -231,7 +231,6 @@ static struct sclp_register sclp_ftp_event = { 
	.receive_mask = EVTYP_DIAG_TEST_MASK, /* want rx events */

	.receiver_fn = sclp_ftp_rxcb,	      /* async callback (rx) */

	.state_change_fn = NULL,

	.pm_event_fn = NULL,

};



/**