drivers/net/wireless/zd1211rw/zd_mac.c

   1 /* zd_mac.c
   2  *
   3  * This program is free software; you can redistribute it and/or modify
   4  * it under the terms of the GNU General Public License as published by
   5  * the Free Software Foundation; either version 2 of the License, or
   6  * (at your option) any later version.
   7  *
   8  * This program is distributed in the hope that it will be useful,
   9  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11  * GNU General Public License for more details.
  12  *
  13  * You should have received a copy of the GNU General Public License
  14  * along with this program; if not, write to the Free Software
  15  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  16  */
  17
  18 #include <linux/netdevice.h>
  19 #include <linux/etherdevice.h>
  20 #include <linux/wireless.h>
  21 #include <linux/usb.h>
  22 #include <linux/jiffies.h>
  23 #include <net/ieee80211_radiotap.h>
  24
  25 #include "zd_def.h"
  26 #include "zd_chip.h"
  27 #include "zd_mac.h"
  28 #include "zd_ieee80211.h"
  29 #include "zd_netdev.h"
  30 #include "zd_rf.h"
  31
  32 static void ieee_init(struct ieee80211_device *ieee);
  33 static void softmac_init(struct ieee80211softmac_device *sm);
  34 static void set_rts_cts_work(struct work_struct *work);
  35 static void set_basic_rates_work(struct work_struct *work);
  36
  37 static void housekeeping_init(struct zd_mac *mac);
  38 static void housekeeping_enable(struct zd_mac *mac);
  39 static void housekeeping_disable(struct zd_mac *mac);
  40
  41 static void set_multicast_hash_handler(struct work_struct *work);
  42
  43 static void do_rx(unsigned long mac_ptr);
  44
  45 int zd_mac_init(struct zd_mac *mac,
  46                 struct net_device *netdev,
  47                 struct usb_interface *intf)
  48 {
  49         struct ieee80211_device *ieee = zd_netdev_ieee80211(netdev);
  50
  51         memset(mac, 0, sizeof(*mac));
  52         spin_lock_init(&mac->lock);
  53         mac->netdev = netdev;
  54         INIT_DELAYED_WORK(&mac->set_rts_cts_work, set_rts_cts_work);
  55         INIT_DELAYED_WORK(&mac->set_basic_rates_work, set_basic_rates_work);
  56
  57         skb_queue_head_init(&mac->rx_queue);
  58         tasklet_init(&mac->rx_tasklet, do_rx, (unsigned long)mac);
  59         tasklet_disable(&mac->rx_tasklet);
  60
  61         ieee_init(ieee);
  62         softmac_init(ieee80211_priv(netdev));
  63         zd_chip_init(&mac->chip, netdev, intf);
  64         housekeeping_init(mac);
  65         INIT_WORK(&mac->set_multicast_hash_work, set_multicast_hash_handler);
  66         return 0;
  67 }
  68
  69 static int reset_channel(struct zd_mac *mac)
  70 {
  71         int r;
  72         unsigned long flags;
  73         const struct channel_range *range;
  74
  75         spin_lock_irqsave(&mac->lock, flags);
  76         range = zd_channel_range(mac->regdomain);
  77         if (!range->start) {
  78                 r = -EINVAL;
  79                 goto out;
  80         }
  81         mac->requested_channel = range->start;
  82         r = 0;
  83 out:
  84         spin_unlock_irqrestore(&mac->lock, flags);
  85         return r;
  86 }
  87
  88 int zd_mac_preinit_hw(struct zd_mac *mac)
  89 {
  90         int r;
  91         u8 addr[ETH_ALEN];
  92
  93         r = zd_chip_read_mac_addr_fw(&mac->chip, addr);
  94         if (r)
  95                 return r;
  96
  97         memcpy(mac->netdev->dev_addr, addr, ETH_ALEN);
  98         return 0;
  99 }
 100
 101 int zd_mac_init_hw(struct zd_mac *mac)
 102 {
 103         int r;
 104         struct zd_chip *chip = &mac->chip;
 105         u8 default_regdomain;
 106
 107         r = zd_chip_enable_int(chip);
 108         if (r)
 109                 goto out;
 110         r = zd_chip_init_hw(chip);
 111         if (r)
 112                 goto disable_int;
 113
 114         ZD_ASSERT(!irqs_disabled());
 115
 116         r = zd_read_regdomain(chip, &default_regdomain);
 117         if (r)
 118                 goto disable_int;
 119         if (!zd_regdomain_supported(default_regdomain)) {
 120                 /* The vendor driver overrides the regulatory domain and
 121                  * allowed channel registers and unconditionally restricts
 122                  * available channels to 1-11 everywhere. Match their
 123                  * questionable behaviour only for regdomains which we don't
 124                  * recognise. */
 125                 dev_warn(zd_mac_dev(mac),  "Unrecognised regulatory domain: "
 126                         "%#04x. Defaulting to FCC.\n", default_regdomain);
 127                 default_regdomain = ZD_REGDOMAIN_FCC;
 128         }
 129         spin_lock_irq(&mac->lock);
 130         mac->regdomain = mac->default_regdomain = default_regdomain;
 131         spin_unlock_irq(&mac->lock);
 132         r = reset_channel(mac);
 133         if (r)
 134                 goto disable_int;
 135
 136         /* We must inform the device that we are doing encryption/decryption in
 137          * software at the moment. */
 138         r = zd_set_encryption_type(chip, ENC_SNIFFER);
 139         if (r)
 140                 goto disable_int;
 141
 142         r = zd_geo_init(zd_mac_to_ieee80211(mac), mac->regdomain);
 143         if (r)
 144                 goto disable_int;
 145
 146         r = 0;
 147 disable_int:
 148         zd_chip_disable_int(chip);
 149 out:
 150         return r;
 151 }
 152
 153 void zd_mac_clear(struct zd_mac *mac)
 154 {
 155         flush_workqueue(zd_workqueue);
 156         skb_queue_purge(&mac->rx_queue);
 157         tasklet_kill(&mac->rx_tasklet);
 158         zd_chip_clear(&mac->chip);
 159         ZD_ASSERT(!spin_is_locked(&mac->lock));
 160         ZD_MEMCLEAR(mac, sizeof(struct zd_mac));
 161 }
 162
 163 static int set_rx_filter(struct zd_mac *mac)
 164 {
 165         struct ieee80211_device *ieee = zd_mac_to_ieee80211(mac);
 166         u32 filter = (ieee->iw_mode == IW_MODE_MONITOR) ? ~0 : STA_RX_FILTER;
 167         return zd_iowrite32(&mac->chip, CR_RX_FILTER, filter);
 168 }
 169
 170 static int set_sniffer(struct zd_mac *mac)
 171 {
 172         struct ieee80211_device *ieee = zd_mac_to_ieee80211(mac);
 173         return zd_iowrite32(&mac->chip, CR_SNIFFER_ON,
 174                 ieee->iw_mode == IW_MODE_MONITOR ? 1 : 0);
 175         return 0;
 176 }
 177
 178 static int set_mc_hash(struct zd_mac *mac)
 179 {
 180         struct zd_mc_hash hash;
 181         struct ieee80211_device *ieee = zd_mac_to_ieee80211(mac);
 182
 183         zd_mc_clear(&hash);
 184         if (ieee->iw_mode == IW_MODE_MONITOR)
 185                 zd_mc_add_all(&hash);
 186
 187         return zd_chip_set_multicast_hash(&mac->chip, &hash);
 188 }
 189
 190 int zd_mac_open(struct net_device *netdev)
 191 {
 192         struct zd_mac *mac = zd_netdev_mac(netdev);
 193         struct zd_chip *chip = &mac->chip;
 194         struct zd_usb *usb = &chip->usb;
 195         int r;
 196
 197         if (!usb->initialized) {
 198                 r = zd_usb_init_hw(usb);
 199                 if (r)
 200                         goto out;
 201         }
 202
 203         tasklet_enable(&mac->rx_tasklet);
 204
 205         r = zd_chip_enable_int(chip);
 206         if (r < 0)
 207                 goto out;
 208
 209         r = zd_write_mac_addr(chip, netdev->dev_addr);
 210         if (r)
 211                 goto disable_int;
 212
 213         r = zd_chip_set_basic_rates(chip, CR_RATES_80211B | CR_RATES_80211G);
 214         if (r < 0)
 215                 goto disable_int;
 216         r = set_rx_filter(mac);
 217         if (r)
 218                 goto disable_int;
 219         r = set_sniffer(mac);
 220         if (r)
 221                 goto disable_int;
 222         r = set_mc_hash(mac);
 223         if (r)
 224                 goto disable_int;
 225         r = zd_chip_switch_radio_on(chip);
 226         if (r < 0)
 227                 goto disable_int;
 228         r = zd_chip_set_channel(chip, mac->requested_channel);
 229         if (r < 0)
 230                 goto disable_radio;
 231         r = zd_chip_enable_rx(chip);
 232         if (r < 0)
 233                 goto disable_radio;
 234         r = zd_chip_enable_hwint(chip);
 235         if (r < 0)
 236                 goto disable_rx;
 237
 238         housekeeping_enable(mac);
 239         ieee80211softmac_start(netdev);
 240         return 0;
 241 disable_rx:
 242         zd_chip_disable_rx(chip);
 243 disable_radio:
 244         zd_chip_switch_radio_off(chip);
 245 disable_int:
 246         zd_chip_disable_int(chip);
 247 out:
 248         return r;
 249 }
 250
 251 int zd_mac_stop(struct net_device *netdev)
 252 {
 253         struct zd_mac *mac = zd_netdev_mac(netdev);
 254         struct zd_chip *chip = &mac->chip;
 255
 256         netif_stop_queue(netdev);
 257
 258         /*
 259          * The order here deliberately is a little different from the open()
 260          * method, since we need to make sure there is no opportunity for RX
 261          * frames to be processed by softmac after we have stopped it.
 262          */
 263
 264         zd_chip_disable_rx(chip);
 265         skb_queue_purge(&mac->rx_queue);
 266         tasklet_disable(&mac->rx_tasklet);
 267         housekeeping_disable(mac);
 268         ieee80211softmac_stop(netdev);
 269
 270         /* Ensure no work items are running or queued from this point */
 271         cancel_delayed_work(&mac->set_rts_cts_work);
 272         cancel_delayed_work(&mac->set_basic_rates_work);
 273         flush_workqueue(zd_workqueue);
 274         mac->updating_rts_rate = 0;
 275         mac->updating_basic_rates = 0;
 276
 277         zd_chip_disable_hwint(chip);
 278         zd_chip_switch_radio_off(chip);
 279         zd_chip_disable_int(chip);
 280
 281         return 0;
 282 }
 283
 284 int zd_mac_set_mac_address(struct net_device *netdev, void *p)
 285 {
 286         int r;
 287         unsigned long flags;
 288         struct sockaddr *addr = p;
 289         struct zd_mac *mac = zd_netdev_mac(netdev);
 290         struct zd_chip *chip = &mac->chip;
 291         DECLARE_MAC_BUF(mac2);
 292
 293         if (!is_valid_ether_addr(addr->sa_data))
 294                 return -EADDRNOTAVAIL;
 295
 296         dev_dbg_f(zd_mac_dev(mac),
 297                   "Setting MAC to %s\n", print_mac(mac2, addr->sa_data));
 298
 299         if (netdev->flags & IFF_UP) {
 300                 r = zd_write_mac_addr(chip, addr->sa_data);
 301                 if (r)
 302                         return r;
 303         }
 304
 305         spin_lock_irqsave(&mac->lock, flags);
 306         memcpy(netdev->dev_addr, addr->sa_data, ETH_ALEN);
 307         spin_unlock_irqrestore(&mac->lock, flags);
 308
 309         return 0;
 310 }
 311
 312 static void set_multicast_hash_handler(struct work_struct *work)
 313 {
 314         struct zd_mac *mac = container_of(work, struct zd_mac,
 315                                           set_multicast_hash_work);
 316         struct zd_mc_hash hash;
 317
 318         spin_lock_irq(&mac->lock);
 319         hash = mac->multicast_hash;
 320         spin_unlock_irq(&mac->lock);
 321
 322         zd_chip_set_multicast_hash(&mac->chip, &hash);
 323 }
 324
 325 void zd_mac_set_multicast_list(struct net_device *dev)
 326 {
 327         struct zd_mac *mac = zd_netdev_mac(dev);
 328         struct ieee80211_device *ieee = zd_mac_to_ieee80211(mac);
 329         struct zd_mc_hash hash;
 330         struct dev_mc_list *mc;
 331         unsigned long flags;
 332         DECLARE_MAC_BUF(mac2);
 333
 334         if (dev->flags & (IFF_PROMISC|IFF_ALLMULTI) ||
 335                         ieee->iw_mode == IW_MODE_MONITOR) {
 336                 zd_mc_add_all(&hash);
 337         } else {
 338                 zd_mc_clear(&hash);
 339                 for (mc = dev->mc_list; mc; mc = mc->next) {
 340                         dev_dbg_f(zd_mac_dev(mac), "mc addr %s\n",
 341                                   print_mac(mac2, mc->dmi_addr));
 342                         zd_mc_add_addr(&hash, mc->dmi_addr);
 343                 }
 344         }
 345
 346         spin_lock_irqsave(&mac->lock, flags);
 347         mac->multicast_hash = hash;
 348         spin_unlock_irqrestore(&mac->lock, flags);
 349         queue_work(zd_workqueue, &mac->set_multicast_hash_work);
 350 }
 351
 352 int zd_mac_set_regdomain(struct zd_mac *mac, u8 regdomain)
 353 {
 354         int r;
 355         u8 channel;
 356
 357         ZD_ASSERT(!irqs_disabled());
 358         spin_lock_irq(&mac->lock);
 359         if (regdomain == 0) {
 360                 regdomain = mac->default_regdomain;
 361         }
 362         if (!zd_regdomain_supported(regdomain)) {
 363                 spin_unlock_irq(&mac->lock);
 364                 return -EINVAL;
 365         }
 366         mac->regdomain = regdomain;
 367         channel = mac->requested_channel;
 368         spin_unlock_irq(&mac->lock);
 369
 370         r = zd_geo_init(zd_mac_to_ieee80211(mac), regdomain);
 371         if (r)
 372                 return r;
 373         if (!zd_regdomain_supports_channel(regdomain, channel)) {
 374                 r = reset_channel(mac);
 375                 if (r)
 376                         return r;
 377         }
 378
 379         return 0;
 380 }
 381
 382 u8 zd_mac_get_regdomain(struct zd_mac *mac)
 383 {
 384         unsigned long flags;
 385         u8 regdomain;
 386
 387         spin_lock_irqsave(&mac->lock, flags);
 388         regdomain = mac->regdomain;
 389         spin_unlock_irqrestore(&mac->lock, flags);
 390         return regdomain;
 391 }
 392
 393 /* Fallback to lowest rate, if rate is unknown. */
 394 static u8 rate_to_zd_rate(u8 rate)
 395 {
 396         switch (rate) {
 397         case IEEE80211_CCK_RATE_2MB:
 398                 return ZD_CCK_RATE_2M;
 399         case IEEE80211_CCK_RATE_5MB:
 400                 return ZD_CCK_RATE_5_5M;
 401         case IEEE80211_CCK_RATE_11MB:
 402                 return ZD_CCK_RATE_11M;
 403         case IEEE80211_OFDM_RATE_6MB:
 404                 return ZD_OFDM_RATE_6M;
 405         case IEEE80211_OFDM_RATE_9MB:
 406                 return ZD_OFDM_RATE_9M;
 407         case IEEE80211_OFDM_RATE_12MB:
 408                 return ZD_OFDM_RATE_12M;
 409         case IEEE80211_OFDM_RATE_18MB:
 410                 return ZD_OFDM_RATE_18M;
 411         case IEEE80211_OFDM_RATE_24MB:
 412                 return ZD_OFDM_RATE_24M;
 413         case IEEE80211_OFDM_RATE_36MB:
 414                 return ZD_OFDM_RATE_36M;
 415         case IEEE80211_OFDM_RATE_48MB:
 416                 return ZD_OFDM_RATE_48M;
 417         case IEEE80211_OFDM_RATE_54MB:
 418                 return ZD_OFDM_RATE_54M;
 419         }
 420         return ZD_CCK_RATE_1M;
 421 }
 422
 423 static u16 rate_to_cr_rate(u8 rate)
 424 {
 425         switch (rate) {
 426         case IEEE80211_CCK_RATE_2MB:
 427                 return CR_RATE_1M;
 428         case IEEE80211_CCK_RATE_5MB:
 429                 return CR_RATE_5_5M;
 430         case IEEE80211_CCK_RATE_11MB:
 431                 return CR_RATE_11M;
 432         case IEEE80211_OFDM_RATE_6MB:
 433                 return CR_RATE_6M;
 434         case IEEE80211_OFDM_RATE_9MB:
 435                 return CR_RATE_9M;
 436         case IEEE80211_OFDM_RATE_12MB:
 437                 return CR_RATE_12M;
 438         case IEEE80211_OFDM_RATE_18MB:
 439                 return CR_RATE_18M;
 440         case IEEE80211_OFDM_RATE_24MB:
 441                 return CR_RATE_24M;
 442         case IEEE80211_OFDM_RATE_36MB:
 443                 return CR_RATE_36M;
 444         case IEEE80211_OFDM_RATE_48MB:
 445                 return CR_RATE_48M;
 446         case IEEE80211_OFDM_RATE_54MB:
 447                 return CR_RATE_54M;
 448         }
 449         return CR_RATE_1M;
 450 }
 451
 452 static void try_enable_tx(struct zd_mac *mac)
 453 {
 454         unsigned long flags;
 455
 456         spin_lock_irqsave(&mac->lock, flags);
 457         if (mac->updating_rts_rate == 0 && mac->updating_basic_rates == 0)
 458                 netif_wake_queue(mac->netdev);
 459         spin_unlock_irqrestore(&mac->lock, flags);
 460 }
 461
 462 static void set_rts_cts_work(struct work_struct *work)
 463 {
 464         struct zd_mac *mac =
 465                 container_of(work, struct zd_mac, set_rts_cts_work.work);
 466         unsigned long flags;
 467         u8 rts_rate;
 468         unsigned int short_preamble;
 469
 470         mutex_lock(&mac->chip.mutex);
 471
 472         spin_lock_irqsave(&mac->lock, flags);
 473         mac->updating_rts_rate = 0;
 474         rts_rate = mac->rts_rate;
 475         short_preamble = mac->short_preamble;
 476         spin_unlock_irqrestore(&mac->lock, flags);
 477
 478         zd_chip_set_rts_cts_rate_locked(&mac->chip, rts_rate, short_preamble);
 479         mutex_unlock(&mac->chip.mutex);
 480
 481         try_enable_tx(mac);
 482 }
 483
 484 static void set_basic_rates_work(struct work_struct *work)
 485 {
 486         struct zd_mac *mac =
 487                 container_of(work, struct zd_mac, set_basic_rates_work.work);
 488         unsigned long flags;
 489         u16 basic_rates;
 490
 491         mutex_lock(&mac->chip.mutex);
 492
 493         spin_lock_irqsave(&mac->lock, flags);
 494         mac->updating_basic_rates = 0;
 495         basic_rates = mac->basic_rates;
 496         spin_unlock_irqrestore(&mac->lock, flags);
 497
 498         zd_chip_set_basic_rates_locked(&mac->chip, basic_rates);
 499         mutex_unlock(&mac->chip.mutex);
 500
 501         try_enable_tx(mac);
 502 }
 503
 504 static void bssinfo_change(struct net_device *netdev, u32 changes)
 505 {
 506         struct zd_mac *mac = zd_netdev_mac(netdev);
 507         struct ieee80211softmac_device *softmac = ieee80211_priv(netdev);
 508         struct ieee80211softmac_bss_info *bssinfo = &softmac->bssinfo;
 509         int need_set_rts_cts = 0;
 510         int need_set_rates = 0;
 511         u16 basic_rates;
 512         unsigned long flags;
 513
 514         dev_dbg_f(zd_mac_dev(mac), "changes: %x\n", changes);
 515
 516         if (changes & IEEE80211SOFTMAC_BSSINFOCHG_SHORT_PREAMBLE) {
 517                 spin_lock_irqsave(&mac->lock, flags);
 518                 mac->short_preamble = bssinfo->short_preamble;
 519                 spin_unlock_irqrestore(&mac->lock, flags);
 520                 need_set_rts_cts = 1;
 521         }
 522
 523         if (changes & IEEE80211SOFTMAC_BSSINFOCHG_RATES) {
 524                 /* Set RTS rate to highest available basic rate */
 525                 u8 hi_rate = ieee80211softmac_highest_supported_rate(softmac,
 526                         &bssinfo->supported_rates, 1);
 527                 hi_rate = rate_to_zd_rate(hi_rate);
 528
 529                 spin_lock_irqsave(&mac->lock, flags);
 530                 if (hi_rate != mac->rts_rate) {
 531                         mac->rts_rate = hi_rate;
 532                         need_set_rts_cts = 1;
 533                 }
 534                 spin_unlock_irqrestore(&mac->lock, flags);
 535
 536                 /* Set basic rates */
 537                 need_set_rates = 1;
 538                 if (bssinfo->supported_rates.count == 0) {
 539                         /* Allow the device to be flexible */
 540                         basic_rates = CR_RATES_80211B | CR_RATES_80211G;
 541                 } else {
 542                         int i = 0;
 543                         basic_rates = 0;
 544
 545                         for (i = 0; i < bssinfo->supported_rates.count; i++) {
 546                                 u16 rate = bssinfo->supported_rates.rates[i];
 547                                 if ((rate & IEEE80211_BASIC_RATE_MASK) == 0)
 548                                         continue;
 549
 550                                 rate &= ~IEEE80211_BASIC_RATE_MASK;
 551                                 basic_rates |= rate_to_cr_rate(rate);
 552                         }
 553                 }
 554                 spin_lock_irqsave(&mac->lock, flags);
 555                 mac->basic_rates = basic_rates;
 556                 spin_unlock_irqrestore(&mac->lock, flags);
 557         }
 558
 559         /* Schedule any changes we made above */
 560
 561         spin_lock_irqsave(&mac->lock, flags);
 562         if (need_set_rts_cts && !mac->updating_rts_rate) {
 563                 mac->updating_rts_rate = 1;
 564                 netif_stop_queue(mac->netdev);
 565                 queue_delayed_work(zd_workqueue, &mac->set_rts_cts_work, 0);
 566         }
 567         if (need_set_rates && !mac->updating_basic_rates) {
 568                 mac->updating_basic_rates = 1;
 569                 netif_stop_queue(mac->netdev);
 570                 queue_delayed_work(zd_workqueue, &mac->set_basic_rates_work,
 571                                    0);
 572         }
 573         spin_unlock_irqrestore(&mac->lock, flags);
 574 }
 575
 576 static void set_channel(struct net_device *netdev, u8 channel)
 577 {
 578         struct zd_mac *mac = zd_netdev_mac(netdev);
 579
 580         dev_dbg_f(zd_mac_dev(mac), "channel %d\n", channel);
 581
 582         zd_chip_set_channel(&mac->chip, channel);
 583 }
 584
 585 int zd_mac_request_channel(struct zd_mac *mac, u8 channel)
 586 {
 587         unsigned long lock_flags;
 588         struct ieee80211_device *ieee = zd_mac_to_ieee80211(mac);
 589
 590         if (ieee->iw_mode == IW_MODE_INFRA)
 591                 return -EPERM;
 592
 593         spin_lock_irqsave(&mac->lock, lock_flags);
 594         if (!zd_regdomain_supports_channel(mac->regdomain, channel)) {
 595                 spin_unlock_irqrestore(&mac->lock, lock_flags);
 596                 return -EINVAL;
 597         }
 598         mac->requested_channel = channel;
 599         spin_unlock_irqrestore(&mac->lock, lock_flags);
 600         if (netif_running(mac->netdev))
 601                 return zd_chip_set_channel(&mac->chip, channel);
 602         else
 603                 return 0;
 604 }
 605
 606 u8 zd_mac_get_channel(struct zd_mac *mac)
 607 {
 608         u8 channel = zd_chip_get_channel(&mac->chip);
 609
 610         dev_dbg_f(zd_mac_dev(mac), "channel %u\n", channel);
 611         return channel;
 612 }
 613
 614 int zd_mac_set_mode(struct zd_mac *mac, u32 mode)
 615 {
 616         struct ieee80211_device *ieee;
 617
 618         switch (mode) {
 619         case IW_MODE_AUTO:
 620         case IW_MODE_ADHOC:
 621         case IW_MODE_INFRA:
 622                 mac->netdev->type = ARPHRD_ETHER;
 623                 break;
 624         case IW_MODE_MONITOR:
 625                 mac->netdev->type = ARPHRD_IEEE80211_RADIOTAP;
 626                 break;
 627         default:
 628                 dev_dbg_f(zd_mac_dev(mac), "wrong mode %u\n", mode);
 629                 return -EINVAL;
 630         }
 631
 632         ieee = zd_mac_to_ieee80211(mac);
 633         ZD_ASSERT(!irqs_disabled());
 634         spin_lock_irq(&ieee->lock);
 635         ieee->iw_mode = mode;
 636         spin_unlock_irq(&ieee->lock);
 637
 638         if (netif_running(mac->netdev)) {
 639                 int r = set_rx_filter(mac);
 640                 if (r)
 641                         return r;
 642                 return set_sniffer(mac);
 643         }
 644
 645         return 0;
 646 }
 647
 648 int zd_mac_get_mode(struct zd_mac *mac, u32 *mode)
 649 {
 650         unsigned long flags;
 651         struct ieee80211_device *ieee;
 652
 653         ieee = zd_mac_to_ieee80211(mac);
 654         spin_lock_irqsave(&ieee->lock, flags);
 655         *mode = ieee->iw_mode;
 656         spin_unlock_irqrestore(&ieee->lock, flags);
 657         return 0;
 658 }
 659
 660 int zd_mac_get_range(struct zd_mac *mac, struct iw_range *range)
 661 {
 662         int i;
 663         const struct channel_range *channel_range;
 664         u8 regdomain;
 665
 666         memset(range, 0, sizeof(*range));
 667
 668         /* FIXME: Not so important and depends on the mode. For 802.11g
 669          * usually this value is used. It seems to be that Bit/s number is
 670          * given here.
 671          */
 672         range->throughput = 27 * 1000 * 1000;
 673
 674         range->max_qual.qual = 100;
 675         range->max_qual.level = 100;
 676
 677         /* FIXME: Needs still to be tuned. */
 678         range->avg_qual.qual = 71;
 679         range->avg_qual.level = 80;
 680
 681         /* FIXME: depends on standard? */
 682         range->min_rts = 256;
 683         range->max_rts = 2346;
 684
 685         range->min_frag = MIN_FRAG_THRESHOLD;
 686         range->max_frag = MAX_FRAG_THRESHOLD;
 687
 688         range->max_encoding_tokens = WEP_KEYS;
 689         range->num_encoding_sizes = 2;
 690         range->encoding_size[0] = 5;
 691         range->encoding_size[1] = WEP_KEY_LEN;
 692
 693         range->we_version_compiled = WIRELESS_EXT;
 694         range->we_version_source = 20;
 695
 696         range->enc_capa = IW_ENC_CAPA_WPA |  IW_ENC_CAPA_WPA2 |
 697                           IW_ENC_CAPA_CIPHER_TKIP | IW_ENC_CAPA_CIPHER_CCMP;
 698
 699         ZD_ASSERT(!irqs_disabled());
 700         spin_lock_irq(&mac->lock);
 701         regdomain = mac->regdomain;
 702         spin_unlock_irq(&mac->lock);
 703         channel_range = zd_channel_range(regdomain);
 704
 705         range->num_channels = channel_range->end - channel_range->start;
 706         range->old_num_channels = range->num_channels;
 707         range->num_frequency = range->num_channels;
 708         range->old_num_frequency = range->num_frequency;
 709
 710         for (i = 0; i < range->num_frequency; i++) {
 711                 struct iw_freq *freq = &range->freq[i];
 712                 freq->i = channel_range->start + i;
 713                 zd_channel_to_freq(freq, freq->i);
 714         }
 715
 716         return 0;
 717 }
 718
 719 static int zd_calc_tx_length_us(u8 *service, u8 zd_rate, u16 tx_length)
 720 {
 721         /* ZD_PURE_RATE() must be used to remove the modulation type flag of
 722          * the zd-rate values. */
 723         static const u8 rate_divisor[] = {
 724                 [ZD_PURE_RATE(ZD_CCK_RATE_1M)]          =  1,
 725                 [ZD_PURE_RATE(ZD_CCK_RATE_2M)]          =  2,
 726
 727                 /* bits must be doubled */
 728                 [ZD_PURE_RATE(ZD_CCK_RATE_5_5M)]        = 11,
 729
 730                 [ZD_PURE_RATE(ZD_CCK_RATE_11M)]         = 11,
 731                 [ZD_PURE_RATE(ZD_OFDM_RATE_6M)]         =  6,
 732                 [ZD_PURE_RATE(ZD_OFDM_RATE_9M)]         =  9,
 733                 [ZD_PURE_RATE(ZD_OFDM_RATE_12M)]        = 12,
 734                 [ZD_PURE_RATE(ZD_OFDM_RATE_18M)]        = 18,
 735                 [ZD_PURE_RATE(ZD_OFDM_RATE_24M)]        = 24,
 736                 [ZD_PURE_RATE(ZD_OFDM_RATE_36M)]        = 36,
 737                 [ZD_PURE_RATE(ZD_OFDM_RATE_48M)]        = 48,
 738                 [ZD_PURE_RATE(ZD_OFDM_RATE_54M)]        = 54,
 739         };
 740
 741         u32 bits = (u32)tx_length * 8;
 742         u32 divisor;
 743
 744         divisor = rate_divisor[ZD_PURE_RATE(zd_rate)];
 745         if (divisor == 0)
 746                 return -EINVAL;
 747
 748         switch (zd_rate) {
 749         case ZD_CCK_RATE_5_5M:
 750                 bits = (2*bits) + 10; /* round up to the next integer */
 751                 break;
 752         case ZD_CCK_RATE_11M:
 753                 if (service) {
 754                         u32 t = bits % 11;
 755                         *service &= ~ZD_PLCP_SERVICE_LENGTH_EXTENSION;
 756                         if (0 < t && t <= 3) {
 757                                 *service |= ZD_PLCP_SERVICE_LENGTH_EXTENSION;
 758                         }
 759                 }
 760                 bits += 10; /* round up to the next integer */
 761                 break;
 762         }
 763
 764         return bits/divisor;
 765 }
 766
 767 static void cs_set_modulation(struct zd_mac *mac, struct zd_ctrlset *cs,
 768                               struct ieee80211_hdr_4addr *hdr)
 769 {
 770         struct ieee80211softmac_device *softmac = ieee80211_priv(mac->netdev);
 771         u16 ftype = WLAN_FC_GET_TYPE(le16_to_cpu(hdr->frame_ctl));
 772         u8 rate;
 773         int is_mgt = (ftype == IEEE80211_FTYPE_MGMT) != 0;
 774         int is_multicast = is_multicast_ether_addr(hdr->addr1);
 775         int short_preamble = ieee80211softmac_short_preamble_ok(softmac,
 776                 is_multicast, is_mgt);
 777
 778         rate = ieee80211softmac_suggest_txrate(softmac, is_multicast, is_mgt);
 779         cs->modulation = rate_to_zd_rate(rate);
 780
 781         /* Set short preamble bit when appropriate */
 782         if (short_preamble && ZD_MODULATION_TYPE(cs->modulation) == ZD_CCK
 783             && cs->modulation != ZD_CCK_RATE_1M)
 784                 cs->modulation |= ZD_CCK_PREA_SHORT;
 785 }
 786
 787 static void cs_set_control(struct zd_mac *mac, struct zd_ctrlset *cs,
 788                            struct ieee80211_hdr_4addr *header)
 789 {
 790         struct ieee80211softmac_device *softmac = ieee80211_priv(mac->netdev);
 791         unsigned int tx_length = le16_to_cpu(cs->tx_length);
 792         u16 fctl = le16_to_cpu(header->frame_ctl);
 793         u16 ftype = WLAN_FC_GET_TYPE(fctl);
 794         u16 stype = WLAN_FC_GET_STYPE(fctl);
 795
 796         /*
 797          * CONTROL TODO:
 798          * - if backoff needed, enable bit 0
 799          * - if burst (backoff not needed) disable bit 0
 800          */
 801
 802         cs->control = 0;
 803
 804         /* First fragment */
 805         if (WLAN_GET_SEQ_FRAG(le16_to_cpu(header->seq_ctl)) == 0)
 806                 cs->control |= ZD_CS_NEED_RANDOM_BACKOFF;
 807
 808         /* Multicast */
 809         if (is_multicast_ether_addr(header->addr1))
 810                 cs->control |= ZD_CS_MULTICAST;
 811
 812         /* PS-POLL */
 813         if (ftype == IEEE80211_FTYPE_CTL && stype == IEEE80211_STYPE_PSPOLL)
 814                 cs->control |= ZD_CS_PS_POLL_FRAME;
 815
 816         /* Unicast data frames over the threshold should have RTS */
 817         if (!is_multicast_ether_addr(header->addr1) &&
 818                 ftype != IEEE80211_FTYPE_MGMT &&
 819                     tx_length > zd_netdev_ieee80211(mac->netdev)->rts)
 820                 cs->control |= ZD_CS_RTS;
 821
 822         /* Use CTS-to-self protection if required */
 823         if (ZD_MODULATION_TYPE(cs->modulation) == ZD_OFDM &&
 824                         ieee80211softmac_protection_needed(softmac)) {
 825                 /* FIXME: avoid sending RTS *and* self-CTS, is that correct? */
 826                 cs->control &= ~ZD_CS_RTS;
 827                 cs->control |= ZD_CS_SELF_CTS;
 828         }
 829
 830         /* FIXME: Management frame? */
 831 }
 832
 833 static int fill_ctrlset(struct zd_mac *mac,
 834                         struct ieee80211_txb *txb,
 835                         int frag_num)
 836 {
 837         int r;
 838         struct sk_buff *skb = txb->fragments[frag_num];
 839         struct ieee80211_hdr_4addr *hdr =
 840                 (struct ieee80211_hdr_4addr *) skb->data;
 841         unsigned int frag_len = skb->len + IEEE80211_FCS_LEN;
 842         unsigned int next_frag_len;
 843         unsigned int packet_length;
 844         struct zd_ctrlset *cs = (struct zd_ctrlset *)
 845                 skb_push(skb, sizeof(struct zd_ctrlset));
 846
 847         if (frag_num+1  < txb->nr_frags) {
 848                 next_frag_len = txb->fragments[frag_num+1]->len +
 849                                 IEEE80211_FCS_LEN;
 850         } else {
 851                 next_frag_len = 0;
 852         }
 853         ZD_ASSERT(frag_len <= 0xffff);
 854         ZD_ASSERT(next_frag_len <= 0xffff);
 855
 856         cs_set_modulation(mac, cs, hdr);
 857
 858         cs->tx_length = cpu_to_le16(frag_len);
 859
 860         cs_set_control(mac, cs, hdr);
 861
 862         packet_length = frag_len + sizeof(struct zd_ctrlset) + 10;
 863         ZD_ASSERT(packet_length <= 0xffff);
 864         /* ZD1211B: Computing the length difference this way, gives us
 865          * flexibility to compute the packet length.
 866          */
 867         cs->packet_length = cpu_to_le16(zd_chip_is_zd1211b(&mac->chip) ?
 868                         packet_length - frag_len : packet_length);
 869
 870         /*
 871          * CURRENT LENGTH:
 872          * - transmit frame length in microseconds
 873          * - seems to be derived from frame length
 874          * - see Cal_Us_Service() in zdinlinef.h
 875          * - if macp->bTxBurstEnable is enabled, then multiply by 4
 876          *  - bTxBurstEnable is never set in the vendor driver
 877          *
 878          * SERVICE:
 879          * - "for PLCP configuration"
 880          * - always 0 except in some situations at 802.11b 11M
 881          * - see line 53 of zdinlinef.h
 882          */
 883         cs->service = 0;
 884         r = zd_calc_tx_length_us(&cs->service, ZD_RATE(cs->modulation),
 885                                  le16_to_cpu(cs->tx_length));
 886         if (r < 0)
 887                 return r;
 888         cs->current_length = cpu_to_le16(r);
 889
 890         if (next_frag_len == 0) {
 891                 cs->next_frame_length = 0;
 892         } else {
 893                 r = zd_calc_tx_length_us(NULL, ZD_RATE(cs->modulation),
 894                                          next_frag_len);
 895                 if (r < 0)
 896                         return r;
 897                 cs->next_frame_length = cpu_to_le16(r);
 898         }
 899
 900         return 0;
 901 }
 902
 903 static int zd_mac_tx(struct zd_mac *mac, struct ieee80211_txb *txb, int pri)
 904 {
 905         int i, r;
 906         struct ieee80211_device *ieee = zd_mac_to_ieee80211(mac);
 907
 908         for (i = 0; i < txb->nr_frags; i++) {
 909                 struct sk_buff *skb = txb->fragments[i];
 910
 911                 r = fill_ctrlset(mac, txb, i);
 912                 if (r) {
 913                         ieee->stats.tx_dropped++;
 914                         return r;
 915                 }
 916                 r = zd_usb_tx(&mac->chip.usb, skb->data, skb->len);
 917                 if (r) {
 918                         ieee->stats.tx_dropped++;
 919                         return r;
 920                 }
 921         }
 922
 923         /* FIXME: shouldn't this be handled by the upper layers? */
 924         mac->netdev->trans_start = jiffies;
 925
 926         ieee80211_txb_free(txb);
 927         return 0;
 928 }
 929
 930 struct zd_rt_hdr {
 931         struct ieee80211_radiotap_header rt_hdr;
 932         u8  rt_flags;
 933         u8  rt_rate;
 934         u16 rt_channel;
 935         u16 rt_chbitmask;
 936 } __attribute__((packed));
 937
 938 static void fill_rt_header(void *buffer, struct zd_mac *mac,
 939                            const struct ieee80211_rx_stats *stats,
 940                            const struct rx_status *status)
 941 {
 942         struct zd_rt_hdr *hdr = buffer;
 943
 944         hdr->rt_hdr.it_version = PKTHDR_RADIOTAP_VERSION;
 945         hdr->rt_hdr.it_pad = 0;
 946         hdr->rt_hdr.it_len = cpu_to_le16(sizeof(struct zd_rt_hdr));
 947         hdr->rt_hdr.it_present = cpu_to_le32((1 << IEEE80211_RADIOTAP_FLAGS) |
 948                                  (1 << IEEE80211_RADIOTAP_CHANNEL) |
 949                                  (1 << IEEE80211_RADIOTAP_RATE));
 950
 951         hdr->rt_flags = 0;
 952         if (status->decryption_type & (ZD_RX_WEP64|ZD_RX_WEP128|ZD_RX_WEP256))
 953                 hdr->rt_flags |= IEEE80211_RADIOTAP_F_WEP;
 954
 955         hdr->rt_rate = stats->rate / 5;
 956
 957         /* FIXME: 802.11a */
 958         hdr->rt_channel = cpu_to_le16(ieee80211chan2mhz(
 959                                              _zd_chip_get_channel(&mac->chip)));
 960         hdr->rt_chbitmask = cpu_to_le16(IEEE80211_CHAN_2GHZ |
 961                 ((status->frame_status & ZD_RX_FRAME_MODULATION_MASK) ==
 962                 ZD_RX_OFDM ? IEEE80211_CHAN_OFDM : IEEE80211_CHAN_CCK));
 963 }
 964
 965 /* Returns 1 if the data packet is for us and 0 otherwise. */
 966 static int is_data_packet_for_us(struct ieee80211_device *ieee,
 967                                  struct ieee80211_hdr_4addr *hdr)
 968 {
 969         struct net_device *netdev = ieee->dev;
 970         u16 fc = le16_to_cpu(hdr->frame_ctl);
 971
 972         ZD_ASSERT(WLAN_FC_GET_TYPE(fc) == IEEE80211_FTYPE_DATA);
 973
 974         switch (ieee->iw_mode) {
 975         case IW_MODE_ADHOC:
 976                 if ((fc & (IEEE80211_FCTL_TODS|IEEE80211_FCTL_FROMDS)) != 0 ||
 977                     compare_ether_addr(hdr->addr3, ieee->bssid) != 0)
 978                         return 0;
 979                 break;
 980         case IW_MODE_AUTO:
 981         case IW_MODE_INFRA:
 982                 if ((fc & (IEEE80211_FCTL_TODS|IEEE80211_FCTL_FROMDS)) !=
 983                     IEEE80211_FCTL_FROMDS ||
 984                     compare_ether_addr(hdr->addr2, ieee->bssid) != 0)
 985                         return 0;
 986                 break;
 987         default:
 988                 ZD_ASSERT(ieee->iw_mode != IW_MODE_MONITOR);
 989                 return 0;
 990         }
 991
 992         return compare_ether_addr(hdr->addr1, netdev->dev_addr) == 0 ||
 993                (is_multicast_ether_addr(hdr->addr1) &&
 994                 compare_ether_addr(hdr->addr3, netdev->dev_addr) != 0) ||
 995                (netdev->flags & IFF_PROMISC);
 996 }
 997
 998 /* Filters received packets. The function returns 1 if the packet should be
 999  * forwarded to ieee80211_rx(). If the packet should be ignored the function
1000  * returns 0. If an invalid packet is found the function returns -EINVAL.
1001  *
1002  * The function calls ieee80211_rx_mgt() directly.
1003  *
1004  * It has been based on ieee80211_rx_any.
1005  */
1006 static int filter_rx(struct ieee80211_device *ieee,
1007                      const u8 *buffer, unsigned int length,
1008                      struct ieee80211_rx_stats *stats)
1009 {
1010         struct ieee80211_hdr_4addr *hdr;
1011         u16 fc;
1012
1013         if (ieee->iw_mode == IW_MODE_MONITOR)
1014                 return 1;
1015
1016         hdr = (struct ieee80211_hdr_4addr *)buffer;
1017         fc = le16_to_cpu(hdr->frame_ctl);
1018         if ((fc & IEEE80211_FCTL_VERS) != 0)
1019                 return -EINVAL;
1020
1021         switch (WLAN_FC_GET_TYPE(fc)) {
1022         case IEEE80211_FTYPE_MGMT:
1023                 if (length < sizeof(struct ieee80211_hdr_3addr))
1024                         return -EINVAL;
1025                 ieee80211_rx_mgt(ieee, hdr, stats);
1026                 return 0;
1027         case IEEE80211_FTYPE_CTL:
1028                 return 0;
1029         case IEEE80211_FTYPE_DATA:
1030                 /* Ignore invalid short buffers */
1031                 if (length < sizeof(struct ieee80211_hdr_3addr))
1032                         return -EINVAL;
1033                 return is_data_packet_for_us(ieee, hdr);
1034         }
1035
1036         return -EINVAL;
1037 }
1038
1039 static void update_qual_rssi(struct zd_mac *mac,
1040                              const u8 *buffer, unsigned int length,
1041                              u8 qual_percent, u8 rssi_percent)
1042 {
1043         unsigned long flags;
1044         struct ieee80211_hdr_3addr *hdr;
1045         int i;
1046
1047         hdr = (struct ieee80211_hdr_3addr *)buffer;
1048         if (length < offsetof(struct ieee80211_hdr_3addr, addr3))
1049                 return;
1050         if (compare_ether_addr(hdr->addr2, zd_mac_to_ieee80211(mac)->bssid) != 0)
1051                 return;
1052
1053         spin_lock_irqsave(&mac->lock, flags);
1054         i = mac->stats_count % ZD_MAC_STATS_BUFFER_SIZE;
1055         mac->qual_buffer[i] = qual_percent;
1056         mac->rssi_buffer[i] = rssi_percent;
1057         mac->stats_count++;
1058         spin_unlock_irqrestore(&mac->lock, flags);
1059 }
1060
1061 static int fill_rx_stats(struct ieee80211_rx_stats *stats,
1062                          const struct rx_status **pstatus,
1063                          struct zd_mac *mac,
1064                          const u8 *buffer, unsigned int length)
1065 {
1066         const struct rx_status *status;
1067
1068         *pstatus = status = (struct rx_status *)
1069                 (buffer + (length - sizeof(struct rx_status)));
1070         if (status->frame_status & ZD_RX_ERROR) {
1071                 struct ieee80211_device *ieee = zd_mac_to_ieee80211(mac);
1072                 ieee->stats.rx_errors++;
1073                 if (status->frame_status & ZD_RX_TIMEOUT_ERROR)
1074                         ieee->stats.rx_missed_errors++;
1075                 else if (status->frame_status & ZD_RX_FIFO_OVERRUN_ERROR)
1076                         ieee->stats.rx_fifo_errors++;
1077                 else if (status->frame_status & ZD_RX_DECRYPTION_ERROR)
1078                         ieee->ieee_stats.rx_discards_undecryptable++;
1079                 else if (status->frame_status & ZD_RX_CRC32_ERROR) {
1080                         ieee->stats.rx_crc_errors++;
1081                         ieee->ieee_stats.rx_fcs_errors++;
1082                 }
1083                 else if (status->frame_status & ZD_RX_CRC16_ERROR)
1084                         ieee->stats.rx_crc_errors++;
1085                 return -EINVAL;
1086         }
1087
1088         memset(stats, 0, sizeof(struct ieee80211_rx_stats));
1089         stats->len = length - (ZD_PLCP_HEADER_SIZE + IEEE80211_FCS_LEN +
1090                                + sizeof(struct rx_status));
1091         /* FIXME: 802.11a */
1092         stats->freq = IEEE80211_24GHZ_BAND;
1093         stats->received_channel = _zd_chip_get_channel(&mac->chip);
1094         stats->rssi = zd_rx_strength_percent(status->signal_strength);
1095         stats->signal = zd_rx_qual_percent(buffer,
1096                                           length - sizeof(struct rx_status),
1097                                           status);
1098         stats->mask = IEEE80211_STATMASK_RSSI | IEEE80211_STATMASK_SIGNAL;
1099         stats->rate = zd_rx_rate(buffer, status);
1100         if (stats->rate)
1101                 stats->mask |= IEEE80211_STATMASK_RATE;
1102
1103         return 0;
1104 }
1105
1106 static void zd_mac_rx(struct zd_mac *mac, struct sk_buff *skb)
1107 {
1108         int r;
1109         struct ieee80211_device *ieee = zd_mac_to_ieee80211(mac);
1110         struct ieee80211_rx_stats stats;
1111         const struct rx_status *status;
1112
1113         if (skb->len < ZD_PLCP_HEADER_SIZE + IEEE80211_1ADDR_LEN +
1114                        IEEE80211_FCS_LEN + sizeof(struct rx_status))
1115         {
1116                 ieee->stats.rx_errors++;
1117                 ieee->stats.rx_length_errors++;
1118                 goto free_skb;
1119         }
1120
1121         r = fill_rx_stats(&stats, &status, mac, skb->data, skb->len);
1122         if (r) {
1123                 /* Only packets with rx errors are included here.
1124                  * The error stats have already been set in fill_rx_stats.
1125                  */
1126                 goto free_skb;
1127         }
1128
1129         __skb_pull(skb, ZD_PLCP_HEADER_SIZE);
1130         __skb_trim(skb, skb->len -
1131                         (IEEE80211_FCS_LEN + sizeof(struct rx_status)));
1132
1133         ZD_ASSERT(IS_ALIGNED((unsigned long)skb->data, 4));
1134
1135         update_qual_rssi(mac, skb->data, skb->len, stats.signal,
1136                          status->signal_strength);
1137
1138         r = filter_rx(ieee, skb->data, skb->len, &stats);
1139         if (r <= 0) {
1140                 if (r < 0) {
1141                         ieee->stats.rx_errors++;
1142                         dev_dbg_f(zd_mac_dev(mac), "Error in packet.\n");
1143                 }
1144                 goto free_skb;
1145         }
1146
1147         if (ieee->iw_mode == IW_MODE_MONITOR)
1148                 fill_rt_header(skb_push(skb, sizeof(struct zd_rt_hdr)), mac,
1149                                &stats, status);
1150
1151         r = ieee80211_rx(ieee, skb, &stats);
1152         if (r)
1153                 return;
1154 free_skb:
1155         /* We are always in a soft irq. */
1156         dev_kfree_skb(skb);
1157 }
1158
1159 static void do_rx(unsigned long mac_ptr)
1160 {
1161         struct zd_mac *mac = (struct zd_mac *)mac_ptr;
1162         struct sk_buff *skb;
1163
1164         while ((skb = skb_dequeue(&mac->rx_queue)) != NULL)
1165                 zd_mac_rx(mac, skb);
1166 }
1167
1168 int zd_mac_rx_irq(struct zd_mac *mac, const u8 *buffer, unsigned int length)
1169 {
1170         struct sk_buff *skb;
1171         unsigned int reserved =
1172                 ALIGN(max_t(unsigned int,
1173                             sizeof(struct zd_rt_hdr), ZD_PLCP_HEADER_SIZE), 4) -
1174                 ZD_PLCP_HEADER_SIZE;
1175
1176         skb = dev_alloc_skb(reserved + length);
1177         if (!skb) {
1178                 struct ieee80211_device *ieee = zd_mac_to_ieee80211(mac);
1179                 dev_warn(zd_mac_dev(mac), "Could not allocate skb.\n");
1180                 ieee->stats.rx_dropped++;
1181                 return -ENOMEM;
1182         }
1183         skb_reserve(skb, reserved);
1184         memcpy(__skb_put(skb, length), buffer, length);
1185         skb_queue_tail(&mac->rx_queue, skb);
1186         tasklet_schedule(&mac->rx_tasklet);
1187         return 0;
1188 }
1189
1190 static int netdev_tx(struct ieee80211_txb *txb, struct net_device *netdev,
1191                      int pri)
1192 {
1193         return zd_mac_tx(zd_netdev_mac(netdev), txb, pri);
1194 }
1195
1196 static void set_security(struct net_device *netdev,
1197                          struct ieee80211_security *sec)
1198 {
1199         struct ieee80211_device *ieee = zd_netdev_ieee80211(netdev);
1200         struct ieee80211_security *secinfo = &ieee->sec;
1201         int keyidx;
1202
1203         dev_dbg_f(zd_mac_dev(zd_netdev_mac(netdev)), "\n");
1204
1205         for (keyidx = 0; keyidx<WEP_KEYS; keyidx++)
1206                 if (sec->flags & (1<<keyidx)) {
1207                         secinfo->encode_alg[keyidx] = sec->encode_alg[keyidx];
1208                         secinfo->key_sizes[keyidx] = sec->key_sizes[keyidx];
1209                         memcpy(secinfo->keys[keyidx], sec->keys[keyidx],
1210                                SCM_KEY_LEN);
1211                 }
1212
1213         if (sec->flags & SEC_ACTIVE_KEY) {
1214                 secinfo->active_key = sec->active_key;
1215                 dev_dbg_f(zd_mac_dev(zd_netdev_mac(netdev)),
1216                         "   .active_key = %d\n", sec->active_key);
1217         }
1218         if (sec->flags & SEC_UNICAST_GROUP) {
1219                 secinfo->unicast_uses_group = sec->unicast_uses_group;
1220                 dev_dbg_f(zd_mac_dev(zd_netdev_mac(netdev)),
1221                         "   .unicast_uses_group = %d\n",
1222                         sec->unicast_uses_group);
1223         }
1224         if (sec->flags & SEC_LEVEL) {
1225                 secinfo->level = sec->level;
1226                 dev_dbg_f(zd_mac_dev(zd_netdev_mac(netdev)),
1227                         "   .level = %d\n", sec->level);
1228         }
1229         if (sec->flags & SEC_ENABLED) {
1230                 secinfo->enabled = sec->enabled;
1231                 dev_dbg_f(zd_mac_dev(zd_netdev_mac(netdev)),
1232                         "   .enabled = %d\n", sec->enabled);
1233         }
1234         if (sec->flags & SEC_ENCRYPT) {
1235                 secinfo->encrypt = sec->encrypt;
1236                 dev_dbg_f(zd_mac_dev(zd_netdev_mac(netdev)),
1237                         "   .encrypt = %d\n", sec->encrypt);
1238         }
1239         if (sec->flags & SEC_AUTH_MODE) {
1240                 secinfo->auth_mode = sec->auth_mode;
1241                 dev_dbg_f(zd_mac_dev(zd_netdev_mac(netdev)),
1242                         "   .auth_mode = %d\n", sec->auth_mode);
1243         }
1244 }
1245
1246 static void ieee_init(struct ieee80211_device *ieee)
1247 {
1248         ieee->mode = IEEE_B | IEEE_G;
1249         ieee->freq_band = IEEE80211_24GHZ_BAND;
1250         ieee->modulation = IEEE80211_OFDM_MODULATION | IEEE80211_CCK_MODULATION;
1251         ieee->tx_headroom = sizeof(struct zd_ctrlset);
1252         ieee->set_security = set_security;
1253         ieee->hard_start_xmit = netdev_tx;
1254
1255         /* Software encryption/decryption for now */
1256         ieee->host_build_iv = 0;
1257         ieee->host_encrypt = 1;
1258         ieee->host_decrypt = 1;
1259
1260         /* FIXME: default to managed mode, until ieee80211 and zd1211rw can
1261          * correctly support AUTO */
1262         ieee->iw_mode = IW_MODE_INFRA;
1263 }
1264
1265 static void softmac_init(struct ieee80211softmac_device *sm)
1266 {
1267         sm->set_channel = set_channel;
1268         sm->bssinfo_change = bssinfo_change;
1269 }
1270
1271 struct iw_statistics *zd_mac_get_wireless_stats(struct net_device *ndev)
1272 {
1273         struct zd_mac *mac = zd_netdev_mac(ndev);
1274         struct iw_statistics *iw_stats = &mac->iw_stats;
1275         unsigned int i, count, qual_total, rssi_total;
1276
1277         memset(iw_stats, 0, sizeof(struct iw_statistics));
1278         /* We are not setting the status, because ieee->state is not updated
1279          * at all and this driver doesn't track authentication state.
1280          */
1281         spin_lock_irq(&mac->lock);
1282         count = mac->stats_count < ZD_MAC_STATS_BUFFER_SIZE ?
1283                 mac->stats_count : ZD_MAC_STATS_BUFFER_SIZE;
1284         qual_total = rssi_total = 0;
1285         for (i = 0; i < count; i++) {
1286                 qual_total += mac->qual_buffer[i];
1287                 rssi_total += mac->rssi_buffer[i];
1288         }
1289         spin_unlock_irq(&mac->lock);
1290         iw_stats->qual.updated = IW_QUAL_NOISE_INVALID;
1291         if (count > 0) {
1292                 iw_stats->qual.qual = qual_total / count;
1293                 iw_stats->qual.level = rssi_total / count;
1294                 iw_stats->qual.updated |=
1295                         IW_QUAL_QUAL_UPDATED|IW_QUAL_LEVEL_UPDATED;
1296         } else {
1297                 iw_stats->qual.updated |=
1298                         IW_QUAL_QUAL_INVALID|IW_QUAL_LEVEL_INVALID;
1299         }
1300         /* TODO: update counter */
1301         return iw_stats;
1302 }
1303
1304 #define LINK_LED_WORK_DELAY HZ
1305
1306 static void link_led_handler(struct work_struct *work)
1307 {
1308         struct zd_mac *mac =
1309                 container_of(work, struct zd_mac, housekeeping.link_led_work.work);
1310         struct zd_chip *chip = &mac->chip;
1311         struct ieee80211softmac_device *sm = ieee80211_priv(mac->netdev);
1312         int is_associated;
1313         int r;
1314
1315         spin_lock_irq(&mac->lock);
1316         is_associated = sm->associnfo.associated != 0;
1317         spin_unlock_irq(&mac->lock);
1318
1319         r = zd_chip_control_leds(chip,
1320                                  is_associated ? LED_ASSOCIATED : LED_SCANNING);
1321         if (r)
1322                 dev_err(zd_mac_dev(mac), "zd_chip_control_leds error %d\n", r);
1323
1324         queue_delayed_work(zd_workqueue, &mac->housekeeping.link_led_work,
1325                            LINK_LED_WORK_DELAY);
1326 }
1327
1328 static void housekeeping_init(struct zd_mac *mac)
1329 {
1330         INIT_DELAYED_WORK(&mac->housekeeping.link_led_work, link_led_handler);
1331 }
1332
1333 static void housekeeping_enable(struct zd_mac *mac)
1334 {
1335         dev_dbg_f(zd_mac_dev(mac), "\n");
1336         queue_delayed_work(zd_workqueue, &mac->housekeeping.link_led_work,
1337                            0);
1338 }
1339
1340 static void housekeeping_disable(struct zd_mac *mac)
1341 {
1342         dev_dbg_f(zd_mac_dev(mac), "\n");
1343         cancel_rearming_delayed_workqueue(zd_workqueue,
1344                 &mac->housekeeping.link_led_work);
1345         zd_chip_control_leds(&mac->chip, LED_OFF);
1346 }