1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3  * Linux LED driver for RTL8187
4  *
5  * Copyright 2009 Larry Finger <Larry.Finger@lwfinger.net>
6  *
7  * Based on the LED handling in the r8187 driver, which is:
8  * Copyright (c) Realtek Semiconductor Corp. All rights reserved.
9  *
10  * Thanks to Realtek for their support!
11  */
12 
13 #ifdef CONFIG_RTL8187_LEDS
14 
15 #include <net/mac80211.h>
16 #include <linux/usb.h>
17 #include <linux/eeprom_93cx6.h>
18 
19 #include "rtl8187.h"
20 #include "leds.h"
21 
22 static void led_turn_on(struct work_struct *work)
23 {
24 	/* As this routine does read/write operations on the hardware, it must
25 	 * be run from a work queue.
26 	 */
27 	u8 reg;
28 	struct rtl8187_priv *priv = container_of(work, struct rtl8187_priv,
29 				    led_on.work);
30 	struct rtl8187_led *led = &priv->led_tx;
31 
32 	/* Don't change the LED, when the device is down. */
33 	if (!priv->vif || priv->vif->type == NL80211_IFTYPE_UNSPECIFIED)
34 		return ;
35 
36 	/* Skip if the LED is not registered. */
37 	if (!led->dev)
38 		return;
39 	mutex_lock(&priv->conf_mutex);
40 	switch (led->ledpin) {
41 	case LED_PIN_GPIO0:
42 		rtl818x_iowrite8(priv, &priv->map->GPIO0, 0x01);
43 		rtl818x_iowrite8(priv, &priv->map->GP_ENABLE, 0x00);
44 		break;
45 	case LED_PIN_LED0:
46 		reg = rtl818x_ioread8(priv, &priv->map->PGSELECT) & ~(1 << 4);
47 		rtl818x_iowrite8(priv, &priv->map->PGSELECT, reg);
48 		break;
49 	case LED_PIN_LED1:
50 		reg = rtl818x_ioread8(priv, &priv->map->PGSELECT) & ~(1 << 5);
51 		rtl818x_iowrite8(priv, &priv->map->PGSELECT, reg);
52 		break;
53 	case LED_PIN_HW:
54 	default:
55 		break;
56 	}
57 	mutex_unlock(&priv->conf_mutex);
58 }
59 
60 static void led_turn_off(struct work_struct *work)
61 {
62 	/* As this routine does read/write operations on the hardware, it must
63 	 * be run from a work queue.
64 	 */
65 	u8 reg;
66 	struct rtl8187_priv *priv = container_of(work, struct rtl8187_priv,
67 				    led_off.work);
68 	struct rtl8187_led *led = &priv->led_tx;
69 
70 	/* Don't change the LED, when the device is down. */
71 	if (!priv->vif || priv->vif->type == NL80211_IFTYPE_UNSPECIFIED)
72 		return ;
73 
74 	/* Skip if the LED is not registered. */
75 	if (!led->dev)
76 		return;
77 	mutex_lock(&priv->conf_mutex);
78 	switch (led->ledpin) {
79 	case LED_PIN_GPIO0:
80 		rtl818x_iowrite8(priv, &priv->map->GPIO0, 0x01);
81 		rtl818x_iowrite8(priv, &priv->map->GP_ENABLE, 0x01);
82 		break;
83 	case LED_PIN_LED0:
84 		reg = rtl818x_ioread8(priv, &priv->map->PGSELECT) | (1 << 4);
85 		rtl818x_iowrite8(priv, &priv->map->PGSELECT, reg);
86 		break;
87 	case LED_PIN_LED1:
88 		reg = rtl818x_ioread8(priv, &priv->map->PGSELECT) | (1 << 5);
89 		rtl818x_iowrite8(priv, &priv->map->PGSELECT, reg);
90 		break;
91 	case LED_PIN_HW:
92 	default:
93 		break;
94 	}
95 	mutex_unlock(&priv->conf_mutex);
96 }
97 
98 /* Callback from the LED subsystem. */
99 static void rtl8187_led_brightness_set(struct led_classdev *led_dev,
100 				   enum led_brightness brightness)
101 {
102 	struct rtl8187_led *led = container_of(led_dev, struct rtl8187_led,
103 					       led_dev);
104 	struct ieee80211_hw *hw = led->dev;
105 	struct rtl8187_priv *priv;
106 	static bool radio_on;
107 
108 	if (!hw)
109 		return;
110 	priv = hw->priv;
111 	if (led->is_radio) {
112 		if (brightness == LED_FULL) {
113 			ieee80211_queue_delayed_work(hw, &priv->led_on, 0);
114 			radio_on = true;
115 		} else if (radio_on) {
116 			radio_on = false;
117 			cancel_delayed_work(&priv->led_on);
118 			ieee80211_queue_delayed_work(hw, &priv->led_off, 0);
119 		}
120 	} else if (radio_on) {
121 		if (brightness == LED_OFF) {
122 			ieee80211_queue_delayed_work(hw, &priv->led_off, 0);
123 			/* The LED is off for 1/20 sec - it just blinks. */
124 			ieee80211_queue_delayed_work(hw, &priv->led_on,
125 						     HZ / 20);
126 		} else
127 			ieee80211_queue_delayed_work(hw, &priv->led_on, 0);
128 	}
129 }
130 
131 static int rtl8187_register_led(struct ieee80211_hw *dev,
132 				struct rtl8187_led *led, const char *name,
133 				const char *default_trigger, u8 ledpin,
134 				bool is_radio)
135 {
136 	int err;
137 	struct rtl8187_priv *priv = dev->priv;
138 
139 	if (led->dev)
140 		return -EEXIST;
141 	if (!default_trigger)
142 		return -EINVAL;
143 	led->dev = dev;
144 	led->ledpin = ledpin;
145 	led->is_radio = is_radio;
146 	strscpy(led->name, name, sizeof(led->name));
147 
148 	led->led_dev.name = led->name;
149 	led->led_dev.default_trigger = default_trigger;
150 	led->led_dev.brightness_set = rtl8187_led_brightness_set;
151 
152 	err = led_classdev_register(&priv->udev->dev, &led->led_dev);
153 	if (err) {
154 		printk(KERN_INFO "LEDs: Failed to register %s\n", name);
155 		led->dev = NULL;
156 		return err;
157 	}
158 	return 0;
159 }
160 
161 static void rtl8187_unregister_led(struct rtl8187_led *led)
162 {
163 	struct ieee80211_hw *hw = led->dev;
164 	struct rtl8187_priv *priv = hw->priv;
165 
166 	led_classdev_unregister(&led->led_dev);
167 	flush_delayed_work(&priv->led_off);
168 	led->dev = NULL;
169 }
170 
171 void rtl8187_leds_init(struct ieee80211_hw *dev, u16 custid)
172 {
173 	struct rtl8187_priv *priv = dev->priv;
174 	char name[RTL8187_LED_MAX_NAME_LEN + 1];
175 	u8 ledpin;
176 	int err;
177 
178 	/* According to the vendor driver, the LED operation depends on the
179 	 * customer ID encoded in the EEPROM
180 	 */
181 	printk(KERN_INFO "rtl8187: Customer ID is 0x%02X\n", custid);
182 	switch (custid) {
183 	case EEPROM_CID_RSVD0:
184 	case EEPROM_CID_RSVD1:
185 	case EEPROM_CID_SERCOMM_PS:
186 	case EEPROM_CID_QMI:
187 	case EEPROM_CID_DELL:
188 	case EEPROM_CID_TOSHIBA:
189 		ledpin = LED_PIN_GPIO0;
190 		break;
191 	case EEPROM_CID_ALPHA0:
192 		ledpin = LED_PIN_LED0;
193 		break;
194 	case EEPROM_CID_HW:
195 		ledpin = LED_PIN_HW;
196 		break;
197 	default:
198 		ledpin = LED_PIN_GPIO0;
199 	}
200 
201 	INIT_DELAYED_WORK(&priv->led_on, led_turn_on);
202 	INIT_DELAYED_WORK(&priv->led_off, led_turn_off);
203 
204 	snprintf(name, sizeof(name),
205 		 "rtl8187-%s::radio", wiphy_name(dev->wiphy));
206 	err = rtl8187_register_led(dev, &priv->led_radio, name,
207 			 ieee80211_get_radio_led_name(dev), ledpin, true);
208 	if (err)
209 		return;
210 
211 	snprintf(name, sizeof(name),
212 		 "rtl8187-%s::tx", wiphy_name(dev->wiphy));
213 	err = rtl8187_register_led(dev, &priv->led_tx, name,
214 			 ieee80211_get_tx_led_name(dev), ledpin, false);
215 	if (err)
216 		goto err_tx;
217 
218 	snprintf(name, sizeof(name),
219 		 "rtl8187-%s::rx", wiphy_name(dev->wiphy));
220 	err = rtl8187_register_led(dev, &priv->led_rx, name,
221 			 ieee80211_get_rx_led_name(dev), ledpin, false);
222 	if (!err)
223 		return;
224 
225 	/* registration of RX LED failed - unregister */
226 	rtl8187_unregister_led(&priv->led_tx);
227 err_tx:
228 	rtl8187_unregister_led(&priv->led_radio);
229 }
230 
231 void rtl8187_leds_exit(struct ieee80211_hw *dev)
232 {
233 	struct rtl8187_priv *priv = dev->priv;
234 
235 	rtl8187_unregister_led(&priv->led_radio);
236 	rtl8187_unregister_led(&priv->led_rx);
237 	rtl8187_unregister_led(&priv->led_tx);
238 	cancel_delayed_work_sync(&priv->led_off);
239 	cancel_delayed_work_sync(&priv->led_on);
240 }
241 #endif /* def CONFIG_RTL8187_LEDS */
242 
243