← Back to branch summary

~ubuntu-branches/ubuntu/natty/linux-backports-modules-2.6.38/natty-proposed

« back to all changes in this revision

Viewing changes to updates/compat-wireless-2.6.37/drivers/net/wireless/rtl818x/rtl8187_leds.c

  • Committer: Bazaar Package Importer
  • Author(s): Tim Gardner, Tim Gardner
  • Date: 2011-06-08 10:44:09 UTC
  • Revision ID: james.westby@ubuntu.com-20110608104409-fnl8carkdo15bwsz
Tags: 2.6.38-10.6
[ Tim Gardner ]

Shorten compat-wireless package name to cw to accomodate
CDROM file name length restrictions.

Show diffs side-by-side

added added

removed removed

Lines of Context:
updates/compat-wireless-2.6.37/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 */
245