[mirror_ubuntu-hirsute-kernel.git] / drivers / leds / leds-fsg.c

// SPDX-License-Identifier: GPL-2.0-only
/*
 * LED Driver for the Freecom FSG-3
 *
 * Copyright (c) 2008 Rod Whitby <rod@whitby.id.au>
 *
 * Author: Rod Whitby <rod@whitby.id.au>
 *
 * Based on leds-spitz.c
 * Copyright 2005-2006 Openedhand Ltd.
 * Author: Richard Purdie <rpurdie@openedhand.com>
 */

#include <linux/kernel.h>
#include <linux/platform_device.h>
#include <linux/leds.h>
#include <linux/module.h>
#include <linux/io.h>
#include <mach/hardware.h>

#define FSG_LED_WLAN_BIT	0
#define FSG_LED_WAN_BIT		1
#define FSG_LED_SATA_BIT	2
#define FSG_LED_USB_BIT		4
#define FSG_LED_RING_BIT	5
#define FSG_LED_SYNC_BIT	7

static short __iomem *latch_address;
static unsigned short latch_value;


static void fsg_led_wlan_set(struct led_classdev *led_cdev,
			     enum led_brightness value)
{
	if (value) {
		latch_value &= ~(1 << FSG_LED_WLAN_BIT);
		*latch_address = latch_value;
	} else {
		latch_value |=  (1 << FSG_LED_WLAN_BIT);
		*latch_address = latch_value;
	}
}

static void fsg_led_wan_set(struct led_classdev *led_cdev,
			    enum led_brightness value)
{
	if (value) {
		latch_value &= ~(1 << FSG_LED_WAN_BIT);
		*latch_address = latch_value;
	} else {
		latch_value |=  (1 << FSG_LED_WAN_BIT);
		*latch_address = latch_value;
	}
}

static void fsg_led_sata_set(struct led_classdev *led_cdev,
			     enum led_brightness value)
{
	if (value) {
		latch_value &= ~(1 << FSG_LED_SATA_BIT);
		*latch_address = latch_value;
	} else {
		latch_value |=  (1 << FSG_LED_SATA_BIT);
		*latch_address = latch_value;
	}
}

static void fsg_led_usb_set(struct led_classdev *led_cdev,
			    enum led_brightness value)
{
	if (value) {
		latch_value &= ~(1 << FSG_LED_USB_BIT);
		*latch_address = latch_value;
	} else {
		latch_value |=  (1 << FSG_LED_USB_BIT);
		*latch_address = latch_value;
	}
}

static void fsg_led_sync_set(struct led_classdev *led_cdev,
			     enum led_brightness value)
{
	if (value) {
		latch_value &= ~(1 << FSG_LED_SYNC_BIT);
		*latch_address = latch_value;
	} else {
		latch_value |=  (1 << FSG_LED_SYNC_BIT);
		*latch_address = latch_value;
	}
}

static void fsg_led_ring_set(struct led_classdev *led_cdev,
			     enum led_brightness value)
{
	if (value) {
		latch_value &= ~(1 << FSG_LED_RING_BIT);
		*latch_address = latch_value;
	} else {
		latch_value |=  (1 << FSG_LED_RING_BIT);
		*latch_address = latch_value;
	}
}


static struct led_classdev fsg_wlan_led = {
	.name			= "fsg:blue:wlan",
	.brightness_set		= fsg_led_wlan_set,
	.flags			= LED_CORE_SUSPENDRESUME,
};

static struct led_classdev fsg_wan_led = {
	.name			= "fsg:blue:wan",
	.brightness_set		= fsg_led_wan_set,
	.flags			= LED_CORE_SUSPENDRESUME,
};

static struct led_classdev fsg_sata_led = {
	.name			= "fsg:blue:sata",
	.brightness_set		= fsg_led_sata_set,
	.flags			= LED_CORE_SUSPENDRESUME,
};

static struct led_classdev fsg_usb_led = {
	.name			= "fsg:blue:usb",
	.brightness_set		= fsg_led_usb_set,
	.flags			= LED_CORE_SUSPENDRESUME,
};

static struct led_classdev fsg_sync_led = {
	.name			= "fsg:blue:sync",
	.brightness_set		= fsg_led_sync_set,
	.flags			= LED_CORE_SUSPENDRESUME,
};

static struct led_classdev fsg_ring_led = {
	.name			= "fsg:blue:ring",
	.brightness_set		= fsg_led_ring_set,
	.flags			= LED_CORE_SUSPENDRESUME,
};


