git.oblomov.eu Git - linux-2.6/blob - drivers/staging/agnx/pci.c

   1 /**
   2  * Airgo MIMO wireless driver
   3  *
   4  * Copyright (c) 2007 Li YanBo <dreamfly281@gmail.com>
   5
   6  * Thanks for Jeff Williams <angelbane@gmail.com> do reverse engineer
   7  * works and published the SPECS at http://airgo.wdwconsulting.net/mymoin
   8
   9  * This program is free software; you can redistribute it and/or modify
  10  * it under the terms of the GNU General Public License version 2 as
  11  * published by the Free Software Foundation.
  12  */
  13
  14 #include <linux/init.h>
  15 #include <linux/etherdevice.h>
  16 #include <linux/pci.h>
  17 #include <linux/delay.h>
  18
  19 #include "agnx.h"
  20 #include "debug.h"
  21 #include "xmit.h"
  22 #include "phy.h"
  23
  24 MODULE_AUTHOR("Li YanBo <dreamfly281@gmail.com>");
  25 MODULE_DESCRIPTION("Airgo MIMO PCI wireless driver");
  26 MODULE_LICENSE("GPL");
  27
  28 static struct pci_device_id agnx_pci_id_tbl[] __devinitdata = {
  29         { PCI_DEVICE(0x17cb, 0x0001) }, /* Beklin F5d8010, Netgear WGM511 etc */
  30         { PCI_DEVICE(0x17cb, 0x0002) }, /* Netgear Wpnt511 */
  31         { 0 }
  32 };
  33
  34 MODULE_DEVICE_TABLE(pci, agnx_pci_id_tbl);
  35
  36
  37 static inline void agnx_interrupt_ack(struct agnx_priv *priv, u32 *reason)
  38 {
  39         void __iomem *ctl = priv->ctl;
  40         u32 reg;
  41
  42         if (*reason & AGNX_STAT_RX) {
  43                 /* Mark complete RX */
  44                 reg = ioread32(ctl + AGNX_CIR_RXCTL);
  45                 reg |= 0x4;
  46                 iowrite32(reg, ctl + AGNX_CIR_RXCTL);
  47                 /* disable Rx interrupt */
  48         }
  49         if (*reason & AGNX_STAT_TX) {
  50                 reg = ioread32(ctl + AGNX_CIR_TXDCTL);
  51                 if (reg & 0x4) {
  52                         iowrite32(reg, ctl + AGNX_CIR_TXDCTL);
  53                         *reason |= AGNX_STAT_TXD;
  54                 }
  55                 reg = ioread32(ctl + AGNX_CIR_TXMCTL);
  56                 if (reg & 0x4) {
  57                         iowrite32(reg, ctl + AGNX_CIR_TXMCTL);
  58                         *reason |= AGNX_STAT_TXM;
  59                 }
  60         }
  61 /*      if (*reason & AGNX_STAT_X) {
  62                 reg = ioread32(ctl + AGNX_INT_STAT);
  63                 iowrite32(reg, ctl + AGNX_INT_STAT);
  64                 /* FIXME reinit interrupt mask *\/
  65                 reg = 0xc390bf9 & ~IRQ_TX_BEACON;
  66                 reg &= ~IRQ_TX_DISABLE;
  67                 iowrite32(reg, ctl + AGNX_INT_MASK);
  68                 iowrite32(0x800, ctl + AGNX_CIR_BLKCTL);
  69         } */
  70 } /* agnx_interrupt_ack */
  71
  72 static irqreturn_t agnx_interrupt_handler(int irq, void *dev_id)
  73 {
  74         struct ieee80211_hw *dev = dev_id;
  75         struct agnx_priv *priv = dev->priv;
  76         void __iomem *ctl = priv->ctl;
  77         irqreturn_t ret = IRQ_NONE;
  78         u32 irq_reason;
  79
  80         spin_lock(&priv->lock);
  81
  82 /*      printk(KERN_ERR PFX "Get a interrupt %s\n", __func__); */
  83
  84         if (priv->init_status != AGNX_START)
  85                 goto out;
  86
  87         /* FiXME  Here has no lock, Is this will lead to race? */
  88         irq_reason = ioread32(ctl + AGNX_CIR_BLKCTL);
  89         if (!(irq_reason & 0x7))
  90                 goto out;
  91
  92         ret = IRQ_HANDLED;
  93         priv->irq_status = ioread32(ctl + AGNX_INT_STAT);
  94
  95 /*      printk(PFX "Interrupt reason is 0x%x\n", irq_reason); */
  96         /* Make sure the txm and txd flags don't conflict with other unknown
  97            interrupt flag, maybe is not necessary */
  98         irq_reason &= 0xF;
  99
 100         disable_rx_interrupt(priv);
 101         /* TODO Make sure the card finished initialized */
 102         agnx_interrupt_ack(priv, &irq_reason);
 103
 104         if (irq_reason & AGNX_STAT_RX)
 105                 handle_rx_irq(priv);
 106         if (irq_reason & AGNX_STAT_TXD)
 107                 handle_txd_irq(priv);
 108         if (irq_reason & AGNX_STAT_TXM)
 109                 handle_txm_irq(priv);
 110         if (irq_reason & AGNX_STAT_X)
 111                 handle_other_irq(priv);
 112
 113         enable_rx_interrupt(priv);
 114 out:
 115         spin_unlock(&priv->lock);
 116         return ret;
 117 } /* agnx_interrupt_handler */
 118
 119
 120 /* FIXME */
 121 static int agnx_tx(struct ieee80211_hw *dev, struct sk_buff *skb)
 122 {
 123         AGNX_TRACE;
 124         return _agnx_tx(dev->priv, skb);
 125 } /* agnx_tx */
 126
 127
 128 static int agnx_get_mac_address(struct agnx_priv *priv)
 129 {
 130         void __iomem *ctl = priv->ctl;
 131         u32 reg;
 132         AGNX_TRACE;
 133
 134         /* Attention! directly read the MAC or other date from EEPROM will
 135          lead to cardbus(WGM511) lock up when write to PM PLL register */
 136         reg = agnx_read32(ctl, 0x3544);
 137         udelay(40);
 138         reg = agnx_read32(ctl, 0x354c);
 139         udelay(50);
 140         /* Get the mac address */
 141         reg = agnx_read32(ctl, 0x3544);
 142         udelay(40);
 143
 144         /* HACK */
 145         reg = cpu_to_le32(reg);
 146         priv->mac_addr[0] = ((u8 *)&reg)[2];
 147         priv->mac_addr[1] = ((u8 *)&reg)[3];
 148         reg = agnx_read32(ctl, 0x3548);
 149         udelay(50);
 150         *((u32 *)(priv->mac_addr + 2)) = cpu_to_le32(reg);
 151
 152         if (!is_valid_ether_addr(priv->mac_addr)) {
 153                 DECLARE_MAC_BUF(mbuf);
 154                 printk(KERN_WARNING PFX "read mac %s\n", print_mac(mbuf, priv->mac_addr));
 155                 printk(KERN_WARNING PFX "Invalid hwaddr! Using random hwaddr\n");
 156                 random_ether_addr(priv->mac_addr);
 157         }
 158
 159         return 0;
 160 } /* agnx_get_mac_address */
 161
 162 static int agnx_alloc_rings(struct agnx_priv *priv)
 163 {
 164         unsigned int len;
 165         AGNX_TRACE;
 166
 167         /* Allocate RX/TXM/TXD rings info */
 168         priv->rx.size = AGNX_RX_RING_SIZE;
 169         priv->txm.size = AGNX_TXM_RING_SIZE;
 170         priv->txd.size = AGNX_TXD_RING_SIZE;
 171
 172         len = priv->rx.size + priv->txm.size + priv->txd.size;
 173
 174 /*      priv->rx.info = kzalloc(sizeof(struct agnx_info) * len, GFP_KERNEL); */
 175         priv->rx.info = kzalloc(sizeof(struct agnx_info) * len, GFP_ATOMIC);
 176         if (!priv->rx.info)
 177                 return -ENOMEM;
 178         priv->txm.info = priv->rx.info + priv->rx.size;
 179         priv->txd.info = priv->txm.info + priv->txm.size;
 180
 181         /* Allocate RX/TXM/TXD descriptors */
 182         priv->rx.desc = pci_alloc_consistent(priv->pdev, sizeof(struct agnx_desc) * len,
 183                                              &priv->rx.dma);
 184         if (!priv->rx.desc) {
 185                 kfree(priv->rx.info);
 186                 return -ENOMEM;
 187         }
 188
 189         priv->txm.desc = priv->rx.desc + priv->rx.size;
 190         priv->txm.dma = priv->rx.dma + sizeof(struct agnx_desc) * priv->rx.size;
 191         priv->txd.desc = priv->txm.desc + priv->txm.size;
 192         priv->txd.dma = priv->txm.dma + sizeof(struct agnx_desc) * priv->txm.size;
 193
 194         return 0;
 195 } /* agnx_alloc_rings */
 196
 197 static void rings_free(struct agnx_priv *priv)
 198 {
 199         unsigned int len = priv->rx.size + priv->txm.size + priv->txd.size;
 200         unsigned long flags;
 201         AGNX_TRACE;
 202
 203         spin_lock_irqsave(&priv->lock, flags);
 204         kfree(priv->rx.info);
 205         pci_free_consistent(priv->pdev, sizeof(struct agnx_desc) * len,
 206                             priv->rx.desc, priv->rx.dma);
 207         spin_unlock_irqrestore(&priv->lock, flags);
 208 }
 209
 210 #if 0
 211 static void agnx_periodic_work_handler(struct work_struct *work)
 212 {
 213         struct agnx_priv *priv = container_of(work, struct agnx_priv, periodic_work.work);
 214 /*      unsigned long flags; */
 215         unsigned long delay;
 216
 217         /* fixme: using mutex?? */
 218 /*      spin_lock_irqsave(&priv->lock, flags); */
 219
 220         /* TODO Recalibrate*/
 221 /*      calibrate_oscillator(priv); */
 222 /*      antenna_calibrate(priv); */
 223 /*      agnx_send_packet(priv, 997); /
 224         /* FIXME */
 225 /*      if (debug == 3) */
 226 /*                 delay = msecs_to_jiffies(AGNX_PERIODIC_DELAY); */
 227 /*      else */
 228         delay = msecs_to_jiffies(AGNX_PERIODIC_DELAY);
 229 /*      delay = round_jiffies(HZ * 15); */
 230
 231         queue_delayed_work(priv->hw->workqueue, &priv->periodic_work, delay);
 232
 233 /*      spin_unlock_irqrestore(&priv->lock, flags); */
 234 }
 235 #endif
 236
 237 static int agnx_start(struct ieee80211_hw *dev)
 238 {
 239         struct agnx_priv *priv = dev->priv;
 240         /* unsigned long delay; */
 241         int err = 0;
 242         AGNX_TRACE;
 243
 244         err = agnx_alloc_rings(priv);
 245         if (err) {
 246                 printk(KERN_ERR PFX "Can't alloc RX/TXM/TXD rings\n");
 247                 goto out;
 248         }
 249         err = request_irq(priv->pdev->irq, &agnx_interrupt_handler,
 250                           IRQF_SHARED, "agnx_pci", dev);
 251         if (err) {
 252                 printk(KERN_ERR PFX "Failed to register IRQ handler\n");
 253                 rings_free(priv);
 254                 goto out;
 255         }
 256
 257 /*      mdelay(500); */
 258
 259         might_sleep();
 260         agnx_hw_init(priv);
 261
 262 /*      mdelay(500); */
 263         might_sleep();
 264
 265         priv->init_status = AGNX_START;
 266 /*         INIT_DELAYED_WORK(&priv->periodic_work, agnx_periodic_work_handler); */
 267 /*      delay = msecs_to_jiffies(AGNX_PERIODIC_DELAY); */
 268 /*         queue_delayed_work(priv->hw->workqueue, &priv->periodic_work, delay); */
 269 out:
 270         return err;
 271 } /* agnx_start */
 272
 273 static void agnx_stop(struct ieee80211_hw *dev)
 274 {
 275         struct agnx_priv *priv = dev->priv;
 276         AGNX_TRACE;
 277
 278         priv->init_status = AGNX_STOP;
 279         /* make sure hardware will not generate irq */
 280         agnx_hw_reset(priv);
 281         free_irq(priv->pdev->irq, dev);
 282         flush_workqueue(priv->hw->workqueue);
 283 /*      cancel_delayed_work_sync(&priv->periodic_work); */
 284         unfill_rings(priv);
 285         rings_free(priv);
 286 }
 287
 288 static int agnx_config(struct ieee80211_hw *dev, u32 changed)
 289 {
 290         struct agnx_priv *priv = dev->priv;
 291         struct ieee80211_conf *conf = &dev->conf;
 292         int channel = ieee80211_frequency_to_channel(conf->channel->center_freq);
 293         AGNX_TRACE;
 294
 295         spin_lock(&priv->lock);
 296         /* FIXME need priv lock? */
 297         if (channel != priv->channel) {
 298                 priv->channel = channel;
 299                 agnx_set_channel(priv, priv->channel);
 300         }
 301
 302         spin_unlock(&priv->lock);
 303         return 0;
 304 }
 305
 306 static void agnx_bss_info_changed(struct ieee80211_hw *dev,
 307                                   struct ieee80211_vif *vif,
 308                                   struct ieee80211_bss_conf *conf,
 309                                   u32 changed)
 310 {
 311         struct agnx_priv *priv = dev->priv;
 312         void __iomem *ctl = priv->ctl;
 313         AGNX_TRACE;
 314
 315         if (!(changed & BSS_CHANGED_BSSID))
 316                 return;
 317
 318         spin_lock(&priv->lock);
 319
 320         if (memcmp(conf->bssid, priv->bssid, ETH_ALEN)) {
 321                 agnx_set_bssid(priv, conf->bssid);
 322                 memcpy(priv->bssid, conf->bssid, ETH_ALEN);
 323                 hash_write(priv, conf->bssid, BSSID_STAID);
 324                 sta_init(priv, BSSID_STAID);
 325                 /* FIXME needed? */
 326                 sta_power_init(priv, BSSID_STAID);
 327                 agnx_write32(ctl, AGNX_BM_MTSM, 0xff & ~0x1);
 328         }
 329         spin_unlock(&priv->lock);
 330 } /* agnx_bss_info_changed */
 331
 332
 333 static void agnx_configure_filter(struct ieee80211_hw *dev,
 334                                   unsigned int changed_flags,
 335                                   unsigned int *total_flags,
 336                                   int mc_count, struct dev_mc_list *mclist)
 337 {
 338         unsigned int new_flags = 0;
 339
 340         *total_flags = new_flags;
 341         /* TODO */
 342 }
 343
 344 static int agnx_add_interface(struct ieee80211_hw *dev,
 345                               struct ieee80211_if_init_conf *conf)
 346 {
 347         struct agnx_priv *priv = dev->priv;
 348         AGNX_TRACE;
 349
 350         spin_lock(&priv->lock);
 351         /* FIXME */
 352         if (priv->mode != NL80211_IFTYPE_MONITOR)
 353                 return -EOPNOTSUPP;
 354
 355         switch (conf->type) {
 356         case NL80211_IFTYPE_STATION:
 357                 priv->mode = conf->type;
 358                 break;
 359         default:
 360                 return -EOPNOTSUPP;
 361         }
 362
 363         spin_unlock(&priv->lock);
 364
 365         return 0;
 366 }
 367
 368 static void agnx_remove_interface(struct ieee80211_hw *dev,
 369                                   struct ieee80211_if_init_conf *conf)
 370 {
 371         struct agnx_priv *priv = dev->priv;
 372         AGNX_TRACE;
 373
 374         /* TODO */
 375         priv->mode = NL80211_IFTYPE_MONITOR;
 376 }
 377
 378 static int agnx_get_stats(struct ieee80211_hw *dev,
 379                           struct ieee80211_low_level_stats *stats)
 380 {
 381         struct agnx_priv *priv = dev->priv;
 382         AGNX_TRACE;
 383         spin_lock(&priv->lock);
 384         /* TODO !! */
 385         memcpy(stats, &priv->stats, sizeof(*stats));
 386         spin_unlock(&priv->lock);
 387
 388         return 0;
 389 }
 390
 391 static u64 agnx_get_tsft(struct ieee80211_hw *dev)
 392 {
 393         void __iomem *ctl = ((struct agnx_priv *)dev->priv)->ctl;
 394         u32 tsftl;
 395         u64 tsft;
 396         AGNX_TRACE;
 397
 398         /* FIXME */
 399         tsftl = ioread32(ctl + AGNX_TXM_TIMESTAMPLO);
 400         tsft = ioread32(ctl + AGNX_TXM_TIMESTAMPHI);
 401         tsft <<= 32;
 402         tsft |= tsftl;
 403
 404         return tsft;
 405 }
 406
 407 static int agnx_get_tx_stats(struct ieee80211_hw *dev,
 408                              struct ieee80211_tx_queue_stats *stats)
 409 {
 410         struct agnx_priv *priv = dev->priv;
 411         AGNX_TRACE;
 412
 413         /* FIXME now we just using txd queue, but should using txm queue too */
 414         stats[0].len = (priv->txd.idx - priv->txd.idx_sent) / 2;
 415         stats[0].limit = priv->txd.size - 2;
 416         stats[0].count = priv->txd.idx / 2;
 417
 418         return 0;
 419 }
 420
 421 static struct ieee80211_ops agnx_ops = {
 422         .tx                     = agnx_tx,
 423         .start                  = agnx_start,
 424         .stop                   = agnx_stop,
 425         .add_interface          = agnx_add_interface,
 426         .remove_interface       = agnx_remove_interface,
 427         .config                 = agnx_config,
 428         .bss_info_changed       = agnx_bss_info_changed,
 429         .configure_filter       = agnx_configure_filter,
 430         .get_stats              = agnx_get_stats,
 431         .get_tx_stats           = agnx_get_tx_stats,
 432         .get_tsf                = agnx_get_tsft
 433 };
 434
 435 static void __devexit agnx_pci_remove(struct pci_dev *pdev)
 436 {
 437         struct ieee80211_hw *dev = pci_get_drvdata(pdev);
 438         struct agnx_priv *priv;
 439         AGNX_TRACE;
 440
 441         if (!dev)
 442                 return;
 443         priv = dev->priv;
 444         ieee80211_unregister_hw(dev);
 445         pci_iounmap(pdev, priv->ctl);
 446         pci_iounmap(pdev, priv->data);
 447         pci_release_regions(pdev);
 448         pci_disable_device(pdev);
 449
 450         ieee80211_free_hw(dev);
 451 }
 452
 453 static int __devinit agnx_pci_probe(struct pci_dev *pdev,
 454                                     const struct pci_device_id *id)
 455 {
 456         struct ieee80211_hw *dev;
 457         struct agnx_priv *priv;
 458         u32 mem_addr0, mem_len0;
 459         u32 mem_addr1, mem_len1;
 460         int err;
 461         DECLARE_MAC_BUF(mac);
 462
 463         err = pci_enable_device(pdev);
 464         if (err) {
 465                 printk(KERN_ERR PFX "Can't enable new PCI device\n");
 466                 return err;
 467         }
 468
 469         /* get pci resource */
 470         mem_addr0 = pci_resource_start(pdev, 0);
 471         mem_len0 = pci_resource_len(pdev, 0);
 472         mem_addr1 = pci_resource_start(pdev, 1);
 473         mem_len1 = pci_resource_len(pdev, 1);
 474         printk(KERN_DEBUG PFX "Memaddr0 is %x, length is %x\n", mem_addr0, mem_len0);
 475         printk(KERN_DEBUG PFX "Memaddr1 is %x, length is %x\n", mem_addr1, mem_len1);
 476
 477         err = pci_request_regions(pdev, "agnx-pci");
 478         if (err) {
 479                 printk(KERN_ERR PFX "Can't obtain PCI resource\n");
 480                 return err;
 481         }
 482
 483         if (pci_set_dma_mask(pdev, DMA_BIT_MASK(32)) ||
 484             pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(32))) {
 485                 printk(KERN_ERR PFX "No suitable DMA available\n");
 486                 goto err_free_reg;
 487         }
 488
 489         pci_set_master(pdev);
 490         printk(KERN_DEBUG PFX "pdev->irq is %d\n", pdev->irq);
 491
 492         dev = ieee80211_alloc_hw(sizeof(*priv), &agnx_ops);
 493         if (!dev) {
 494                 printk(KERN_ERR PFX "ieee80211 alloc failed\n");
 495                 err = -ENOMEM;
 496                 goto err_free_reg;
 497         }
 498         /* init priv  */
 499         priv = dev->priv;
 500         memset(priv, 0, sizeof(*priv));
 501         priv->mode = NL80211_IFTYPE_MONITOR;
 502         priv->pdev = pdev;
 503         priv->hw = dev;
 504         spin_lock_init(&priv->lock);
 505         priv->init_status = AGNX_UNINIT;
 506
 507         /* Map mem #1 and #2 */
 508         priv->ctl = pci_iomap(pdev, 0, mem_len0);
 509 /*      printk(KERN_DEBUG PFX"MEM1 mapped address is 0x%p\n", priv->ctl); */
 510         if (!priv->ctl) {
 511                 printk(KERN_ERR PFX "Can't map device memory\n");
 512                 goto err_free_dev;
 513         }
 514         priv->data = pci_iomap(pdev, 1, mem_len1);
 515         printk(KERN_DEBUG PFX "MEM2 mapped address is 0x%p\n", priv->data);
 516         if (!priv->data) {
 517                 printk(KERN_ERR PFX "Can't map device memory\n");
 518                 goto err_iounmap2;
 519         }
 520
 521         pci_read_config_byte(pdev, PCI_REVISION_ID, &priv->revid);
 522
 523         priv->band.channels   = (struct ieee80211_channel *)agnx_channels;
 524         priv->band.n_channels = ARRAY_SIZE(agnx_channels);
 525         priv->band.bitrates   = (struct ieee80211_rate *)agnx_rates_80211g;
 526         priv->band.n_bitrates = ARRAY_SIZE(agnx_rates_80211g);
 527
 528         /* Init ieee802.11 dev  */
 529         SET_IEEE80211_DEV(dev, &pdev->dev);
 530         pci_set_drvdata(pdev, dev);
 531         dev->extra_tx_headroom = sizeof(struct agnx_hdr);
 532
 533         /* FIXME It only include FCS in promious mode but not manage mode */
 534 /*      dev->flags =  IEEE80211_HW_RX_INCLUDES_FCS; */
 535         dev->channel_change_time = 5000;
 536         dev->max_signal = 100;
 537         /* FIXME */
 538         dev->queues = 1;
 539
 540         agnx_get_mac_address(priv);
 541
 542         SET_IEEE80211_PERM_ADDR(dev, priv->mac_addr);
 543
 544 /*      /\* FIXME *\/ */
 545 /*      for (i = 1; i < NUM_DRIVE_MODES; i++) { */
 546 /*              err = ieee80211_register_hwmode(dev, &priv->modes[i]); */
 547 /*              if (err) { */
 548 /*                      printk(KERN_ERR PFX "Can't register hwmode\n"); */
 549 /*                      goto  err_iounmap; */
 550 /*              } */
 551 /*      } */
 552
 553         priv->channel = 1;
 554         dev->wiphy->bands[IEEE80211_BAND_2GHZ] = &priv->band;
 555
 556         err = ieee80211_register_hw(dev);
 557         if (err) {
 558                 printk(KERN_ERR PFX "Can't register hardware\n");
 559                 goto err_iounmap;
 560         }
 561
 562         agnx_hw_reset(priv);
 563
 564
 565         printk(PFX "%s: hwaddr %s, Rev 0x%02x\n", wiphy_name(dev->wiphy),
 566                print_mac(mac, dev->wiphy->perm_addr), priv->revid);
 567         return 0;
 568
 569  err_iounmap:
 570         pci_iounmap(pdev, priv->data);
 571
 572  err_iounmap2:
 573         pci_iounmap(pdev, priv->ctl);
 574
 575  err_free_dev:
 576         pci_set_drvdata(pdev, NULL);
 577         ieee80211_free_hw(dev);
 578
 579  err_free_reg:
 580         pci_release_regions(pdev);
 581
 582         pci_disable_device(pdev);
 583         return err;
 584 } /* agnx_pci_probe*/
 585
 586 #ifdef CONFIG_PM
 587
 588 static int agnx_pci_suspend(struct pci_dev *pdev, pm_message_t state)
 589 {
 590         struct ieee80211_hw *dev = pci_get_drvdata(pdev);
 591         AGNX_TRACE;
 592
 593         ieee80211_stop_queues(dev);
 594         agnx_stop(dev);
 595
 596         pci_save_state(pdev);
 597         pci_set_power_state(pdev, pci_choose_state(pdev, state));
 598         return 0;
 599 }
 600
 601 static int agnx_pci_resume(struct pci_dev *pdev)
 602 {
 603         struct ieee80211_hw *dev = pci_get_drvdata(pdev);
 604         AGNX_TRACE;
 605
 606         pci_set_power_state(pdev, PCI_D0);
 607         pci_restore_state(pdev);
 608
 609         agnx_start(dev);
 610         ieee80211_wake_queues(dev);
 611
 612         return 0;
 613 }
 614
 615 #else
 616
 617 #define agnx_pci_suspend NULL
 618 #define agnx_pci_resume NULL
 619
 620 #endif /* CONFIG_PM */
 621
 622
 623 static struct pci_driver agnx_pci_driver = {
 624         .name           = "agnx-pci",
 625         .id_table       = agnx_pci_id_tbl,
 626         .probe          = agnx_pci_probe,
 627         .remove         = __devexit_p(agnx_pci_remove),
 628         .suspend        = agnx_pci_suspend,
 629         .resume         = agnx_pci_resume,
 630 };
 631
 632 static int __init agnx_pci_init(void)
 633 {
 634         AGNX_TRACE;
 635         return pci_register_driver(&agnx_pci_driver);
 636 }
 637
 638 static void __exit agnx_pci_exit(void)
 639 {
 640         AGNX_TRACE;
 641         pci_unregister_driver(&agnx_pci_driver);
 642 }
 643
 644
 645 module_init(agnx_pci_init);
 646 module_exit(agnx_pci_exit);