release/src-rt-6.x.4708/linux/linux-2.6.36/drivers/net/wireless/rtl818x/rtl8187_leds.c

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