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