1 /*
2 
3   Broadcom B43 wireless driver
4   LED control
5 
6   Copyright (c) 2005 Martin Langer <martin-langer@gmx.de>,
7   Copyright (c) 2005 Stefano Brivio <stefano.brivio@polimi.it>
8   Copyright (c) 2005-2007 Michael Buesch <m@bues.ch>
9   Copyright (c) 2005 Danny van Dyk <kugelfang@gentoo.org>
10   Copyright (c) 2005 Andreas Jaggi <andreas.jaggi@waterwave.ch>
11 
12   This program is free software; you can redistribute it and/or modify
13   it under the terms of the GNU General Public License as published by
14   the Free Software Foundation; either version 2 of the License, or
15   (at your option) any later version.
16 
17   This program is distributed in the hope that it will be useful,
18   but WITHOUT ANY WARRANTY; without even the implied warranty of
19   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
20   GNU General Public License for more details.
21 
22   You should have received a copy of the GNU General Public License
23   along with this program; see the file COPYING.  If not, write to
24   the Free Software Foundation, Inc., 51 Franklin Steet, Fifth Floor,
25   Boston, MA 02110-1301, USA.
26 
27 */
28 
29 #include "b43.h"
30 #include "leds.h"
31 #include "rfkill.h"
32 
33 
34 static void b43_led_turn_on(struct b43_wldev *dev, u8 led_index,
35 			    bool activelow)
36 {
37 	u16 ctl;
38 
39 	ctl = b43_read16(dev, B43_MMIO_GPIO_CONTROL);
40 	if (activelow)
41 		ctl &= ~(1 << led_index);
42 	else
43 		ctl |= (1 << led_index);
44 	b43_write16(dev, B43_MMIO_GPIO_CONTROL, ctl);
45 }
46 
47 static void b43_led_turn_off(struct b43_wldev *dev, u8 led_index,
48 			     bool activelow)
49 {
50 	u16 ctl;
51 
52 	ctl = b43_read16(dev, B43_MMIO_GPIO_CONTROL);
53 	if (activelow)
54 		ctl |= (1 << led_index);
55 	else
56 		ctl &= ~(1 << led_index);
57 	b43_write16(dev, B43_MMIO_GPIO_CONTROL, ctl);
58 }
59 
60 static void b43_led_update(struct b43_wldev *dev,
61 			   struct b43_led *led)
62 {
63 	bool radio_enabled;
64 	bool turn_on;
65 
66 	if (!led->wl)
67 		return;
68 
69 	radio_enabled = (dev->phy.radio_on && dev->radio_hw_enable);
70 
71 	/* The led->state read is racy, but we don't care. In case we raced
72 	 * with the brightness_set handler, we will be called again soon
73 	 * to fixup our state. */
74 	if (radio_enabled)
75 		turn_on = atomic_read(&led->state) != LED_OFF;
76 	else
77 		turn_on = false;
78 	if (turn_on == led->hw_state)
79 		return;
80 	led->hw_state = turn_on;
81 
82 	if (turn_on)
83 		b43_led_turn_on(dev, led->index, led->activelow);
84 	else
85 		b43_led_turn_off(dev, led->index, led->activelow);
86 }
87 
88 static void b43_leds_work(struct work_struct *work)
89 {
90 	struct b43_leds *leds = container_of(work, struct b43_leds, work);
91 	struct b43_wl *wl = container_of(leds, struct b43_wl, leds);
92 	struct b43_wldev *dev;
93 
94 	mutex_lock(&wl->mutex);
95 	dev = wl->current_dev;
96 	if (unlikely(!dev || b43_status(dev) < B43_STAT_STARTED))
97 		goto out_unlock;
98 
99 	b43_led_update(dev, &wl->leds.led_tx);
100 	b43_led_update(dev, &wl->leds.led_rx);
101 	b43_led_update(dev, &wl->leds.led_radio);
102 	b43_led_update(dev, &wl->leds.led_assoc);
103 
104 out_unlock:
105 	mutex_unlock(&wl->mutex);
106 }
107 
108 /* Callback from the LED subsystem. */
109 static void b43_led_brightness_set(struct led_classdev *led_dev,
110 				   enum led_brightness brightness)
111 {
112 	struct b43_led *led = container_of(led_dev, struct b43_led, led_dev);
113 	struct b43_wl *wl = led->wl;
114 
115 	if (likely(!wl->leds.stop)) {
116 		atomic_set(&led->state, brightness);
117 		ieee80211_queue_work(wl->hw, &wl->leds.work);
118 	}
119 }
120 
121 static int b43_register_led(struct b43_wldev *dev, struct b43_led *led,
122 			    const char *name, const char *default_trigger,
123 			    u8 led_index, bool activelow)
124 {
125 	int err;
126 
127 	if (led->wl)
128 		return -EEXIST;
129 	if (!default_trigger)
130 		return -EINVAL;
131 	led->wl = dev->wl;
132 	led->index = led_index;
133 	led->activelow = activelow;
134 	strncpy(led->name, name, sizeof(led->name));
135 	atomic_set(&led->state, 0);
136 
137 	led->led_dev.name = led->name;
138 	led->led_dev.default_trigger = default_trigger;
139 	led->led_dev.brightness_set = b43_led_brightness_set;
140 
141 	err = led_classdev_register(dev->dev->dev, &led->led_dev);
142 	if (err) {
143 		b43warn(dev->wl, "LEDs: Failed to register %s\n", name);
144 		led->wl = NULL;
145 		return err;
146 	}
147 
148 	return 0;
149 }
150 
151 static void b43_unregister_led(struct b43_led *led)
152 {
153 	if (!led->wl)
154 		return;
155 	led_classdev_unregister(&led->led_dev);
156 	led->wl = NULL;
157 }
158 
159 static void b43_map_led(struct b43_wldev *dev,
160 			u8 led_index,
161 			enum b43_led_behaviour behaviour,
162 			bool activelow)
163 {
164 	struct ieee80211_hw *hw = dev->wl->hw;
165 	char name[B43_LED_MAX_NAME_LEN + 1];
166 
167 	/* Map the b43 specific LED behaviour value to the
168 	 * generic LED triggers. */
169 	switch (behaviour) {
170 	case B43_LED_INACTIVE:
171 	case B43_LED_OFF:
172 	case B43_LED_ON:
173 		break;
174 	case B43_LED_ACTIVITY:
175 	case B43_LED_TRANSFER:
176 	case B43_LED_APTRANSFER:
177 		snprintf(name, sizeof(name),
178 			 "b43-%s::tx", wiphy_name(hw->wiphy));
179 		b43_register_led(dev, &dev->wl->leds.led_tx, name,
180 				 ieee80211_get_tx_led_name(hw),
181 				 led_index, activelow);
182 		snprintf(name, sizeof(name),
183 			 "b43-%s::rx", wiphy_name(hw->wiphy));
184 		b43_register_led(dev, &dev->wl->leds.led_rx, name,
185 				 ieee80211_get_rx_led_name(hw),
186 				 led_index, activelow);
187 		break;
188 	case B43_LED_RADIO_ALL:
189 	case B43_LED_RADIO_A:
190 	case B43_LED_RADIO_B:
191 	case B43_LED_MODE_BG:
192 		snprintf(name, sizeof(name),
193 			 "b43-%s::radio", wiphy_name(hw->wiphy));
194 		b43_register_led(dev, &dev->wl->leds.led_radio, name,
195 				 ieee80211_get_radio_led_name(hw),
196 				 led_index, activelow);
197 		break;
198 	case B43_LED_WEIRD:
199 	case B43_LED_ASSOC:
200 		snprintf(name, sizeof(name),
201 			 "b43-%s::assoc", wiphy_name(hw->wiphy));
202 		b43_register_led(dev, &dev->wl->leds.led_assoc, name,
203 				 ieee80211_get_assoc_led_name(hw),
204 				 led_index, activelow);
205 		break;
206 	default:
207 		b43warn(dev->wl, "LEDs: Unknown behaviour 0x%02X\n",
208 			behaviour);
209 		break;
210 	}
211 }
212 
213 static void b43_led_get_sprominfo(struct b43_wldev *dev,
214 				  unsigned int led_index,
215 				  enum b43_led_behaviour *behaviour,
216 				  bool *activelow)
217 {
218 	u8 sprom[4];
219 
220 	sprom[0] = dev->dev->bus_sprom->gpio0;
221 	sprom[1] = dev->dev->bus_sprom->gpio1;
222 	sprom[2] = dev->dev->bus_sprom->gpio2;
223 	sprom[3] = dev->dev->bus_sprom->gpio3;
224 
225 	if ((sprom[0] & sprom[1] & sprom[2] & sprom[3]) == 0xff) {
226 		/* There is no LED information in the SPROM
227 		 * for this LED. Hardcode it here. */
228 		*activelow = false;
229 		switch (led_index) {
230 		case 0:
231 			*behaviour = B43_LED_ACTIVITY;
232 			*activelow = true;
233 			if (dev->dev->board_vendor == PCI_VENDOR_ID_COMPAQ)
234 				*behaviour = B43_LED_RADIO_ALL;
235 			break;
236 		case 1:
237 			*behaviour = B43_LED_RADIO_B;
238 			if (dev->dev->board_vendor == PCI_VENDOR_ID_ASUSTEK)
239 				*behaviour = B43_LED_ASSOC;
240 			break;
241 		case 2:
242 			*behaviour = B43_LED_RADIO_A;
243 			break;
244 		case 3:
245 			*behaviour = B43_LED_OFF;
246 			break;
247 		default:
248 			*behaviour = B43_LED_OFF;
249 			B43_WARN_ON(1);
250 			return;
251 		}
252 	} else {
253 		/* keep LED disabled if no mapping is defined */
254 		if (sprom[led_index] == 0xff)
255 			*behaviour = B43_LED_OFF;
256 		else
257 			*behaviour = sprom[led_index] & B43_LED_BEHAVIOUR;
258 		*activelow = !!(sprom[led_index] & B43_LED_ACTIVELOW);
259 	}
260 }
261 
262 void b43_leds_init(struct b43_wldev *dev)
263 {
264 	struct b43_led *led;
265 	unsigned int i;
266 	enum b43_led_behaviour behaviour;
267 	bool activelow;
268 
269 	/* Sync the RF-kill LED state (if we have one) with radio and switch states. */
270 	led = &dev->wl->leds.led_radio;
271 	if (led->wl) {
272 		if (dev->phy.radio_on && b43_is_hw_radio_enabled(dev)) {
273 			b43_led_turn_on(dev, led->index, led->activelow);
274 			led->hw_state = true;
275 			atomic_set(&led->state, 1);
276 		} else {
277 			b43_led_turn_off(dev, led->index, led->activelow);
278 			led->hw_state = false;
279 			atomic_set(&led->state, 0);
280 		}
281 	}
282 
283 	/* Initialize TX/RX/ASSOC leds */
284 	led = &dev->wl->leds.led_tx;
285 	if (led->wl) {
286 		b43_led_turn_off(dev, led->index, led->activelow);
287 		led->hw_state = false;
288 		atomic_set(&led->state, 0);
289 	}
290 	led = &dev->wl->leds.led_rx;
291 	if (led->wl) {
292 		b43_led_turn_off(dev, led->index, led->activelow);
293 		led->hw_state = false;
294 		atomic_set(&led->state, 0);
295 	}
296 	led = &dev->wl->leds.led_assoc;
297 	if (led->wl) {
298 		b43_led_turn_off(dev, led->index, led->activelow);
299 		led->hw_state = false;
300 		atomic_set(&led->state, 0);
301 	}
302 
303 	/* Initialize other LED states. */
304 	for (i = 0; i < B43_MAX_NR_LEDS; i++) {
305 		b43_led_get_sprominfo(dev, i, &behaviour, &activelow);
306 		switch (behaviour) {
307 		case B43_LED_OFF:
308 			b43_led_turn_off(dev, i, activelow);
309 			break;
310 		case B43_LED_ON:
311 			b43_led_turn_on(dev, i, activelow);
312 			break;
313 		default:
314 			/* Leave others as-is. */
315 			break;
316 		}
317 	}
318 
319 	dev->wl->leds.stop = 0;
320 }
321 
322 void b43_leds_exit(struct b43_wldev *dev)
323 {
324 	struct b43_leds *leds = &dev->wl->leds;
325 
326 	b43_led_turn_off(dev, leds->led_tx.index, leds->led_tx.activelow);
327 	b43_led_turn_off(dev, leds->led_rx.index, leds->led_rx.activelow);
328 	b43_led_turn_off(dev, leds->led_assoc.index, leds->led_assoc.activelow);
329 	b43_led_turn_off(dev, leds->led_radio.index, leds->led_radio.activelow);
330 }
331 
332 void b43_leds_stop(struct b43_wldev *dev)
333 {
334 	struct b43_leds *leds = &dev->wl->leds;
335 
336 	leds->stop = 1;
337 	cancel_work_sync(&leds->work);
338 }
339 
340 void b43_leds_register(struct b43_wldev *dev)
341 {
342 	unsigned int i;
343 	enum b43_led_behaviour behaviour;
344 	bool activelow;
345 
346 	INIT_WORK(&dev->wl->leds.work, b43_leds_work);
347 
348 	/* Register the LEDs to the LED subsystem. */
349 	for (i = 0; i < B43_MAX_NR_LEDS; i++) {
350 		b43_led_get_sprominfo(dev, i, &behaviour, &activelow);
351 		b43_map_led(dev, i, behaviour, activelow);
352 	}
353 }
354 
355 void b43_leds_unregister(struct b43_wl *wl)
356 {
357 	struct b43_leds *leds = &wl->leds;
358 
359 	b43_unregister_led(&leds->led_tx);
360 	b43_unregister_led(&leds->led_rx);
361 	b43_unregister_led(&leds->led_assoc);
362 	b43_unregister_led(&leds->led_radio);
363 }
364