static int fsg_led_probe(struct platform_device *pdev)
{
	int ret;

	/* Map the LED chip select address space */
	latch_address = (unsigned short *) devm_ioremap(&pdev->dev,
						IXP4XX_EXP_BUS_BASE(2), 512);
	if (!latch_address)
		return -ENOMEM;

	latch_value = 0xffff;
	*latch_address = latch_value;

	ret = devm_led_classdev_register(&pdev->dev, &fsg_wlan_led);
	if (ret < 0)
		return ret;

	ret = devm_led_classdev_register(&pdev->dev, &fsg_wan_led);
	if (ret < 0)
		return ret;

	ret = devm_led_classdev_register(&pdev->dev, &fsg_sata_led);
	if (ret < 0)
		return ret;

	ret = devm_led_classdev_register(&pdev->dev, &fsg_usb_led);
	if (ret < 0)
		return ret;

	ret = devm_led_classdev_register(&pdev->dev, &fsg_sync_led);
	if (ret < 0)
		return ret;

	ret = devm_led_classdev_register(&pdev->dev, &fsg_ring_led);
	if (ret < 0)
		return ret;

	return ret;
}

static struct platform_driver fsg_led_driver = {
	.probe		= fsg_led_probe,
	.driver		= {
		.name		= "fsg-led",
	},
};

module_platform_driver(fsg_led_driver);

MODULE_AUTHOR("Rod Whitby <rod@whitby.id.au>");
MODULE_DESCRIPTION("Freecom FSG-3 LED driver");
MODULE_LICENSE("GPL");
Commit	Line	Data
d2912cb1	1	// SPDX-License-Identifier: GPL-2.0-only
3b2e46f8 RW	2	/*
	3	* LED Driver for the Freecom FSG-3
	4	*
	5	* Copyright (c) 2008 Rod Whitby <rod@whitby.id.au>
	6	*
	7	* Author: Rod Whitby <rod@whitby.id.au>
	8	*
	9	* Based on leds-spitz.c
	10	* Copyright 2005-2006 Openedhand Ltd.
	11	* Author: Richard Purdie <rpurdie@openedhand.com>
3b2e46f8 RW	12	*/
	13
	14	#include <linux/kernel.h>
3b2e46f8 RW	15	#include <linux/platform_device.h>
3b2e46f8 RW	16	#include <linux/leds.h>
54f4dedb	17	#include <linux/module.h>
aa2dcf9d	18	#include <linux/io.h>
a09e64fb	19	#include <mach/hardware.h>
3b2e46f8	20
914e7bc2 KH	21	#define FSG_LED_WLAN_BIT 0
	22	#define FSG_LED_WAN_BIT 1
	23	#define FSG_LED_SATA_BIT 2
	24	#define FSG_LED_USB_BIT 4
	25	#define FSG_LED_RING_BIT 5
	26	#define FSG_LED_SYNC_BIT 7
	27
3b2e46f8 RW	28	static short __iomem *latch_address;
	29	static unsigned short latch_value;
	30
	31
	32	static void fsg_led_wlan_set(struct led_classdev *led_cdev,
	33	enum led_brightness value)
	34	{
	35	if (value) {
	36	latch_value &= ~(1 << FSG_LED_WLAN_BIT);
	37	*latch_address = latch_value;
	38	} else {
	39	latch_value \|= (1 << FSG_LED_WLAN_BIT);
	40	*latch_address = latch_value;
	41	}
	42	}
	43
	44	static void fsg_led_wan_set(struct led_classdev *led_cdev,
	45	enum led_brightness value)
	46	{
	47	if (value) {
	48	latch_value &= ~(1 << FSG_LED_WAN_BIT);
	49	*latch_address = latch_value;
	50	} else {
	51	latch_value \|= (1 << FSG_LED_WAN_BIT);
	52	*latch_address = latch_value;
	53	}
	54	}
	55
	56	static void fsg_led_sata_set(struct led_classdev *led_cdev,
	57	enum led_brightness value)
	58	{
	59	if (value) {
	60	latch_value &= ~(1 << FSG_LED_SATA_BIT);
	61	*latch_address = latch_value;
	62	} else {
	63	latch_value \|= (1 << FSG_LED_SATA_BIT);
	64	*latch_address = latch_value;
	65	}
	66	}
	67
	68	static void fsg_led_usb_set(struct led_classdev *led_cdev,
	69	enum led_brightness value)
	70	{
	71	if (value) {
	72	latch_value &= ~(1 << FSG_LED_USB_BIT);
	73	*latch_address = latch_value;
	74	} else {
	75	latch_value \|= (1 << FSG_LED_USB_BIT);
	76	*latch_address = latch_value;
	77	}
	78	}
	79
	80	static void fsg_led_sync_set(struct led_classdev *led_cdev,
	81	enum led_brightness value)
	82	{
	83	if (value) {
	84	latch_value &= ~(1 << FSG_LED_SYNC_BIT);
	85	*latch_address = latch_value;
	86	} else {
	87	latch_value \|= (1 << FSG_LED_SYNC_BIT);
	88	*latch_address = latch_value;
	89	}
	90	}
	91
