[GitHub/LineageOS/android_kernel_motorola_exynos9610.git] / arch / sparc / kernel / pmc.c

// SPDX-License-Identifier: GPL-2.0
/* pmc - Driver implementation for power management functions
 * of Power Management Controller (PMC) on SPARCstation-Voyager.
 *
 * Copyright (c) 2002 Eric Brower (ebrower@usa.net)
 */

#include <linux/kernel.h>
#include <linux/fs.h>
#include <linux/errno.h>
#include <linux/init.h>
#include <linux/pm.h>
#include <linux/of.h>
#include <linux/of_device.h>
#include <linux/module.h>

#include <asm/io.h>
#include <asm/oplib.h>
#include <linux/uaccess.h>
#include <asm/auxio.h>
#include <asm/processor.h>

/* Debug
 *
 * #define PMC_DEBUG_LED
 * #define PMC_NO_IDLE
 */

#define PMC_OBPNAME	"SUNW,pmc"
#define PMC_DEVNAME	"pmc"

#define PMC_IDLE_REG	0x00
#define PMC_IDLE_ON	0x01

static u8 __iomem *regs;

#define pmc_readb(offs)		(sbus_readb(regs+offs))
#define pmc_writeb(val, offs)	(sbus_writeb(val, regs+offs))

/*
 * CPU idle callback function
 * See .../arch/sparc/kernel/process.c
 */
static void pmc_swift_idle(void)
{
#ifdef PMC_DEBUG_LED
	set_auxio(0x00, AUXIO_LED);
#endif

	pmc_writeb(pmc_readb(PMC_IDLE_REG) | PMC_IDLE_ON, PMC_IDLE_REG);

#ifdef PMC_DEBUG_LED
	set_auxio(AUXIO_LED, 0x00);
#endif
}

static int pmc_probe(struct platform_device *op)
{
	regs = of_ioremap(&op->resource[0], 0,
			  resource_size(&op->resource[0]), PMC_OBPNAME);
	if (!regs) {
		printk(KERN_ERR "%s: unable to map registers\n", PMC_DEVNAME);
		return -ENODEV;
	}

#ifndef PMC_NO_IDLE
	/* Assign power management IDLE handler */
	sparc_idle = pmc_swift_idle;
#endif

	printk(KERN_INFO "%s: power management initialized\n", PMC_DEVNAME);
	return 0;
}

static const struct of_device_id pmc_match[] = {
	{
		.name = PMC_OBPNAME,
	},
	{},
};
MODULE_DEVICE_TABLE(of, pmc_match);

static struct platform_driver pmc_driver = {
	.driver = {
		.name = "pmc",
		.of_match_table = pmc_match,
	},
	.probe		= pmc_probe,
};

static int __init pmc_init(void)
{
	return platform_driver_register(&pmc_driver);
}

/* This driver is not critical to the boot process
 * and is easiest to ioremap when SBus is already
 * initialized, so we install ourselves thusly:
 */
__initcall(pmc_init);
Commit	Line	Data
b2441318	1	// SPDX-License-Identifier: GPL-2.0
1da177e4 LT	2	/* pmc - Driver implementation for power management functions
	3	* of Power Management Controller (PMC) on SPARCstation-Voyager.
	4	*
	5	* Copyright (c) 2002 Eric Brower (ebrower@usa.net)
	6	*/
	7
	8	#include <linux/kernel.h>
	9	#include <linux/fs.h>
	10	#include <linux/errno.h>
	11	#include <linux/init.h>
1da177e4	12	#include <linux/pm.h>
f1b6aa87 DM	13	#include <linux/of.h>
f1b6aa87 DM	14	#include <linux/of_device.h>
f060ac54	15	#include <linux/module.h>
1da177e4 LT	16
1da177e4 LT	17	#include <asm/io.h>
1da177e4	18	#include <asm/oplib.h>
7c0f6ba6	19	#include <linux/uaccess.h>
1da177e4	20	#include <asm/auxio.h>
d472ba84	21	#include <asm/processor.h>
1da177e4 LT	22
	23	/* Debug
	24	*
	25	* #define PMC_DEBUG_LED
	26	* #define PMC_NO_IDLE
	27	*/
	28
1da177e4	29	#define PMC_OBPNAME "SUNW,pmc"
85bfbf44	30	#define PMC_DEVNAME "pmc"
1da177e4 LT	31
1da177e4 LT	32	#define PMC_IDLE_REG 0x00
85bfbf44	33	#define PMC_IDLE_ON 0x01
1da177e4	34
f1b6aa87	35	static u8 __iomem *regs;
1da177e4	36
f1b6aa87	37	#define pmc_readb(offs) (sbus_readb(regs+offs))
85bfbf44	38	#define pmc_writeb(val, offs) (sbus_writeb(val, regs+offs))
1da177e4	39
85bfbf44	40	/*
1da177e4 LT	41	* CPU idle callback function
	42	* See .../arch/sparc/kernel/process.c
	43	*/
39f6649b	44	static void pmc_swift_idle(void)
1da177e4 LT	45	{
1da177e4 LT	46	#ifdef PMC_DEBUG_LED
85bfbf44	47	set_auxio(0x00, AUXIO_LED);
1da177e4 LT	48	#endif
	49
	50	pmc_writeb(pmc_readb(PMC_IDLE_REG) \| PMC_IDLE_ON, PMC_IDLE_REG);
	51
	52	#ifdef PMC_DEBUG_LED
85bfbf44	53	set_auxio(AUXIO_LED, 0x00);
1da177e4	54	#endif
85bfbf44	55	}
1da177e4	56
7c9503b8	57	static int pmc_probe(struct platform_device *op)
1da177e4	58	{
f1b6aa87 DM	59	regs = of_ioremap(&op->resource[0], 0,
f1b6aa87 DM	60	resource_size(&op->resource[0]), PMC_OBPNAME);
1da177e4 LT	61	if (!regs) {
	62	printk(KERN_ERR "%s: unable to map registers\n", PMC_DEVNAME);
	63	return -ENODEV;
	64	}
	65
	66	#ifndef PMC_NO_IDLE
	67	/* Assign power management IDLE handler */
d472ba84	68	sparc_idle = pmc_swift_idle;
1da177e4 LT	69	#endif
	70
	71	printk(KERN_INFO "%s: power management initialized\n", PMC_DEVNAME);
	72	return 0;
	73	}
	74
0cd52df8	75	static const struct of_device_id pmc_match[] = {
f1b6aa87 DM	76	{
	77	.name = PMC_OBPNAME,
	78	},
	79	{},
	80	};
	81	MODULE_DEVICE_TABLE(of, pmc_match);
	82
4ebb24f7	83	static struct platform_driver pmc_driver = {
4018294b GL	84	.driver = {
4018294b GL	85	.name = "pmc",
4018294b GL	86	.of_match_table = pmc_match,
4018294b GL	87	},
f1b6aa87 DM	88	.probe = pmc_probe,
	89	};
	90
	91	static int __init pmc_init(void)
	92	{
4ebb24f7	93	return platform_driver_register(&pmc_driver);
f1b6aa87 DM	94	}
f1b6aa87 DM	95
1da177e4 LT	96	/* This driver is not critical to the boot process
	97	* and is easiest to ioremap when SBus is already
	98	* initialized, so we install ourselves thusly:
	99	*/
f1b6aa87	100	__initcall(pmc_init);