Merge git://git.kernel.org/pub/scm/linux/kernel/git/mason/btrfs-unstable
[linux-2.6] / 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 ethX 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
1208         lbs_deb_thread("Starting main thread...\n");
1209         init_waitqueue_head(&priv->waitq);
1210         priv->main_thread = kthread_run(lbs_thread, dev, "lbs_main");
1211         if (IS_ERR(priv->main_thread)) {
1212                 lbs_deb_thread("Error creating main thread.\n");
1213                 goto err_init_adapter;
1214         }
1215
1216         priv->work_thread = create_singlethread_workqueue("lbs_worker");
1217         INIT_DELAYED_WORK(&priv->assoc_work, lbs_association_worker);
1218         INIT_DELAYED_WORK(&priv->scan_work, lbs_scan_worker);
1219         INIT_WORK(&priv->mcast_work, lbs_set_mcast_worker);
1220         INIT_WORK(&priv->sync_channel, lbs_sync_channel_worker);
1221
1222         sprintf(priv->mesh_ssid, "mesh");
1223         priv->mesh_ssid_len = 4;
1224
1225         priv->wol_criteria = 0xffffffff;
1226         priv->wol_gpio = 0xff;
1227
1228         goto done;
1229
1230 err_init_adapter:
1231         lbs_free_adapter(priv);
1232         free_netdev(dev);
1233         priv = NULL;
1234
1235 done:
1236         lbs_deb_leave_args(LBS_DEB_MAIN, "priv %p", priv);
1237         return priv;
1238 }
1239 EXPORT_SYMBOL_GPL(lbs_add_card);
1240
1241
1242 void lbs_remove_card(struct lbs_private *priv)
1243 {
1244         struct net_device *dev = priv->dev;
1245         union iwreq_data wrqu;
1246
1247         lbs_deb_enter(LBS_DEB_MAIN);
1248
1249         lbs_remove_mesh(priv);
1250         lbs_remove_rtap(priv);
1251
1252         dev = priv->dev;
1253
1254         cancel_delayed_work_sync(&priv->scan_work);
1255         cancel_delayed_work_sync(&priv->assoc_work);
1256         cancel_work_sync(&priv->mcast_work);
1257
1258         /* worker thread destruction blocks on the in-flight command which
1259          * should have been cleared already in lbs_stop_card().
1260          */
1261         lbs_deb_main("destroying worker thread\n");
1262         destroy_workqueue(priv->work_thread);
1263         lbs_deb_main("done destroying worker thread\n");
1264
1265         if (priv->psmode == LBS802_11POWERMODEMAX_PSP) {
1266                 priv->psmode = LBS802_11POWERMODECAM;
1267                 lbs_ps_wakeup(priv, CMD_OPTION_WAITFORRSP);
1268         }
1269
1270         memset(wrqu.ap_addr.sa_data, 0xaa, ETH_ALEN);
1271         wrqu.ap_addr.sa_family = ARPHRD_ETHER;
1272         wireless_send_event(priv->dev, SIOCGIWAP, &wrqu, NULL);
1273
1274         /* Stop the thread servicing the interrupts */
1275         priv->surpriseremoved = 1;
1276         kthread_stop(priv->main_thread);
1277
1278         lbs_free_adapter(priv);
1279
1280         priv->dev = NULL;
1281         free_netdev(dev);
1282
1283         lbs_deb_leave(LBS_DEB_MAIN);
1284 }
1285 EXPORT_SYMBOL_GPL(lbs_remove_card);
1286
1287
1288 int lbs_start_card(struct lbs_private *priv)
1289 {
1290         struct net_device *dev = priv->dev;
1291         int ret = -1;
1292
1293         lbs_deb_enter(LBS_DEB_MAIN);
1294
1295         /* poke the firmware */
1296         ret = lbs_setup_firmware(priv);
1297         if (ret)
1298                 goto done;
1299
1300         /* init 802.11d */
1301         lbs_init_11d(priv);
1302
1303         if (register_netdev(dev)) {
1304                 lbs_pr_err("cannot register ethX device\n");
1305                 goto done;
1306         }
1307
1308         lbs_update_channel(priv);
1309
1310         /* Check mesh FW version and appropriately send the mesh start
1311          * command
1312          */
1313         if (priv->mesh_fw_ver == MESH_FW_OLD) {
1314                 /* Enable mesh, if supported, and work out which TLV it uses.
1315                    0x100 + 291 is an unofficial value used in 5.110.20.pXX
1316                    0x100 + 37 is the official value used in 5.110.21.pXX
1317                    but we check them in that order because 20.pXX doesn't
1318                    give an error -- it just silently fails. */
1319
1320                 /* 5.110.20.pXX firmware will fail the command if the channel
1321                    doesn't match the existing channel. But only if the TLV
1322                    is correct. If the channel is wrong, _BOTH_ versions will
1323                    give an error to 0x100+291, and allow 0x100+37 to succeed.
1324                    It's just that 5.110.20.pXX will not have done anything
1325                    useful */
1326
1327                 priv->mesh_tlv = TLV_TYPE_OLD_MESH_ID;
1328                 if (lbs_mesh_config(priv, CMD_ACT_MESH_CONFIG_START,
1329                                     priv->curbssparams.channel)) {
1330                         priv->mesh_tlv = TLV_TYPE_MESH_ID;
1331                         if (lbs_mesh_config(priv, CMD_ACT_MESH_CONFIG_START,
1332                                             priv->curbssparams.channel))
1333                                 priv->mesh_tlv = 0;
1334                 }
1335         } else if (priv->mesh_fw_ver == MESH_FW_NEW) {
1336                 /* 10.0.0.pXX new firmwares should succeed with TLV
1337                  * 0x100+37; Do not invoke command with old TLV.
1338                  */
1339                 priv->mesh_tlv = TLV_TYPE_MESH_ID;
1340                 if (lbs_mesh_config(priv, CMD_ACT_MESH_CONFIG_START,
1341                                     priv->curbssparams.channel))
1342                         priv->mesh_tlv = 0;
1343         }
1344         if (priv->mesh_tlv) {
1345                 lbs_add_mesh(priv);
1346
1347                 if (device_create_file(&dev->dev, &dev_attr_lbs_mesh))
1348                         lbs_pr_err("cannot register lbs_mesh attribute\n");
1349
1350                 /* While rtap isn't related to mesh, only mesh-enabled
1351                  * firmware implements the rtap functionality via
1352                  * CMD_802_11_MONITOR_MODE.
1353                  */
1354                 if (device_create_file(&dev->dev, &dev_attr_lbs_rtap))
1355                         lbs_pr_err("cannot register lbs_rtap attribute\n");
1356         }
1357
1358         lbs_debugfs_init_one(priv, dev);
1359
1360         lbs_pr_info("%s: Marvell WLAN 802.11 adapter\n", dev->name);
1361
1362         ret = 0;
1363
1364 done:
1365         lbs_deb_leave_args(LBS_DEB_MAIN, "ret %d", ret);
1366         return ret;
1367 }
1368 EXPORT_SYMBOL_GPL(lbs_start_card);
1369
1370
1371 void lbs_stop_card(struct lbs_private *priv)
1372 {
1373         struct net_device *dev;
1374         struct cmd_ctrl_node *cmdnode;
1375         unsigned long flags;
1376
1377         lbs_deb_enter(LBS_DEB_MAIN);
1378
1379         if (!priv)
1380                 goto out;
1381         dev = priv->dev;
1382
1383         netif_stop_queue(dev);
1384         netif_carrier_off(dev);
1385
1386         lbs_debugfs_remove_one(priv);
1387         if (priv->mesh_tlv) {
1388                 device_remove_file(&dev->dev, &dev_attr_lbs_mesh);
1389                 device_remove_file(&dev->dev, &dev_attr_lbs_rtap);
1390         }
1391
1392         /* Delete the timeout of the currently processing command */
1393         del_timer_sync(&priv->command_timer);
1394
1395         /* Flush pending command nodes */
1396         spin_lock_irqsave(&priv->driver_lock, flags);
1397         lbs_deb_main("clearing pending commands\n");
1398         list_for_each_entry(cmdnode, &priv->cmdpendingq, list) {
1399                 cmdnode->result = -ENOENT;
1400                 cmdnode->cmdwaitqwoken = 1;
1401                 wake_up_interruptible(&cmdnode->cmdwait_q);
1402         }
1403
1404         /* Flush the command the card is currently processing */
1405         if (priv->cur_cmd) {
1406                 lbs_deb_main("clearing current command\n");
1407                 priv->cur_cmd->result = -ENOENT;
1408                 priv->cur_cmd->cmdwaitqwoken = 1;
1409                 wake_up_interruptible(&priv->cur_cmd->cmdwait_q);
1410         }
1411         lbs_deb_main("done clearing commands\n");
1412         spin_unlock_irqrestore(&priv->driver_lock, flags);
1413
1414         unregister_netdev(dev);
1415
1416 out:
1417         lbs_deb_leave(LBS_DEB_MAIN);
1418 }
1419 EXPORT_SYMBOL_GPL(lbs_stop_card);
1420
1421
1422 static const struct net_device_ops mesh_netdev_ops = {
1423         .ndo_open               = lbs_dev_open,
1424         .ndo_stop               = lbs_mesh_stop,
1425         .ndo_start_xmit         = lbs_hard_start_xmit,
1426         .ndo_set_mac_address    = lbs_set_mac_address,
1427         .ndo_set_multicast_list = lbs_set_multicast_list,
1428 };
1429
1430 /**
1431  * @brief This function adds mshX interface
1432  *
1433  *  @param priv    A pointer to the struct lbs_private structure
1434  *  @return        0 if successful, -X otherwise
1435  */
1436 static int lbs_add_mesh(struct lbs_private *priv)
1437 {
1438         struct net_device *mesh_dev = NULL;
1439         int ret = 0;
1440
1441         lbs_deb_enter(LBS_DEB_MESH);
1442
1443         /* Allocate a virtual mesh device */
1444         if (!(mesh_dev = alloc_netdev(0, "msh%d", ether_setup))) {
1445                 lbs_deb_mesh("init mshX device failed\n");
1446                 ret = -ENOMEM;
1447                 goto done;
1448         }
1449         mesh_dev->ml_priv = priv;
1450         priv->mesh_dev = mesh_dev;
1451
1452         mesh_dev->netdev_ops = &mesh_netdev_ops;
1453         mesh_dev->ethtool_ops = &lbs_ethtool_ops;
1454         memcpy(mesh_dev->dev_addr, priv->dev->dev_addr,
1455                         sizeof(priv->dev->dev_addr));
1456
1457         SET_NETDEV_DEV(priv->mesh_dev, priv->dev->dev.parent);
1458
1459 #ifdef  WIRELESS_EXT
1460         mesh_dev->wireless_handlers = (struct iw_handler_def *)&mesh_handler_def;
1461 #endif
1462         mesh_dev->flags |= IFF_BROADCAST | IFF_MULTICAST;
1463         /* Register virtual mesh interface */
1464         ret = register_netdev(mesh_dev);
1465         if (ret) {
1466                 lbs_pr_err("cannot register mshX virtual interface\n");
1467                 goto err_free;
1468         }
1469
1470         ret = sysfs_create_group(&(mesh_dev->dev.kobj), &lbs_mesh_attr_group);
1471         if (ret)
1472                 goto err_unregister;
1473
1474         lbs_persist_config_init(mesh_dev);
1475
1476         /* Everything successful */
1477         ret = 0;
1478         goto done;
1479
1480 err_unregister:
1481         unregister_netdev(mesh_dev);
1482
1483 err_free:
1484         free_netdev(mesh_dev);
1485
1486 done:
1487         lbs_deb_leave_args(LBS_DEB_MESH, "ret %d", ret);
1488         return ret;
1489 }
1490
1491 static void lbs_remove_mesh(struct lbs_private *priv)
1492 {
1493         struct net_device *mesh_dev;
1494
1495
1496         mesh_dev = priv->mesh_dev;
1497         if (!mesh_dev)
1498                 return;
1499
1500         lbs_deb_enter(LBS_DEB_MESH);
1501         netif_stop_queue(mesh_dev);
1502         netif_carrier_off(mesh_dev);
1503         sysfs_remove_group(&(mesh_dev->dev.kobj), &lbs_mesh_attr_group);
1504         lbs_persist_config_remove(mesh_dev);
1505         unregister_netdev(mesh_dev);
1506         priv->mesh_dev = NULL;
1507         free_netdev(mesh_dev);
1508         lbs_deb_leave(LBS_DEB_MESH);
1509 }
1510
1511 /**
1512  *  @brief This function finds the CFP in
1513  *  region_cfp_table based on region and band parameter.
1514  *
1515  *  @param region  The region code
1516  *  @param band    The band
1517  *  @param cfp_no  A pointer to CFP number
1518  *  @return        A pointer to CFP
1519  */
1520 struct chan_freq_power *lbs_get_region_cfp_table(u8 region, int *cfp_no)
1521 {
1522         int i, end;
1523
1524         lbs_deb_enter(LBS_DEB_MAIN);
1525
1526         end = ARRAY_SIZE(region_cfp_table);
1527
1528         for (i = 0; i < end ; i++) {
1529                 lbs_deb_main("region_cfp_table[i].region=%d\n",
1530                         region_cfp_table[i].region);
1531                 if (region_cfp_table[i].region == region) {
1532                         *cfp_no = region_cfp_table[i].cfp_no_BG;
1533                         lbs_deb_leave(LBS_DEB_MAIN);
1534                         return region_cfp_table[i].cfp_BG;
1535                 }
1536         }
1537
1538         lbs_deb_leave_args(LBS_DEB_MAIN, "ret NULL");
1539         return NULL;
1540 }
1541
1542 int lbs_set_regiontable(struct lbs_private *priv, u8 region, u8 band)
1543 {
1544         int ret = 0;
1545         int i = 0;
1546
1547         struct chan_freq_power *cfp;
1548         int cfp_no;
1549
1550         lbs_deb_enter(LBS_DEB_MAIN);
1551
1552         memset(priv->region_channel, 0, sizeof(priv->region_channel));
1553
1554         cfp = lbs_get_region_cfp_table(region, &cfp_no);
1555         if (cfp != NULL) {
1556                 priv->region_channel[i].nrcfp = cfp_no;
1557                 priv->region_channel[i].CFP = cfp;
1558         } else {
1559                 lbs_deb_main("wrong region code %#x in band B/G\n",
1560                        region);
1561                 ret = -1;
1562                 goto out;
1563         }
1564         priv->region_channel[i].valid = 1;
1565         priv->region_channel[i].region = region;
1566         priv->region_channel[i].band = band;
1567         i++;
1568 out:
1569         lbs_deb_leave_args(LBS_DEB_MAIN, "ret %d", ret);
1570         return ret;
1571 }
1572
1573 void lbs_queue_event(struct lbs_private *priv, u32 event)
1574 {
1575         unsigned long flags;
1576
1577         lbs_deb_enter(LBS_DEB_THREAD);
1578         spin_lock_irqsave(&priv->driver_lock, flags);
1579
1580         if (priv->psstate == PS_STATE_SLEEP)
1581                 priv->psstate = PS_STATE_AWAKE;
1582
1583         __kfifo_put(priv->event_fifo, (unsigned char *) &event, sizeof(u32));
1584
1585         wake_up_interruptible(&priv->waitq);
1586
1587         spin_unlock_irqrestore(&priv->driver_lock, flags);
1588         lbs_deb_leave(LBS_DEB_THREAD);
1589 }
1590 EXPORT_SYMBOL_GPL(lbs_queue_event);
1591
1592 void lbs_notify_command_response(struct lbs_private *priv, u8 resp_idx)
1593 {
1594         lbs_deb_enter(LBS_DEB_THREAD);
1595
1596         if (priv->psstate == PS_STATE_SLEEP)
1597                 priv->psstate = PS_STATE_AWAKE;
1598
1599         /* Swap buffers by flipping the response index */
1600         BUG_ON(resp_idx > 1);
1601         priv->resp_idx = resp_idx;
1602
1603         wake_up_interruptible(&priv->waitq);
1604
1605         lbs_deb_leave(LBS_DEB_THREAD);
1606 }
1607 EXPORT_SYMBOL_GPL(lbs_notify_command_response);
1608
1609 static int __init lbs_init_module(void)
1610 {
1611         lbs_deb_enter(LBS_DEB_MAIN);
1612         memset(&confirm_sleep, 0, sizeof(confirm_sleep));
1613         confirm_sleep.hdr.command = cpu_to_le16(CMD_802_11_PS_MODE);
1614         confirm_sleep.hdr.size = cpu_to_le16(sizeof(confirm_sleep));
1615         confirm_sleep.action = cpu_to_le16(CMD_SUBCMD_SLEEP_CONFIRMED);
1616         lbs_debugfs_init();
1617         lbs_deb_leave(LBS_DEB_MAIN);
1618         return 0;
1619 }
1620
1621 static void __exit lbs_exit_module(void)
1622 {
1623         lbs_deb_enter(LBS_DEB_MAIN);
1624         lbs_debugfs_remove();
1625         lbs_deb_leave(LBS_DEB_MAIN);
1626 }
1627
1628 /*
1629  * rtap interface support fuctions
1630  */
1631
1632 static int lbs_rtap_open(struct net_device *dev)
1633 {
1634         /* Yes, _stop_ the queue. Because we don't support injection */
1635         lbs_deb_enter(LBS_DEB_MAIN);
1636         netif_carrier_off(dev);
1637         netif_stop_queue(dev);
1638         lbs_deb_leave(LBS_DEB_LEAVE);
1639         return 0;
1640 }
1641
1642 static int lbs_rtap_stop(struct net_device *dev)
1643 {
1644         lbs_deb_enter(LBS_DEB_MAIN);
1645         lbs_deb_leave(LBS_DEB_MAIN);
1646         return 0;
1647 }
1648
1649 static int lbs_rtap_hard_start_xmit(struct sk_buff *skb, struct net_device *dev)
1650 {
1651         netif_stop_queue(dev);
1652         return NETDEV_TX_BUSY;
1653 }
1654
1655 static void lbs_remove_rtap(struct lbs_private *priv)
1656 {
1657         lbs_deb_enter(LBS_DEB_MAIN);
1658         if (priv->rtap_net_dev == NULL)
1659                 goto out;
1660         unregister_netdev(priv->rtap_net_dev);
1661         free_netdev(priv->rtap_net_dev);
1662         priv->rtap_net_dev = NULL;
1663 out:
1664         lbs_deb_leave(LBS_DEB_MAIN);
1665 }
1666
1667 static const struct net_device_ops rtap_netdev_ops = {
1668         .ndo_open = lbs_rtap_open,
1669         .ndo_stop = lbs_rtap_stop,
1670         .ndo_start_xmit = lbs_rtap_hard_start_xmit,
1671 };
1672
1673 static int lbs_add_rtap(struct lbs_private *priv)
1674 {
1675         int ret = 0;
1676         struct net_device *rtap_dev;
1677
1678         lbs_deb_enter(LBS_DEB_MAIN);
1679         if (priv->rtap_net_dev) {
1680                 ret = -EPERM;
1681                 goto out;
1682         }
1683
1684         rtap_dev = alloc_netdev(0, "rtap%d", ether_setup);
1685         if (rtap_dev == NULL) {
1686                 ret = -ENOMEM;
1687                 goto out;
1688         }
1689
1690         memcpy(rtap_dev->dev_addr, priv->current_addr, ETH_ALEN);
1691         rtap_dev->type = ARPHRD_IEEE80211_RADIOTAP;
1692         rtap_dev->netdev_ops = &rtap_netdev_ops;
1693         rtap_dev->ml_priv = priv;
1694         SET_NETDEV_DEV(rtap_dev, priv->dev->dev.parent);
1695
1696         ret = register_netdev(rtap_dev);
1697         if (ret) {
1698                 free_netdev(rtap_dev);
1699                 goto out;
1700         }
1701         priv->rtap_net_dev = rtap_dev;
1702
1703 out:
1704         lbs_deb_leave_args(LBS_DEB_MAIN, "ret %d", ret);
1705         return ret;
1706 }
1707
1708 module_init(lbs_init_module);
1709 module_exit(lbs_exit_module);
1710
1711 MODULE_DESCRIPTION("Libertas WLAN Driver Library");
1712 MODULE_AUTHOR("Marvell International Ltd.");
1713 MODULE_LICENSE("GPL");