libertas: Add auto deep sleep support for SD8385/SD8686/SD8688
[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                 if (!priv->wakeup_dev_required)
579                         wake_up_interruptible(&priv->waitq);
580         }
581
582         spin_unlock_irqrestore(&priv->driver_lock, flags);
583         lbs_deb_leave(LBS_DEB_THREAD);
584 }
585 EXPORT_SYMBOL_GPL(lbs_host_to_card_done);
586
587 static int lbs_set_mac_address(struct net_device *dev, void *addr)
588 {
589         int ret = 0;
590         struct lbs_private *priv = dev->ml_priv;
591         struct sockaddr *phwaddr = addr;
592         struct cmd_ds_802_11_mac_address cmd;
593
594         lbs_deb_enter(LBS_DEB_NET);
595
596         /* In case it was called from the mesh device */
597         dev = priv->dev;
598
599         cmd.hdr.size = cpu_to_le16(sizeof(cmd));
600         cmd.action = cpu_to_le16(CMD_ACT_SET);
601         memcpy(cmd.macadd, phwaddr->sa_data, ETH_ALEN);
602
603         ret = lbs_cmd_with_response(priv, CMD_802_11_MAC_ADDRESS, &cmd);
604         if (ret) {
605                 lbs_deb_net("set MAC address failed\n");
606                 goto done;
607         }
608
609         memcpy(priv->current_addr, phwaddr->sa_data, ETH_ALEN);
610         memcpy(dev->dev_addr, phwaddr->sa_data, ETH_ALEN);
611         if (priv->mesh_dev)
612                 memcpy(priv->mesh_dev->dev_addr, phwaddr->sa_data, ETH_ALEN);
613
614 done:
615         lbs_deb_leave_args(LBS_DEB_NET, "ret %d", ret);
616         return ret;
617 }
618
619
620 static inline int mac_in_list(unsigned char *list, int list_len,
621                               unsigned char *mac)
622 {
623         while (list_len) {
624                 if (!memcmp(list, mac, ETH_ALEN))
625                         return 1;
626                 list += ETH_ALEN;
627                 list_len--;
628         }
629         return 0;
630 }
631
632
633 static int lbs_add_mcast_addrs(struct cmd_ds_mac_multicast_adr *cmd,
634                                struct net_device *dev, int nr_addrs)
635 {
636         int i = nr_addrs;
637         struct dev_mc_list *mc_list;
638
639         if ((dev->flags & (IFF_UP|IFF_MULTICAST)) != (IFF_UP|IFF_MULTICAST))
640                 return nr_addrs;
641
642         netif_addr_lock_bh(dev);
643         for (mc_list = dev->mc_list; mc_list; mc_list = mc_list->next) {
644                 if (mac_in_list(cmd->maclist, nr_addrs, mc_list->dmi_addr)) {
645                         lbs_deb_net("mcast address %s:%pM skipped\n", dev->name,
646                                     mc_list->dmi_addr);
647                         continue;
648                 }
649
650                 if (i == MRVDRV_MAX_MULTICAST_LIST_SIZE)
651                         break;
652                 memcpy(&cmd->maclist[6*i], mc_list->dmi_addr, ETH_ALEN);
653                 lbs_deb_net("mcast address %s:%pM added to filter\n", dev->name,
654                             mc_list->dmi_addr);
655                 i++;
656         }
657         netif_addr_unlock_bh(dev);
658         if (mc_list)
659                 return -EOVERFLOW;
660
661         return i;
662 }
663
664 static void lbs_set_mcast_worker(struct work_struct *work)
665 {
666         struct lbs_private *priv = container_of(work, struct lbs_private, mcast_work);
667         struct cmd_ds_mac_multicast_adr mcast_cmd;
668         int dev_flags;
669         int nr_addrs;
670         int old_mac_control = priv->mac_control;
671
672         lbs_deb_enter(LBS_DEB_NET);
673
674         dev_flags = priv->dev->flags;
675         if (priv->mesh_dev)
676                 dev_flags |= priv->mesh_dev->flags;
677
678         if (dev_flags & IFF_PROMISC) {
679                 priv->mac_control |= CMD_ACT_MAC_PROMISCUOUS_ENABLE;
680                 priv->mac_control &= ~(CMD_ACT_MAC_ALL_MULTICAST_ENABLE |
681                                        CMD_ACT_MAC_MULTICAST_ENABLE);
682                 goto out_set_mac_control;
683         } else if (dev_flags & IFF_ALLMULTI) {
684         do_allmulti:
685                 priv->mac_control |= CMD_ACT_MAC_ALL_MULTICAST_ENABLE;
686                 priv->mac_control &= ~(CMD_ACT_MAC_PROMISCUOUS_ENABLE |
687                                        CMD_ACT_MAC_MULTICAST_ENABLE);
688                 goto out_set_mac_control;
689         }
690
691         /* Once for priv->dev, again for priv->mesh_dev if it exists */
692         nr_addrs = lbs_add_mcast_addrs(&mcast_cmd, priv->dev, 0);
693         if (nr_addrs >= 0 && priv->mesh_dev)
694                 nr_addrs = lbs_add_mcast_addrs(&mcast_cmd, priv->mesh_dev, nr_addrs);
695         if (nr_addrs < 0)
696                 goto do_allmulti;
697
698         if (nr_addrs) {
699                 int size = offsetof(struct cmd_ds_mac_multicast_adr,
700                                     maclist[6*nr_addrs]);
701
702                 mcast_cmd.action = cpu_to_le16(CMD_ACT_SET);
703                 mcast_cmd.hdr.size = cpu_to_le16(size);
704                 mcast_cmd.nr_of_adrs = cpu_to_le16(nr_addrs);
705
706                 lbs_cmd_async(priv, CMD_MAC_MULTICAST_ADR, &mcast_cmd.hdr, size);
707
708                 priv->mac_control |= CMD_ACT_MAC_MULTICAST_ENABLE;
709         } else
710                 priv->mac_control &= ~CMD_ACT_MAC_MULTICAST_ENABLE;
711
712         priv->mac_control &= ~(CMD_ACT_MAC_PROMISCUOUS_ENABLE |
713                                CMD_ACT_MAC_ALL_MULTICAST_ENABLE);
714  out_set_mac_control:
715         if (priv->mac_control != old_mac_control)
716                 lbs_set_mac_control(priv);
717
718         lbs_deb_leave(LBS_DEB_NET);
719 }
720
721 static void lbs_set_multicast_list(struct net_device *dev)
722 {
723         struct lbs_private *priv = dev->ml_priv;
724
725         schedule_work(&priv->mcast_work);
726 }
727
728 /**
729  *  @brief This function handles the major jobs in the LBS driver.
730  *  It handles all events generated by firmware, RX data received
731  *  from firmware and TX data sent from kernel.
732  *
733  *  @param data    A pointer to lbs_thread structure
734  *  @return        0
735  */
736 static int lbs_thread(void *data)
737 {
738         struct net_device *dev = data;
739         struct lbs_private *priv = dev->ml_priv;
740         wait_queue_t wait;
741
742         lbs_deb_enter(LBS_DEB_THREAD);
743
744         init_waitqueue_entry(&wait, current);
745
746         for (;;) {
747                 int shouldsleep;
748                 u8 resp_idx;
749
750                 lbs_deb_thread("1: currenttxskb %p, dnld_sent %d\n",
751                                 priv->currenttxskb, priv->dnld_sent);
752
753                 add_wait_queue(&priv->waitq, &wait);
754                 set_current_state(TASK_INTERRUPTIBLE);
755                 spin_lock_irq(&priv->driver_lock);
756
757                 if (kthread_should_stop())
758                         shouldsleep = 0;        /* Bye */
759                 else if (priv->surpriseremoved)
760                         shouldsleep = 1;        /* We need to wait until we're _told_ to die */
761                 else if (priv->psstate == PS_STATE_SLEEP)
762                         shouldsleep = 1;        /* Sleep mode. Nothing we can do till it wakes */
763                 else if (priv->cmd_timed_out)
764                         shouldsleep = 0;        /* Command timed out. Recover */
765                 else if (!priv->fw_ready)
766                         shouldsleep = 1;        /* Firmware not ready. We're waiting for it */
767                 else if (priv->dnld_sent)
768                         shouldsleep = 1;        /* Something is en route to the device already */
769                 else if (priv->tx_pending_len > 0)
770                         shouldsleep = 0;        /* We've a packet to send */
771                 else if (priv->resp_len[priv->resp_idx])
772                         shouldsleep = 0;        /* We have a command response */
773                 else if (priv->cur_cmd)
774                         shouldsleep = 1;        /* Can't send a command; one already running */
775                 else if (!list_empty(&priv->cmdpendingq) &&
776                                         !(priv->wakeup_dev_required))
777                         shouldsleep = 0;        /* We have a command to send */
778                 else if (__kfifo_len(priv->event_fifo))
779                         shouldsleep = 0;        /* We have an event to process */
780                 else
781                         shouldsleep = 1;        /* No command */
782
783                 if (shouldsleep) {
784                         lbs_deb_thread("sleeping, connect_status %d, "
785                                 "psmode %d, psstate %d\n",
786                                 priv->connect_status,
787                                 priv->psmode, priv->psstate);
788                         spin_unlock_irq(&priv->driver_lock);
789                         schedule();
790                 } else
791                         spin_unlock_irq(&priv->driver_lock);
792
793                 lbs_deb_thread("2: currenttxskb %p, dnld_send %d\n",
794                                priv->currenttxskb, priv->dnld_sent);
795
796                 set_current_state(TASK_RUNNING);
797                 remove_wait_queue(&priv->waitq, &wait);
798
799                 lbs_deb_thread("3: currenttxskb %p, dnld_sent %d\n",
800                                priv->currenttxskb, priv->dnld_sent);
801
802                 if (kthread_should_stop()) {
803                         lbs_deb_thread("break from main thread\n");
804                         break;
805                 }
806
807                 if (priv->surpriseremoved) {
808                         lbs_deb_thread("adapter removed; waiting to die...\n");
809                         continue;
810                 }
811
812                 lbs_deb_thread("4: currenttxskb %p, dnld_sent %d\n",
813                        priv->currenttxskb, priv->dnld_sent);
814
815                 /* Process any pending command response */
816                 spin_lock_irq(&priv->driver_lock);
817                 resp_idx = priv->resp_idx;
818                 if (priv->resp_len[resp_idx]) {
819                         spin_unlock_irq(&priv->driver_lock);
820                         lbs_process_command_response(priv,
821                                 priv->resp_buf[resp_idx],
822                                 priv->resp_len[resp_idx]);
823                         spin_lock_irq(&priv->driver_lock);
824                         priv->resp_len[resp_idx] = 0;
825                 }
826                 spin_unlock_irq(&priv->driver_lock);
827
828                 /* Process hardware events, e.g. card removed, link lost */
829                 spin_lock_irq(&priv->driver_lock);
830                 while (__kfifo_len(priv->event_fifo)) {
831                         u32 event;
832                         __kfifo_get(priv->event_fifo, (unsigned char *) &event,
833                                 sizeof(event));
834                         spin_unlock_irq(&priv->driver_lock);
835                         lbs_process_event(priv, event);
836                         spin_lock_irq(&priv->driver_lock);
837                 }
838                 spin_unlock_irq(&priv->driver_lock);
839
840                 if (priv->wakeup_dev_required) {
841                         lbs_deb_thread("Waking up device...\n");
842                         /* Wake up device */
843                         if (priv->exit_deep_sleep(priv))
844                                 lbs_deb_thread("Wakeup device failed\n");
845                         continue;
846                 }
847
848                 /* command timeout stuff */
849                 if (priv->cmd_timed_out && priv->cur_cmd) {
850                         struct cmd_ctrl_node *cmdnode = priv->cur_cmd;
851
852                         if (++priv->nr_retries > 3) {
853                                 lbs_pr_info("Excessive timeouts submitting "
854                                         "command 0x%04x\n",
855                                         le16_to_cpu(cmdnode->cmdbuf->command));
856                                 lbs_complete_command(priv, cmdnode, -ETIMEDOUT);
857                                 priv->nr_retries = 0;
858                                 if (priv->reset_card)
859                                         priv->reset_card(priv);
860                         } else {
861                                 priv->cur_cmd = NULL;
862                                 priv->dnld_sent = DNLD_RES_RECEIVED;
863                                 lbs_pr_info("requeueing command 0x%04x due "
864                                         "to timeout (#%d)\n",
865                                         le16_to_cpu(cmdnode->cmdbuf->command),
866                                         priv->nr_retries);
867
868                                 /* Stick it back at the _top_ of the pending queue
869                                    for immediate resubmission */
870                                 list_add(&cmdnode->list, &priv->cmdpendingq);
871                         }
872                 }
873                 priv->cmd_timed_out = 0;
874
875
876
877                 if (!priv->fw_ready)
878                         continue;
879
880                 /* Check if we need to confirm Sleep Request received previously */
881                 if (priv->psstate == PS_STATE_PRE_SLEEP &&
882                     !priv->dnld_sent && !priv->cur_cmd) {
883                         if (priv->connect_status == LBS_CONNECTED) {
884                                 lbs_deb_thread("pre-sleep, currenttxskb %p, "
885                                         "dnld_sent %d, cur_cmd %p\n",
886                                         priv->currenttxskb, priv->dnld_sent,
887                                         priv->cur_cmd);
888
889                                 lbs_ps_confirm_sleep(priv);
890                         } else {
891                                 /* workaround for firmware sending
892                                  * deauth/linkloss event immediately
893                                  * after sleep request; remove this
894                                  * after firmware fixes it
895                                  */
896                                 priv->psstate = PS_STATE_AWAKE;
897                                 lbs_pr_alert("ignore PS_SleepConfirm in "
898                                         "non-connected state\n");
899                         }
900                 }
901
902                 /* The PS state is changed during processing of Sleep Request
903                  * event above
904                  */
905                 if ((priv->psstate == PS_STATE_SLEEP) ||
906                     (priv->psstate == PS_STATE_PRE_SLEEP))
907                         continue;
908
909                 if (priv->is_deep_sleep)
910                         continue;
911
912                 /* Execute the next command */
913                 if (!priv->dnld_sent && !priv->cur_cmd)
914                         lbs_execute_next_command(priv);
915
916                 /* Wake-up command waiters which can't sleep in
917                  * lbs_prepare_and_send_command
918                  */
919                 if (!list_empty(&priv->cmdpendingq))
920                         wake_up_all(&priv->cmd_pending);
921
922                 spin_lock_irq(&priv->driver_lock);
923                 if (!priv->dnld_sent && priv->tx_pending_len > 0) {
924                         int ret = priv->hw_host_to_card(priv, MVMS_DAT,
925                                                         priv->tx_pending_buf,
926                                                         priv->tx_pending_len);
927                         if (ret) {
928                                 lbs_deb_tx("host_to_card failed %d\n", ret);
929                                 priv->dnld_sent = DNLD_RES_RECEIVED;
930                         }
931                         priv->tx_pending_len = 0;
932                         if (!priv->currenttxskb) {
933                                 /* We can wake the queues immediately if we aren't
934                                    waiting for TX feedback */
935                                 if (priv->connect_status == LBS_CONNECTED)
936                                         netif_wake_queue(priv->dev);
937                                 if (priv->mesh_dev &&
938                                     priv->mesh_connect_status == LBS_CONNECTED)
939                                         netif_wake_queue(priv->mesh_dev);
940                         }
941                 }
942                 spin_unlock_irq(&priv->driver_lock);
943         }
944
945         del_timer(&priv->command_timer);
946         del_timer(&priv->auto_deepsleep_timer);
947         wake_up_all(&priv->cmd_pending);
948
949         lbs_deb_leave(LBS_DEB_THREAD);
950         return 0;
951 }
952
953 static int lbs_suspend_callback(struct lbs_private *priv, unsigned long dummy,
954                                 struct cmd_header *cmd)
955 {
956         lbs_deb_enter(LBS_DEB_FW);
957
958         netif_device_detach(priv->dev);
959         if (priv->mesh_dev)
960                 netif_device_detach(priv->mesh_dev);
961
962         priv->fw_ready = 0;
963         lbs_deb_leave(LBS_DEB_FW);
964         return 0;
965 }
966
967 int lbs_suspend(struct lbs_private *priv)
968 {
969         struct cmd_header cmd;
970         int ret;
971
972         lbs_deb_enter(LBS_DEB_FW);
973
974         if (priv->wol_criteria == 0xffffffff) {
975                 lbs_pr_info("Suspend attempt without configuring wake params!\n");
976                 return -EINVAL;
977         }
978
979         memset(&cmd, 0, sizeof(cmd));
980
981         ret = __lbs_cmd(priv, CMD_802_11_HOST_SLEEP_ACTIVATE, &cmd,
982                         sizeof(cmd), lbs_suspend_callback, 0);
983         if (ret)
984                 lbs_pr_info("HOST_SLEEP_ACTIVATE failed: %d\n", ret);
985
986         lbs_deb_leave_args(LBS_DEB_FW, "ret %d", ret);
987         return ret;
988 }
989 EXPORT_SYMBOL_GPL(lbs_suspend);
990
991 void lbs_resume(struct lbs_private *priv)
992 {
993         lbs_deb_enter(LBS_DEB_FW);
994
995         priv->fw_ready = 1;
996
997         /* Firmware doesn't seem to give us RX packets any more
998            until we send it some command. Might as well update */
999         lbs_prepare_and_send_command(priv, CMD_802_11_RSSI, 0,
1000                                      0, 0, NULL);
1001
1002         netif_device_attach(priv->dev);
1003         if (priv->mesh_dev)
1004                 netif_device_attach(priv->mesh_dev);
1005
1006         lbs_deb_leave(LBS_DEB_FW);
1007 }
1008 EXPORT_SYMBOL_GPL(lbs_resume);
1009
1010 /**
1011  * @brief This function gets the HW spec from the firmware and sets
1012  *        some basic parameters.
1013  *
1014  *  @param priv    A pointer to struct lbs_private structure
1015  *  @return        0 or -1
1016  */
1017 static int lbs_setup_firmware(struct lbs_private *priv)
1018 {
1019         int ret = -1;
1020         s16 curlevel = 0, minlevel = 0, maxlevel = 0;
1021
1022         lbs_deb_enter(LBS_DEB_FW);
1023
1024         /* Read MAC address from firmware */
1025         memset(priv->current_addr, 0xff, ETH_ALEN);
1026         ret = lbs_update_hw_spec(priv);
1027         if (ret)
1028                 goto done;
1029
1030         /* Read power levels if available */
1031         ret = lbs_get_tx_power(priv, &curlevel, &minlevel, &maxlevel);
1032         if (ret == 0) {
1033                 priv->txpower_cur = curlevel;
1034                 priv->txpower_min = minlevel;
1035                 priv->txpower_max = maxlevel;
1036         }
1037
1038         lbs_set_mac_control(priv);
1039 done:
1040         lbs_deb_leave_args(LBS_DEB_FW, "ret %d", ret);
1041         return ret;
1042 }
1043
1044 /**
1045  *  This function handles the timeout of command sending.
1046  *  It will re-send the same command again.
1047  */
1048 static void command_timer_fn(unsigned long data)
1049 {
1050         struct lbs_private *priv = (struct lbs_private *)data;
1051         unsigned long flags;
1052
1053         lbs_deb_enter(LBS_DEB_CMD);
1054         spin_lock_irqsave(&priv->driver_lock, flags);
1055
1056         if (!priv->cur_cmd)
1057                 goto out;
1058
1059         lbs_pr_info("command 0x%04x timed out\n",
1060                 le16_to_cpu(priv->cur_cmd->cmdbuf->command));
1061
1062         priv->cmd_timed_out = 1;
1063         wake_up_interruptible(&priv->waitq);
1064 out:
1065         spin_unlock_irqrestore(&priv->driver_lock, flags);
1066         lbs_deb_leave(LBS_DEB_CMD);
1067 }
1068
1069 /**
1070  *  This function put the device back to deep sleep mode when timer expires
1071  *  and no activity (command, event, data etc.) is detected.
1072  */
1073 static void auto_deepsleep_timer_fn(unsigned long data)
1074 {
1075         struct lbs_private *priv = (struct lbs_private *)data;
1076         int ret;
1077
1078         lbs_deb_enter(LBS_DEB_CMD);
1079
1080         if (priv->is_activity_detected) {
1081                 priv->is_activity_detected = 0;
1082         } else {
1083                 if (priv->is_auto_deep_sleep_enabled &&
1084                                 (!priv->wakeup_dev_required) &&
1085                                 (priv->connect_status != LBS_CONNECTED)) {
1086                         lbs_deb_main("Entering auto deep sleep mode...\n");
1087                         ret = lbs_prepare_and_send_command(priv,
1088                                         CMD_802_11_DEEP_SLEEP, 0,
1089                                         0, 0, NULL);
1090                 }
1091         }
1092         mod_timer(&priv->auto_deepsleep_timer , jiffies +
1093                                 (priv->auto_deep_sleep_timeout * HZ)/1000);
1094         lbs_deb_leave(LBS_DEB_CMD);
1095 }
1096
1097 int lbs_enter_auto_deep_sleep(struct lbs_private *priv)
1098 {
1099         lbs_deb_enter(LBS_DEB_SDIO);
1100
1101         priv->is_auto_deep_sleep_enabled = 1;
1102         if (priv->is_deep_sleep)
1103                 priv->wakeup_dev_required = 1;
1104         mod_timer(&priv->auto_deepsleep_timer ,
1105                         jiffies + (priv->auto_deep_sleep_timeout * HZ)/1000);
1106
1107         lbs_deb_leave(LBS_DEB_SDIO);
1108         return 0;
1109 }
1110
1111 int lbs_exit_auto_deep_sleep(struct lbs_private *priv)
1112 {
1113         lbs_deb_enter(LBS_DEB_SDIO);
1114
1115         priv->is_auto_deep_sleep_enabled = 0;
1116         priv->auto_deep_sleep_timeout = 0;
1117         del_timer(&priv->auto_deepsleep_timer);
1118
1119         lbs_deb_leave(LBS_DEB_SDIO);
1120         return 0;
1121 }
1122
1123 static void lbs_sync_channel_worker(struct work_struct *work)
1124 {
1125         struct lbs_private *priv = container_of(work, struct lbs_private,
1126                 sync_channel);
1127
1128         lbs_deb_enter(LBS_DEB_MAIN);
1129         if (lbs_update_channel(priv))
1130                 lbs_pr_info("Channel synchronization failed.");
1131         lbs_deb_leave(LBS_DEB_MAIN);
1132 }
1133
1134
1135 static int lbs_init_adapter(struct lbs_private *priv)
1136 {
1137         size_t bufsize;
1138         int i, ret = 0;
1139
1140         lbs_deb_enter(LBS_DEB_MAIN);
1141
1142         /* Allocate buffer to store the BSSID list */
1143         bufsize = MAX_NETWORK_COUNT * sizeof(struct bss_descriptor);
1144         priv->networks = kzalloc(bufsize, GFP_KERNEL);
1145         if (!priv->networks) {
1146                 lbs_pr_err("Out of memory allocating beacons\n");
1147                 ret = -1;
1148                 goto out;
1149         }
1150
1151         /* Initialize scan result lists */
1152         INIT_LIST_HEAD(&priv->network_free_list);
1153         INIT_LIST_HEAD(&priv->network_list);
1154         for (i = 0; i < MAX_NETWORK_COUNT; i++) {
1155                 list_add_tail(&priv->networks[i].list,
1156                               &priv->network_free_list);
1157         }
1158
1159         memset(priv->current_addr, 0xff, ETH_ALEN);
1160
1161         priv->connect_status = LBS_DISCONNECTED;
1162         priv->mesh_connect_status = LBS_DISCONNECTED;
1163         priv->secinfo.auth_mode = IW_AUTH_ALG_OPEN_SYSTEM;
1164         priv->mode = IW_MODE_INFRA;
1165         priv->curbssparams.channel = DEFAULT_AD_HOC_CHANNEL;
1166         priv->mac_control = CMD_ACT_MAC_RX_ON | CMD_ACT_MAC_TX_ON;
1167         priv->radio_on = 1;
1168         priv->enablehwauto = 1;
1169         priv->capability = WLAN_CAPABILITY_SHORT_PREAMBLE;
1170         priv->psmode = LBS802_11POWERMODECAM;
1171         priv->psstate = PS_STATE_FULL_POWER;
1172         priv->is_deep_sleep = 0;
1173         priv->is_auto_deep_sleep_enabled = 0;
1174         priv->wakeup_dev_required = 0;
1175         init_waitqueue_head(&priv->ds_awake_q);
1176
1177         mutex_init(&priv->lock);
1178
1179         setup_timer(&priv->command_timer, command_timer_fn,
1180                 (unsigned long)priv);
1181         setup_timer(&priv->auto_deepsleep_timer, auto_deepsleep_timer_fn,
1182                         (unsigned long)priv);
1183
1184         INIT_LIST_HEAD(&priv->cmdfreeq);
1185         INIT_LIST_HEAD(&priv->cmdpendingq);
1186
1187         spin_lock_init(&priv->driver_lock);
1188         init_waitqueue_head(&priv->cmd_pending);
1189
1190         /* Allocate the command buffers */
1191         if (lbs_allocate_cmd_buffer(priv)) {
1192                 lbs_pr_err("Out of memory allocating command buffers\n");
1193                 ret = -ENOMEM;
1194                 goto out;
1195         }
1196         priv->resp_idx = 0;
1197         priv->resp_len[0] = priv->resp_len[1] = 0;
1198
1199         /* Create the event FIFO */
1200         priv->event_fifo = kfifo_alloc(sizeof(u32) * 16, GFP_KERNEL, NULL);
1201         if (IS_ERR(priv->event_fifo)) {
1202                 lbs_pr_err("Out of memory allocating event FIFO buffer\n");
1203                 ret = -ENOMEM;
1204                 goto out;
1205         }
1206
1207 out:
1208         lbs_deb_leave_args(LBS_DEB_MAIN, "ret %d", ret);
1209
1210         return ret;
1211 }
1212
1213 static void lbs_free_adapter(struct lbs_private *priv)
1214 {
1215         lbs_deb_enter(LBS_DEB_MAIN);
1216
1217         lbs_free_cmd_buffer(priv);
1218         if (priv->event_fifo)
1219                 kfifo_free(priv->event_fifo);
1220         del_timer(&priv->command_timer);
1221         del_timer(&priv->auto_deepsleep_timer);
1222         kfree(priv->networks);
1223         priv->networks = NULL;
1224
1225         lbs_deb_leave(LBS_DEB_MAIN);
1226 }
1227
1228 static const struct net_device_ops lbs_netdev_ops = {
1229         .ndo_open               = lbs_dev_open,
1230         .ndo_stop               = lbs_eth_stop,
1231         .ndo_start_xmit         = lbs_hard_start_xmit,
1232         .ndo_set_mac_address    = lbs_set_mac_address,
1233         .ndo_tx_timeout         = lbs_tx_timeout,
1234         .ndo_set_multicast_list = lbs_set_multicast_list,
1235         .ndo_change_mtu         = eth_change_mtu,
1236         .ndo_validate_addr      = eth_validate_addr,
1237 };
1238
1239 /**
1240  * @brief This function adds the card. it will probe the
1241  * card, allocate the lbs_priv and initialize the device.
1242  *
1243  *  @param card    A pointer to card
1244  *  @return        A pointer to struct lbs_private structure
1245  */
1246 struct lbs_private *lbs_add_card(void *card, struct device *dmdev)
1247 {
1248         struct net_device *dev = NULL;
1249         struct lbs_private *priv = NULL;
1250
1251         lbs_deb_enter(LBS_DEB_MAIN);
1252
1253         /* Allocate an Ethernet device and register it */
1254         dev = alloc_etherdev(sizeof(struct lbs_private));
1255         if (!dev) {
1256                 lbs_pr_err("init wlanX device failed\n");
1257                 goto done;
1258         }
1259         priv = netdev_priv(dev);
1260         dev->ml_priv = priv;
1261
1262         if (lbs_init_adapter(priv)) {
1263                 lbs_pr_err("failed to initialize adapter structure.\n");
1264                 goto err_init_adapter;
1265         }
1266
1267         priv->dev = dev;
1268         priv->card = card;
1269         priv->mesh_open = 0;
1270         priv->infra_open = 0;
1271
1272         /* Setup the OS Interface to our functions */
1273         dev->netdev_ops = &lbs_netdev_ops;
1274         dev->watchdog_timeo = 5 * HZ;
1275         dev->ethtool_ops = &lbs_ethtool_ops;
1276 #ifdef  WIRELESS_EXT
1277         dev->wireless_handlers = &lbs_handler_def;
1278 #endif
1279         dev->flags |= IFF_BROADCAST | IFF_MULTICAST;
1280
1281         SET_NETDEV_DEV(dev, dmdev);
1282
1283         priv->rtap_net_dev = NULL;
1284         strcpy(dev->name, "wlan%d");
1285
1286         lbs_deb_thread("Starting main thread...\n");
1287         init_waitqueue_head(&priv->waitq);
1288         priv->main_thread = kthread_run(lbs_thread, dev, "lbs_main");
1289         if (IS_ERR(priv->main_thread)) {
1290                 lbs_deb_thread("Error creating main thread.\n");
1291                 goto err_init_adapter;
1292         }
1293
1294         priv->work_thread = create_singlethread_workqueue("lbs_worker");
1295         INIT_DELAYED_WORK(&priv->assoc_work, lbs_association_worker);
1296         INIT_DELAYED_WORK(&priv->scan_work, lbs_scan_worker);
1297         INIT_WORK(&priv->mcast_work, lbs_set_mcast_worker);
1298         INIT_WORK(&priv->sync_channel, lbs_sync_channel_worker);
1299
1300         sprintf(priv->mesh_ssid, "mesh");
1301         priv->mesh_ssid_len = 4;
1302
1303         priv->wol_criteria = 0xffffffff;
1304         priv->wol_gpio = 0xff;
1305
1306         goto done;
1307
1308 err_init_adapter:
1309         lbs_free_adapter(priv);
1310         free_netdev(dev);
1311         priv = NULL;
1312
1313 done:
1314         lbs_deb_leave_args(LBS_DEB_MAIN, "priv %p", priv);
1315         return priv;
1316 }
1317 EXPORT_SYMBOL_GPL(lbs_add_card);
1318
1319
1320 void lbs_remove_card(struct lbs_private *priv)
1321 {
1322         struct net_device *dev = priv->dev;
1323         union iwreq_data wrqu;
1324
1325         lbs_deb_enter(LBS_DEB_MAIN);
1326
1327         lbs_remove_mesh(priv);
1328         lbs_remove_rtap(priv);
1329
1330         dev = priv->dev;
1331
1332         cancel_delayed_work_sync(&priv->scan_work);
1333         cancel_delayed_work_sync(&priv->assoc_work);
1334         cancel_work_sync(&priv->mcast_work);
1335
1336         /* worker thread destruction blocks on the in-flight command which
1337          * should have been cleared already in lbs_stop_card().
1338          */
1339         lbs_deb_main("destroying worker thread\n");
1340         destroy_workqueue(priv->work_thread);
1341         lbs_deb_main("done destroying worker thread\n");
1342
1343         if (priv->psmode == LBS802_11POWERMODEMAX_PSP) {
1344                 priv->psmode = LBS802_11POWERMODECAM;
1345                 lbs_ps_wakeup(priv, CMD_OPTION_WAITFORRSP);
1346         }
1347
1348         memset(wrqu.ap_addr.sa_data, 0xaa, ETH_ALEN);
1349         wrqu.ap_addr.sa_family = ARPHRD_ETHER;
1350         wireless_send_event(priv->dev, SIOCGIWAP, &wrqu, NULL);
1351
1352         if (priv->is_deep_sleep) {
1353                 priv->is_deep_sleep = 0;
1354                 wake_up_interruptible(&priv->ds_awake_q);
1355         }
1356
1357         /* Stop the thread servicing the interrupts */
1358         priv->surpriseremoved = 1;
1359         kthread_stop(priv->main_thread);
1360
1361         lbs_free_adapter(priv);
1362
1363         priv->dev = NULL;
1364         free_netdev(dev);
1365
1366         lbs_deb_leave(LBS_DEB_MAIN);
1367 }
1368 EXPORT_SYMBOL_GPL(lbs_remove_card);
1369
1370
1371 int lbs_start_card(struct lbs_private *priv)
1372 {
1373         struct net_device *dev = priv->dev;
1374         int ret = -1;
1375
1376         lbs_deb_enter(LBS_DEB_MAIN);
1377
1378         /* poke the firmware */
1379         ret = lbs_setup_firmware(priv);
1380         if (ret)
1381                 goto done;
1382
1383         /* init 802.11d */
1384         lbs_init_11d(priv);
1385
1386         if (register_netdev(dev)) {
1387                 lbs_pr_err("cannot register ethX device\n");
1388                 goto done;
1389         }
1390
1391         lbs_update_channel(priv);
1392
1393         /* Check mesh FW version and appropriately send the mesh start
1394          * command
1395          */
1396         if (priv->mesh_fw_ver == MESH_FW_OLD) {
1397                 /* Enable mesh, if supported, and work out which TLV it uses.
1398                    0x100 + 291 is an unofficial value used in 5.110.20.pXX
1399                    0x100 + 37 is the official value used in 5.110.21.pXX
1400                    but we check them in that order because 20.pXX doesn't
1401                    give an error -- it just silently fails. */
1402
1403                 /* 5.110.20.pXX firmware will fail the command if the channel
1404                    doesn't match the existing channel. But only if the TLV
1405                    is correct. If the channel is wrong, _BOTH_ versions will
1406                    give an error to 0x100+291, and allow 0x100+37 to succeed.
1407                    It's just that 5.110.20.pXX will not have done anything
1408                    useful */
1409
1410                 priv->mesh_tlv = TLV_TYPE_OLD_MESH_ID;
1411                 if (lbs_mesh_config(priv, CMD_ACT_MESH_CONFIG_START,
1412                                     priv->curbssparams.channel)) {
1413                         priv->mesh_tlv = TLV_TYPE_MESH_ID;
1414                         if (lbs_mesh_config(priv, CMD_ACT_MESH_CONFIG_START,
1415                                             priv->curbssparams.channel))
1416                                 priv->mesh_tlv = 0;
1417                 }
1418         } else if (priv->mesh_fw_ver == MESH_FW_NEW) {
1419                 /* 10.0.0.pXX new firmwares should succeed with TLV
1420                  * 0x100+37; Do not invoke command with old TLV.
1421                  */
1422                 priv->mesh_tlv = TLV_TYPE_MESH_ID;
1423                 if (lbs_mesh_config(priv, CMD_ACT_MESH_CONFIG_START,
1424                                     priv->curbssparams.channel))
1425                         priv->mesh_tlv = 0;
1426         }
1427         if (priv->mesh_tlv) {
1428                 lbs_add_mesh(priv);
1429
1430                 if (device_create_file(&dev->dev, &dev_attr_lbs_mesh))
1431                         lbs_pr_err("cannot register lbs_mesh attribute\n");
1432
1433                 /* While rtap isn't related to mesh, only mesh-enabled
1434                  * firmware implements the rtap functionality via
1435                  * CMD_802_11_MONITOR_MODE.
1436                  */
1437                 if (device_create_file(&dev->dev, &dev_attr_lbs_rtap))
1438                         lbs_pr_err("cannot register lbs_rtap attribute\n");
1439         }
1440
1441         lbs_debugfs_init_one(priv, dev);
1442
1443         lbs_pr_info("%s: Marvell WLAN 802.11 adapter\n", dev->name);
1444
1445         ret = 0;
1446
1447 done:
1448         lbs_deb_leave_args(LBS_DEB_MAIN, "ret %d", ret);
1449         return ret;
1450 }
1451 EXPORT_SYMBOL_GPL(lbs_start_card);
1452
1453
1454 void lbs_stop_card(struct lbs_private *priv)
1455 {
1456         struct net_device *dev;
1457         struct cmd_ctrl_node *cmdnode;
1458         unsigned long flags;
1459
1460         lbs_deb_enter(LBS_DEB_MAIN);
1461
1462         if (!priv)
1463                 goto out;
1464         dev = priv->dev;
1465
1466         netif_stop_queue(dev);
1467         netif_carrier_off(dev);
1468
1469         lbs_debugfs_remove_one(priv);
1470         if (priv->mesh_tlv) {
1471                 device_remove_file(&dev->dev, &dev_attr_lbs_mesh);
1472                 device_remove_file(&dev->dev, &dev_attr_lbs_rtap);
1473         }
1474
1475         /* Delete the timeout of the currently processing command */
1476         del_timer_sync(&priv->command_timer);
1477         del_timer_sync(&priv->auto_deepsleep_timer);
1478
1479         /* Flush pending command nodes */
1480         spin_lock_irqsave(&priv->driver_lock, flags);
1481         lbs_deb_main("clearing pending commands\n");
1482         list_for_each_entry(cmdnode, &priv->cmdpendingq, list) {
1483                 cmdnode->result = -ENOENT;
1484                 cmdnode->cmdwaitqwoken = 1;
1485                 wake_up_interruptible(&cmdnode->cmdwait_q);
1486         }
1487
1488         /* Flush the command the card is currently processing */
1489         if (priv->cur_cmd) {
1490                 lbs_deb_main("clearing current command\n");
1491                 priv->cur_cmd->result = -ENOENT;
1492                 priv->cur_cmd->cmdwaitqwoken = 1;
1493                 wake_up_interruptible(&priv->cur_cmd->cmdwait_q);
1494         }
1495         lbs_deb_main("done clearing commands\n");
1496         spin_unlock_irqrestore(&priv->driver_lock, flags);
1497
1498         unregister_netdev(dev);
1499
1500 out:
1501         lbs_deb_leave(LBS_DEB_MAIN);
1502 }
1503 EXPORT_SYMBOL_GPL(lbs_stop_card);
1504
1505
1506 static const struct net_device_ops mesh_netdev_ops = {
1507         .ndo_open               = lbs_dev_open,
1508         .ndo_stop               = lbs_mesh_stop,
1509         .ndo_start_xmit         = lbs_hard_start_xmit,
1510         .ndo_set_mac_address    = lbs_set_mac_address,
1511         .ndo_set_multicast_list = lbs_set_multicast_list,
1512 };
1513
1514 /**
1515  * @brief This function adds mshX interface
1516  *
1517  *  @param priv    A pointer to the struct lbs_private structure
1518  *  @return        0 if successful, -X otherwise
1519  */
1520 static int lbs_add_mesh(struct lbs_private *priv)
1521 {
1522         struct net_device *mesh_dev = NULL;
1523         int ret = 0;
1524
1525         lbs_deb_enter(LBS_DEB_MESH);
1526
1527         /* Allocate a virtual mesh device */
1528         if (!(mesh_dev = alloc_netdev(0, "msh%d", ether_setup))) {
1529                 lbs_deb_mesh("init mshX device failed\n");
1530                 ret = -ENOMEM;
1531                 goto done;
1532         }
1533         mesh_dev->ml_priv = priv;
1534         priv->mesh_dev = mesh_dev;
1535
1536         mesh_dev->netdev_ops = &mesh_netdev_ops;
1537         mesh_dev->ethtool_ops = &lbs_ethtool_ops;
1538         memcpy(mesh_dev->dev_addr, priv->dev->dev_addr,
1539                         sizeof(priv->dev->dev_addr));
1540
1541         SET_NETDEV_DEV(priv->mesh_dev, priv->dev->dev.parent);
1542
1543 #ifdef  WIRELESS_EXT
1544         mesh_dev->wireless_handlers = (struct iw_handler_def *)&mesh_handler_def;
1545 #endif
1546         mesh_dev->flags |= IFF_BROADCAST | IFF_MULTICAST;
1547         /* Register virtual mesh interface */
1548         ret = register_netdev(mesh_dev);
1549         if (ret) {
1550                 lbs_pr_err("cannot register mshX virtual interface\n");
1551                 goto err_free;
1552         }
1553
1554         ret = sysfs_create_group(&(mesh_dev->dev.kobj), &lbs_mesh_attr_group);
1555         if (ret)
1556                 goto err_unregister;
1557
1558         lbs_persist_config_init(mesh_dev);
1559
1560         /* Everything successful */
1561         ret = 0;
1562         goto done;
1563
1564 err_unregister:
1565         unregister_netdev(mesh_dev);
1566
1567 err_free:
1568         free_netdev(mesh_dev);
1569
1570 done:
1571         lbs_deb_leave_args(LBS_DEB_MESH, "ret %d", ret);
1572         return ret;
1573 }
1574
1575 static void lbs_remove_mesh(struct lbs_private *priv)
1576 {
1577         struct net_device *mesh_dev;
1578
1579
1580         mesh_dev = priv->mesh_dev;
1581         if (!mesh_dev)
1582                 return;
1583
1584         lbs_deb_enter(LBS_DEB_MESH);
1585         netif_stop_queue(mesh_dev);
1586         netif_carrier_off(mesh_dev);
1587         sysfs_remove_group(&(mesh_dev->dev.kobj), &lbs_mesh_attr_group);
1588         lbs_persist_config_remove(mesh_dev);
1589         unregister_netdev(mesh_dev);
1590         priv->mesh_dev = NULL;
1591         free_netdev(mesh_dev);
1592         lbs_deb_leave(LBS_DEB_MESH);
1593 }
1594
1595 /**
1596  *  @brief This function finds the CFP in
1597  *  region_cfp_table based on region and band parameter.
1598  *
1599  *  @param region  The region code
1600  *  @param band    The band
1601  *  @param cfp_no  A pointer to CFP number
1602  *  @return        A pointer to CFP
1603  */
1604 struct chan_freq_power *lbs_get_region_cfp_table(u8 region, int *cfp_no)
1605 {
1606         int i, end;
1607
1608         lbs_deb_enter(LBS_DEB_MAIN);
1609
1610         end = ARRAY_SIZE(region_cfp_table);
1611
1612         for (i = 0; i < end ; i++) {
1613                 lbs_deb_main("region_cfp_table[i].region=%d\n",
1614                         region_cfp_table[i].region);
1615                 if (region_cfp_table[i].region == region) {
1616                         *cfp_no = region_cfp_table[i].cfp_no_BG;
1617                         lbs_deb_leave(LBS_DEB_MAIN);
1618                         return region_cfp_table[i].cfp_BG;
1619                 }
1620         }
1621
1622         lbs_deb_leave_args(LBS_DEB_MAIN, "ret NULL");
1623         return NULL;
1624 }
1625
1626 int lbs_set_regiontable(struct lbs_private *priv, u8 region, u8 band)
1627 {
1628         int ret = 0;
1629         int i = 0;
1630
1631         struct chan_freq_power *cfp;
1632         int cfp_no;
1633
1634         lbs_deb_enter(LBS_DEB_MAIN);
1635
1636         memset(priv->region_channel, 0, sizeof(priv->region_channel));
1637
1638         cfp = lbs_get_region_cfp_table(region, &cfp_no);
1639         if (cfp != NULL) {
1640                 priv->region_channel[i].nrcfp = cfp_no;
1641                 priv->region_channel[i].CFP = cfp;
1642         } else {
1643                 lbs_deb_main("wrong region code %#x in band B/G\n",
1644                        region);
1645                 ret = -1;
1646                 goto out;
1647         }
1648         priv->region_channel[i].valid = 1;
1649         priv->region_channel[i].region = region;
1650         priv->region_channel[i].band = band;
1651         i++;
1652 out:
1653         lbs_deb_leave_args(LBS_DEB_MAIN, "ret %d", ret);
1654         return ret;
1655 }
1656
1657 void lbs_queue_event(struct lbs_private *priv, u32 event)
1658 {
1659         unsigned long flags;
1660
1661         lbs_deb_enter(LBS_DEB_THREAD);
1662         spin_lock_irqsave(&priv->driver_lock, flags);
1663
1664         if (priv->psstate == PS_STATE_SLEEP)
1665                 priv->psstate = PS_STATE_AWAKE;
1666
1667         __kfifo_put(priv->event_fifo, (unsigned char *) &event, sizeof(u32));
1668
1669         wake_up_interruptible(&priv->waitq);
1670
1671         spin_unlock_irqrestore(&priv->driver_lock, flags);
1672         lbs_deb_leave(LBS_DEB_THREAD);
1673 }
1674 EXPORT_SYMBOL_GPL(lbs_queue_event);
1675
1676 void lbs_notify_command_response(struct lbs_private *priv, u8 resp_idx)
1677 {
1678         lbs_deb_enter(LBS_DEB_THREAD);
1679
1680         if (priv->psstate == PS_STATE_SLEEP)
1681                 priv->psstate = PS_STATE_AWAKE;
1682
1683         /* Swap buffers by flipping the response index */
1684         BUG_ON(resp_idx > 1);
1685         priv->resp_idx = resp_idx;
1686
1687         wake_up_interruptible(&priv->waitq);
1688
1689         lbs_deb_leave(LBS_DEB_THREAD);
1690 }
1691 EXPORT_SYMBOL_GPL(lbs_notify_command_response);
1692
1693 static int __init lbs_init_module(void)
1694 {
1695         lbs_deb_enter(LBS_DEB_MAIN);
1696         memset(&confirm_sleep, 0, sizeof(confirm_sleep));
1697         confirm_sleep.hdr.command = cpu_to_le16(CMD_802_11_PS_MODE);
1698         confirm_sleep.hdr.size = cpu_to_le16(sizeof(confirm_sleep));
1699         confirm_sleep.action = cpu_to_le16(CMD_SUBCMD_SLEEP_CONFIRMED);
1700         lbs_debugfs_init();
1701         lbs_deb_leave(LBS_DEB_MAIN);
1702         return 0;
1703 }
1704
1705 static void __exit lbs_exit_module(void)
1706 {
1707         lbs_deb_enter(LBS_DEB_MAIN);
1708         lbs_debugfs_remove();
1709         lbs_deb_leave(LBS_DEB_MAIN);
1710 }
1711
1712 /*
1713  * rtap interface support fuctions
1714  */
1715
1716 static int lbs_rtap_open(struct net_device *dev)
1717 {
1718         /* Yes, _stop_ the queue. Because we don't support injection */
1719         lbs_deb_enter(LBS_DEB_MAIN);
1720         netif_carrier_off(dev);
1721         netif_stop_queue(dev);
1722         lbs_deb_leave(LBS_DEB_LEAVE);
1723         return 0;
1724 }
1725
1726 static int lbs_rtap_stop(struct net_device *dev)
1727 {
1728         lbs_deb_enter(LBS_DEB_MAIN);
1729         lbs_deb_leave(LBS_DEB_MAIN);
1730         return 0;
1731 }
1732
1733 static netdev_tx_t lbs_rtap_hard_start_xmit(struct sk_buff *skb,
1734                                             struct net_device *dev)
1735 {
1736         netif_stop_queue(dev);
1737         return NETDEV_TX_BUSY;
1738 }
1739
1740 static void lbs_remove_rtap(struct lbs_private *priv)
1741 {
1742         lbs_deb_enter(LBS_DEB_MAIN);
1743         if (priv->rtap_net_dev == NULL)
1744                 goto out;
1745         unregister_netdev(priv->rtap_net_dev);
1746         free_netdev(priv->rtap_net_dev);
1747         priv->rtap_net_dev = NULL;
1748 out:
1749         lbs_deb_leave(LBS_DEB_MAIN);
1750 }
1751
1752 static const struct net_device_ops rtap_netdev_ops = {
1753         .ndo_open = lbs_rtap_open,
1754         .ndo_stop = lbs_rtap_stop,
1755         .ndo_start_xmit = lbs_rtap_hard_start_xmit,
1756 };
1757
1758 static int lbs_add_rtap(struct lbs_private *priv)
1759 {
1760         int ret = 0;
1761         struct net_device *rtap_dev;
1762
1763         lbs_deb_enter(LBS_DEB_MAIN);
1764         if (priv->rtap_net_dev) {
1765                 ret = -EPERM;
1766                 goto out;
1767         }
1768
1769         rtap_dev = alloc_netdev(0, "rtap%d", ether_setup);
1770         if (rtap_dev == NULL) {
1771                 ret = -ENOMEM;
1772                 goto out;
1773         }
1774
1775         memcpy(rtap_dev->dev_addr, priv->current_addr, ETH_ALEN);
1776         rtap_dev->type = ARPHRD_IEEE80211_RADIOTAP;
1777         rtap_dev->netdev_ops = &rtap_netdev_ops;
1778         rtap_dev->ml_priv = priv;
1779         SET_NETDEV_DEV(rtap_dev, priv->dev->dev.parent);
1780
1781         ret = register_netdev(rtap_dev);
1782         if (ret) {
1783                 free_netdev(rtap_dev);
1784                 goto out;
1785         }
1786         priv->rtap_net_dev = rtap_dev;
1787
1788 out:
1789         lbs_deb_leave_args(LBS_DEB_MAIN, "ret %d", ret);
1790         return ret;
1791 }
1792
1793 module_init(lbs_init_module);
1794 module_exit(lbs_exit_module);
1795
1796 MODULE_DESCRIPTION("Libertas WLAN Driver Library");
1797 MODULE_AUTHOR("Marvell International Ltd.");
1798 MODULE_LICENSE("GPL");