Commit 4b32f86b authored by Julian Wiedmann's avatar Julian Wiedmann Committed by David S. Miller
Browse files

net/iucv: remove pm support 



commit 39421627 ("s390: remove broken hibernate / power management support")
removed support for ARCH_HIBERNATION_POSSIBLE from s390.

So drop the unused pm ops from the s390-only iucv bus driver.

CC: Hendrik Brueckner <brueckner@linux.ibm.com>
Signed-off-by: default avatarJulian Wiedmann <jwi@linux.ibm.com>
Signed-off-by: default avatarDavid S. Miller <davem@davemloft.net>
parent 2de49925

net/iucv/iucv.c

+0 −188
Original line number Diff line number Diff line
@@ -67,32 +67,9 @@ static int iucv_bus_match(struct device *dev, struct device_driver *drv) 
	return 0;

}



enum iucv_pm_states {

	IUCV_PM_INITIAL = 0,

	IUCV_PM_FREEZING = 1,

	IUCV_PM_THAWING = 2,

	IUCV_PM_RESTORING = 3,

};

static enum iucv_pm_states iucv_pm_state;



static int iucv_pm_prepare(struct device *);

static void iucv_pm_complete(struct device *);

static int iucv_pm_freeze(struct device *);

static int iucv_pm_thaw(struct device *);

static int iucv_pm_restore(struct device *);



static const struct dev_pm_ops iucv_pm_ops = {

	.prepare = iucv_pm_prepare,

	.complete = iucv_pm_complete,

	.freeze = iucv_pm_freeze,

	.thaw = iucv_pm_thaw,

	.restore = iucv_pm_restore,

};



struct bus_type iucv_bus = {

	.name = "iucv",

	.match = iucv_bus_match,

	.pm = &iucv_pm_ops,

};

EXPORT_SYMBOL(iucv_bus);
@@ -434,31 +411,6 @@ static void iucv_block_cpu(void *data) 
	cpumask_clear_cpu(cpu, &iucv_irq_cpumask);

}



/**

 * iucv_block_cpu_almost

 * @data: unused

 *

 * Allow connection-severed interrupts only on this cpu.

 */

static void iucv_block_cpu_almost(void *data)

{

	int cpu = smp_processor_id();

	union iucv_param *parm;



	/* Allow iucv control interrupts only */

	parm = iucv_param_irq[cpu];

	memset(parm, 0, sizeof(union iucv_param));

	parm->set_mask.ipmask = 0x08;

	iucv_call_b2f0(IUCV_SETMASK, parm);

	/* Allow iucv-severed interrupt only */

	memset(parm, 0, sizeof(union iucv_param));

	parm->set_mask.ipmask = 0x20;

	iucv_call_b2f0(IUCV_SETCONTROLMASK, parm);



	/* Clear indication that iucv interrupts are allowed for this cpu. */

	cpumask_clear_cpu(cpu, &iucv_irq_cpumask);

}



/**

 * iucv_declare_cpu

 * @data: unused
@@ -1834,146 +1786,6 @@ static void iucv_external_interrupt(struct ext_code ext_code, 
	spin_unlock(&iucv_queue_lock);

}



static int iucv_pm_prepare(struct device *dev)

{

	int rc = 0;



#ifdef CONFIG_PM_DEBUG

	printk(KERN_INFO "iucv_pm_prepare\n");

#endif

	if (dev->driver && dev->driver->pm && dev->driver->pm->prepare)

		rc = dev->driver->pm->prepare(dev);

	return rc;

}



static void iucv_pm_complete(struct device *dev)

{

#ifdef CONFIG_PM_DEBUG

	printk(KERN_INFO "iucv_pm_complete\n");

#endif

	if (dev->driver && dev->driver->pm && dev->driver->pm->complete)

		dev->driver->pm->complete(dev);

}



/**

 * iucv_path_table_empty() - determine if iucv path table is empty

 *

 * Returns 0 if there are still iucv pathes defined

 *	   1 if there are no iucv pathes defined

 */

