7d383a27b9274d71027fb92c4f5d207f40833aa8
[linux-3.10.git] / drivers / net / wireless / bcm43xx / bcm43xx_leds.c
1 /*
2
3   Broadcom BCM43xx wireless driver
4
5   Copyright (c) 2005 Martin Langer <martin-langer@gmx.de>,
6                      Stefano Brivio <st3@riseup.net>
7                      Michael Buesch <mbuesch@freenet.de>
8                      Danny van Dyk <kugelfang@gentoo.org>
9                      Andreas Jaggi <andreas.jaggi@waterwave.ch>
10
11   This program is free software; you can redistribute it and/or modify
12   it under the terms of the GNU General Public License as published by
13   the Free Software Foundation; either version 2 of the License, or
14   (at your option) any later version.
15
16   This program is distributed in the hope that it will be useful,
17   but WITHOUT ANY WARRANTY; without even the implied warranty of
18   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
19   GNU General Public License for more details.
20
21   You should have received a copy of the GNU General Public License
22   along with this program; see the file COPYING.  If not, write to
23   the Free Software Foundation, Inc., 51 Franklin Steet, Fifth Floor,
24   Boston, MA 02110-1301, USA.
25
26 */
27
28 #include "bcm43xx_leds.h"
29 #include "bcm43xx.h"
30
31 #include <asm/bitops.h>
32
33
34 static void bcm43xx_led_changestate(struct bcm43xx_led *led)
35 {
36         struct bcm43xx_private *bcm = led->bcm;
37         const int index = bcm43xx_led_index(led);
38         const u16 mask = (1 << index);
39         u16 ledctl;
40
41         assert(index >= 0 && index < BCM43xx_NR_LEDS);
42         assert(led->blink_interval);
43         ledctl = bcm43xx_read16(bcm, BCM43xx_MMIO_GPIO_CONTROL);
44         ledctl = (ledctl & mask) ? (ledctl & ~mask) : (ledctl | mask);
45         bcm43xx_write16(bcm, BCM43xx_MMIO_GPIO_CONTROL, ledctl);
46 }
47
48 static void bcm43xx_led_blink(unsigned long d)
49 {
50         struct bcm43xx_led *led = (struct bcm43xx_led *)d;
51         struct bcm43xx_private *bcm = led->bcm;
52         unsigned long flags;
53
54         spin_lock_irqsave(&bcm->leds_lock, flags);
55         if (led->blink_interval) {
56                 bcm43xx_led_changestate(led);
57                 mod_timer(&led->blink_timer, jiffies + led->blink_interval);
58         }
59         spin_unlock_irqrestore(&bcm->leds_lock, flags);
60 }
61
62 static void bcm43xx_led_blink_start(struct bcm43xx_led *led,
63                                     unsigned long interval)
64 {
65         if (led->blink_interval)
66                 return;
67         led->blink_interval = interval;
68         bcm43xx_led_changestate(led);
69         led->blink_timer.expires = jiffies + interval;
70         add_timer(&led->blink_timer);
71 }
72
73 static void bcm43xx_led_blink_stop(struct bcm43xx_led *led, int sync)
74 {
75         struct bcm43xx_private *bcm = led->bcm;
76         const int index = bcm43xx_led_index(led);
77         u16 ledctl;
78
79         if (!led->blink_interval)
80                 return;
81         if (unlikely(sync))
82                 del_timer_sync(&led->blink_timer);
83         else
84                 del_timer(&led->blink_timer);
85         led->blink_interval = 0;
86
87         /* Make sure the LED is turned off. */
88         assert(index >= 0 && index < BCM43xx_NR_LEDS);
89         ledctl = bcm43xx_read16(bcm, BCM43xx_MMIO_GPIO_CONTROL);
90         if (led->activelow)
91                 ledctl |= (1 << index);
92         else
93                 ledctl &= ~(1 << index);
94         bcm43xx_write16(bcm, BCM43xx_MMIO_GPIO_CONTROL, ledctl);
95 }
96
97 static void bcm43xx_led_init_hardcoded(struct bcm43xx_private *bcm,
98                                        struct bcm43xx_led *led,
99                                        int led_index)
100 {
101         /* This function is called, if the behaviour (and activelow)
102          * information for a LED is missing in the SPROM.
103          * We hardcode the behaviour values for various devices here.
104          * Note that the BCM43xx_LED_TEST_XXX behaviour values can
105          * be used to figure out which led is mapped to which index.
106          */
107
108         switch (led_index) {
109         case 0:
110                 led->behaviour = BCM43xx_LED_ACTIVITY;
111                 if (bcm->board_vendor == PCI_VENDOR_ID_COMPAQ)
112                         led->behaviour = BCM43xx_LED_RADIO_ALL;
113                 break;
114         case 1:
115                 led->behaviour = BCM43xx_LED_RADIO_B;
116                 if (bcm->board_vendor == PCI_VENDOR_ID_ASUSTEK)
117                         led->behaviour = BCM43xx_LED_ASSOC;
118                 break;
119         case 2:
120                 led->behaviour = BCM43xx_LED_RADIO_A;
121                 break;
122         case 3:
123                 led->behaviour = BCM43xx_LED_OFF;
124                 break;
125         default:
126                 assert(0);
127         }
128 }
129
130 int bcm43xx_leds_init(struct bcm43xx_private *bcm)
131 {
132         struct bcm43xx_led *led;
133         u8 sprom[4];
134         int i;
135
136         sprom[0] = bcm->sprom.wl0gpio0;
137         sprom[1] = bcm->sprom.wl0gpio1;
138         sprom[2] = bcm->sprom.wl0gpio2;
139         sprom[3] = bcm->sprom.wl0gpio3;
140
141         for (i = 0; i < BCM43xx_NR_LEDS; i++) {
142                 led = &(bcm->leds[i]);
143                 led->bcm = bcm;
144                 setup_timer(&led->blink_timer,
145                             bcm43xx_led_blink,
146                             (unsigned long)led);
147
148                 if (sprom[i] == 0xFF) {
149                         bcm43xx_led_init_hardcoded(bcm, led, i);
150                 } else {
151                         led->behaviour = sprom[i] & BCM43xx_LED_BEHAVIOUR;
152                         led->activelow = !!(sprom[i] & BCM43xx_LED_ACTIVELOW);
153                 }
154         }
155
156         return 0;
157 }
158
159 void bcm43xx_leds_exit(struct bcm43xx_private *bcm)
160 {
161         struct bcm43xx_led *led;
162         int i;
163
164         for (i = 0; i < BCM43xx_NR_LEDS; i++) {
165                 led = &(bcm->leds[i]);
166                 bcm43xx_led_blink_stop(led, 1);
167         }
168         bcm43xx_leds_switch_all(bcm, 0);
169 }
170
171 void bcm43xx_leds_update(struct bcm43xx_private *bcm, int activity)
172 {
173         struct bcm43xx_led *led;
174         struct bcm43xx_radioinfo *radio = bcm43xx_current_radio(bcm);
175         struct bcm43xx_phyinfo *phy = bcm43xx_current_phy(bcm);
176         const int transferring = (jiffies - bcm->stats.last_tx) < BCM43xx_LED_XFER_THRES;
177         int i, turn_on;
178         unsigned long interval = 0;
179         u16 ledctl;
180         unsigned long flags;
181
182         spin_lock_irqsave(&bcm->leds_lock, flags);
183         ledctl = bcm43xx_read16(bcm, BCM43xx_MMIO_GPIO_CONTROL);
184         for (i = 0; i < BCM43xx_NR_LEDS; i++) {
185                 led = &(bcm->leds[i]);
186
187                 turn_on = 0;
188                 switch (led->behaviour) {
189                 case BCM43xx_LED_INACTIVE:
190                         continue;
191                 case BCM43xx_LED_OFF:
192                 case BCM43xx_LED_BCM4303_3:
193                         break;
194                 case BCM43xx_LED_ON:
195                         turn_on = 1;
196                         break;
197                 case BCM43xx_LED_ACTIVITY:
198                 case BCM43xx_LED_BCM4303_0:
199                         turn_on = activity;
200                         break;
201                 case BCM43xx_LED_RADIO_ALL:
202                         turn_on = radio->enabled;
203                         break;
204                 case BCM43xx_LED_RADIO_A:
205                 case BCM43xx_LED_BCM4303_2:
206                         turn_on = (radio->enabled && phy->type == BCM43xx_PHYTYPE_A);
207                         break;
208                 case BCM43xx_LED_RADIO_B:
209                 case BCM43xx_LED_BCM4303_1:
210                         turn_on = (radio->enabled &&
211                                    (phy->type == BCM43xx_PHYTYPE_B ||
212                                     phy->type == BCM43xx_PHYTYPE_G));
213                         break;
214                 case BCM43xx_LED_MODE_BG:
215                         if (phy->type == BCM43xx_PHYTYPE_G &&
216                             1/*FIXME: using G rates.*/)
217                                 turn_on = 1;
218                         break;
219                 case BCM43xx_LED_TRANSFER:
220                         if (transferring)
221                                 bcm43xx_led_blink_start(led, BCM43xx_LEDBLINK_MEDIUM);
222                         else
223                                 bcm43xx_led_blink_stop(led, 0);
224                         continue;
225                 case BCM43xx_LED_APTRANSFER:
226                         if (bcm->ieee->iw_mode == IW_MODE_MASTER) {
227                                 if (transferring) {
228                                         interval = BCM43xx_LEDBLINK_FAST;
229                                         turn_on = 1;
230                                 }
231                         } else {
232                                 turn_on = 1;
233                                 if (0/*TODO: not assoc*/)
234                                         interval = BCM43xx_LEDBLINK_SLOW;
235                                 else if (transferring)
236                                         interval = BCM43xx_LEDBLINK_FAST;
237                                 else
238                                         turn_on = 0;
239                         }
240                         if (turn_on)
241                                 bcm43xx_led_blink_start(led, interval);
242                         else
243                                 bcm43xx_led_blink_stop(led, 0);
244                         continue;
245                 case BCM43xx_LED_WEIRD:
246                         //TODO
247                         break;
248                 case BCM43xx_LED_ASSOC:
249                         if (bcm->softmac->associnfo.associated)
250                                 turn_on = 1;
251                         break;
252 #ifdef CONFIG_BCM43XX_DEBUG
253                 case BCM43xx_LED_TEST_BLINKSLOW:
254                         bcm43xx_led_blink_start(led, BCM43xx_LEDBLINK_SLOW);
255                         continue;
256                 case BCM43xx_LED_TEST_BLINKMEDIUM:
257                         bcm43xx_led_blink_start(led, BCM43xx_LEDBLINK_MEDIUM);
258                         continue;
259                 case BCM43xx_LED_TEST_BLINKFAST:
260                         bcm43xx_led_blink_start(led, BCM43xx_LEDBLINK_FAST);
261                         continue;
262 #endif /* CONFIG_BCM43XX_DEBUG */
263                 default:
264                         dprintkl(KERN_INFO PFX "Bad value in leds_update,"
265                                 " led->behaviour: 0x%x\n", led->behaviour);
266                 };
267
268                 if (led->activelow)
269                         turn_on = !turn_on;
270                 if (turn_on)
271                         ledctl |= (1 << i);
272                 else
273                         ledctl &= ~(1 << i);
274         }
275         bcm43xx_write16(bcm, BCM43xx_MMIO_GPIO_CONTROL, ledctl);
276         spin_unlock_irqrestore(&bcm->leds_lock, flags);
277 }
278
279 void bcm43xx_leds_switch_all(struct bcm43xx_private *bcm, int on)
280 {
281         struct bcm43xx_led *led;
282         u16 ledctl;
283         int i;
284         int bit_on;
285         unsigned long flags;
286
287         spin_lock_irqsave(&bcm->leds_lock, flags);
288         ledctl = bcm43xx_read16(bcm, BCM43xx_MMIO_GPIO_CONTROL);
289         for (i = 0; i < BCM43xx_NR_LEDS; i++) {
290                 led = &(bcm->leds[i]);
291                 if (led->behaviour == BCM43xx_LED_INACTIVE)
292                         continue;
293                 if (on)
294                         bit_on = led->activelow ? 0 : 1;
295                 else
296                         bit_on = led->activelow ? 1 : 0;
297                 if (bit_on)
298                         ledctl |= (1 << i);
299                 else
300                         ledctl &= ~(1 << i);
301         }
302         bcm43xx_write16(bcm, BCM43xx_MMIO_GPIO_CONTROL, ledctl);
303         spin_unlock_irqrestore(&bcm->leds_lock, flags);
304 }