drivers/net/wireless/b43/leds.c

   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 <mb@bu3sch.de>
   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 = 0;
  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         struct ssb_bus *bus = dev->dev->bus;
 219         u8 sprom[4];
 220
 221         sprom[0] = bus->sprom.gpio0;
 222         sprom[1] = bus->sprom.gpio1;
 223         sprom[2] = bus->sprom.gpio2;
 224         sprom[3] = bus->sprom.gpio3;
 225
 226         if (sprom[led_index] == 0xFF) {
 227                 /* There is no LED information in the SPROM
 228                  * for this LED. Hardcode it here. */
 229                 *activelow = 0;
 230                 switch (led_index) {
 231                 case 0:
 232                         *behaviour = B43_LED_ACTIVITY;
 233                         *activelow = 1;
 234                         if (bus->boardinfo.vendor == PCI_VENDOR_ID_COMPAQ)
 235                                 *behaviour = B43_LED_RADIO_ALL;
 236                         break;
 237                 case 1:
 238                         *behaviour = B43_LED_RADIO_B;
 239                         if (bus->boardinfo.vendor == PCI_VENDOR_ID_ASUSTEK)
 240                                 *behaviour = B43_LED_ASSOC;
 241                         break;
 242                 case 2:
 243                         *behaviour = B43_LED_RADIO_A;
 244                         break;
 245                 case 3:
 246                         *behaviour = B43_LED_OFF;
 247                         break;
 248                 default:
 249                         *behaviour = B43_LED_OFF;
 250                         B43_WARN_ON(1);
 251                         return;
 252                 }
 253         } else {
 254                 *behaviour = sprom[led_index] & B43_LED_BEHAVIOUR;
 255                 *activelow = !!(sprom[led_index] & B43_LED_ACTIVELOW);
 256         }
 257 }
 258
 259 void b43_leds_init(struct b43_wldev *dev)
 260 {
 261         struct b43_led *led;
 262         unsigned int i;
 263         enum b43_led_behaviour behaviour;
 264         bool activelow;
 265
 266         /* Sync the RF-kill LED state (if we have one) with radio and switch states. */
 267         led = &dev->wl->leds.led_radio;
 268         if (led->wl) {
 269                 if (dev->phy.radio_on && b43_is_hw_radio_enabled(dev)) {
 270                         b43_led_turn_on(dev, led->index, led->activelow);
 271                         led->hw_state = 1;
 272                         atomic_set(&led->state, 1);
 273                 } else {
 274                         b43_led_turn_off(dev, led->index, led->activelow);
 275                         led->hw_state = 0;
 276                         atomic_set(&led->state, 0);
 277                 }
 278         }
 279
 280         /* Initialize TX/RX/ASSOC leds */
 281         led = &dev->wl->leds.led_tx;
 282         if (led->wl) {
 283                 b43_led_turn_off(dev, led->index, led->activelow);
 284                 led->hw_state = 0;
 285                 atomic_set(&led->state, 0);
 286         }
 287         led = &dev->wl->leds.led_rx;
 288         if (led->wl) {
 289                 b43_led_turn_off(dev, led->index, led->activelow);
 290                 led->hw_state = 0;
 291                 atomic_set(&led->state, 0);
 292         }
 293         led = &dev->wl->leds.led_assoc;
 294         if (led->wl) {
 295                 b43_led_turn_off(dev, led->index, led->activelow);
 296                 led->hw_state = 0;
 297                 atomic_set(&led->state, 0);
 298         }
 299
 300         /* Initialize other LED states. */
 301         for (i = 0; i < B43_MAX_NR_LEDS; i++) {
 302                 b43_led_get_sprominfo(dev, i, &behaviour, &activelow);
 303                 switch (behaviour) {
 304                 case B43_LED_OFF:
 305                         b43_led_turn_off(dev, i, activelow);
 306                         break;
 307                 case B43_LED_ON:
 308                         b43_led_turn_on(dev, i, activelow);
 309                         break;
 310                 default:
 311                         /* Leave others as-is. */
 312                         break;
 313                 }
 314         }
 315
 316         dev->wl->leds.stop = 0;
 317 }
 318
 319 void b43_leds_exit(struct b43_wldev *dev)
 320 {
 321         struct b43_leds *leds = &dev->wl->leds;
 322
 323         b43_led_turn_off(dev, leds->led_tx.index, leds->led_tx.activelow);
 324         b43_led_turn_off(dev, leds->led_rx.index, leds->led_rx.activelow);
 325         b43_led_turn_off(dev, leds->led_assoc.index, leds->led_assoc.activelow);
 326         b43_led_turn_off(dev, leds->led_radio.index, leds->led_radio.activelow);
 327 }
 328
 329 void b43_leds_stop(struct b43_wldev *dev)
 330 {
 331         struct b43_leds *leds = &dev->wl->leds;
 332
 333         leds->stop = 1;
 334         cancel_work_sync(&leds->work);
 335 }
 336
 337 void b43_leds_register(struct b43_wldev *dev)
 338 {
 339         unsigned int i;
 340         enum b43_led_behaviour behaviour;
 341         bool activelow;
 342
 343         INIT_WORK(&dev->wl->leds.work, b43_leds_work);
 344
 345         /* Register the LEDs to the LED subsystem. */
 346         for (i = 0; i < B43_MAX_NR_LEDS; i++) {
 347                 b43_led_get_sprominfo(dev, i, &behaviour, &activelow);
 348                 b43_map_led(dev, i, behaviour, activelow);
 349         }
 350 }
 351
 352 void b43_leds_unregister(struct b43_wl *wl)
 353 {
 354         struct b43_leds *leds = &wl->leds;
 355
 356         b43_unregister_led(&leds->led_tx);
 357         b43_unregister_led(&leds->led_rx);
 358         b43_unregister_led(&leds->led_assoc);
 359         b43_unregister_led(&leds->led_radio);
 360 }