static int iucv_path_table_empty(void)

{

	int i;



	for (i = 0; i < iucv_max_pathid; i++) {

		if (iucv_path_table[i])

			return 0;

	}

	return 1;

}



/**

 * iucv_pm_freeze() - Freeze PM callback

 * @dev:	iucv-based device

 *

 * disable iucv interrupts

 * invoke callback function of the iucv-based driver

 * shut down iucv, if no iucv-pathes are established anymore

 */

static int iucv_pm_freeze(struct device *dev)

{

	int cpu;

	struct iucv_irq_list *p, *n;

	int rc = 0;



#ifdef CONFIG_PM_DEBUG

	printk(KERN_WARNING "iucv_pm_freeze\n");

#endif

	if (iucv_pm_state != IUCV_PM_FREEZING) {

		for_each_cpu(cpu, &iucv_irq_cpumask)

			smp_call_function_single(cpu, iucv_block_cpu_almost,

						 NULL, 1);

		cancel_work_sync(&iucv_work);

		list_for_each_entry_safe(p, n, &iucv_work_queue, list) {

			list_del_init(&p->list);

			iucv_sever_pathid(p->data.ippathid,

					  iucv_error_no_listener);

			kfree(p);

		}

	}

	iucv_pm_state = IUCV_PM_FREEZING;

	if (dev->driver && dev->driver->pm && dev->driver->pm->freeze)

		rc = dev->driver->pm->freeze(dev);

	if (iucv_path_table_empty())

		iucv_disable();

	return rc;

}



/**

 * iucv_pm_thaw() - Thaw PM callback

 * @dev:	iucv-based device

 *

 * make iucv ready for use again: allocate path table, declare interrupt buffers

 *				  and enable iucv interrupts

 * invoke callback function of the iucv-based driver

 */

static int iucv_pm_thaw(struct device *dev)

{

	int rc = 0;



#ifdef CONFIG_PM_DEBUG

	printk(KERN_WARNING "iucv_pm_thaw\n");

#endif

	iucv_pm_state = IUCV_PM_THAWING;

	if (!iucv_path_table) {

		rc = iucv_enable();

		if (rc)

			goto out;

	}

	if (cpumask_empty(&iucv_irq_cpumask)) {

		if (iucv_nonsmp_handler)

			/* enable interrupts on one cpu */

			iucv_allow_cpu(NULL);

		else

			/* enable interrupts on all cpus */

			iucv_setmask_mp();

	}

	if (dev->driver && dev->driver->pm && dev->driver->pm->thaw)

		rc = dev->driver->pm->thaw(dev);

out:

	return rc;

}



/**

 * iucv_pm_restore() - Restore PM callback

 * @dev:	iucv-based device

 *

 * make iucv ready for use again: allocate path table, declare interrupt buffers

 *				  and enable iucv interrupts

 * invoke callback function of the iucv-based driver

 */

static int iucv_pm_restore(struct device *dev)

{

	int rc = 0;



#ifdef CONFIG_PM_DEBUG

	printk(KERN_WARNING "iucv_pm_restore %p\n", iucv_path_table);

#endif

	if ((iucv_pm_state != IUCV_PM_RESTORING) && iucv_path_table)

		pr_warn("Suspending Linux did not completely close all IUCV connections\n");

	iucv_pm_state = IUCV_PM_RESTORING;

	if (cpumask_empty(&iucv_irq_cpumask)) {

		rc = iucv_query_maxconn();

		rc = iucv_enable();

		if (rc)

			goto out;

	}

	if (dev->driver && dev->driver->pm && dev->driver->pm->restore)

		rc = dev->driver->pm->restore(dev);

out:

	return rc;

}



struct iucv_interface iucv_if = {

	.message_receive = iucv_message_receive,

	.__message_receive = __iucv_message_receive,

CRA Git | Maintained and supported by SUSTech CRA and CCSE