drivers/net/pcmcia/ibmtr_cs.c

   1 /*======================================================================
   2
   3     A PCMCIA token-ring driver for IBM-based cards
   4
   5     This driver supports the IBM PCMCIA Token-Ring Card.
   6     Written by Steve Kipisz, kipisz@vnet.ibm.com or
   7                              bungy@ibm.net
   8
   9     Written 1995,1996.
  10
  11     This code is based on pcnet_cs.c from David Hinds.
  12
  13     V2.2.0 February 1999 - Mike Phillips phillim@amtrak.com
  14
  15     Linux V2.2.x presented significant changes to the underlying
  16     ibmtr.c code.  Mainly the code became a lot more organized and
  17     modular.
  18
  19     This caused the old PCMCIA Token Ring driver to give up and go
  20     home early. Instead of just patching the old code to make it
  21     work, the PCMCIA code has been streamlined, updated and possibly
  22     improved.
  23
  24     This code now only contains code required for the Card Services.
  25     All we do here is set the card up enough so that the real ibmtr.c
  26     driver can find it and work with it properly.
  27
  28     i.e. We set up the io port, irq, mmio memory and shared ram
  29     memory.  This enables ibmtr_probe in ibmtr.c to find the card and
  30     configure it as though it was a normal ISA and/or PnP card.
  31
  32     CHANGES
  33
  34     v2.2.5 April 1999 Mike Phillips (phillim@amtrak.com)
  35     Obscure bug fix, required changed to ibmtr.c not ibmtr_cs.c
  36
  37     v2.2.7 May 1999 Mike Phillips (phillim@amtrak.com)
  38     Updated to version 2.2.7 to match the first version of the kernel
  39     that the modification to ibmtr.c were incorporated into.
  40
  41     v2.2.17 July 2000 Burt Silverman (burts@us.ibm.com)
  42     Address translation feature of PCMCIA controller is usable so
  43     memory windows can be placed in High memory (meaning above
  44     0xFFFFF.)
  45
  46 ======================================================================*/
  47
  48 #include <linux/kernel.h>
  49 #include <linux/init.h>
  50 #include <linux/ptrace.h>
  51 #include <linux/slab.h>
  52 #include <linux/string.h>
  53 #include <linux/timer.h>
  54 #include <linux/module.h>
  55 #include <linux/ethtool.h>
  56 #include <linux/netdevice.h>
  57 #include <linux/trdevice.h>
  58 #include <linux/ibmtr.h>
  59
  60 #include <pcmcia/version.h>
  61 #include <pcmcia/cs_types.h>
  62 #include <pcmcia/cs.h>
  63 #include <pcmcia/cistpl.h>
  64 #include <pcmcia/ds.h>
  65
  66 #include <asm/uaccess.h>
  67 #include <asm/io.h>
  68 #include <asm/system.h>
  69
  70 #define PCMCIA
  71 #include "../tokenring/ibmtr.c"
  72
  73 #ifdef PCMCIA_DEBUG
  74 static int pc_debug = PCMCIA_DEBUG;
  75 MODULE_PARM(pc_debug, "i");
  76 #define DEBUG(n, args...) if (pc_debug>(n)) printk(KERN_DEBUG args)
  77 static char *version =
  78 "ibmtr_cs.c 1.10   1996/01/06 05:19:00 (Steve Kipisz)\n"
  79 "           2.2.7  1999/05/03 12:00:00 (Mike Phillips)\n"
  80 "           2.4.2  2001/30/28 Midnight (Burt Silverman)\n";
  81 #else
  82 #define DEBUG(n, args...)
  83 #endif
  84
  85 /*====================================================================*/
  86
  87 /* Parameters that can be set with 'insmod' */
  88
  89 /* Bit map of interrupts to choose from */
  90 static u_int irq_mask = 0xdeb8;
  91 static int irq_list[4] = { -1 };
  92
  93 /* MMIO base address */
  94 static u_long mmiobase = 0xce000;
  95
  96 /* SRAM base address */
  97 static u_long srambase = 0xd0000;
  98
  99 /* SRAM size 8,16,32,64 */
 100 static u_long sramsize = 64;
 101
 102 /* Ringspeed 4,16 */
 103 static int ringspeed = 16;
 104
 105 MODULE_PARM(irq_mask, "i");
 106 MODULE_PARM(irq_list, "1-4i");
 107 MODULE_PARM(mmiobase, "i");
 108 MODULE_PARM(srambase, "i");
 109 MODULE_PARM(sramsize, "i");
 110 MODULE_PARM(ringspeed, "i");
 111 MODULE_LICENSE("GPL");
 112
 113 /*====================================================================*/
 114
 115 static void ibmtr_config(dev_link_t *link);
 116 static void ibmtr_hw_setup(struct net_device *dev, u_int mmiobase);
 117 static void ibmtr_release(dev_link_t *link);
 118 static int ibmtr_event(event_t event, int priority,
 119                        event_callback_args_t *args);
 120
 121 static dev_info_t dev_info = "ibmtr_cs";
 122
 123 static dev_link_t *ibmtr_attach(void);
 124 static void ibmtr_detach(dev_link_t *);
 125
 126 static dev_link_t *dev_list;
 127
 128 extern int ibmtr_probe_card(struct net_device *dev);
 129 extern irqreturn_t tok_interrupt (int irq, void *dev_id, struct pt_regs *regs);
 130
 131 /*====================================================================*/
 132
 133 typedef struct ibmtr_dev_t {
 134     dev_link_t          link;
 135     struct net_device   *dev;
 136     dev_node_t          node;
 137     window_handle_t     sram_win_handle;
 138     struct tok_info     *ti;
 139 } ibmtr_dev_t;
 140
 141 static void netdev_get_drvinfo(struct net_device *dev,
 142                                struct ethtool_drvinfo *info)
 143 {
 144         strcpy(info->driver, "ibmtr_cs");
 145 }
 146
 147 static struct ethtool_ops netdev_ethtool_ops = {
 148         .get_drvinfo            = netdev_get_drvinfo,
 149 };
 150
 151 /*======================================================================
 152
 153     ibmtr_attach() creates an "instance" of the driver, allocating
 154     local data structures for one device.  The device is registered
 155     with Card Services.
 156
 157 ======================================================================*/
 158
 159 static dev_link_t *ibmtr_attach(void)
 160 {
 161     ibmtr_dev_t *info;
 162     dev_link_t *link;
 163     struct net_device *dev;
 164     client_reg_t client_reg;
 165     int i, ret;
 166
 167     DEBUG(0, "ibmtr_attach()\n");
 168
 169     /* Create new token-ring device */
 170     info = kmalloc(sizeof(*info), GFP_KERNEL);
 171     if (!info) return NULL;
 172     memset(info,0,sizeof(*info));
 173     dev = alloc_trdev(sizeof(struct tok_info));
 174     if (!dev) {
 175         kfree(info);
 176         return NULL;
 177     }
 178
 179     link = &info->link;
 180     link->priv = info;
 181     info->ti = netdev_priv(dev);
 182
 183     link->io.Attributes1 = IO_DATA_PATH_WIDTH_8;
 184     link->io.NumPorts1 = 4;
 185     link->io.IOAddrLines = 16;
 186     link->irq.Attributes = IRQ_TYPE_EXCLUSIVE | IRQ_HANDLE_PRESENT;
 187     link->irq.IRQInfo1 = IRQ_INFO2_VALID|IRQ_LEVEL_ID;
 188     if (irq_list[0] == -1)
 189         link->irq.IRQInfo2 = irq_mask;
 190     else
 191         for (i = 0; i < 4; i++)
 192             link->irq.IRQInfo2 |= 1 << irq_list[i];
 193     link->irq.Handler = &tok_interrupt;
 194     link->conf.Attributes = CONF_ENABLE_IRQ;
 195     link->conf.Vcc = 50;
 196     link->conf.IntType = INT_MEMORY_AND_IO;
 197     link->conf.Present = PRESENT_OPTION;
 198
 199     link->irq.Instance = info->dev = dev;
 200
 201     SET_ETHTOOL_OPS(dev, &netdev_ethtool_ops);
 202
 203     /* Register with Card Services */
 204     link->next = dev_list;
 205     dev_list = link;
 206     client_reg.dev_info = &dev_info;
 207     client_reg.Attributes = INFO_IO_CLIENT | INFO_CARD_SHARE;
 208     client_reg.EventMask =
 209         CS_EVENT_CARD_INSERTION | CS_EVENT_CARD_REMOVAL |
 210         CS_EVENT_RESET_PHYSICAL | CS_EVENT_CARD_RESET |
 211         CS_EVENT_PM_SUSPEND | CS_EVENT_PM_RESUME;
 212     client_reg.event_handler = &ibmtr_event;
 213     client_reg.Version = 0x0210;
 214     client_reg.event_callback_args.client_data = link;
 215     ret = pcmcia_register_client(&link->handle, &client_reg);
 216     if (ret != 0) {
 217         cs_error(link->handle, RegisterClient, ret);
 218         goto out_detach;
 219     }
 220
 221 out:
 222     return link;
 223
 224 out_detach:
 225     ibmtr_detach(link);
 226     link = NULL;
 227     goto out;
 228 } /* ibmtr_attach */
 229
 230 /*======================================================================
 231
 232     This deletes a driver "instance".  The device is de-registered
 233     with Card Services.  If it has been released, all local data
 234     structures are freed.  Otherwise, the structures will be freed
 235     when the device is released.
 236
 237 ======================================================================*/
 238
 239 static void ibmtr_detach(dev_link_t *link)
 240 {
 241     struct ibmtr_dev_t *info = link->priv;
 242     dev_link_t **linkp;
 243     struct net_device *dev;
 244
 245     DEBUG(0, "ibmtr_detach(0x%p)\n", link);
 246
 247     /* Locate device structure */
 248     for (linkp = &dev_list; *linkp; linkp = &(*linkp)->next)
 249         if (*linkp == link) break;
 250     if (*linkp == NULL)
 251         return;
 252
 253     dev = info->dev;
 254
 255     if (link->dev)
 256         unregister_netdev(dev);
 257
 258     {
 259         struct tok_info *ti = netdev_priv(dev);
 260         del_timer_sync(&(ti->tr_timer));
 261     }
 262     if (link->state & DEV_CONFIG)
 263         ibmtr_release(link);
 264
 265     if (link->handle)
 266         pcmcia_deregister_client(link->handle);
 267
 268     /* Unlink device structure, free bits */
 269     *linkp = link->next;
 270     free_netdev(dev);
 271     kfree(info);
 272 } /* ibmtr_detach */
 273
 274 /*======================================================================
 275
 276     ibmtr_config() is scheduled to run after a CARD_INSERTION event
 277     is received, to configure the PCMCIA socket, and to make the
 278     token-ring device available to the system.
 279
 280 ======================================================================*/
 281
 282 #define CS_CHECK(fn, ret) \
 283 do { last_fn = (fn); if ((last_ret = (ret)) != 0) goto cs_failed; } while (0)
 284
 285 static void ibmtr_config(dev_link_t *link)
 286 {
 287     client_handle_t handle = link->handle;
 288     ibmtr_dev_t *info = link->priv;
 289     struct net_device *dev = info->dev;
 290     struct tok_info *ti = netdev_priv(dev);
 291     tuple_t tuple;
 292     cisparse_t parse;
 293     win_req_t req;
 294     memreq_t mem;
 295     int i, last_ret, last_fn;
 296     u_char buf[64];
 297
 298     DEBUG(0, "ibmtr_config(0x%p)\n", link);
 299
 300     tuple.Attributes = 0;
 301     tuple.TupleData = buf;
 302     tuple.TupleDataMax = 64;
 303     tuple.TupleOffset = 0;
 304     tuple.DesiredTuple = CISTPL_CONFIG;
 305     CS_CHECK(GetFirstTuple, pcmcia_get_first_tuple(handle, &tuple));
 306     CS_CHECK(GetTupleData, pcmcia_get_tuple_data(handle, &tuple));
 307     CS_CHECK(ParseTuple, pcmcia_parse_tuple(handle, &tuple, &parse));
 308     link->conf.ConfigBase = parse.config.base;
 309
 310     /* Configure card */
 311     link->state |= DEV_CONFIG;
 312
 313     link->conf.ConfigIndex = 0x61;
 314
 315     /* Determine if this is PRIMARY or ALTERNATE. */
 316
 317     /* Try PRIMARY card at 0xA20-0xA23 */
 318     link->io.BasePort1 = 0xA20;
 319     i = pcmcia_request_io(link->handle, &link->io);
 320     if (i != CS_SUCCESS) {
 321         /* Couldn't get 0xA20-0xA23.  Try ALTERNATE at 0xA24-0xA27. */
 322         link->io.BasePort1 = 0xA24;
 323         CS_CHECK(RequestIO, pcmcia_request_io(link->handle, &link->io));
 324     }
 325     dev->base_addr = link->io.BasePort1;
 326
 327     CS_CHECK(RequestIRQ, pcmcia_request_irq(link->handle, &link->irq));
 328     dev->irq = link->irq.AssignedIRQ;
 329     ti->irq = link->irq.AssignedIRQ;
 330     ti->global_int_enable=GLOBAL_INT_ENABLE+((dev->irq==9) ? 2 : dev->irq);
 331
 332     /* Allocate the MMIO memory window */
 333     req.Attributes = WIN_DATA_WIDTH_16|WIN_MEMORY_TYPE_CM|WIN_ENABLE;
 334     req.Attributes |= WIN_USE_WAIT;
 335     req.Base = 0;
 336     req.Size = 0x2000;
 337     req.AccessSpeed = 250;
 338     CS_CHECK(RequestWindow, pcmcia_request_window(&link->handle, &req, &link->win));
 339
 340     mem.CardOffset = mmiobase;
 341     mem.Page = 0;
 342     CS_CHECK(MapMemPage, pcmcia_map_mem_page(link->win, &mem));
 343     ti->mmio = ioremap(req.Base, req.Size);
 344
 345     /* Allocate the SRAM memory window */
 346     req.Attributes = WIN_DATA_WIDTH_16|WIN_MEMORY_TYPE_CM|WIN_ENABLE;
 347     req.Attributes |= WIN_USE_WAIT;
 348     req.Base = 0;
 349     req.Size = sramsize * 1024;
 350     req.AccessSpeed = 250;
 351     CS_CHECK(RequestWindow, pcmcia_request_window(&link->handle, &req, &info->sram_win_handle));
 352
 353     mem.CardOffset = srambase;
 354     mem.Page = 0;
 355     CS_CHECK(MapMemPage, pcmcia_map_mem_page(info->sram_win_handle, &mem));
 356
 357     ti->sram_base = mem.CardOffset >> 12;
 358     ti->sram_virt = (u_long)ioremap(req.Base, req.Size);
 359
 360     CS_CHECK(RequestConfiguration, pcmcia_request_configuration(link->handle, &link->conf));
 361
 362     /*  Set up the Token-Ring Controller Configuration Register and
 363         turn on the card.  Check the "Local Area Network Credit Card
 364         Adapters Technical Reference"  SC30-3585 for this info.  */
 365     ibmtr_hw_setup(dev, mmiobase);
 366
 367     link->dev = &info->node;
 368     link->state &= ~DEV_CONFIG_PENDING;
 369
 370     i = ibmtr_probe_card(dev);
 371     if (i != 0) {
 372         printk(KERN_NOTICE "ibmtr_cs: register_netdev() failed\n");
 373         link->dev = NULL;
 374         goto failed;
 375     }
 376
 377     strcpy(info->node.dev_name, dev->name);
 378
 379     printk(KERN_INFO "%s: port %#3lx, irq %d,",
 380            dev->name, dev->base_addr, dev->irq);
 381     printk (" mmio %#5lx,", (u_long)ti->mmio);
 382     printk (" sram %#5lx,", (u_long)ti->sram_base << 12);
 383     printk ("\n" KERN_INFO "  hwaddr=");
 384     for (i = 0; i < TR_ALEN; i++)
 385         printk("%02X", dev->dev_addr[i]);
 386     printk("\n");
 387     return;
 388
 389 cs_failed:
 390     cs_error(link->handle, last_fn, last_ret);
 391 failed:
 392     ibmtr_release(link);
 393 } /* ibmtr_config */
 394
 395 /*======================================================================
 396
 397     After a card is removed, ibmtr_release() will unregister the net
 398     device, and release the PCMCIA configuration.  If the device is
 399     still open, this will be postponed until it is closed.
 400
 401 ======================================================================*/
 402
 403 static void ibmtr_release(dev_link_t *link)
 404 {
 405     ibmtr_dev_t *info = link->priv;
 406     struct net_device *dev = info->dev;
 407
 408     DEBUG(0, "ibmtr_release(0x%p)\n", link);
 409
 410     pcmcia_release_configuration(link->handle);
 411     pcmcia_release_io(link->handle, &link->io);
 412     pcmcia_release_irq(link->handle, &link->irq);
 413     if (link->win) {
 414         struct tok_info *ti = netdev_priv(dev);
 415         iounmap((void *)ti->mmio);
 416         pcmcia_release_window(link->win);
 417         pcmcia_release_window(info->sram_win_handle);
 418     }
 419
 420     link->state &= ~DEV_CONFIG;
 421 }
 422
 423 /*======================================================================
 424
 425     The card status event handler.  Mostly, this schedules other
 426     stuff to run after an event is received.  A CARD_REMOVAL event
 427     also sets some flags to discourage the net drivers from trying
 428     to talk to the card any more.
 429
 430 ======================================================================*/
 431
 432 static int ibmtr_event(event_t event, int priority,
 433                        event_callback_args_t *args)
 434 {
 435     dev_link_t *link = args->client_data;
 436     ibmtr_dev_t *info = link->priv;
 437     struct net_device *dev = info->dev;
 438
 439     DEBUG(1, "ibmtr_event(0x%06x)\n", event);
 440
 441     switch (event) {
 442     case CS_EVENT_CARD_REMOVAL:
 443         link->state &= ~DEV_PRESENT;
 444         if (link->state & DEV_CONFIG) {
 445             /* set flag to bypass normal interrupt code */
 446             struct tok_info *priv = netdev_priv(dev);
 447             priv->sram_virt |= 1;
 448             netif_device_detach(dev);
 449         }
 450         break;
 451     case CS_EVENT_CARD_INSERTION:
 452         link->state |= DEV_PRESENT;
 453         ibmtr_config(link);
 454         break;
 455     case CS_EVENT_PM_SUSPEND:
 456         link->state |= DEV_SUSPEND;
 457         /* Fall through... */
 458     case CS_EVENT_RESET_PHYSICAL:
 459         if (link->state & DEV_CONFIG) {
 460             if (link->open)
 461                 netif_device_detach(dev);
 462             pcmcia_release_configuration(link->handle);
 463         }
 464         break;
 465     case CS_EVENT_PM_RESUME:
 466         link->state &= ~DEV_SUSPEND;
 467         /* Fall through... */
 468     case CS_EVENT_CARD_RESET:
 469         if (link->state & DEV_CONFIG) {
 470             pcmcia_request_configuration(link->handle, &link->conf);
 471             if (link->open) {
 472                 ibmtr_probe(dev);       /* really? */
 473                 netif_device_attach(dev);
 474             }
 475         }
 476         break;
 477     }
 478     return 0;
 479 } /* ibmtr_event */
 480
 481 /*====================================================================*/
 482
 483 static void ibmtr_hw_setup(struct net_device *dev, u_int mmiobase)
 484 {
 485     int i;
 486
 487     /* Bizarre IBM behavior, there are 16 bits of information we
 488        need to set, but the card only allows us to send 4 bits at a
 489        time.  For each byte sent to base_addr, bits 7-4 tell the
 490        card which part of the 16 bits we are setting, bits 3-0 contain
 491        the actual information */
 492
 493     /* First nibble provides 4 bits of mmio */
 494     i = (mmiobase >> 16) & 0x0F;
 495     outb(i, dev->base_addr);
 496
 497     /* Second nibble provides 3 bits of mmio */
 498     i = 0x10 | ((mmiobase >> 12) & 0x0E);
 499     outb(i, dev->base_addr);
 500
 501     /* Third nibble, hard-coded values */
 502     i = 0x26;
 503     outb(i, dev->base_addr);
 504
 505     /* Fourth nibble sets shared ram page size */
 506
 507     /* 8 = 00, 16 = 01, 32 = 10, 64 = 11 */
 508     i = (sramsize >> 4) & 0x07;
 509     i = ((i == 4) ? 3 : i) << 2;
 510     i |= 0x30;
 511
 512     if (ringspeed == 16)
 513         i |= 2;
 514     if (dev->base_addr == 0xA24)
 515         i |= 1;
 516     outb(i, dev->base_addr);
 517
 518     /* 0x40 will release the card for use */
 519     outb(0x40, dev->base_addr);
 520
 521     return;
 522 }
 523
 524 static struct pcmcia_driver ibmtr_cs_driver = {
 525         .owner          = THIS_MODULE,
 526         .drv            = {
 527                 .name   = "ibmtr_cs",
 528         },
 529         .attach         = ibmtr_attach,
 530         .detach         = ibmtr_detach,
 531 };
 532
 533 static int __init init_ibmtr_cs(void)
 534 {
 535         return pcmcia_register_driver(&ibmtr_cs_driver);
 536 }
 537
 538 static void __exit exit_ibmtr_cs(void)
 539 {
 540         pcmcia_unregister_driver(&ibmtr_cs_driver);
 541         while (dev_list != NULL)
 542                 ibmtr_detach(dev_list);
 543 }
 544
 545 module_init(init_ibmtr_cs);
 546 module_exit(exit_ibmtr_cs);