87b4e497faa2eee4818e81d5df49732710bdd48e
[linux-2.6.git] / drivers / net / wireless / libertas / main.c
1 /**
2   * This file contains the major functions in WLAN
3   * driver. It includes init, exit, open, close and main
4   * thread etc..
5   */
6
7 #include <linux/moduleparam.h>
8 #include <linux/delay.h>
9 #include <linux/etherdevice.h>
10 #include <linux/netdevice.h>
11 #include <linux/if_arp.h>
12 #include <linux/kthread.h>
13 #include <linux/kfifo.h>
14 #include <linux/stddef.h>
15 #include <linux/ieee80211.h>
16 #include <net/iw_handler.h>
17
18 #include "host.h"
19 #include "decl.h"
20 #include "dev.h"
21 #include "wext.h"
22 #include "debugfs.h"
23 #include "scan.h"
24 #include "assoc.h"
25 #include "cmd.h"
26
27 #define DRIVER_RELEASE_VERSION "323.p0"
28 const char lbs_driver_version[] = "COMM-USB8388-" DRIVER_RELEASE_VERSION
29 #ifdef  DEBUG
30     "-dbg"
31 #endif
32     "";
33
34
35 /* Module parameters */
36 unsigned int lbs_debug;
37 EXPORT_SYMBOL_GPL(lbs_debug);
38 module_param_named(libertas_debug, lbs_debug, int, 0644);
39
40
41 /* This global structure is used to send the confirm_sleep command as
42  * fast as possible down to the firmware. */
43 struct cmd_confirm_sleep confirm_sleep;
44
45
46 #define LBS_TX_PWR_DEFAULT              20      /*100mW */
47 #define LBS_TX_PWR_US_DEFAULT           20      /*100mW */
48 #define LBS_TX_PWR_JP_DEFAULT           16      /*50mW */
49 #define LBS_TX_PWR_FR_DEFAULT           20      /*100mW */
50 #define LBS_TX_PWR_EMEA_DEFAULT 20      /*100mW */
51
52 /* Format { channel, frequency (MHz), maxtxpower } */
53 /* band: 'B/G', region: USA FCC/Canada IC */
54 static struct chan_freq_power channel_freq_power_US_BG[] = {
55         {1, 2412, LBS_TX_PWR_US_DEFAULT},
56         {2, 2417, LBS_TX_PWR_US_DEFAULT},
57         {3, 2422, LBS_TX_PWR_US_DEFAULT},
58         {4, 2427, LBS_TX_PWR_US_DEFAULT},
59         {5, 2432, LBS_TX_PWR_US_DEFAULT},
60         {6, 2437, LBS_TX_PWR_US_DEFAULT},
61         {7, 2442, LBS_TX_PWR_US_DEFAULT},
62         {8, 2447, LBS_TX_PWR_US_DEFAULT},
63         {9, 2452, LBS_TX_PWR_US_DEFAULT},
64         {10, 2457, LBS_TX_PWR_US_DEFAULT},
65         {11, 2462, LBS_TX_PWR_US_DEFAULT}
66 };
67
68 /* band: 'B/G', region: Europe ETSI */
69 static struct chan_freq_power channel_freq_power_EU_BG[] = {
70         {1, 2412, LBS_TX_PWR_EMEA_DEFAULT},
71         {2, 2417, LBS_TX_PWR_EMEA_DEFAULT},
72         {3, 2422, LBS_TX_PWR_EMEA_DEFAULT},
73         {4, 2427, LBS_TX_PWR_EMEA_DEFAULT},
74         {5, 2432, LBS_TX_PWR_EMEA_DEFAULT},
75         {6, 2437, LBS_TX_PWR_EMEA_DEFAULT},
76         {7, 2442, LBS_TX_PWR_EMEA_DEFAULT},
77         {8, 2447, LBS_TX_PWR_EMEA_DEFAULT},
78         {9, 2452, LBS_TX_PWR_EMEA_DEFAULT},
79         {10, 2457, LBS_TX_PWR_EMEA_DEFAULT},
80         {11, 2462, LBS_TX_PWR_EMEA_DEFAULT},
81         {12, 2467, LBS_TX_PWR_EMEA_DEFAULT},
82         {13, 2472, LBS_TX_PWR_EMEA_DEFAULT}
83 };
84
85 /* band: 'B/G', region: Spain */
86 static struct chan_freq_power channel_freq_power_SPN_BG[] = {
87         {10, 2457, LBS_TX_PWR_DEFAULT},
88         {11, 2462, LBS_TX_PWR_DEFAULT}
89 };
90
91 /* band: 'B/G', region: France */
92 static struct chan_freq_power channel_freq_power_FR_BG[] = {
93         {10, 2457, LBS_TX_PWR_FR_DEFAULT},
94         {11, 2462, LBS_TX_PWR_FR_DEFAULT},
95         {12, 2467, LBS_TX_PWR_FR_DEFAULT},
96         {13, 2472, LBS_TX_PWR_FR_DEFAULT}
97 };
98
99 /* band: 'B/G', region: Japan */
100 static struct chan_freq_power channel_freq_power_JPN_BG[] = {
101         {1, 2412, LBS_TX_PWR_JP_DEFAULT},
102         {2, 2417, LBS_TX_PWR_JP_DEFAULT},
103         {3, 2422, LBS_TX_PWR_JP_DEFAULT},
104         {4, 2427, LBS_TX_PWR_JP_DEFAULT},
105         {5, 2432, LBS_TX_PWR_JP_DEFAULT},
106         {6, 2437, LBS_TX_PWR_JP_DEFAULT},
107         {7, 2442, LBS_TX_PWR_JP_DEFAULT},
108         {8, 2447, LBS_TX_PWR_JP_DEFAULT},
109         {9, 2452, LBS_TX_PWR_JP_DEFAULT},
110         {10, 2457, LBS_TX_PWR_JP_DEFAULT},
111         {11, 2462, LBS_TX_PWR_JP_DEFAULT},
112         {12, 2467, LBS_TX_PWR_JP_DEFAULT},
113         {13, 2472, LBS_TX_PWR_JP_DEFAULT},
114         {14, 2484, LBS_TX_PWR_JP_DEFAULT}
115 };
116
117 /**
118  * the structure for channel, frequency and power
119  */
120 struct region_cfp_table {
121         u8 region;
122         struct chan_freq_power *cfp_BG;
123         int cfp_no_BG;
124 };
125
126 /**
127  * the structure for the mapping between region and CFP
128  */
129 static struct region_cfp_table region_cfp_table[] = {
130         {0x10,                  /*US FCC */
131          channel_freq_power_US_BG,
132          ARRAY_SIZE(channel_freq_power_US_BG),
133          }
134         ,
135         {0x20,                  /*CANADA IC */
136          channel_freq_power_US_BG,
137          ARRAY_SIZE(channel_freq_power_US_BG),
138          }
139         ,
140         {0x30, /*EU*/ channel_freq_power_EU_BG,
141          ARRAY_SIZE(channel_freq_power_EU_BG),
142          }
143         ,
144         {0x31, /*SPAIN*/ channel_freq_power_SPN_BG,
145          ARRAY_SIZE(channel_freq_power_SPN_BG),
146          }
147         ,
148         {0x32, /*FRANCE*/ channel_freq_power_FR_BG,
149          ARRAY_SIZE(channel_freq_power_FR_BG),
150          }
151         ,
152         {0x40, /*JAPAN*/ channel_freq_power_JPN_BG,
153          ARRAY_SIZE(channel_freq_power_JPN_BG),
154          }
155         ,
156 /*Add new region here */
157 };
158
159 /**
160  * the table to keep region code
161  */
162 u16 lbs_region_code_to_index[MRVDRV_MAX_REGION_CODE] =
163     { 0x10, 0x20, 0x30, 0x31, 0x32, 0x40 };
164
165 /**
166  * 802.11b/g supported bitrates (in 500Kb/s units)
167  */
168 u8 lbs_bg_rates[MAX_RATES] =
169     { 0x02, 0x04, 0x0b, 0x16, 0x0c, 0x12, 0x18, 0x24, 0x30, 0x48, 0x60, 0x6c,
170 0x00, 0x00 };
171
172 /**
173  * FW rate table.  FW refers to rates by their index in this table, not by the
174  * rate value itself.  Values of 0x00 are
175  * reserved positions.
176  */
177 static u8 fw_data_rates[MAX_RATES] =
178     { 0x02, 0x04, 0x0B, 0x16, 0x00, 0x0C, 0x12,
179       0x18, 0x24, 0x30, 0x48, 0x60, 0x6C, 0x00
180 };
181
182 /**
183  *  @brief use index to get the data rate
184  *
185  *  @param idx                The index of data rate
186  *  @return                     data rate or 0
187  */
188 u32 lbs_fw_index_to_data_rate(u8 idx)
189 {
190         if (idx >= sizeof(fw_data_rates))
191                 idx = 0;
192         return fw_data_rates[idx];
193 }
194
195 /**
196  *  @brief use rate to get the index
197  *
198  *  @param rate                 data rate
199  *  @return                     index or 0
200  */
201 u8 lbs_data_rate_to_fw_index(u32 rate)
202 {
203         u8 i;
204
205         if (!rate)
206                 return 0;
207
208         for (i = 0; i < sizeof(fw_data_rates); i++) {
209                 if (rate == fw_data_rates[i])
210                         return i;
211         }
212         return 0;
213 }
214
215 /**
216  * Attributes exported through sysfs
217  */
218
219 /**
220  * @brief Get function for sysfs attribute anycast_mask
221  */
222 static ssize_t lbs_anycast_get(struct device *dev,
223                 struct device_attribute *attr, char * buf)
224 {
225         struct lbs_private *priv = to_net_dev(dev)->ml_priv;
226         struct cmd_ds_mesh_access mesh_access;
227         int ret;
228
229         memset(&mesh_access, 0, sizeof(mesh_access));
230
231         ret = lbs_mesh_access(priv, CMD_ACT_MESH_GET_ANYCAST, &mesh_access);
232         if (ret)
233                 return ret;
234
235         return snprintf(buf, 12, "0x%X\n", le32_to_cpu(mesh_access.data[0]));
236 }
237
238 /**
239  * @brief Set function for sysfs attribute anycast_mask
240  */
241 static ssize_t lbs_anycast_set(struct device *dev,
242                 struct device_attribute *attr, const char * buf, size_t count)
243 {
244         struct lbs_private *priv = to_net_dev(dev)->ml_priv;
245         struct cmd_ds_mesh_access mesh_access;
246         uint32_t datum;
247         int ret;
248
249         memset(&mesh_access, 0, sizeof(mesh_access));
250         sscanf(buf, "%x", &datum);
251         mesh_access.data[0] = cpu_to_le32(datum);
252
253         ret = lbs_mesh_access(priv, CMD_ACT_MESH_SET_ANYCAST, &mesh_access);
254         if (ret)
255                 return ret;
256
257         return strlen(buf);
258 }
259
260 /**
261  * @brief Get function for sysfs attribute prb_rsp_limit
262  */
263 static ssize_t lbs_prb_rsp_limit_get(struct device *dev,
264                 struct device_attribute *attr, char *buf)
265 {
266         struct lbs_private *priv = to_net_dev(dev)->ml_priv;
267         struct cmd_ds_mesh_access mesh_access;
268         int ret;
269         u32 retry_limit;
270
271         memset(&mesh_access, 0, sizeof(mesh_access));
272         mesh_access.data[0] = cpu_to_le32(CMD_ACT_GET);
273
274         ret = lbs_mesh_access(priv, CMD_ACT_MESH_SET_GET_PRB_RSP_LIMIT,
275                         &mesh_access);
276         if (ret)
277                 return ret;
278
279         retry_limit = le32_to_cpu(mesh_access.data[1]);
280         return snprintf(buf, 10, "%d\n", retry_limit);
281 }
282
283 /**
284  * @brief Set function for sysfs attribute prb_rsp_limit
285  */
286 static ssize_t lbs_prb_rsp_limit_set(struct device *dev,
287                 struct device_attribute *attr, const char *buf, size_t count)
288 {
289         struct lbs_private *priv = to_net_dev(dev)->ml_priv;
290         struct cmd_ds_mesh_access mesh_access;
291         int ret;
292         unsigned long retry_limit;
293
294         memset(&mesh_access, 0, sizeof(mesh_access));
295         mesh_access.data[0] = cpu_to_le32(CMD_ACT_SET);
296
297         if (!strict_strtoul(buf, 10, &retry_limit))
298                 return -ENOTSUPP;
299         if (retry_limit > 15)
300                 return -ENOTSUPP;
301
302         mesh_access.data[1] = cpu_to_le32(retry_limit);
303
304         ret = lbs_mesh_access(priv, CMD_ACT_MESH_SET_GET_PRB_RSP_LIMIT,
305                         &mesh_access);
306         if (ret)
307                 return ret;
308
309         return strlen(buf);
310 }
311
312 static int lbs_add_rtap(struct lbs_private *priv);
313 static void lbs_remove_rtap(struct lbs_private *priv);
314 static int lbs_add_mesh(struct lbs_private *priv);
315 static void lbs_remove_mesh(struct lbs_private *priv);
316
317
318 /**
319  * Get function for sysfs attribute rtap
320  */
321 static ssize_t lbs_rtap_get(struct device *dev,
322                 struct device_attribute *attr, char * buf)
323 {
324         struct lbs_private *priv = to_net_dev(dev)->ml_priv;
325         return snprintf(buf, 5, "0x%X\n", priv->monitormode);
326 }
327
328 /**
329  *  Set function for sysfs attribute rtap
330  */
331 static ssize_t lbs_rtap_set(struct device *dev,
332                 struct device_attribute *attr, const char * buf, size_t count)
333 {
334         int monitor_mode;
335         struct lbs_private *priv = to_net_dev(dev)->ml_priv;
336
337         sscanf(buf, "%x", &monitor_mode);
338         if (monitor_mode) {
339                 if (priv->monitormode == monitor_mode)
340                         return strlen(buf);
341                 if (!priv->monitormode) {
342                         if (priv->infra_open || priv->mesh_open)
343                                 return -EBUSY;
344                         if (priv->mode == IW_MODE_INFRA)
345                                 lbs_cmd_80211_deauthenticate(priv,
346                                                              priv->curbssparams.bssid,
347                                                              WLAN_REASON_DEAUTH_LEAVING);
348                         else if (priv->mode == IW_MODE_ADHOC)
349                                 lbs_adhoc_stop(priv);
350                         lbs_add_rtap(priv);
351                 }
352                 priv->monitormode = monitor_mode;
353         } else {
354                 if (!priv->monitormode)
355                         return strlen(buf);
356                 priv->monitormode = 0;
357                 lbs_remove_rtap(priv);
358
359                 if (priv->currenttxskb) {
360                         dev_kfree_skb_any(priv->currenttxskb);
361                         priv->currenttxskb = NULL;
362                 }
363
364                 /* Wake queues, command thread, etc. */
365                 lbs_host_to_card_done(priv);
366         }
367
368         lbs_prepare_and_send_command(priv,
369                         CMD_802_11_MONITOR_MODE, CMD_ACT_SET,
370                         CMD_OPTION_WAITFORRSP, 0, &priv->monitormode);
371         return strlen(buf);
372 }
373
374 /**
375  * lbs_rtap attribute to be exported per ethX interface
376  * through sysfs (/sys/class/net/ethX/lbs_rtap)
377  */
378 static DEVICE_ATTR(lbs_rtap, 0644, lbs_rtap_get, lbs_rtap_set );
379
380 /**
381  * Get function for sysfs attribute mesh
382  */
383 static ssize_t lbs_mesh_get(struct device *dev,
384                 struct device_attribute *attr, char * buf)
385 {
386         struct lbs_private *priv = to_net_dev(dev)->ml_priv;
387         return snprintf(buf, 5, "0x%X\n", !!priv->mesh_dev);
388 }
389
390 /**
391  *  Set function for sysfs attribute mesh
392  */
393 static ssize_t lbs_mesh_set(struct device *dev,
394                 struct device_attribute *attr, const char * buf, size_t count)
395 {
396         struct lbs_private *priv = to_net_dev(dev)->ml_priv;
397         int enable;
398         int ret, action = CMD_ACT_MESH_CONFIG_STOP;
399
400         sscanf(buf, "%x", &enable);
401         enable = !!enable;
402         if (enable == !!priv->mesh_dev)
403                 return count;
404         if (enable)
405                 action = CMD_ACT_MESH_CONFIG_START;
406         ret = lbs_mesh_config(priv, action, priv->curbssparams.channel);
407         if (ret)
408                 return ret;
409
410         if (enable)
411                 lbs_add_mesh(priv);
412         else
413                 lbs_remove_mesh(priv);
414
415         return count;
416 }
417
418 /**
419  * lbs_mesh attribute to be exported per ethX interface
420  * through sysfs (/sys/class/net/ethX/lbs_mesh)
421  */
422 static DEVICE_ATTR(lbs_mesh, 0644, lbs_mesh_get, lbs_mesh_set);
423
424 /**
425  * anycast_mask attribute to be exported per mshX interface
426  * through sysfs (/sys/class/net/mshX/anycast_mask)
427  */
428 static DEVICE_ATTR(anycast_mask, 0644, lbs_anycast_get, lbs_anycast_set);
429
430 /**
431  * prb_rsp_limit attribute to be exported per mshX interface
432  * through sysfs (/sys/class/net/mshX/prb_rsp_limit)
433  */
434 static DEVICE_ATTR(prb_rsp_limit, 0644, lbs_prb_rsp_limit_get,
435                 lbs_prb_rsp_limit_set);
436
437 static struct attribute *lbs_mesh_sysfs_entries[] = {
438         &dev_attr_anycast_mask.attr,
439         &dev_attr_prb_rsp_limit.attr,
440         NULL,
441 };
442
443 static struct attribute_group lbs_mesh_attr_group = {
444         .attrs = lbs_mesh_sysfs_entries,
445 };
446
447 /**
448  *  @brief This function opens the ethX or mshX interface
449  *
450  *  @param dev     A pointer to net_device structure
451  *  @return        0 or -EBUSY if monitor mode active
452  */
453 static int lbs_dev_open(struct net_device *dev)
454 {
455         struct lbs_private *priv = dev->ml_priv;
456         int ret = 0;
457
458         lbs_deb_enter(LBS_DEB_NET);
459
460         spin_lock_irq(&priv->driver_lock);
461
462         if (priv->monitormode) {
463                 ret = -EBUSY;
464                 goto out;
465         }
466
467         if (dev == priv->mesh_dev) {
468                 priv->mesh_open = 1;
469                 priv->mesh_connect_status = LBS_CONNECTED;
470                 netif_carrier_on(dev);
471         } else {
472                 priv->infra_open = 1;
473
474                 if (priv->connect_status == LBS_CONNECTED)
475                         netif_carrier_on(dev);
476                 else
477                         netif_carrier_off(dev);
478         }
479
480         if (!priv->tx_pending_len)
481                 netif_wake_queue(dev);
482  out:
483
484         spin_unlock_irq(&priv->driver_lock);
485         lbs_deb_leave_args(LBS_DEB_NET, "ret %d", ret);
486         return ret;
487 }
488
489 /**
490  *  @brief This function closes the mshX interface
491  *
492  *  @param dev     A pointer to net_device structure
493  *  @return        0
494  */
495 static int lbs_mesh_stop(struct net_device *dev)
496 {
497         struct lbs_private *priv = dev->ml_priv;
498
499         lbs_deb_enter(LBS_DEB_MESH);
500         spin_lock_irq(&priv->driver_lock);
501
502         priv->mesh_open = 0;
503         priv->mesh_connect_status = LBS_DISCONNECTED;
504
505         netif_stop_queue(dev);
506         netif_carrier_off(dev);
507
508         spin_unlock_irq(&priv->driver_lock);
509
510         schedule_work(&priv->mcast_work);
511
512         lbs_deb_leave(LBS_DEB_MESH);
513         return 0;
514 }
515
516 /**
517  *  @brief This function closes the ethX interface
518  *
519  *  @param dev     A pointer to net_device structure
520  *  @return        0
521  */
522 static int lbs_eth_stop(struct net_device *dev)
523 {
524         struct lbs_private *priv = dev->ml_priv;
525
526         lbs_deb_enter(LBS_DEB_NET);
527
528         spin_lock_irq(&priv->driver_lock);
529         priv->infra_open = 0;
530         netif_stop_queue(dev);
531         spin_unlock_irq(&priv->driver_lock);
532
533         schedule_work(&priv->mcast_work);
534
535         lbs_deb_leave(LBS_DEB_NET);
536         return 0;
537 }
538
539 static void lbs_tx_timeout(struct net_device *dev)
540 {
541         struct lbs_private *priv = dev->ml_priv;
542
543         lbs_deb_enter(LBS_DEB_TX);
544
545         lbs_pr_err("tx watch dog timeout\n");
546
547         dev->trans_start = jiffies;
548
549         if (priv->currenttxskb)
550                 lbs_send_tx_feedback(priv, 0);
551
552         /* XX: Shouldn't we also call into the hw-specific driver
553            to kick it somehow? */
554         lbs_host_to_card_done(priv);
555
556         /* More often than not, this actually happens because the
557            firmware has crapped itself -- rather than just a very
558            busy medium. So send a harmless command, and if/when
559            _that_ times out, we'll kick it in the head. */
560         lbs_prepare_and_send_command(priv, CMD_802_11_RSSI, 0,
561                                      0, 0, NULL);
562
563         lbs_deb_leave(LBS_DEB_TX);
564 }
565
566 void lbs_host_to_card_done(struct lbs_private *priv)
567 {
568         unsigned long flags;
569
570         lbs_deb_enter(LBS_DEB_THREAD);
571
572         spin_lock_irqsave(&priv->driver_lock, flags);
573
574         priv->dnld_sent = DNLD_RES_RECEIVED;
575
576         /* Wake main thread if commands are pending */
577         if (!priv->cur_cmd || priv->tx_pending_len > 0)
578                 wake_up_interruptible(&priv->waitq);
579
580         spin_unlock_irqrestore(&priv->driver_lock, flags);
581         lbs_deb_leave(LBS_DEB_THREAD);
582 }
583 EXPORT_SYMBOL_GPL(lbs_host_to_card_done);
584
585 static int lbs_set_mac_address(struct net_device *dev, void *addr)
586 {
587         int ret = 0;
588         struct lbs_private *priv = dev->ml_priv;
589         struct sockaddr *phwaddr = addr;
590         struct cmd_ds_802_11_mac_address cmd;
591
592         lbs_deb_enter(LBS_DEB_NET);
593
594         /* In case it was called from the mesh device */
595         dev = priv->dev;
596
597         cmd.hdr.size = cpu_to_le16(sizeof(cmd));
598         cmd.action = cpu_to_le16(CMD_ACT_SET);
599         memcpy(cmd.macadd, phwaddr->sa_data, ETH_ALEN);
600
601         ret = lbs_cmd_with_response(priv, CMD_802_11_MAC_ADDRESS, &cmd);
602         if (ret) {
603                 lbs_deb_net("set MAC address failed\n");
604                 goto done;
605         }
606
607         memcpy(priv->current_addr, phwaddr->sa_data, ETH_ALEN);
608         memcpy(dev->dev_addr, phwaddr->sa_data, ETH_ALEN);
609         if (priv->mesh_dev)
610                 memcpy(priv->mesh_dev->dev_addr, phwaddr->sa_data, ETH_ALEN);
611
612 done:
613         lbs_deb_leave_args(LBS_DEB_NET, "ret %d", ret);
614         return ret;
615 }
616
617
618 static inline int mac_in_list(unsigned char *list, int list_len,
619                               unsigned char *mac)
620 {
621         while (list_len) {
622                 if (!memcmp(list, mac, ETH_ALEN))
623                         return 1;
624                 list += ETH_ALEN;
625                 list_len--;
626         }
627         return 0;
628 }
629
630
631 static int lbs_add_mcast_addrs(struct cmd_ds_mac_multicast_adr *cmd,
632                                struct net_device *dev, int nr_addrs)
633 {
634         int i = nr_addrs;
635         struct dev_mc_list *mc_list;
636
637         if ((dev->flags & (IFF_UP|IFF_MULTICAST)) != (IFF_UP|IFF_MULTICAST))
638                 return nr_addrs;
639
640         netif_addr_lock_bh(dev);
641         for (mc_list = dev->mc_list; mc_list; mc_list = mc_list->next) {
642                 if (mac_in_list(cmd->maclist, nr_addrs, mc_list->dmi_addr)) {
643                         lbs_deb_net("mcast address %s:%pM skipped\n", dev->name,
644                                     mc_list->dmi_addr);
645                         continue;
646                 }
647
648                 if (i == MRVDRV_MAX_MULTICAST_LIST_SIZE)
649                         break;
650                 memcpy(&cmd->maclist[6*i], mc_list->dmi_addr, ETH_ALEN);
651                 lbs_deb_net("mcast address %s:%pM added to filter\n", dev->name,
652                             mc_list->dmi_addr);
653                 i++;
654         }
655         netif_addr_unlock_bh(dev);
656         if (mc_list)
657                 return -EOVERFLOW;
658
659         return i;
660 }
661
662 static void lbs_set_mcast_worker(struct work_struct *work)
663 {
664         struct lbs_private *priv = container_of(work, struct lbs_private, mcast_work);
665         struct cmd_ds_mac_multicast_adr mcast_cmd;
666         int dev_flags;
667         int nr_addrs;
668         int old_mac_control = priv->mac_control;
669
670         lbs_deb_enter(LBS_DEB_NET);
671
672         dev_flags = priv->dev->flags;
673         if (priv->mesh_dev)
674                 dev_flags |= priv->mesh_dev->flags;
675
676         if (dev_flags & IFF_PROMISC) {
677                 priv->mac_control |= CMD_ACT_MAC_PROMISCUOUS_ENABLE;
678                 priv->mac_control &= ~(CMD_ACT_MAC_ALL_MULTICAST_ENABLE |
679                                        CMD_ACT_MAC_MULTICAST_ENABLE);
680                 goto out_set_mac_control;
681         } else if (dev_flags & IFF_ALLMULTI) {
682         do_allmulti:
683                 priv->mac_control |= CMD_ACT_MAC_ALL_MULTICAST_ENABLE;
684                 priv->mac_control &= ~(CMD_ACT_MAC_PROMISCUOUS_ENABLE |
685                                        CMD_ACT_MAC_MULTICAST_ENABLE);
686                 goto out_set_mac_control;
687         }
688
689         /* Once for priv->dev, again for priv->mesh_dev if it exists */
690         nr_addrs = lbs_add_mcast_addrs(&mcast_cmd, priv->dev, 0);
691         if (nr_addrs >= 0 && priv->mesh_dev)
692                 nr_addrs = lbs_add_mcast_addrs(&mcast_cmd, priv->mesh_dev, nr_addrs);
693         if (nr_addrs < 0)
694                 goto do_allmulti;
695
696         if (nr_addrs) {
697                 int size = offsetof(struct cmd_ds_mac_multicast_adr,
698                                     maclist[6*nr_addrs]);
699
700                 mcast_cmd.action = cpu_to_le16(CMD_ACT_SET);
701                 mcast_cmd.hdr.size = cpu_to_le16(size);
702                 mcast_cmd.nr_of_adrs = cpu_to_le16(nr_addrs);
703
704                 lbs_cmd_async(priv, CMD_MAC_MULTICAST_ADR, &mcast_cmd.hdr, size);
705
706                 priv->mac_control |= CMD_ACT_MAC_MULTICAST_ENABLE;
707         } else
708                 priv->mac_control &= ~CMD_ACT_MAC_MULTICAST_ENABLE;
709
710         priv->mac_control &= ~(CMD_ACT_MAC_PROMISCUOUS_ENABLE |
711                                CMD_ACT_MAC_ALL_MULTICAST_ENABLE);
712  out_set_mac_control:
713         if (priv->mac_control != old_mac_control)
714                 lbs_set_mac_control(priv);
715
716         lbs_deb_leave(LBS_DEB_NET);
717 }
718
719 static void lbs_set_multicast_list(struct net_device *dev)
720 {
721         struct lbs_private *priv = dev->ml_priv;
722
723         schedule_work(&priv->mcast_work);
724 }
725
726 /**
727  *  @brief This function handles the major jobs in the LBS driver.
728  *  It handles all events generated by firmware, RX data received
729  *  from firmware and TX data sent from kernel.
730  *
731  *  @param data    A pointer to lbs_thread structure
732  *  @return        0
733  */
734 static int lbs_thread(void *data)
735 {
736         struct net_device *dev = data;
737         struct lbs_private *priv = dev->ml_priv;
738         wait_queue_t wait;
739
740         lbs_deb_enter(LBS_DEB_THREAD);
741
742         init_waitqueue_entry(&wait, current);
743
744         for (;;) {
745                 int shouldsleep;
746                 u8 resp_idx;
747
748                 lbs_deb_thread("1: currenttxskb %p, dnld_sent %d\n",
749                                 priv->currenttxskb, priv->dnld_sent);
750
751                 add_wait_queue(&priv->waitq, &wait);
752                 set_current_state(TASK_INTERRUPTIBLE);
753                 spin_lock_irq(&priv->driver_lock);
754
755                 if (kthread_should_stop())
756                         shouldsleep = 0;        /* Bye */
757                 else if (priv->surpriseremoved)
758                         shouldsleep = 1;        /* We need to wait until we're _told_ to die */
759                 else if (priv->psstate == PS_STATE_SLEEP)
760                         shouldsleep = 1;        /* Sleep mode. Nothing we can do till it wakes */
761                 else if (priv->cmd_timed_out)
762                         shouldsleep = 0;        /* Command timed out. Recover */
763                 else if (!priv->fw_ready)
764                         shouldsleep = 1;        /* Firmware not ready. We're waiting for it */
765                 else if (priv->dnld_sent)
766                         shouldsleep = 1;        /* Something is en route to the device already */
767                 else if (priv->tx_pending_len > 0)
768                         shouldsleep = 0;        /* We've a packet to send */
769                 else if (priv->resp_len[priv->resp_idx])
770                         shouldsleep = 0;        /* We have a command response */
771                 else if (priv->cur_cmd)
772                         shouldsleep = 1;        /* Can't send a command; one already running */
773                 else if (!list_empty(&priv->cmdpendingq))
774                         shouldsleep = 0;        /* We have a command to send */
775                 else if (__kfifo_len(priv->event_fifo))
776                         shouldsleep = 0;        /* We have an event to process */
777                 else
778                         shouldsleep = 1;        /* No command */
779
780                 if (shouldsleep) {
781                         lbs_deb_thread("sleeping, connect_status %d, "
782                                 "psmode %d, psstate %d\n",
783                                 priv->connect_status,
784                                 priv->psmode, priv->psstate);
785                         spin_unlock_irq(&priv->driver_lock);
786                         schedule();
787                 } else
788                         spin_unlock_irq(&priv->driver_lock);
789
790                 lbs_deb_thread("2: currenttxskb %p, dnld_send %d\n",
791                                priv->currenttxskb, priv->dnld_sent);
792
793                 set_current_state(TASK_RUNNING);
794                 remove_wait_queue(&priv->waitq, &wait);
795
796                 lbs_deb_thread("3: currenttxskb %p, dnld_sent %d\n",
797                                priv->currenttxskb, priv->dnld_sent);
798
799                 if (kthread_should_stop()) {
800                         lbs_deb_thread("break from main thread\n");
801                         break;
802                 }
803
804                 if (priv->surpriseremoved) {
805                         lbs_deb_thread("adapter removed; waiting to die...\n");
806                         continue;
807                 }
808
809                 lbs_deb_thread("4: currenttxskb %p, dnld_sent %d\n",
810                        priv->currenttxskb, priv->dnld_sent);
811
812                 /* Process any pending command response */
813                 spin_lock_irq(&priv->driver_lock);
814                 resp_idx = priv->resp_idx;
815                 if (priv->resp_len[resp_idx]) {
816                         spin_unlock_irq(&priv->driver_lock);
817                         lbs_process_command_response(priv,
818                                 priv->resp_buf[resp_idx],
819                                 priv->resp_len[resp_idx]);
820                         spin_lock_irq(&priv->driver_lock);
821                         priv->resp_len[resp_idx] = 0;
822                 }
823                 spin_unlock_irq(&priv->driver_lock);
824
825                 /* command timeout stuff */
826                 if (priv->cmd_timed_out && priv->cur_cmd) {
827                         struct cmd_ctrl_node *cmdnode = priv->cur_cmd;
828
829                         if (++priv->nr_retries > 3) {
830                                 lbs_pr_info("Excessive timeouts submitting "
831                                         "command 0x%04x\n",
832                                         le16_to_cpu(cmdnode->cmdbuf->command));
833                                 lbs_complete_command(priv, cmdnode, -ETIMEDOUT);
834                                 priv->nr_retries = 0;
835                                 if (priv->reset_card)
836                                         priv->reset_card(priv);
837                         } else {
838                                 priv->cur_cmd = NULL;
839                                 priv->dnld_sent = DNLD_RES_RECEIVED;
840                                 lbs_pr_info("requeueing command 0x%04x due "
841                                         "to timeout (#%d)\n",
842                                         le16_to_cpu(cmdnode->cmdbuf->command),
843                                         priv->nr_retries);
844
845                                 /* Stick it back at the _top_ of the pending queue
846                                    for immediate resubmission */
847                                 list_add(&cmdnode->list, &priv->cmdpendingq);
848                         }
849                 }
850                 priv->cmd_timed_out = 0;
851
852                 /* Process hardware events, e.g. card removed, link lost */
853                 spin_lock_irq(&priv->driver_lock);
854                 while (__kfifo_len(priv->event_fifo)) {
855                         u32 event;
856
857                         __kfifo_get(priv->event_fifo, (unsigned char *) &event,
858                                 sizeof(event));
859                         spin_unlock_irq(&priv->driver_lock);
860                         lbs_process_event(priv, event);
861                         spin_lock_irq(&priv->driver_lock);
862                 }
863                 spin_unlock_irq(&priv->driver_lock);
864
865                 if (!priv->fw_ready)
866                         continue;
867
868                 /* Check if we need to confirm Sleep Request received previously */
869                 if (priv->psstate == PS_STATE_PRE_SLEEP &&
870                     !priv->dnld_sent && !priv->cur_cmd) {
871                         if (priv->connect_status == LBS_CONNECTED) {
872                                 lbs_deb_thread("pre-sleep, currenttxskb %p, "
873                                         "dnld_sent %d, cur_cmd %p\n",
874                                         priv->currenttxskb, priv->dnld_sent,
875                                         priv->cur_cmd);
876
877                                 lbs_ps_confirm_sleep(priv);
878                         } else {
879                                 /* workaround for firmware sending
880                                  * deauth/linkloss event immediately
881                                  * after sleep request; remove this
882                                  * after firmware fixes it
883                                  */
884                                 priv->psstate = PS_STATE_AWAKE;
885                                 lbs_pr_alert("ignore PS_SleepConfirm in "
886                                         "non-connected state\n");
887                         }
888                 }
889
890                 /* The PS state is changed during processing of Sleep Request
891                  * event above
892                  */
893                 if ((priv->psstate == PS_STATE_SLEEP) ||
894                     (priv->psstate == PS_STATE_PRE_SLEEP))
895                         continue;
896
897                 /* Execute the next command */
898                 if (!priv->dnld_sent && !priv->cur_cmd)
899                         lbs_execute_next_command(priv);
900
901                 /* Wake-up command waiters which can't sleep in
902                  * lbs_prepare_and_send_command
903                  */
904                 if (!list_empty(&priv->cmdpendingq))
905                         wake_up_all(&priv->cmd_pending);
906
907                 spin_lock_irq(&priv->driver_lock);
908                 if (!priv->dnld_sent && priv->tx_pending_len > 0) {
909                         int ret = priv->hw_host_to_card(priv, MVMS_DAT,
910                                                         priv->tx_pending_buf,
911                                                         priv->tx_pending_len);
912                         if (ret) {
913                                 lbs_deb_tx("host_to_card failed %d\n", ret);
914                                 priv->dnld_sent = DNLD_RES_RECEIVED;
915                         }
916                         priv->tx_pending_len = 0;
917                         if (!priv->currenttxskb) {
918                                 /* We can wake the queues immediately if we aren't
919                                    waiting for TX feedback */
920                                 if (priv->connect_status == LBS_CONNECTED)
921                                         netif_wake_queue(priv->dev);
922                                 if (priv->mesh_dev &&
923                                     priv->mesh_connect_status == LBS_CONNECTED)
924                                         netif_wake_queue(priv->mesh_dev);
925                         }
926                 }
927                 spin_unlock_irq(&priv->driver_lock);
928         }
929
930         del_timer(&priv->command_timer);
931         wake_up_all(&priv->cmd_pending);
932
933         lbs_deb_leave(LBS_DEB_THREAD);
934         return 0;
935 }
936
937 static int lbs_suspend_callback(struct lbs_private *priv, unsigned long dummy,
938                                 struct cmd_header *cmd)
939 {
940         lbs_deb_enter(LBS_DEB_FW);
941
942         netif_device_detach(priv->dev);
943         if (priv->mesh_dev)
944                 netif_device_detach(priv->mesh_dev);
945
946         priv->fw_ready = 0;
947         lbs_deb_leave(LBS_DEB_FW);
948         return 0;
949 }
950
951 int lbs_suspend(struct lbs_private *priv)
952 {
953         struct cmd_header cmd;
954         int ret;
955
956         lbs_deb_enter(LBS_DEB_FW);
957
958         if (priv->wol_criteria == 0xffffffff) {
959                 lbs_pr_info("Suspend attempt without configuring wake params!\n");
960                 return -EINVAL;
961         }
962
963         memset(&cmd, 0, sizeof(cmd));
964
965         ret = __lbs_cmd(priv, CMD_802_11_HOST_SLEEP_ACTIVATE, &cmd,
966                         sizeof(cmd), lbs_suspend_callback, 0);
967         if (ret)
968                 lbs_pr_info("HOST_SLEEP_ACTIVATE failed: %d\n", ret);
969
970         lbs_deb_leave_args(LBS_DEB_FW, "ret %d", ret);
971         return ret;
972 }
973 EXPORT_SYMBOL_GPL(lbs_suspend);
974
975 void lbs_resume(struct lbs_private *priv)
976 {
977         lbs_deb_enter(LBS_DEB_FW);
978
979         priv->fw_ready = 1;
980
981         /* Firmware doesn't seem to give us RX packets any more
982            until we send it some command. Might as well update */
983         lbs_prepare_and_send_command(priv, CMD_802_11_RSSI, 0,
984                                      0, 0, NULL);
985
986         netif_device_attach(priv->dev);
987         if (priv->mesh_dev)
988                 netif_device_attach(priv->mesh_dev);
989
990         lbs_deb_leave(LBS_DEB_FW);
991 }
992 EXPORT_SYMBOL_GPL(lbs_resume);
993
994 /**
995  * @brief This function gets the HW spec from the firmware and sets
996  *        some basic parameters.
997  *
998  *  @param priv    A pointer to struct lbs_private structure
999  *  @return        0 or -1
1000  */
1001 static int lbs_setup_firmware(struct lbs_private *priv)
1002 {
1003         int ret = -1;
1004         s16 curlevel = 0, minlevel = 0, maxlevel = 0;
1005
1006         lbs_deb_enter(LBS_DEB_FW);
1007
1008         /* Read MAC address from firmware */
1009         memset(priv->current_addr, 0xff, ETH_ALEN);
1010         ret = lbs_update_hw_spec(priv);
1011         if (ret)
1012                 goto done;
1013
1014         /* Read power levels if available */
1015         ret = lbs_get_tx_power(priv, &curlevel, &minlevel, &maxlevel);
1016         if (ret == 0) {
1017                 priv->txpower_cur = curlevel;
1018                 priv->txpower_min = minlevel;
1019                 priv->txpower_max = maxlevel;
1020         }
1021
1022         lbs_set_mac_control(priv);
1023 done:
1024         lbs_deb_leave_args(LBS_DEB_FW, "ret %d", ret);
1025         return ret;
1026 }
1027
1028 /**
1029  *  This function handles the timeout of command sending.
1030  *  It will re-send the same command again.
1031  */
1032 static void command_timer_fn(unsigned long data)
1033 {
1034         struct lbs_private *priv = (struct lbs_private *)data;
1035         unsigned long flags;
1036
1037         lbs_deb_enter(LBS_DEB_CMD);
1038         spin_lock_irqsave(&priv->driver_lock, flags);
1039
1040         if (!priv->cur_cmd)
1041                 goto out;
1042
1043         lbs_pr_info("command 0x%04x timed out\n",
1044                 le16_to_cpu(priv->cur_cmd->cmdbuf->command));
1045
1046         priv->cmd_timed_out = 1;
1047         wake_up_interruptible(&priv->waitq);
1048 out:
1049         spin_unlock_irqrestore(&priv->driver_lock, flags);
1050         lbs_deb_leave(LBS_DEB_CMD);
1051 }
1052
1053 static void lbs_sync_channel_worker(struct work_struct *work)
1054 {
1055         struct lbs_private *priv = container_of(work, struct lbs_private,
1056                 sync_channel);
1057
1058         lbs_deb_enter(LBS_DEB_MAIN);
1059         if (lbs_update_channel(priv))
1060                 lbs_pr_info("Channel synchronization failed.");
1061         lbs_deb_leave(LBS_DEB_MAIN);
1062 }
1063
1064
1065 static int lbs_init_adapter(struct lbs_private *priv)
1066 {
1067         size_t bufsize;
1068         int i, ret = 0;
1069
1070         lbs_deb_enter(LBS_DEB_MAIN);
1071
1072         /* Allocate buffer to store the BSSID list */
1073         bufsize = MAX_NETWORK_COUNT * sizeof(struct bss_descriptor);
1074         priv->networks = kzalloc(bufsize, GFP_KERNEL);
1075         if (!priv->networks) {
1076                 lbs_pr_err("Out of memory allocating beacons\n");
1077                 ret = -1;
1078                 goto out;
1079         }
1080
1081         /* Initialize scan result lists */
1082         INIT_LIST_HEAD(&priv->network_free_list);
1083         INIT_LIST_HEAD(&priv->network_list);
1084         for (i = 0; i < MAX_NETWORK_COUNT; i++) {
1085                 list_add_tail(&priv->networks[i].list,
1086                               &priv->network_free_list);
1087         }
1088
1089         memset(priv->current_addr, 0xff, ETH_ALEN);
1090
1091         priv->connect_status = LBS_DISCONNECTED;
1092         priv->mesh_connect_status = LBS_DISCONNECTED;
1093         priv->secinfo.auth_mode = IW_AUTH_ALG_OPEN_SYSTEM;
1094         priv->mode = IW_MODE_INFRA;
1095         priv->curbssparams.channel = DEFAULT_AD_HOC_CHANNEL;
1096         priv->mac_control = CMD_ACT_MAC_RX_ON | CMD_ACT_MAC_TX_ON;
1097         priv->radio_on = 1;
1098         priv->enablehwauto = 1;
1099         priv->capability = WLAN_CAPABILITY_SHORT_PREAMBLE;
1100         priv->psmode = LBS802_11POWERMODECAM;
1101         priv->psstate = PS_STATE_FULL_POWER;
1102
1103         mutex_init(&priv->lock);
1104
1105         setup_timer(&priv->command_timer, command_timer_fn,
1106                 (unsigned long)priv);
1107
1108         INIT_LIST_HEAD(&priv->cmdfreeq);
1109         INIT_LIST_HEAD(&priv->cmdpendingq);
1110
1111         spin_lock_init(&priv->driver_lock);
1112         init_waitqueue_head(&priv->cmd_pending);
1113
1114         /* Allocate the command buffers */
1115         if (lbs_allocate_cmd_buffer(priv)) {
1116                 lbs_pr_err("Out of memory allocating command buffers\n");
1117                 ret = -ENOMEM;
1118                 goto out;
1119         }
1120         priv->resp_idx = 0;
1121         priv->resp_len[0] = priv->resp_len[1] = 0;
1122
1123         /* Create the event FIFO */
1124         priv->event_fifo = kfifo_alloc(sizeof(u32) * 16, GFP_KERNEL, NULL);
1125         if (IS_ERR(priv->event_fifo)) {
1126                 lbs_pr_err("Out of memory allocating event FIFO buffer\n");
1127                 ret = -ENOMEM;
1128                 goto out;
1129         }
1130
1131 out:
1132         lbs_deb_leave_args(LBS_DEB_MAIN, "ret %d", ret);
1133
1134         return ret;
1135 }
1136
1137 static void lbs_free_adapter(struct lbs_private *priv)
1138 {
1139         lbs_deb_enter(LBS_DEB_MAIN);
1140
1141         lbs_free_cmd_buffer(priv);
1142         if (priv->event_fifo)
1143                 kfifo_free(priv->event_fifo);
1144         del_timer(&priv->command_timer);
1145         kfree(priv->networks);
1146         priv->networks = NULL;
1147
1148         lbs_deb_leave(LBS_DEB_MAIN);
1149 }
1150
1151 static const struct net_device_ops lbs_netdev_ops = {
1152         .ndo_open               = lbs_dev_open,
1153         .ndo_stop               = lbs_eth_stop,
1154         .ndo_start_xmit         = lbs_hard_start_xmit,
1155         .ndo_set_mac_address    = lbs_set_mac_address,
1156         .ndo_tx_timeout         = lbs_tx_timeout,
1157         .ndo_set_multicast_list = lbs_set_multicast_list,
1158         .ndo_change_mtu         = eth_change_mtu,
1159         .ndo_validate_addr      = eth_validate_addr,
1160 };
1161
1162 /**
1163  * @brief This function adds the card. it will probe the
1164  * card, allocate the lbs_priv and initialize the device.
1165  *
1166  *  @param card    A pointer to card
1167  *  @return        A pointer to struct lbs_private structure
1168  */
1169 struct lbs_private *lbs_add_card(void *card, struct device *dmdev)
1170 {
1171         struct net_device *dev = NULL;
1172         struct lbs_private *priv = NULL;
1173
1174         lbs_deb_enter(LBS_DEB_MAIN);
1175
1176         /* Allocate an Ethernet device and register it */
1177         dev = alloc_etherdev(sizeof(struct lbs_private));
1178         if (!dev) {
1179                 lbs_pr_err("init wlanX device failed\n");
1180                 goto done;
1181         }
1182         priv = netdev_priv(dev);
1183         dev->ml_priv = priv;
1184
1185         if (lbs_init_adapter(priv)) {
1186                 lbs_pr_err("failed to initialize adapter structure.\n");
1187                 goto err_init_adapter;
1188         }
1189
1190         priv->dev = dev;
1191         priv->card = card;
1192         priv->mesh_open = 0;
1193         priv->infra_open = 0;
1194
1195         /* Setup the OS Interface to our functions */
1196         dev->netdev_ops = &lbs_netdev_ops;
1197         dev->watchdog_timeo = 5 * HZ;
1198         dev->ethtool_ops = &lbs_ethtool_ops;
1199 #ifdef  WIRELESS_EXT
1200         dev->wireless_handlers = &lbs_handler_def;
1201 #endif
1202         dev->flags |= IFF_BROADCAST | IFF_MULTICAST;
1203
1204         SET_NETDEV_DEV(dev, dmdev);
1205
1206         priv->rtap_net_dev = NULL;
1207         strcpy(dev->name, "wlan%d");
1208
1209         lbs_deb_thread("Starting main thread...\n");
1210         init_waitqueue_head(&priv->waitq);
1211         priv->main_thread = kthread_run(lbs_thread, dev, "lbs_main");
1212         if (IS_ERR(priv->main_thread)) {
1213                 lbs_deb_thread("Error creating main thread.\n");
1214                 goto err_init_adapter;
1215         }
1216
1217         priv->work_thread = create_singlethread_workqueue("lbs_worker");
1218         INIT_DELAYED_WORK(&priv->assoc_work, lbs_association_worker);
1219         INIT_DELAYED_WORK(&priv->scan_work, lbs_scan_worker);
1220         INIT_WORK(&priv->mcast_work, lbs_set_mcast_worker);
1221         INIT_WORK(&priv->sync_channel, lbs_sync_channel_worker);
1222
1223         sprintf(priv->mesh_ssid, "mesh");
1224         priv->mesh_ssid_len = 4;
1225
1226         priv->wol_criteria = 0xffffffff;
1227         priv->wol_gpio = 0xff;
1228
1229         goto done;
1230
1231 err_init_adapter:
1232         lbs_free_adapter(priv);
1233         free_netdev(dev);
1234         priv = NULL;
1235
1236 done:
1237         lbs_deb_leave_args(LBS_DEB_MAIN, "priv %p", priv);
1238         return priv;
1239 }
1240 EXPORT_SYMBOL_GPL(lbs_add_card);
1241
1242
1243 void lbs_remove_card(struct lbs_private *priv)
1244 {
1245         struct net_device *dev = priv->dev;
1246         union iwreq_data wrqu;
1247
1248         lbs_deb_enter(LBS_DEB_MAIN);
1249
1250         lbs_remove_mesh(priv);
1251         lbs_remove_rtap(priv);
1252
1253         dev = priv->dev;
1254
1255         cancel_delayed_work_sync(&priv->scan_work);
1256         cancel_delayed_work_sync(&priv->assoc_work);
1257         cancel_work_sync(&priv->mcast_work);
1258
1259         /* worker thread destruction blocks on the in-flight command which
1260          * should have been cleared already in lbs_stop_card().
1261          */
1262         lbs_deb_main("destroying worker thread\n");
1263         destroy_workqueue(priv->work_thread);
1264         lbs_deb_main("done destroying worker thread\n");
1265
1266         if (priv->psmode == LBS802_11POWERMODEMAX_PSP) {
1267                 priv->psmode = LBS802_11POWERMODECAM;
1268                 lbs_ps_wakeup(priv, CMD_OPTION_WAITFORRSP);
1269         }
1270
1271         memset(wrqu.ap_addr.sa_data, 0xaa, ETH_ALEN);
1272         wrqu.ap_addr.sa_family = ARPHRD_ETHER;
1273         wireless_send_event(priv->dev, SIOCGIWAP, &wrqu, NULL);
1274
1275         /* Stop the thread servicing the interrupts */
1276         priv->surpriseremoved = 1;
1277         kthread_stop(priv->main_thread);
1278
1279         lbs_free_adapter(priv);
1280
1281         priv->dev = NULL;
1282         free_netdev(dev);
1283
1284         lbs_deb_leave(LBS_DEB_MAIN);
1285 }
1286 EXPORT_SYMBOL_GPL(lbs_remove_card);
1287
1288
1289 int lbs_start_card(struct lbs_private *priv)
1290 {
1291         struct net_device *dev = priv->dev;
1292         int ret = -1;
1293
1294         lbs_deb_enter(LBS_DEB_MAIN);
1295
1296         /* poke the firmware */
1297         ret = lbs_setup_firmware(priv);
1298         if (ret)
1299                 goto done;
1300
1301         /* init 802.11d */
1302         lbs_init_11d(priv);
1303
1304         if (register_netdev(dev)) {
1305                 lbs_pr_err("cannot register ethX device\n");
1306                 goto done;
1307         }
1308
1309         lbs_update_channel(priv);
1310
1311         /* Check mesh FW version and appropriately send the mesh start
1312          * command
1313          */
1314         if (priv->mesh_fw_ver == MESH_FW_OLD) {
1315                 /* Enable mesh, if supported, and work out which TLV it uses.
1316                    0x100 + 291 is an unofficial value used in 5.110.20.pXX
1317                    0x100 + 37 is the official value used in 5.110.21.pXX
1318                    but we check them in that order because 20.pXX doesn't
1319                    give an error -- it just silently fails. */
1320
1321                 /* 5.110.20.pXX firmware will fail the command if the channel
1322                    doesn't match the existing channel. But only if the TLV
1323                    is correct. If the channel is wrong, _BOTH_ versions will
1324                    give an error to 0x100+291, and allow 0x100+37 to succeed.
1325                    It's just that 5.110.20.pXX will not have done anything
1326                    useful */
1327
1328                 priv->mesh_tlv = TLV_TYPE_OLD_MESH_ID;
1329                 if (lbs_mesh_config(priv, CMD_ACT_MESH_CONFIG_START,
1330                                     priv->curbssparams.channel)) {
1331                         priv->mesh_tlv = TLV_TYPE_MESH_ID;
1332                         if (lbs_mesh_config(priv, CMD_ACT_MESH_CONFIG_START,
1333                                             priv->curbssparams.channel))
1334                                 priv->mesh_tlv = 0;
1335                 }
1336         } else if (priv->mesh_fw_ver == MESH_FW_NEW) {
1337                 /* 10.0.0.pXX new firmwares should succeed with TLV
1338                  * 0x100+37; Do not invoke command with old TLV.
1339                  */
1340                 priv->mesh_tlv = TLV_TYPE_MESH_ID;
1341                 if (lbs_mesh_config(priv, CMD_ACT_MESH_CONFIG_START,
1342                                     priv->curbssparams.channel))
1343                         priv->mesh_tlv = 0;
1344         }
1345         if (priv->mesh_tlv) {
1346                 lbs_add_mesh(priv);
1347
1348                 if (device_create_file(&dev->dev, &dev_attr_lbs_mesh))
1349                         lbs_pr_err("cannot register lbs_mesh attribute\n");
1350
1351                 /* While rtap isn't related to mesh, only mesh-enabled
1352                  * firmware implements the rtap functionality via
1353                  * CMD_802_11_MONITOR_MODE.
1354                  */
1355                 if (device_create_file(&dev->dev, &dev_attr_lbs_rtap))
1356                         lbs_pr_err("cannot register lbs_rtap attribute\n");
1357         }
1358
1359         lbs_debugfs_init_one(priv, dev);
1360
1361         lbs_pr_info("%s: Marvell WLAN 802.11 adapter\n", dev->name);
1362
1363         ret = 0;
1364
1365 done:
1366         lbs_deb_leave_args(LBS_DEB_MAIN, "ret %d", ret);
1367         return ret;
1368 }
1369 EXPORT_SYMBOL_GPL(lbs_start_card);
1370
1371
1372 void lbs_stop_card(struct lbs_private *priv)
1373 {
1374         struct net_device *dev;
1375         struct cmd_ctrl_node *cmdnode;
1376         unsigned long flags;
1377
1378         lbs_deb_enter(LBS_DEB_MAIN);
1379
1380         if (!priv)
1381                 goto out;
1382         dev = priv->dev;
1383
1384         netif_stop_queue(dev);
1385         netif_carrier_off(dev);
1386
1387         lbs_debugfs_remove_one(priv);
1388         if (priv->mesh_tlv) {
1389                 device_remove_file(&dev->dev, &dev_attr_lbs_mesh);
1390                 device_remove_file(&dev->dev, &dev_attr_lbs_rtap);
1391         }
1392
1393         /* Delete the timeout of the currently processing command */
1394         del_timer_sync(&priv->command_timer);
1395
1396         /* Flush pending command nodes */
1397         spin_lock_irqsave(&priv->driver_lock, flags);
1398         lbs_deb_main("clearing pending commands\n");
1399         list_for_each_entry(cmdnode, &priv->cmdpendingq, list) {
1400                 cmdnode->result = -ENOENT;
1401                 cmdnode->cmdwaitqwoken = 1;
1402                 wake_up_interruptible(&cmdnode->cmdwait_q);
1403         }
1404
1405         /* Flush the command the card is currently processing */
1406         if (priv->cur_cmd) {
1407                 lbs_deb_main("clearing current command\n");
1408                 priv->cur_cmd->result = -ENOENT;
1409                 priv->cur_cmd->cmdwaitqwoken = 1;
1410                 wake_up_interruptible(&priv->cur_cmd->cmdwait_q);
1411         }
1412         lbs_deb_main("done clearing commands\n");
1413         spin_unlock_irqrestore(&priv->driver_lock, flags);
1414
1415         unregister_netdev(dev);
1416
1417 out:
1418         lbs_deb_leave(LBS_DEB_MAIN);
1419 }
1420 EXPORT_SYMBOL_GPL(lbs_stop_card);
1421
1422
1423 static const struct net_device_ops mesh_netdev_ops = {
1424         .ndo_open               = lbs_dev_open,
1425         .ndo_stop               = lbs_mesh_stop,
1426         .ndo_start_xmit         = lbs_hard_start_xmit,
1427         .ndo_set_mac_address    = lbs_set_mac_address,
1428         .ndo_set_multicast_list = lbs_set_multicast_list,
1429 };
1430
1431 /**
1432  * @brief This function adds mshX interface
1433  *
1434  *  @param priv    A pointer to the struct lbs_private structure
1435  *  @return        0 if successful, -X otherwise
1436  */
1437 static int lbs_add_mesh(struct lbs_private *priv)
1438 {
1439         struct net_device *mesh_dev = NULL;
1440         int ret = 0;
1441
1442         lbs_deb_enter(LBS_DEB_MESH);
1443
1444         /* Allocate a virtual mesh device */
1445         if (!(mesh_dev = alloc_netdev(0, "msh%d", ether_setup))) {
1446                 lbs_deb_mesh("init mshX device failed\n");
1447                 ret = -ENOMEM;
1448                 goto done;
1449         }
1450         mesh_dev->ml_priv = priv;
1451         priv->mesh_dev = mesh_dev;
1452
1453         mesh_dev->netdev_ops = &mesh_netdev_ops;
1454         mesh_dev->ethtool_ops = &lbs_ethtool_ops;
1455         memcpy(mesh_dev->dev_addr, priv->dev->dev_addr,
1456                         sizeof(priv->dev->dev_addr));
1457
1458         SET_NETDEV_DEV(priv->mesh_dev, priv->dev->dev.parent);
1459
1460 #ifdef  WIRELESS_EXT
1461         mesh_dev->wireless_handlers = (struct iw_handler_def *)&mesh_handler_def;
1462 #endif
1463         mesh_dev->flags |= IFF_BROADCAST | IFF_MULTICAST;
1464         /* Register virtual mesh interface */
1465         ret = register_netdev(mesh_dev);
1466         if (ret) {
1467                 lbs_pr_err("cannot register mshX virtual interface\n");
1468                 goto err_free;
1469         }
1470
1471         ret = sysfs_create_group(&(mesh_dev->dev.kobj), &lbs_mesh_attr_group);
1472         if (ret)
1473                 goto err_unregister;
1474
1475         lbs_persist_config_init(mesh_dev);
1476
1477         /* Everything successful */
1478         ret = 0;
1479         goto done;
1480
1481 err_unregister:
1482         unregister_netdev(mesh_dev);
1483
1484 err_free:
1485         free_netdev(mesh_dev);
1486
1487 done:
1488         lbs_deb_leave_args(LBS_DEB_MESH, "ret %d", ret);
1489         return ret;
1490 }
1491
1492 static void lbs_remove_mesh(struct lbs_private *priv)
1493 {
1494         struct net_device *mesh_dev;
1495
1496
1497         mesh_dev = priv->mesh_dev;
1498         if (!mesh_dev)
1499                 return;
1500
1501         lbs_deb_enter(LBS_DEB_MESH);
1502         netif_stop_queue(mesh_dev);
1503         netif_carrier_off(mesh_dev);
1504         sysfs_remove_group(&(mesh_dev->dev.kobj), &lbs_mesh_attr_group);
1505         lbs_persist_config_remove(mesh_dev);
1506         unregister_netdev(mesh_dev);
1507         priv->mesh_dev = NULL;
1508         free_netdev(mesh_dev);
1509         lbs_deb_leave(LBS_DEB_MESH);
1510 }
1511
1512 /**
1513  *  @brief This function finds the CFP in
1514  *  region_cfp_table based on region and band parameter.
1515  *
1516  *  @param region  The region code
1517  *  @param band    The band
1518  *  @param cfp_no  A pointer to CFP number
1519  *  @return        A pointer to CFP
1520  */
1521 struct chan_freq_power *lbs_get_region_cfp_table(u8 region, int *cfp_no)
1522 {
1523         int i, end;
1524
1525         lbs_deb_enter(LBS_DEB_MAIN);
1526
1527         end = ARRAY_SIZE(region_cfp_table);
1528
1529         for (i = 0; i < end ; i++) {
1530                 lbs_deb_main("region_cfp_table[i].region=%d\n",
1531                         region_cfp_table[i].region);
1532                 if (region_cfp_table[i].region == region) {
1533                         *cfp_no = region_cfp_table[i].cfp_no_BG;
1534                         lbs_deb_leave(LBS_DEB_MAIN);
1535                         return region_cfp_table[i].cfp_BG;
1536                 }
1537         }
1538
1539         lbs_deb_leave_args(LBS_DEB_MAIN, "ret NULL");
1540         return NULL;
1541 }
1542
1543 int lbs_set_regiontable(struct lbs_private *priv, u8 region, u8 band)
1544 {
1545         int ret = 0;
1546         int i = 0;
1547
1548         struct chan_freq_power *cfp;
1549         int cfp_no;
1550
1551         lbs_deb_enter(LBS_DEB_MAIN);
1552
1553         memset(priv->region_channel, 0, sizeof(priv->region_channel));
1554
1555         cfp = lbs_get_region_cfp_table(region, &cfp_no);
1556         if (cfp != NULL) {
1557                 priv->region_channel[i].nrcfp = cfp_no;
1558                 priv->region_channel[i].CFP = cfp;
1559         } else {
1560                 lbs_deb_main("wrong region code %#x in band B/G\n",
1561                        region);
1562                 ret = -1;
1563                 goto out;
1564         }
1565         priv->region_channel[i].valid = 1;
1566         priv->region_channel[i].region = region;
1567         priv->region_channel[i].band = band;
1568         i++;
1569 out:
1570         lbs_deb_leave_args(LBS_DEB_MAIN, "ret %d", ret);
1571         return ret;
1572 }
1573
1574 void lbs_queue_event(struct lbs_private *priv, u32 event)
1575 {
1576         unsigned long flags;
1577
1578         lbs_deb_enter(LBS_DEB_THREAD);
1579         spin_lock_irqsave(&priv->driver_lock, flags);
1580
1581         if (priv->psstate == PS_STATE_SLEEP)
1582                 priv->psstate = PS_STATE_AWAKE;
1583
1584         __kfifo_put(priv->event_fifo, (unsigned char *) &event, sizeof(u32));
1585
1586         wake_up_interruptible(&priv->waitq);
1587
1588         spin_unlock_irqrestore(&priv->driver_lock, flags);
1589         lbs_deb_leave(LBS_DEB_THREAD);
1590 }
1591 EXPORT_SYMBOL_GPL(lbs_queue_event);
1592
1593 void lbs_notify_command_response(struct lbs_private *priv, u8 resp_idx)
1594 {
1595         lbs_deb_enter(LBS_DEB_THREAD);
1596
1597         if (priv->psstate == PS_STATE_SLEEP)
1598                 priv->psstate = PS_STATE_AWAKE;
1599
1600         /* Swap buffers by flipping the response index */
1601         BUG_ON(resp_idx > 1);
1602         priv->resp_idx = resp_idx;
1603
1604         wake_up_interruptible(&priv->waitq);
1605
1606         lbs_deb_leave(LBS_DEB_THREAD);
1607 }
1608 EXPORT_SYMBOL_GPL(lbs_notify_command_response);
1609
1610 static int __init lbs_init_module(void)
1611 {
1612         lbs_deb_enter(LBS_DEB_MAIN);
1613         memset(&confirm_sleep, 0, sizeof(confirm_sleep));
1614         confirm_sleep.hdr.command = cpu_to_le16(CMD_802_11_PS_MODE);
1615         confirm_sleep.hdr.size = cpu_to_le16(sizeof(confirm_sleep));
1616         confirm_sleep.action = cpu_to_le16(CMD_SUBCMD_SLEEP_CONFIRMED);
1617         lbs_debugfs_init();
1618         lbs_deb_leave(LBS_DEB_MAIN);
1619         return 0;
1620 }
1621
1622 static void __exit lbs_exit_module(void)
1623 {
1624         lbs_deb_enter(LBS_DEB_MAIN);
1625         lbs_debugfs_remove();
1626         lbs_deb_leave(LBS_DEB_MAIN);
1627 }
1628
1629 /*
1630  * rtap interface support fuctions
1631  */
1632
1633 static int lbs_rtap_open(struct net_device *dev)
1634 {
1635         /* Yes, _stop_ the queue. Because we don't support injection */
1636         lbs_deb_enter(LBS_DEB_MAIN);
1637         netif_carrier_off(dev);
1638         netif_stop_queue(dev);
1639         lbs_deb_leave(LBS_DEB_LEAVE);
1640         return 0;
1641 }
1642
1643 static int lbs_rtap_stop(struct net_device *dev)
1644 {
1645         lbs_deb_enter(LBS_DEB_MAIN);
1646         lbs_deb_leave(LBS_DEB_MAIN);
1647         return 0;
1648 }
1649
1650 static netdev_tx_t lbs_rtap_hard_start_xmit(struct sk_buff *skb,
1651                                             struct net_device *dev)
1652 {
1653         netif_stop_queue(dev);
1654         return NETDEV_TX_BUSY;
1655 }
1656
1657 static void lbs_remove_rtap(struct lbs_private *priv)
1658 {
1659         lbs_deb_enter(LBS_DEB_MAIN);
1660         if (priv->rtap_net_dev == NULL)
1661                 goto out;
1662         unregister_netdev(priv->rtap_net_dev);
1663         free_netdev(priv->rtap_net_dev);
1664         priv->rtap_net_dev = NULL;
1665 out:
1666         lbs_deb_leave(LBS_DEB_MAIN);
1667 }
1668
1669 static const struct net_device_ops rtap_netdev_ops = {
1670         .ndo_open = lbs_rtap_open,
1671         .ndo_stop = lbs_rtap_stop,
1672         .ndo_start_xmit = lbs_rtap_hard_start_xmit,
1673 };
1674
1675 static int lbs_add_rtap(struct lbs_private *priv)
1676 {
1677         int ret = 0;
1678         struct net_device *rtap_dev;
1679
1680         lbs_deb_enter(LBS_DEB_MAIN);
1681         if (priv->rtap_net_dev) {
1682                 ret = -EPERM;
1683                 goto out;
1684         }
1685
1686         rtap_dev = alloc_netdev(0, "rtap%d", ether_setup);
1687         if (rtap_dev == NULL) {
1688                 ret = -ENOMEM;
1689                 goto out;
1690         }
1691
1692         memcpy(rtap_dev->dev_addr, priv->current_addr, ETH_ALEN);
1693         rtap_dev->type = ARPHRD_IEEE80211_RADIOTAP;
1694         rtap_dev->netdev_ops = &rtap_netdev_ops;
1695         rtap_dev->ml_priv = priv;
1696         SET_NETDEV_DEV(rtap_dev, priv->dev->dev.parent);
1697
1698         ret = register_netdev(rtap_dev);
1699         if (ret) {
1700                 free_netdev(rtap_dev);
1701                 goto out;
1702         }
1703         priv->rtap_net_dev = rtap_dev;
1704
1705 out:
1706         lbs_deb_leave_args(LBS_DEB_MAIN, "ret %d", ret);
1707         return ret;
1708 }
1709
1710 module_init(lbs_init_module);
1711 module_exit(lbs_exit_module);
1712
1713 MODULE_DESCRIPTION("Libertas WLAN Driver Library");
1714 MODULE_AUTHOR("Marvell International Ltd.");
1715 MODULE_LICENSE("GPL");