iwlwifi: rename iwl_eeprom_aqcuire_semaphore to _acquire_
[linux-2.6] / drivers / net / wireless / zd1211rw / zd_netdev.c
1 /* zd_netdev.c
2  *
3  * This program is free software; you can redistribute it and/or modify
4  * it under the terms of the GNU General Public License as published by
5  * the Free Software Foundation; either version 2 of the License, or
6  * (at your option) any later version.
7  *
8  * This program is distributed in the hope that it will be useful,
9  * but WITHOUT ANY WARRANTY; without even the implied warranty of
10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
11  * GNU General Public License for more details.
12  *
13  * You should have received a copy of the GNU General Public License
14  * along with this program; if not, write to the Free Software
15  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
16  */
17
18 #include <linux/netdevice.h>
19 #include <linux/etherdevice.h>
20 #include <linux/skbuff.h>
21 #include <net/ieee80211.h>
22 #include <net/ieee80211softmac.h>
23 #include <net/ieee80211softmac_wx.h>
24 #include <net/iw_handler.h>
25
26 #include "zd_def.h"
27 #include "zd_netdev.h"
28 #include "zd_mac.h"
29 #include "zd_ieee80211.h"
30
31 /* Region 0 means reset regdomain to default. */
32 static int zd_set_regdomain(struct net_device *netdev,
33                             struct iw_request_info *info,
34                             union iwreq_data *req, char *extra)
35 {
36         const u8 *regdomain = (u8 *)req;
37         return zd_mac_set_regdomain(zd_netdev_mac(netdev), *regdomain);
38 }
39
40 static int zd_get_regdomain(struct net_device *netdev,
41                             struct iw_request_info *info,
42                             union iwreq_data *req, char *extra)
43 {
44         u8 *regdomain = (u8 *)req;
45         if (!regdomain)
46                 return -EINVAL;
47         *regdomain = zd_mac_get_regdomain(zd_netdev_mac(netdev));
48         return 0;
49 }
50
51 static const struct iw_priv_args zd_priv_args[] = {
52         {
53                 .cmd = ZD_PRIV_SET_REGDOMAIN,
54                 .set_args = IW_PRIV_TYPE_BYTE | IW_PRIV_SIZE_FIXED | 1,
55                 .name = "set_regdomain",
56         },
57         {
58                 .cmd = ZD_PRIV_GET_REGDOMAIN,
59                 .get_args = IW_PRIV_TYPE_BYTE | IW_PRIV_SIZE_FIXED | 1,
60                 .name = "get_regdomain",
61         },
62 };
63
64 #define PRIV_OFFSET(x) [(x)-SIOCIWFIRSTPRIV]
65
66 static const iw_handler zd_priv_handler[] = {
67         PRIV_OFFSET(ZD_PRIV_SET_REGDOMAIN) = zd_set_regdomain,
68         PRIV_OFFSET(ZD_PRIV_GET_REGDOMAIN) = zd_get_regdomain,
69 };
70
71 static int iw_get_name(struct net_device *netdev,
72                        struct iw_request_info *info,
73                        union iwreq_data *req, char *extra)
74 {
75         /* FIXME: check whether 802.11a will also supported */
76         strlcpy(req->name, "IEEE 802.11b/g", IFNAMSIZ);
77         return 0;
78 }
79
80 static int iw_get_nick(struct net_device *netdev,
81                        struct iw_request_info *info,
82                        union iwreq_data *req, char *extra)
83 {
84         strcpy(extra, "zd1211");
85         req->data.length = strlen(extra);
86         req->data.flags = 1;
87         return 0;
88 }
89
90 static int iw_set_freq(struct net_device *netdev,
91                        struct iw_request_info *info,
92                        union iwreq_data *req, char *extra)
93 {
94         int r;
95         struct zd_mac *mac = zd_netdev_mac(netdev);
96         struct iw_freq *freq = &req->freq;
97         u8 channel;
98
99         r = zd_find_channel(&channel, freq);
100         if (r < 0)
101                 return r;
102         r = zd_mac_request_channel(mac, channel);
103         return r;
104 }
105
106 static int iw_get_freq(struct net_device *netdev,
107                    struct iw_request_info *info,
108                    union iwreq_data *req, char *extra)
109 {
110         struct zd_mac *mac = zd_netdev_mac(netdev);
111         struct iw_freq *freq = &req->freq;
112
113         return zd_channel_to_freq(freq, zd_mac_get_channel(mac));
114 }
115
116 static int iw_set_mode(struct net_device *netdev,
117                        struct iw_request_info *info,
118                        union iwreq_data *req, char *extra)
119 {
120         return zd_mac_set_mode(zd_netdev_mac(netdev), req->mode);
121 }
122
123 static int iw_get_mode(struct net_device *netdev,
124                        struct iw_request_info *info,
125                        union iwreq_data *req, char *extra)
126 {
127         return zd_mac_get_mode(zd_netdev_mac(netdev), &req->mode);
128 }
129
130 static int iw_get_range(struct net_device *netdev,
131                        struct iw_request_info *info,
132                        union iwreq_data *req, char *extra)
133 {
134         struct iw_range *range = (struct iw_range *)extra;
135
136         dev_dbg_f(zd_mac_dev(zd_netdev_mac(netdev)), "\n");
137         req->data.length = sizeof(*range);
138         return zd_mac_get_range(zd_netdev_mac(netdev), range);
139 }
140
141 static int iw_set_encode(struct net_device *netdev,
142                          struct iw_request_info *info,
143                          union iwreq_data *data,
144                          char *extra)
145 {
146         return ieee80211_wx_set_encode(zd_netdev_ieee80211(netdev), info,
147                 data, extra);
148 }
149
150 static int iw_get_encode(struct net_device *netdev,
151                          struct iw_request_info *info,
152                          union iwreq_data *data,
153                          char *extra)
154 {
155         return ieee80211_wx_get_encode(zd_netdev_ieee80211(netdev), info,
156                 data, extra);
157 }
158
159 static int iw_set_encodeext(struct net_device *netdev,
160                          struct iw_request_info *info,
161                          union iwreq_data *data,
162                          char *extra)
163 {
164         return ieee80211_wx_set_encodeext(zd_netdev_ieee80211(netdev), info,
165                 data, extra);
166 }
167
168 static int iw_get_encodeext(struct net_device *netdev,
169                          struct iw_request_info *info,
170                          union iwreq_data *data,
171                          char *extra)
172 {
173         return ieee80211_wx_get_encodeext(zd_netdev_ieee80211(netdev), info,
174                 data, extra);
175 }
176
177 #define WX(x) [(x)-SIOCIWFIRST]
178
179 static const iw_handler zd_standard_iw_handlers[] = {
180         WX(SIOCGIWNAME)         = iw_get_name,
181         WX(SIOCGIWNICKN)        = iw_get_nick,
182         WX(SIOCSIWFREQ)         = iw_set_freq,
183         WX(SIOCGIWFREQ)         = iw_get_freq,
184         WX(SIOCSIWMODE)         = iw_set_mode,
185         WX(SIOCGIWMODE)         = iw_get_mode,
186         WX(SIOCGIWRANGE)        = iw_get_range,
187         WX(SIOCSIWENCODE)       = iw_set_encode,
188         WX(SIOCGIWENCODE)       = iw_get_encode,
189         WX(SIOCSIWENCODEEXT)    = iw_set_encodeext,
190         WX(SIOCGIWENCODEEXT)    = iw_get_encodeext,
191         WX(SIOCSIWAUTH)         = ieee80211_wx_set_auth,
192         WX(SIOCGIWAUTH)         = ieee80211_wx_get_auth,
193         WX(SIOCSIWSCAN)         = ieee80211softmac_wx_trigger_scan,
194         WX(SIOCGIWSCAN)         = ieee80211softmac_wx_get_scan_results,
195         WX(SIOCSIWESSID)        = ieee80211softmac_wx_set_essid,
196         WX(SIOCGIWESSID)        = ieee80211softmac_wx_get_essid,
197         WX(SIOCSIWAP)           = ieee80211softmac_wx_set_wap,
198         WX(SIOCGIWAP)           = ieee80211softmac_wx_get_wap,
199         WX(SIOCSIWRATE)         = ieee80211softmac_wx_set_rate,
200         WX(SIOCGIWRATE)         = ieee80211softmac_wx_get_rate,
201         WX(SIOCSIWGENIE)        = ieee80211softmac_wx_set_genie,
202         WX(SIOCGIWGENIE)        = ieee80211softmac_wx_get_genie,
203         WX(SIOCSIWMLME)         = ieee80211softmac_wx_set_mlme,
204 };
205
206 static const struct iw_handler_def iw_handler_def = {
207         .standard               = zd_standard_iw_handlers,
208         .num_standard           = ARRAY_SIZE(zd_standard_iw_handlers),
209         .private                = zd_priv_handler,
210         .num_private            = ARRAY_SIZE(zd_priv_handler),
211         .private_args           = zd_priv_args,
212         .num_private_args       = ARRAY_SIZE(zd_priv_args),
213         .get_wireless_stats     = zd_mac_get_wireless_stats,
214 };
215
216 struct net_device *zd_netdev_alloc(struct usb_interface *intf)
217 {
218         int r;
219         struct net_device *netdev;
220         struct zd_mac *mac;
221
222         netdev = alloc_ieee80211softmac(sizeof(struct zd_mac));
223         if (!netdev) {
224                 dev_dbg_f(&intf->dev, "out of memory\n");
225                 return NULL;
226         }
227
228         mac = zd_netdev_mac(netdev);
229         r = zd_mac_init(mac, netdev, intf);
230         if (r) {
231                 usb_set_intfdata(intf, NULL);
232                 free_ieee80211(netdev);
233                 return NULL;
234         }
235
236         SET_NETDEV_DEV(netdev, &intf->dev);
237
238         dev_dbg_f(&intf->dev, "netdev->flags %#06hx\n", netdev->flags);
239         dev_dbg_f(&intf->dev, "netdev->features %#010lx\n", netdev->features);
240
241         netdev->open = zd_mac_open;
242         netdev->stop = zd_mac_stop;
243         /* netdev->get_stats = */
244         netdev->set_multicast_list = zd_mac_set_multicast_list;
245         netdev->set_mac_address = zd_mac_set_mac_address;
246         netdev->wireless_handlers = &iw_handler_def;
247         /* netdev->ethtool_ops = */
248
249         return netdev;
250 }
251
252 void zd_netdev_free(struct net_device *netdev)
253 {
254         if (!netdev)
255                 return;
256
257         zd_mac_clear(zd_netdev_mac(netdev));
258         free_ieee80211(netdev);
259 }
260
261 void zd_netdev_disconnect(struct net_device *netdev)
262 {
263         unregister_netdev(netdev);
264 }