92	static void fsg_led_ring_set(struct led_classdev *led_cdev,
93	enum led_brightness value)
94	{
95	if (value) {
96	latch_value &= ~(1 << FSG_LED_RING_BIT);
97	*latch_address = latch_value;
98	} else {
99	latch_value \|= (1 << FSG_LED_RING_BIT);
100	*latch_address = latch_value;
101	}
102	}
103
104
3b2e46f8 RW	105	static struct led_classdev fsg_wlan_led = {
	106	.name = "fsg:blue:wlan",
	107	.brightness_set = fsg_led_wlan_set,
859cb7f2	108	.flags = LED_CORE_SUSPENDRESUME,
3b2e46f8 RW	109	};
	110
	111	static struct led_classdev fsg_wan_led = {
	112	.name = "fsg:blue:wan",
	113	.brightness_set = fsg_led_wan_set,
859cb7f2	114	.flags = LED_CORE_SUSPENDRESUME,
3b2e46f8 RW	115	};
	116
	117	static struct led_classdev fsg_sata_led = {
	118	.name = "fsg:blue:sata",
	119	.brightness_set = fsg_led_sata_set,
859cb7f2	120	.flags = LED_CORE_SUSPENDRESUME,
3b2e46f8 RW	121	};
	122
	123	static struct led_classdev fsg_usb_led = {
	124	.name = "fsg:blue:usb",
	125	.brightness_set = fsg_led_usb_set,
859cb7f2	126	.flags = LED_CORE_SUSPENDRESUME,
3b2e46f8 RW	127	};
	128
	129	static struct led_classdev fsg_sync_led = {
	130	.name = "fsg:blue:sync",
	131	.brightness_set = fsg_led_sync_set,
859cb7f2	132	.flags = LED_CORE_SUSPENDRESUME,
3b2e46f8 RW	133	};
	134
	135	static struct led_classdev fsg_ring_led = {
	136	.name = "fsg:blue:ring",
	137	.brightness_set = fsg_led_ring_set,
859cb7f2	138	.flags = LED_CORE_SUSPENDRESUME,
3b2e46f8 RW	139	};
	140
	141
3b2e46f8 RW	142	static int fsg_led_probe(struct platform_device *pdev)
	143	{
	144	int ret;
	145
07f696c7	146	/* Map the LED chip select address space */
aa2dcf9d JH	147	latch_address = (unsigned short *) devm_ioremap(&pdev->dev,
	148	IXP4XX_EXP_BUS_BASE(2), 512);
	149	if (!latch_address)
	150	return -ENOMEM;
07f696c7 SW	151
	152	latch_value = 0xffff;
	153	*latch_address = latch_value;
	154
c2d4af93	155	ret = devm_led_classdev_register(&pdev->dev, &fsg_wlan_led);
3b2e46f8	156	if (ret < 0)
c2d4af93	157	return ret;
3b2e46f8	158
c2d4af93	159	ret = devm_led_classdev_register(&pdev->dev, &fsg_wan_led);
3b2e46f8	160	if (ret < 0)
c2d4af93	161	return ret;
3b2e46f8	162
c2d4af93	163	ret = devm_led_classdev_register(&pdev->dev, &fsg_sata_led);
3b2e46f8	164	if (ret < 0)
c2d4af93	165	return ret;
3b2e46f8	166
c2d4af93	167	ret = devm_led_classdev_register(&pdev->dev, &fsg_usb_led);
3b2e46f8	168	if (ret < 0)
c2d4af93	169	return ret;
3b2e46f8	170
c2d4af93	171	ret = devm_led_classdev_register(&pdev->dev, &fsg_sync_led);
3b2e46f8	172	if (ret < 0)
c2d4af93	173	return ret;
3b2e46f8	174
c2d4af93	175	ret = devm_led_classdev_register(&pdev->dev, &fsg_ring_led);
3b2e46f8	176	if (ret < 0)
c2d4af93	177	return ret;
3b2e46f8 RW	178
	179	return ret;
	180	}
	181
3b2e46f8 RW	182	static struct platform_driver fsg_led_driver = {
3b2e46f8 RW	183	.probe = fsg_led_probe,
3b2e46f8 RW	184	.driver = {
	185	.name = "fsg-led",
	186	},
	187	};
	188
892a8843	189	module_platform_driver(fsg_led_driver);
3b2e46f8 RW	190
	191	MODULE_AUTHOR("Rod Whitby <rod@whitby.id.au>");
	192	MODULE_DESCRIPTION("Freecom FSG-3 LED driver");
	193	MODULE_LICENSE("GPL");