Pileus Git - ~andy/linux/blob - drivers/net/wireless/hostap/hostap_pci.c

   1 #define PRISM2_PCI
   2
   3 /* Host AP driver's support for Intersil Prism2.5 PCI cards is based on
   4  * driver patches from Reyk Floeter <reyk@vantronix.net> and
   5  * Andy Warner <andyw@pobox.com> */
   6
   7 #include <linux/config.h>
   8 #include <linux/version.h>
   9 #include <linux/module.h>
  10 #include <linux/init.h>
  11 #include <linux/if.h>
  12 #include <linux/skbuff.h>
  13 #include <linux/netdevice.h>
  14 #include <linux/workqueue.h>
  15 #include <linux/wireless.h>
  16 #include <net/iw_handler.h>
  17
  18 #include <linux/ioport.h>
  19 #include <linux/pci.h>
  20 #include <asm/io.h>
  21
  22 #include "hostap_wlan.h"
  23
  24
  25 static char *version = PRISM2_VERSION " (Jouni Malinen <jkmaline@cc.hut.fi>)";
  26 static char *dev_info = "hostap_pci";
  27
  28
  29 MODULE_AUTHOR("Jouni Malinen");
  30 MODULE_DESCRIPTION("Support for Intersil Prism2.5-based 802.11 wireless LAN "
  31                    "PCI cards.");
  32 MODULE_SUPPORTED_DEVICE("Intersil Prism2.5-based WLAN PCI cards");
  33 MODULE_LICENSE("GPL");
  34 MODULE_VERSION(PRISM2_VERSION);
  35
  36
  37 /* struct local_info::hw_priv */
  38 struct hostap_pci_priv {
  39         void __iomem *mem_start;
  40 };
  41
  42
  43 /* FIX: do we need mb/wmb/rmb with memory operations? */
  44
  45
  46 static struct pci_device_id prism2_pci_id_table[] __devinitdata = {
  47         /* Intersil Prism3 ISL3872 11Mb/s WLAN Controller */
  48         { 0x1260, 0x3872, PCI_ANY_ID, PCI_ANY_ID },
  49         /* Intersil Prism2.5 ISL3874 11Mb/s WLAN Controller */
  50         { 0x1260, 0x3873, PCI_ANY_ID, PCI_ANY_ID },
  51         /* Samsung MagicLAN SWL-2210P */
  52         { 0x167d, 0xa000, PCI_ANY_ID, PCI_ANY_ID },
  53         { 0 }
  54 };
  55
  56
  57 #ifdef PRISM2_IO_DEBUG
  58
  59 static inline void hfa384x_outb_debug(struct net_device *dev, int a, u8 v)
  60 {
  61         struct hostap_interface *iface;
  62         local_info_t *local;
  63         unsigned long flags;
  64
  65         iface = netdev_priv(dev);
  66         local = iface->local;
  67
  68         spin_lock_irqsave(&local->lock, flags);
  69         prism2_io_debug_add(dev, PRISM2_IO_DEBUG_CMD_OUTB, a, v);
  70         writeb(v, hw_priv->mem_start + a);
  71         spin_unlock_irqrestore(&local->lock, flags);
  72 }
  73
  74 static inline u8 hfa384x_inb_debug(struct net_device *dev, int a)
  75 {
  76         struct hostap_interface *iface;
  77         local_info_t *local;
  78         unsigned long flags;
  79         u8 v;
  80
  81         iface = netdev_priv(dev);
  82         local = iface->local;
  83
  84         spin_lock_irqsave(&local->lock, flags);
  85         v = readb(hw_priv->mem_start + a);
  86         prism2_io_debug_add(dev, PRISM2_IO_DEBUG_CMD_INB, a, v);
  87         spin_unlock_irqrestore(&local->lock, flags);
  88         return v;
  89 }
  90
  91 static inline void hfa384x_outw_debug(struct net_device *dev, int a, u16 v)
  92 {
  93         struct hostap_interface *iface;
  94         local_info_t *local;
  95         unsigned long flags;
  96
  97         iface = netdev_priv(dev);
  98         local = iface->local;
  99
 100         spin_lock_irqsave(&local->lock, flags);
 101         prism2_io_debug_add(dev, PRISM2_IO_DEBUG_CMD_OUTW, a, v);
 102         writew(v, hw_priv->mem_start + a);
 103         spin_unlock_irqrestore(&local->lock, flags);
 104 }
 105
 106 static inline u16 hfa384x_inw_debug(struct net_device *dev, int a)
 107 {
 108         struct hostap_interface *iface;
 109         local_info_t *local;
 110         unsigned long flags;
 111         u16 v;
 112
 113         iface = netdev_priv(dev);
 114         local = iface->local;
 115
 116         spin_lock_irqsave(&local->lock, flags);
 117         v = readw(hw_priv->mem_start + a);
 118         prism2_io_debug_add(dev, PRISM2_IO_DEBUG_CMD_INW, a, v);
 119         spin_unlock_irqrestore(&local->lock, flags);
 120         return v;
 121 }
 122
 123 #define HFA384X_OUTB(v,a) hfa384x_outb_debug(dev, (a), (v))
 124 #define HFA384X_INB(a) hfa384x_inb_debug(dev, (a))
 125 #define HFA384X_OUTW(v,a) hfa384x_outw_debug(dev, (a), (v))
 126 #define HFA384X_INW(a) hfa384x_inw_debug(dev, (a))
 127 #define HFA384X_OUTW_DATA(v,a) hfa384x_outw_debug(dev, (a), cpu_to_le16((v)))
 128 #define HFA384X_INW_DATA(a) (u16) le16_to_cpu(hfa384x_inw_debug(dev, (a)))
 129
 130 #else /* PRISM2_IO_DEBUG */
 131
 132 static inline void hfa384x_outb(struct net_device *dev, int a, u8 v)
 133 {
 134         struct hostap_interface *iface;
 135         struct hostap_pci_priv *hw_priv;
 136         iface = netdev_priv(dev);
 137         hw_priv = iface->local->hw_priv;
 138         writeb(v, hw_priv->mem_start + a);
 139 }
 140
 141 static inline u8 hfa384x_inb(struct net_device *dev, int a)
 142 {
 143         struct hostap_interface *iface;
 144         struct hostap_pci_priv *hw_priv;
 145         iface = netdev_priv(dev);
 146         hw_priv = iface->local->hw_priv;
 147         return readb(hw_priv->mem_start + a);
 148 }
 149
 150 static inline void hfa384x_outw(struct net_device *dev, int a, u16 v)
 151 {
 152         struct hostap_interface *iface;
 153         struct hostap_pci_priv *hw_priv;
 154         iface = netdev_priv(dev);
 155         hw_priv = iface->local->hw_priv;
 156         writew(v, hw_priv->mem_start + a);
 157 }
 158
 159 static inline u16 hfa384x_inw(struct net_device *dev, int a)
 160 {
 161         struct hostap_interface *iface;
 162         struct hostap_pci_priv *hw_priv;
 163         iface = netdev_priv(dev);
 164         hw_priv = iface->local->hw_priv;
 165         return readw(hw_priv->mem_start + a);
 166 }
 167
 168 #define HFA384X_OUTB(v,a) hfa384x_outb(dev, (a), (v))
 169 #define HFA384X_INB(a) hfa384x_inb(dev, (a))
 170 #define HFA384X_OUTW(v,a) hfa384x_outw(dev, (a), (v))
 171 #define HFA384X_INW(a) hfa384x_inw(dev, (a))
 172 #define HFA384X_OUTW_DATA(v,a) hfa384x_outw(dev, (a), cpu_to_le16((v)))
 173 #define HFA384X_INW_DATA(a) (u16) le16_to_cpu(hfa384x_inw(dev, (a)))
 174
 175 #endif /* PRISM2_IO_DEBUG */
 176
 177
 178 static int hfa384x_from_bap(struct net_device *dev, u16 bap, void *buf,
 179                             int len)
 180 {
 181         u16 d_off;
 182         u16 *pos;
 183
 184         d_off = (bap == 1) ? HFA384X_DATA1_OFF : HFA384X_DATA0_OFF;
 185         pos = (u16 *) buf;
 186
 187         for ( ; len > 1; len -= 2)
 188                 *pos++ = HFA384X_INW_DATA(d_off);
 189
 190         if (len & 1)
 191                 *((char *) pos) = HFA384X_INB(d_off);
 192
 193         return 0;
 194 }
 195
 196
 197 static int hfa384x_to_bap(struct net_device *dev, u16 bap, void *buf, int len)
 198 {
 199         u16 d_off;
 200         u16 *pos;
 201
 202         d_off = (bap == 1) ? HFA384X_DATA1_OFF : HFA384X_DATA0_OFF;
 203         pos = (u16 *) buf;
 204
 205         for ( ; len > 1; len -= 2)
 206                 HFA384X_OUTW_DATA(*pos++, d_off);
 207
 208         if (len & 1)
 209                 HFA384X_OUTB(*((char *) pos), d_off);
 210
 211         return 0;
 212 }
 213
 214
 215 /* FIX: This might change at some point.. */
 216 #include "hostap_hw.c"
 217
 218 static void prism2_pci_cor_sreset(local_info_t *local)
 219 {
 220         struct net_device *dev = local->dev;
 221         u16 reg;
 222
 223         reg = HFA384X_INB(HFA384X_PCICOR_OFF);
 224         printk(KERN_DEBUG "%s: Original COR value: 0x%0x\n", dev->name, reg);
 225
 226         /* linux-wlan-ng uses extremely long hold and settle times for
 227          * COR sreset. A comment in the driver code mentions that the long
 228          * delays appear to be necessary. However, at least IBM 22P6901 seems
 229          * to work fine with shorter delays.
 230          *
 231          * Longer delays can be configured by uncommenting following line: */
 232 /* #define PRISM2_PCI_USE_LONG_DELAYS */
 233
 234 #ifdef PRISM2_PCI_USE_LONG_DELAYS
 235         int i;
 236
 237         HFA384X_OUTW(reg | 0x0080, HFA384X_PCICOR_OFF);
 238         mdelay(250);
 239
 240         HFA384X_OUTW(reg & ~0x0080, HFA384X_PCICOR_OFF);
 241         mdelay(500);
 242
 243         /* Wait for f/w to complete initialization (CMD:BUSY == 0) */
 244         i = 2000000 / 10;
 245         while ((HFA384X_INW(HFA384X_CMD_OFF) & HFA384X_CMD_BUSY) && --i)
 246                 udelay(10);
 247
 248 #else /* PRISM2_PCI_USE_LONG_DELAYS */
 249
 250         HFA384X_OUTW(reg | 0x0080, HFA384X_PCICOR_OFF);
 251         mdelay(2);
 252         HFA384X_OUTW(reg & ~0x0080, HFA384X_PCICOR_OFF);
 253         mdelay(2);
 254
 255 #endif /* PRISM2_PCI_USE_LONG_DELAYS */
 256
 257         if (HFA384X_INW(HFA384X_CMD_OFF) & HFA384X_CMD_BUSY) {
 258                 printk(KERN_DEBUG "%s: COR sreset timeout\n", dev->name);
 259         }
 260 }
 261
 262
 263 static void prism2_pci_genesis_reset(local_info_t *local, int hcr)
 264 {
 265         struct net_device *dev = local->dev;
 266
 267         HFA384X_OUTW(0x00C5, HFA384X_PCICOR_OFF);
 268         mdelay(10);
 269         HFA384X_OUTW(hcr, HFA384X_PCIHCR_OFF);
 270         mdelay(10);
 271         HFA384X_OUTW(0x0045, HFA384X_PCICOR_OFF);
 272         mdelay(10);
 273 }
 274
 275
 276 static struct prism2_helper_functions prism2_pci_funcs =
 277 {
 278         .card_present   = NULL,
 279         .cor_sreset     = prism2_pci_cor_sreset,
 280         .genesis_reset  = prism2_pci_genesis_reset,
 281         .hw_type        = HOSTAP_HW_PCI,
 282 };
 283
 284
 285 static int prism2_pci_probe(struct pci_dev *pdev,
 286                             const struct pci_device_id *id)
 287 {
 288         unsigned long phymem;
 289         void __iomem *mem = NULL;
 290         local_info_t *local = NULL;
 291         struct net_device *dev = NULL;
 292         static int cards_found /* = 0 */;
 293         int irq_registered = 0;
 294         struct hostap_interface *iface;
 295         struct hostap_pci_priv *hw_priv;
 296
 297         hw_priv = kmalloc(sizeof(*hw_priv), GFP_KERNEL);
 298         if (hw_priv == NULL)
 299                 return -ENOMEM;
 300         memset(hw_priv, 0, sizeof(*hw_priv));
 301
 302         if (pci_enable_device(pdev))
 303                 return -EIO;
 304
 305         phymem = pci_resource_start(pdev, 0);
 306
 307         if (!request_mem_region(phymem, pci_resource_len(pdev, 0), "Prism2")) {
 308                 printk(KERN_ERR "prism2: Cannot reserve PCI memory region\n");
 309                 goto err_out_disable;
 310         }
 311
 312         mem = ioremap(phymem, pci_resource_len(pdev, 0));
 313         if (mem == NULL) {
 314                 printk(KERN_ERR "prism2: Cannot remap PCI memory region\n") ;
 315                 goto fail;
 316         }
 317
 318         dev = prism2_init_local_data(&prism2_pci_funcs, cards_found,
 319                                      &pdev->dev);
 320         if (dev == NULL)
 321                 goto fail;
 322         iface = netdev_priv(dev);
 323         local = iface->local;
 324         local->hw_priv = hw_priv;
 325         cards_found++;
 326
 327         dev->irq = pdev->irq;
 328         hw_priv->mem_start = mem;
 329
 330         prism2_pci_cor_sreset(local);
 331
 332         pci_set_drvdata(pdev, dev);
 333
 334         if (request_irq(dev->irq, prism2_interrupt, SA_SHIRQ, dev->name,
 335                         dev)) {
 336                 printk(KERN_WARNING "%s: request_irq failed\n", dev->name);
 337                 goto fail;
 338         } else
 339                 irq_registered = 1;
 340
 341         if (!local->pri_only && prism2_hw_config(dev, 1)) {
 342                 printk(KERN_DEBUG "%s: hardware initialization failed\n",
 343                        dev_info);
 344                 goto fail;
 345         }
 346
 347         printk(KERN_INFO "%s: Intersil Prism2.5 PCI: "
 348                "mem=0x%lx, irq=%d\n", dev->name, phymem, dev->irq);
 349
 350         return hostap_hw_ready(dev);
 351
 352  fail:
 353         kfree(hw_priv);
 354
 355         if (irq_registered && dev)
 356                 free_irq(dev->irq, dev);
 357
 358         if (mem)
 359                 iounmap(mem);
 360
 361         release_mem_region(phymem, pci_resource_len(pdev, 0));
 362
 363  err_out_disable:
 364         pci_disable_device(pdev);
 365         kfree(hw_priv);
 366         if (local)
 367                 local->hw_priv = NULL;
 368         prism2_free_local_data(dev);
 369
 370         return -ENODEV;
 371 }
 372
 373
 374 static void prism2_pci_remove(struct pci_dev *pdev)
 375 {
 376         struct net_device *dev;
 377         struct hostap_interface *iface;
 378         void __iomem *mem_start;
 379         struct hostap_pci_priv *hw_priv;
 380
 381         dev = pci_get_drvdata(pdev);
 382         iface = netdev_priv(dev);
 383         hw_priv = iface->local->hw_priv;
 384
 385         /* Reset the hardware, and ensure interrupts are disabled. */
 386         prism2_pci_cor_sreset(iface->local);
 387         hfa384x_disable_interrupts(dev);
 388
 389         if (dev->irq)
 390                 free_irq(dev->irq, dev);
 391
 392         mem_start = hw_priv->mem_start;
 393         kfree(hw_priv);
 394         iface->local->hw_priv = NULL;
 395         prism2_free_local_data(dev);
 396
 397         iounmap(mem_start);
 398
 399         release_mem_region(pci_resource_start(pdev, 0),
 400                            pci_resource_len(pdev, 0));
 401         pci_disable_device(pdev);
 402 }
 403
 404
 405 #ifdef CONFIG_PM
 406 static int prism2_pci_suspend(struct pci_dev *pdev, pm_message_t state)
 407 {
 408         struct net_device *dev = pci_get_drvdata(pdev);
 409
 410         if (netif_running(dev)) {
 411                 netif_stop_queue(dev);
 412                 netif_device_detach(dev);
 413         }
 414         prism2_suspend(dev);
 415         pci_save_state(pdev);
 416         pci_disable_device(pdev);
 417         pci_set_power_state(pdev, PCI_D3hot);
 418
 419         return 0;
 420 }
 421
 422 static int prism2_pci_resume(struct pci_dev *pdev)
 423 {
 424         struct net_device *dev = pci_get_drvdata(pdev);
 425
 426         pci_enable_device(pdev);
 427         pci_restore_state(pdev);
 428         prism2_hw_config(dev, 0);
 429         if (netif_running(dev)) {
 430                 netif_device_attach(dev);
 431                 netif_start_queue(dev);
 432         }
 433
 434         return 0;
 435 }
 436 #endif /* CONFIG_PM */
 437
 438
 439 MODULE_DEVICE_TABLE(pci, prism2_pci_id_table);
 440
 441 static struct pci_driver prism2_pci_drv_id = {
 442         .name           = "hostap_pci",
 443         .id_table       = prism2_pci_id_table,
 444         .probe          = prism2_pci_probe,
 445         .remove         = prism2_pci_remove,
 446 #ifdef CONFIG_PM
 447         .suspend        = prism2_pci_suspend,
 448         .resume         = prism2_pci_resume,
 449 #endif /* CONFIG_PM */
 450         /* Linux 2.4.6 added save_state and enable_wake that are not used here
 451          */
 452 };
 453
 454
 455 static int __init init_prism2_pci(void)
 456 {
 457         printk(KERN_INFO "%s: %s\n", dev_info, version);
 458
 459         return pci_register_driver(&prism2_pci_drv_id);
 460 }
 461
 462
 463 static void __exit exit_prism2_pci(void)
 464 {
 465         pci_unregister_driver(&prism2_pci_drv_id);
 466         printk(KERN_INFO "%s: Driver unloaded\n", dev_info);
 467 }
 468
 469
 470 module_init(init_prism2_pci);
 471 module_exit(exit_prism2_pci);