git.oblomov.eu Git - linux-2.6/blob - drivers/atm/nicstar.c

   1 /******************************************************************************
   2  *
   3  * nicstar.c
   4  *
   5  * Device driver supporting CBR for IDT 77201/77211 "NICStAR" based cards.
   6  *
   7  * IMPORTANT: The included file nicstarmac.c was NOT WRITTEN BY ME.
   8  *            It was taken from the frle-0.22 device driver.
   9  *            As the file doesn't have a copyright notice, in the file
  10  *            nicstarmac.copyright I put the copyright notice from the
  11  *            frle-0.22 device driver.
  12  *            Some code is based on the nicstar driver by M. Welsh.
  13  *
  14  * Author: Rui Prior (rprior@inescn.pt)
  15  * PowerPC support by Jay Talbott (jay_talbott@mcg.mot.com) April 1999
  16  *
  17  *
  18  * (C) INESC 1999
  19  *
  20  *
  21  ******************************************************************************/
  22
  23
  24 /**** IMPORTANT INFORMATION ***************************************************
  25  *
  26  * There are currently three types of spinlocks:
  27  *
  28  * 1 - Per card interrupt spinlock (to protect structures and such)
  29  * 2 - Per SCQ scq spinlock
  30  * 3 - Per card resource spinlock (to access registers, etc.)
  31  *
  32  * These must NEVER be grabbed in reverse order.
  33  *
  34  ******************************************************************************/
  35
  36 /* Header files ***************************************************************/
  37
  38 #include <linux/module.h>
  39 #include <linux/config.h>
  40 #include <linux/kernel.h>
  41 #include <linux/skbuff.h>
  42 #include <linux/atmdev.h>
  43 #include <linux/atm.h>
  44 #include <linux/pci.h>
  45 #include <linux/types.h>
  46 #include <linux/string.h>
  47 #include <linux/delay.h>
  48 #include <linux/init.h>
  49 #include <linux/sched.h>
  50 #include <linux/timer.h>
  51 #include <linux/interrupt.h>
  52 #include <linux/bitops.h>
  53 #include <asm/io.h>
  54 #include <asm/uaccess.h>
  55 #include <asm/atomic.h>
  56 #include "nicstar.h"
  57 #ifdef CONFIG_ATM_NICSTAR_USE_SUNI
  58 #include "suni.h"
  59 #endif /* CONFIG_ATM_NICSTAR_USE_SUNI */
  60 #ifdef CONFIG_ATM_NICSTAR_USE_IDT77105
  61 #include "idt77105.h"
  62 #endif /* CONFIG_ATM_NICSTAR_USE_IDT77105 */
  63
  64 #if BITS_PER_LONG != 32
  65 #  error FIXME: this driver requires a 32-bit platform
  66 #endif
  67
  68 /* Additional code ************************************************************/
  69
  70 #include "nicstarmac.c"
  71
  72
  73 /* Configurable parameters ****************************************************/
  74
  75 #undef PHY_LOOPBACK
  76 #undef TX_DEBUG
  77 #undef RX_DEBUG
  78 #undef GENERAL_DEBUG
  79 #undef EXTRA_DEBUG
  80
  81 #undef NS_USE_DESTRUCTORS /* For now keep this undefined unless you know
  82                              you're going to use only raw ATM */
  83
  84
  85 /* Do not touch these *********************************************************/
  86
  87 #ifdef TX_DEBUG
  88 #define TXPRINTK(args...) printk(args)
  89 #else
  90 #define TXPRINTK(args...)
  91 #endif /* TX_DEBUG */
  92
  93 #ifdef RX_DEBUG
  94 #define RXPRINTK(args...) printk(args)
  95 #else
  96 #define RXPRINTK(args...)
  97 #endif /* RX_DEBUG */
  98
  99 #ifdef GENERAL_DEBUG
 100 #define PRINTK(args...) printk(args)
 101 #else
 102 #define PRINTK(args...)
 103 #endif /* GENERAL_DEBUG */
 104
 105 #ifdef EXTRA_DEBUG
 106 #define XPRINTK(args...) printk(args)
 107 #else
 108 #define XPRINTK(args...)
 109 #endif /* EXTRA_DEBUG */
 110
 111
 112 /* Macros *********************************************************************/
 113
 114 #define CMD_BUSY(card) (readl((card)->membase + STAT) & NS_STAT_CMDBZ)
 115
 116 #define NS_DELAY mdelay(1)
 117
 118 #define ALIGN_BUS_ADDR(addr, alignment) \
 119         ((((u32) (addr)) + (((u32) (alignment)) - 1)) & ~(((u32) (alignment)) - 1))
 120 #define ALIGN_ADDRESS(addr, alignment) \
 121         bus_to_virt(ALIGN_BUS_ADDR(virt_to_bus(addr), alignment))
 122
 123 #undef CEIL
 124
 125 #ifndef ATM_SKB
 126 #define ATM_SKB(s) (&(s)->atm)
 127 #endif
 128
 129    /* Spinlock debugging stuff */
 130 #ifdef NS_DEBUG_SPINLOCKS /* See nicstar.h */
 131 #define ns_grab_int_lock(card,flags) \
 132  do { \
 133     unsigned long nsdsf, nsdsf2; \
 134     local_irq_save(flags); \
 135     save_flags(nsdsf); cli();\
 136     if (nsdsf & (1<<9)) printk ("nicstar.c: ints %sabled -> enabled.\n", \
 137                                 (flags)&(1<<9)?"en":"dis"); \
 138     if (spin_is_locked(&(card)->int_lock) && \
 139         (card)->cpu_int == smp_processor_id()) { \
 140        printk("nicstar.c: line %d (cpu %d) int_lock already locked at line %d (cpu %d)\n", \
 141               __LINE__, smp_processor_id(), (card)->has_int_lock, \
 142               (card)->cpu_int); \
 143        printk("nicstar.c: ints were %sabled.\n", ((flags)&(1<<9)?"en":"dis")); \
 144     } \
 145     if (spin_is_locked(&(card)->res_lock) && \
 146         (card)->cpu_res == smp_processor_id()) { \
 147        printk("nicstar.c: line %d (cpu %d) res_lock locked at line %d (cpu %d)(trying int)\n", \
 148               __LINE__, smp_processor_id(), (card)->has_res_lock, \
 149               (card)->cpu_res); \
 150        printk("nicstar.c: ints were %sabled.\n", ((flags)&(1<<9)?"en":"dis")); \
 151     } \
 152     spin_lock_irq(&(card)->int_lock); \
 153     (card)->has_int_lock = __LINE__; \
 154     (card)->cpu_int = smp_processor_id(); \
 155     restore_flags(nsdsf); } while (0)
 156 #define ns_grab_res_lock(card,flags) \
 157  do { \
 158     unsigned long nsdsf, nsdsf2; \
 159     local_irq_save(flags); \
 160     save_flags(nsdsf); cli();\
 161     if (nsdsf & (1<<9)) printk ("nicstar.c: ints %sabled -> enabled.\n", \
 162                                 (flags)&(1<<9)?"en":"dis"); \
 163     if (spin_is_locked(&(card)->res_lock) && \
 164         (card)->cpu_res == smp_processor_id()) { \
 165        printk("nicstar.c: line %d (cpu %d) res_lock already locked at line %d (cpu %d)\n", \
 166               __LINE__, smp_processor_id(), (card)->has_res_lock, \
 167               (card)->cpu_res); \
 168        printk("nicstar.c: ints were %sabled.\n", ((flags)&(1<<9)?"en":"dis")); \
 169     } \
 170     spin_lock_irq(&(card)->res_lock); \
 171     (card)->has_res_lock = __LINE__; \
 172     (card)->cpu_res = smp_processor_id(); \
 173     restore_flags(nsdsf); } while (0)
 174 #define ns_grab_scq_lock(card,scq,flags) \
 175  do { \
 176     unsigned long nsdsf, nsdsf2; \
 177     local_irq_save(flags); \
 178     save_flags(nsdsf); cli();\
 179     if (nsdsf & (1<<9)) printk ("nicstar.c: ints %sabled -> enabled.\n", \
 180                                 (flags)&(1<<9)?"en":"dis"); \
 181     if (spin_is_locked(&(scq)->lock) && \
 182         (scq)->cpu_lock == smp_processor_id()) { \
 183        printk("nicstar.c: line %d (cpu %d) this scq_lock already locked at line %d (cpu %d)\n", \
 184               __LINE__, smp_processor_id(), (scq)->has_lock, \
 185               (scq)->cpu_lock); \
 186        printk("nicstar.c: ints were %sabled.\n", ((flags)&(1<<9)?"en":"dis")); \
 187     } \
 188     if (spin_is_locked(&(card)->res_lock) && \
 189         (card)->cpu_res == smp_processor_id()) { \
 190        printk("nicstar.c: line %d (cpu %d) res_lock locked at line %d (cpu %d)(trying scq)\n", \
 191               __LINE__, smp_processor_id(), (card)->has_res_lock, \
 192               (card)->cpu_res); \
 193        printk("nicstar.c: ints were %sabled.\n", ((flags)&(1<<9)?"en":"dis")); \
 194     } \
 195     spin_lock_irq(&(scq)->lock); \
 196     (scq)->has_lock = __LINE__; \
 197     (scq)->cpu_lock = smp_processor_id(); \
 198     restore_flags(nsdsf); } while (0)
 199 #else /* !NS_DEBUG_SPINLOCKS */
 200 #define ns_grab_int_lock(card,flags) \
 201         spin_lock_irqsave(&(card)->int_lock,(flags))
 202 #define ns_grab_res_lock(card,flags) \
 203         spin_lock_irqsave(&(card)->res_lock,(flags))
 204 #define ns_grab_scq_lock(card,scq,flags) \
 205         spin_lock_irqsave(&(scq)->lock,flags)
 206 #endif /* NS_DEBUG_SPINLOCKS */
 207
 208
 209 /* Function declarations ******************************************************/
 210
 211 static u32 ns_read_sram(ns_dev *card, u32 sram_address);
 212 static void ns_write_sram(ns_dev *card, u32 sram_address, u32 *value, int count);
 213 static int __devinit ns_init_card(int i, struct pci_dev *pcidev);
 214 static void __devinit ns_init_card_error(ns_dev *card, int error);
 215 static scq_info *get_scq(int size, u32 scd);
 216 static void free_scq(scq_info *scq, struct atm_vcc *vcc);
 217 static void push_rxbufs(ns_dev *card, u32 type, u32 handle1, u32 addr1,
 218                        u32 handle2, u32 addr2);
 219 static irqreturn_t ns_irq_handler(int irq, void *dev_id, struct pt_regs *regs);
 220 static int ns_open(struct atm_vcc *vcc);
 221 static void ns_close(struct atm_vcc *vcc);
 222 static void fill_tst(ns_dev *card, int n, vc_map *vc);
 223 static int ns_send(struct atm_vcc *vcc, struct sk_buff *skb);
 224 static int push_scqe(ns_dev *card, vc_map *vc, scq_info *scq, ns_scqe *tbd,
 225                      struct sk_buff *skb);
 226 static void process_tsq(ns_dev *card);
 227 static void drain_scq(ns_dev *card, scq_info *scq, int pos);
 228 static void process_rsq(ns_dev *card);
 229 static void dequeue_rx(ns_dev *card, ns_rsqe *rsqe);
 230 #ifdef NS_USE_DESTRUCTORS
 231 static void ns_sb_destructor(struct sk_buff *sb);
 232 static void ns_lb_destructor(struct sk_buff *lb);
 233 static void ns_hb_destructor(struct sk_buff *hb);
 234 #endif /* NS_USE_DESTRUCTORS */
 235 static void recycle_rx_buf(ns_dev *card, struct sk_buff *skb);
 236 static void recycle_iovec_rx_bufs(ns_dev *card, struct iovec *iov, int count);
 237 static void recycle_iov_buf(ns_dev *card, struct sk_buff *iovb);
 238 static void dequeue_sm_buf(ns_dev *card, struct sk_buff *sb);
 239 static void dequeue_lg_buf(ns_dev *card, struct sk_buff *lb);
 240 static int ns_proc_read(struct atm_dev *dev, loff_t *pos, char *page);
 241 static int ns_ioctl(struct atm_dev *dev, unsigned int cmd, void __user *arg);
 242 static void which_list(ns_dev *card, struct sk_buff *skb);
 243 static void ns_poll(unsigned long arg);
 244 static int ns_parse_mac(char *mac, unsigned char *esi);
 245 static short ns_h2i(char c);
 246 static void ns_phy_put(struct atm_dev *dev, unsigned char value,
 247                        unsigned long addr);
 248 static unsigned char ns_phy_get(struct atm_dev *dev, unsigned long addr);
 249
 250
 251
 252 /* Global variables ***********************************************************/
 253
 254 static struct ns_dev *cards[NS_MAX_CARDS];
 255 static unsigned num_cards;
 256 static struct atmdev_ops atm_ops =
 257 {
 258    .open        = ns_open,
 259    .close       = ns_close,
 260    .ioctl       = ns_ioctl,
 261    .send        = ns_send,
 262    .phy_put     = ns_phy_put,
 263    .phy_get     = ns_phy_get,
 264    .proc_read   = ns_proc_read,
 265    .owner       = THIS_MODULE,
 266 };
 267 static struct timer_list ns_timer;
 268 static char *mac[NS_MAX_CARDS];
 269 module_param_array(mac, charp, NULL, 0);
 270 MODULE_LICENSE("GPL");
 271
 272
 273 /* Functions*******************************************************************/
 274
 275 static int __devinit nicstar_init_one(struct pci_dev *pcidev,
 276                                       const struct pci_device_id *ent)
 277 {
 278    static int index = -1;
 279    unsigned int error;
 280
 281    index++;
 282    cards[index] = NULL;
 283
 284    error = ns_init_card(index, pcidev);
 285    if (error) {
 286       cards[index--] = NULL;    /* don't increment index */
 287       goto err_out;
 288    }
 289
 290    return 0;
 291 err_out:
 292    return -ENODEV;
 293 }
 294
 295
 296
 297 static void __devexit nicstar_remove_one(struct pci_dev *pcidev)
 298 {
 299    int i, j;
 300    ns_dev *card = pci_get_drvdata(pcidev);
 301    struct sk_buff *hb;
 302    struct sk_buff *iovb;
 303    struct sk_buff *lb;
 304    struct sk_buff *sb;
 305
 306    i = card->index;
 307
 308    if (cards[i] == NULL)
 309       return;
 310
 311    if (card->atmdev->phy && card->atmdev->phy->stop)
 312       card->atmdev->phy->stop(card->atmdev);
 313
 314    /* Stop everything */
 315    writel(0x00000000, card->membase + CFG);
 316
 317    /* De-register device */
 318    atm_dev_deregister(card->atmdev);
 319
 320    /* Disable PCI device */
 321    pci_disable_device(pcidev);
 322
 323    /* Free up resources */
 324    j = 0;
 325    PRINTK("nicstar%d: freeing %d huge buffers.\n", i, card->hbpool.count);
 326    while ((hb = skb_dequeue(&card->hbpool.queue)) != NULL)
 327    {
 328       dev_kfree_skb_any(hb);
 329       j++;
 330    }
 331    PRINTK("nicstar%d: %d huge buffers freed.\n", i, j);
 332    j = 0;
 333    PRINTK("nicstar%d: freeing %d iovec buffers.\n", i, card->iovpool.count);
 334    while ((iovb = skb_dequeue(&card->iovpool.queue)) != NULL)
 335    {
 336       dev_kfree_skb_any(iovb);
 337       j++;
 338    }
 339    PRINTK("nicstar%d: %d iovec buffers freed.\n", i, j);
 340    while ((lb = skb_dequeue(&card->lbpool.queue)) != NULL)
 341       dev_kfree_skb_any(lb);
 342    while ((sb = skb_dequeue(&card->sbpool.queue)) != NULL)
 343       dev_kfree_skb_any(sb);
 344    free_scq(card->scq0, NULL);
 345    for (j = 0; j < NS_FRSCD_NUM; j++)
 346    {
 347       if (card->scd2vc[j] != NULL)
 348          free_scq(card->scd2vc[j]->scq, card->scd2vc[j]->tx_vcc);
 349    }
 350    kfree(card->rsq.org);
 351    kfree(card->tsq.org);
 352    free_irq(card->pcidev->irq, card);
 353    iounmap(card->membase);
 354    kfree(card);
 355 }
 356
 357
 358
 359 static struct pci_device_id nicstar_pci_tbl[] __devinitdata =
 360 {
 361         {PCI_VENDOR_ID_IDT, PCI_DEVICE_ID_IDT_IDT77201,
 362          PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
 363         {0,}                    /* terminate list */
 364 };
 365 MODULE_DEVICE_TABLE(pci, nicstar_pci_tbl);
 366
 367
 368
 369 static struct pci_driver nicstar_driver = {
 370         .name           = "nicstar",
 371         .id_table       = nicstar_pci_tbl,
 372         .probe          = nicstar_init_one,
 373         .remove         = __devexit_p(nicstar_remove_one),
 374 };
 375
 376
 377
 378 static int __init nicstar_init(void)
 379 {
 380    unsigned error = 0;  /* Initialized to remove compile warning */
 381
 382    XPRINTK("nicstar: nicstar_init() called.\n");
 383
 384    error = pci_register_driver(&nicstar_driver);
 385
 386    TXPRINTK("nicstar: TX debug enabled.\n");
 387    RXPRINTK("nicstar: RX debug enabled.\n");
 388    PRINTK("nicstar: General debug enabled.\n");
 389 #ifdef PHY_LOOPBACK
 390    printk("nicstar: using PHY loopback.\n");
 391 #endif /* PHY_LOOPBACK */
 392    XPRINTK("nicstar: nicstar_init() returned.\n");
 393
 394    if (!error) {
 395       init_timer(&ns_timer);
 396       ns_timer.expires = jiffies + NS_POLL_PERIOD;
 397       ns_timer.data = 0UL;
 398       ns_timer.function = ns_poll;
 399       add_timer(&ns_timer);
 400    }
 401
 402    return error;
 403 }
 404
 405
 406
 407 static void __exit nicstar_cleanup(void)
 408 {
 409    XPRINTK("nicstar: nicstar_cleanup() called.\n");
 410
 411    del_timer(&ns_timer);
 412
 413    pci_unregister_driver(&nicstar_driver);
 414
 415    XPRINTK("nicstar: nicstar_cleanup() returned.\n");
 416 }
 417
 418
 419
 420 static u32 ns_read_sram(ns_dev *card, u32 sram_address)
 421 {
 422    unsigned long flags;
 423    u32 data;
 424    sram_address <<= 2;
 425    sram_address &= 0x0007FFFC;  /* address must be dword aligned */
 426    sram_address |= 0x50000000;  /* SRAM read command */
 427    ns_grab_res_lock(card, flags);
 428    while (CMD_BUSY(card));
 429    writel(sram_address, card->membase + CMD);
 430    while (CMD_BUSY(card));
 431    data = readl(card->membase + DR0);
 432    spin_unlock_irqrestore(&card->res_lock, flags);
 433    return data;
 434 }
 435
 436
 437
 438 static void ns_write_sram(ns_dev *card, u32 sram_address, u32 *value, int count)
 439 {
 440    unsigned long flags;
 441    int i, c;
 442    count--;     /* count range now is 0..3 instead of 1..4 */
 443    c = count;
 444    c <<= 2;     /* to use increments of 4 */
 445    ns_grab_res_lock(card, flags);
 446    while (CMD_BUSY(card));
 447    for (i = 0; i <= c; i += 4)
 448       writel(*(value++), card->membase + i);
 449    /* Note: DR# registers are the first 4 dwords in nicstar's memspace,
 450             so card->membase + DR0 == card->membase */
 451    sram_address <<= 2;
 452    sram_address &= 0x0007FFFC;
 453    sram_address |= (0x40000000 | count);
 454    writel(sram_address, card->membase + CMD);
 455    spin_unlock_irqrestore(&card->res_lock, flags);
 456 }
 457
 458
 459 static int __devinit ns_init_card(int i, struct pci_dev *pcidev)
 460 {
 461    int j;
 462    struct ns_dev *card = NULL;
 463    unsigned char pci_latency;
 464    unsigned error;
 465    u32 data;
 466    u32 u32d[4];
 467    u32 ns_cfg_rctsize;
 468    int bcount;
 469    unsigned long membase;
 470
 471    error = 0;
 472
 473    if (pci_enable_device(pcidev))
 474    {
 475       printk("nicstar%d: can't enable PCI device\n", i);
 476       error = 2;
 477       ns_init_card_error(card, error);
 478       return error;
 479    }
 480
 481    if ((card = kmalloc(sizeof(ns_dev), GFP_KERNEL)) == NULL)
 482    {
 483       printk("nicstar%d: can't allocate memory for device structure.\n", i);
 484       error = 2;
 485       ns_init_card_error(card, error);
 486       return error;
 487    }
 488    cards[i] = card;
 489    spin_lock_init(&card->int_lock);
 490    spin_lock_init(&card->res_lock);
 491
 492    pci_set_drvdata(pcidev, card);
 493
 494    card->index = i;
 495    card->atmdev = NULL;
 496    card->pcidev = pcidev;
 497    membase = pci_resource_start(pcidev, 1);
 498    card->membase = ioremap(membase, NS_IOREMAP_SIZE);
 499    if (card->membase == 0)
 500    {
 501       printk("nicstar%d: can't ioremap() membase.\n",i);
 502       error = 3;
 503       ns_init_card_error(card, error);
 504       return error;
 505    }
 506    PRINTK("nicstar%d: membase at 0x%x.\n", i, card->membase);
 507
 508    pci_set_master(pcidev);
 509
 510    if (pci_read_config_byte(pcidev, PCI_LATENCY_TIMER, &pci_latency) != 0)
 511    {
 512       printk("nicstar%d: can't read PCI latency timer.\n", i);
 513       error = 6;
 514       ns_init_card_error(card, error);
 515       return error;
 516    }
 517 #ifdef NS_PCI_LATENCY
 518    if (pci_latency < NS_PCI_LATENCY)
 519    {
 520       PRINTK("nicstar%d: setting PCI latency timer to %d.\n", i, NS_PCI_LATENCY);
 521       for (j = 1; j < 4; j++)
 522       {
 523          if (pci_write_config_byte(pcidev, PCI_LATENCY_TIMER, NS_PCI_LATENCY) != 0)
 524             break;
 525       }
 526       if (j == 4)
 527       {
 528          printk("nicstar%d: can't set PCI latency timer to %d.\n", i, NS_PCI_LATENCY);
 529          error = 7;
 530          ns_init_card_error(card, error);
 531          return error;
 532       }
 533    }
 534 #endif /* NS_PCI_LATENCY */
 535
 536    /* Clear timer overflow */
 537    data = readl(card->membase + STAT);
 538    if (data & NS_STAT_TMROF)
 539       writel(NS_STAT_TMROF, card->membase + STAT);
 540
 541    /* Software reset */
 542    writel(NS_CFG_SWRST, card->membase + CFG);
 543    NS_DELAY;
 544    writel(0x00000000, card->membase + CFG);
 545
 546    /* PHY reset */
 547    writel(0x00000008, card->membase + GP);
 548    NS_DELAY;
 549    writel(0x00000001, card->membase + GP);
 550    NS_DELAY;
 551    while (CMD_BUSY(card));
 552    writel(NS_CMD_WRITE_UTILITY | 0x00000100, card->membase + CMD);      /* Sync UTOPIA with SAR clock */
 553    NS_DELAY;
 554
 555    /* Detect PHY type */
 556    while (CMD_BUSY(card));
 557    writel(NS_CMD_READ_UTILITY | 0x00000200, card->membase + CMD);
 558    while (CMD_BUSY(card));
 559    data = readl(card->membase + DR0);
 560    switch(data) {
 561       case 0x00000009:
 562          printk("nicstar%d: PHY seems to be 25 Mbps.\n", i);
 563          card->max_pcr = ATM_25_PCR;
 564          while(CMD_BUSY(card));
 565          writel(0x00000008, card->membase + DR0);
 566          writel(NS_CMD_WRITE_UTILITY | 0x00000200, card->membase + CMD);
 567          /* Clear an eventual pending interrupt */
 568          writel(NS_STAT_SFBQF, card->membase + STAT);
 569 #ifdef PHY_LOOPBACK
 570          while(CMD_BUSY(card));
 571          writel(0x00000022, card->membase + DR0);
 572          writel(NS_CMD_WRITE_UTILITY | 0x00000202, card->membase + CMD);
 573 #endif /* PHY_LOOPBACK */
 574          break;
 575       case 0x00000030:
 576       case 0x00000031:
 577          printk("nicstar%d: PHY seems to be 155 Mbps.\n", i);
 578          card->max_pcr = ATM_OC3_PCR;
 579 #ifdef PHY_LOOPBACK
 580          while(CMD_BUSY(card));
 581          writel(0x00000002, card->membase + DR0);
 582          writel(NS_CMD_WRITE_UTILITY | 0x00000205, card->membase + CMD);
 583 #endif /* PHY_LOOPBACK */
 584          break;
 585       default:
 586          printk("nicstar%d: unknown PHY type (0x%08X).\n", i, data);
 587          error = 8;
 588          ns_init_card_error(card, error);
 589          return error;
 590    }
 591    writel(0x00000000, card->membase + GP);
 592
 593    /* Determine SRAM size */
 594    data = 0x76543210;
 595    ns_write_sram(card, 0x1C003, &data, 1);
 596    data = 0x89ABCDEF;
 597    ns_write_sram(card, 0x14003, &data, 1);
 598    if (ns_read_sram(card, 0x14003) == 0x89ABCDEF &&
 599        ns_read_sram(card, 0x1C003) == 0x76543210)
 600        card->sram_size = 128;
 601    else
 602       card->sram_size = 32;
 603    PRINTK("nicstar%d: %dK x 32bit SRAM size.\n", i, card->sram_size);
 604
 605    card->rct_size = NS_MAX_RCTSIZE;
 606
 607 #if (NS_MAX_RCTSIZE == 4096)
 608    if (card->sram_size == 128)
 609       printk("nicstar%d: limiting maximum VCI. See NS_MAX_RCTSIZE in nicstar.h\n", i);
 610 #elif (NS_MAX_RCTSIZE == 16384)
 611    if (card->sram_size == 32)
 612    {
 613       printk("nicstar%d: wasting memory. See NS_MAX_RCTSIZE in nicstar.h\n", i);
 614       card->rct_size = 4096;
 615    }
 616 #else
 617 #error NS_MAX_RCTSIZE must be either 4096 or 16384 in nicstar.c
 618 #endif
 619
 620    card->vpibits = NS_VPIBITS;
 621    if (card->rct_size == 4096)
 622       card->vcibits = 12 - NS_VPIBITS;
 623    else /* card->rct_size == 16384 */
 624       card->vcibits = 14 - NS_VPIBITS;
 625
 626    /* Initialize the nicstar eeprom/eprom stuff, for the MAC addr */
 627    if (mac[i] == NULL)
 628       nicstar_init_eprom(card->membase);
 629
 630    if (request_irq(pcidev->irq, &ns_irq_handler, SA_INTERRUPT | SA_SHIRQ, "nicstar", card) != 0)
 631    {
 632       printk("nicstar%d: can't allocate IRQ %d.\n", i, pcidev->irq);
 633       error = 9;
 634       ns_init_card_error(card, error);
 635       return error;
 636    }
 637
 638    /* Set the VPI/VCI MSb mask to zero so we can receive OAM cells */
 639    writel(0x00000000, card->membase + VPM);
 640
 641    /* Initialize TSQ */
 642    card->tsq.org = kmalloc(NS_TSQSIZE + NS_TSQ_ALIGNMENT, GFP_KERNEL);
 643    if (card->tsq.org == NULL)
 644    {
 645       printk("nicstar%d: can't allocate TSQ.\n", i);
 646       error = 10;
 647       ns_init_card_error(card, error);
 648       return error;
 649    }
 650    card->tsq.base = (ns_tsi *) ALIGN_ADDRESS(card->tsq.org, NS_TSQ_ALIGNMENT);
 651    card->tsq.next = card->tsq.base;
 652    card->tsq.last = card->tsq.base + (NS_TSQ_NUM_ENTRIES - 1);
 653    for (j = 0; j < NS_TSQ_NUM_ENTRIES; j++)
 654       ns_tsi_init(card->tsq.base + j);
 655    writel(0x00000000, card->membase + TSQH);
 656    writel((u32) virt_to_bus(card->tsq.base), card->membase + TSQB);
 657    PRINTK("nicstar%d: TSQ base at 0x%x  0x%x  0x%x.\n", i, (u32) card->tsq.base,
 658           (u32) virt_to_bus(card->tsq.base), readl(card->membase + TSQB));
 659
 660    /* Initialize RSQ */
 661    card->rsq.org = kmalloc(NS_RSQSIZE + NS_RSQ_ALIGNMENT, GFP_KERNEL);
 662    if (card->rsq.org == NULL)
 663    {
 664       printk("nicstar%d: can't allocate RSQ.\n", i);
 665       error = 11;
 666       ns_init_card_error(card, error);
 667       return error;
 668    }
 669    card->rsq.base = (ns_rsqe *) ALIGN_ADDRESS(card->rsq.org, NS_RSQ_ALIGNMENT);
 670    card->rsq.next = card->rsq.base;
 671    card->rsq.last = card->rsq.base + (NS_RSQ_NUM_ENTRIES - 1);
 672    for (j = 0; j < NS_RSQ_NUM_ENTRIES; j++)
 673       ns_rsqe_init(card->rsq.base + j);
 674    writel(0x00000000, card->membase + RSQH);
 675    writel((u32) virt_to_bus(card->rsq.base), card->membase + RSQB);
 676    PRINTK("nicstar%d: RSQ base at 0x%x.\n", i, (u32) card->rsq.base);
 677
 678    /* Initialize SCQ0, the only VBR SCQ used */
 679    card->scq1 = NULL;
 680    card->scq2 = NULL;
 681    card->scq0 = get_scq(VBR_SCQSIZE, NS_VRSCD0);
 682    if (card->scq0 == NULL)
 683    {
 684       printk("nicstar%d: can't get SCQ0.\n", i);
 685       error = 12;
 686       ns_init_card_error(card, error);
 687       return error;
 688    }
 689    u32d[0] = (u32) virt_to_bus(card->scq0->base);
 690    u32d[1] = (u32) 0x00000000;
 691    u32d[2] = (u32) 0xffffffff;
 692    u32d[3] = (u32) 0x00000000;
 693    ns_write_sram(card, NS_VRSCD0, u32d, 4);
 694    ns_write_sram(card, NS_VRSCD1, u32d, 4);     /* These last two won't be used */
 695    ns_write_sram(card, NS_VRSCD2, u32d, 4);     /* but are initialized, just in case... */
 696    card->scq0->scd = NS_VRSCD0;
 697    PRINTK("nicstar%d: VBR-SCQ0 base at 0x%x.\n", i, (u32) card->scq0->base);
 698
 699    /* Initialize TSTs */
 700    card->tst_addr = NS_TST0;
 701    card->tst_free_entries = NS_TST_NUM_ENTRIES;
 702    data = NS_TST_OPCODE_VARIABLE;
 703    for (j = 0; j < NS_TST_NUM_ENTRIES; j++)
 704       ns_write_sram(card, NS_TST0 + j, &data, 1);
 705    data = ns_tste_make(NS_TST_OPCODE_END, NS_TST0);
 706    ns_write_sram(card, NS_TST0 + NS_TST_NUM_ENTRIES, &data, 1);
 707    for (j = 0; j < NS_TST_NUM_ENTRIES; j++)
 708       ns_write_sram(card, NS_TST1 + j, &data, 1);
 709    data = ns_tste_make(NS_TST_OPCODE_END, NS_TST1);
 710    ns_write_sram(card, NS_TST1 + NS_TST_NUM_ENTRIES, &data, 1);
 711    for (j = 0; j < NS_TST_NUM_ENTRIES; j++)
 712       card->tste2vc[j] = NULL;
 713    writel(NS_TST0 << 2, card->membase + TSTB);
 714
 715
 716    /* Initialize RCT. AAL type is set on opening the VC. */
 717 #ifdef RCQ_SUPPORT
 718    u32d[0] = NS_RCTE_RAWCELLINTEN;
 719 #else
 720    u32d[0] = 0x00000000;
 721 #endif /* RCQ_SUPPORT */
 722    u32d[1] = 0x00000000;
 723    u32d[2] = 0x00000000;
 724    u32d[3] = 0xFFFFFFFF;
 725    for (j = 0; j < card->rct_size; j++)
 726       ns_write_sram(card, j * 4, u32d, 4);
 727
 728    memset(card->vcmap, 0, NS_MAX_RCTSIZE * sizeof(vc_map));
 729
 730    for (j = 0; j < NS_FRSCD_NUM; j++)
 731       card->scd2vc[j] = NULL;
 732
 733    /* Initialize buffer levels */
 734    card->sbnr.min = MIN_SB;
 735    card->sbnr.init = NUM_SB;
 736    card->sbnr.max = MAX_SB;
 737    card->lbnr.min = MIN_LB;
 738    card->lbnr.init = NUM_LB;
 739    card->lbnr.max = MAX_LB;
 740    card->iovnr.min = MIN_IOVB;
 741    card->iovnr.init = NUM_IOVB;
 742    card->iovnr.max = MAX_IOVB;
 743    card->hbnr.min = MIN_HB;
 744    card->hbnr.init = NUM_HB;
 745    card->hbnr.max = MAX_HB;
 746
 747    card->sm_handle = 0x00000000;
 748    card->sm_addr = 0x00000000;
 749    card->lg_handle = 0x00000000;
 750    card->lg_addr = 0x00000000;
 751
 752    card->efbie = 1;     /* To prevent push_rxbufs from enabling the interrupt */
 753
 754    /* Pre-allocate some huge buffers */
 755    skb_queue_head_init(&card->hbpool.queue);
 756    card->hbpool.count = 0;
 757    for (j = 0; j < NUM_HB; j++)
 758    {
 759       struct sk_buff *hb;
 760       hb = __dev_alloc_skb(NS_HBUFSIZE, GFP_KERNEL);
 761       if (hb == NULL)
 762       {
 763          printk("nicstar%d: can't allocate %dth of %d huge buffers.\n",
 764                 i, j, NUM_HB);
 765          error = 13;
 766          ns_init_card_error(card, error);
 767          return error;
 768       }
 769       skb_queue_tail(&card->hbpool.queue, hb);
 770       card->hbpool.count++;
 771    }
 772
 773
 774    /* Allocate large buffers */
 775    skb_queue_head_init(&card->lbpool.queue);
 776    card->lbpool.count = 0;                      /* Not used */
 777    for (j = 0; j < NUM_LB; j++)
 778    {
 779       struct sk_buff *lb;
 780       lb = __dev_alloc_skb(NS_LGSKBSIZE, GFP_KERNEL);
 781       if (lb == NULL)
 782       {
 783          printk("nicstar%d: can't allocate %dth of %d large buffers.\n",
 784                 i, j, NUM_LB);
 785          error = 14;
 786          ns_init_card_error(card, error);
 787          return error;
 788       }
 789       skb_queue_tail(&card->lbpool.queue, lb);
 790       skb_reserve(lb, NS_SMBUFSIZE);
 791       push_rxbufs(card, BUF_LG, (u32) lb, (u32) virt_to_bus(lb->data), 0, 0);
 792       /* Due to the implementation of push_rxbufs() this is 1, not 0 */
 793       if (j == 1)
 794       {
 795          card->rcbuf = lb;
 796          card->rawch = (u32) virt_to_bus(lb->data);
 797       }
 798    }
 799    /* Test for strange behaviour which leads to crashes */
 800    if ((bcount = ns_stat_lfbqc_get(readl(card->membase + STAT))) < card->lbnr.min)
 801    {
 802       printk("nicstar%d: Strange... Just allocated %d large buffers and lfbqc = %d.\n",
 803              i, j, bcount);
 804       error = 14;
 805       ns_init_card_error(card, error);
 806       return error;
 807    }
 808
 809
 810    /* Allocate small buffers */
 811    skb_queue_head_init(&card->sbpool.queue);
 812    card->sbpool.count = 0;                      /* Not used */
 813    for (j = 0; j < NUM_SB; j++)
 814    {
 815       struct sk_buff *sb;
 816       sb = __dev_alloc_skb(NS_SMSKBSIZE, GFP_KERNEL);
 817       if (sb == NULL)
 818       {
 819          printk("nicstar%d: can't allocate %dth of %d small buffers.\n",
 820                 i, j, NUM_SB);
 821          error = 15;
 822          ns_init_card_error(card, error);
 823          return error;
 824       }
 825       skb_queue_tail(&card->sbpool.queue, sb);
 826       skb_reserve(sb, NS_AAL0_HEADER);
 827       push_rxbufs(card, BUF_SM, (u32) sb, (u32) virt_to_bus(sb->data), 0, 0);
 828    }
 829    /* Test for strange behaviour which leads to crashes */
 830    if ((bcount = ns_stat_sfbqc_get(readl(card->membase + STAT))) < card->sbnr.min)
 831    {
 832       printk("nicstar%d: Strange... Just allocated %d small buffers and sfbqc = %d.\n",
 833              i, j, bcount);
 834       error = 15;
 835       ns_init_card_error(card, error);
 836       return error;
 837    }
 838
 839
 840    /* Allocate iovec buffers */
 841    skb_queue_head_init(&card->iovpool.queue);
 842    card->iovpool.count = 0;
 843    for (j = 0; j < NUM_IOVB; j++)
 844    {
 845       struct sk_buff *iovb;
 846       iovb = alloc_skb(NS_IOVBUFSIZE, GFP_KERNEL);
 847       if (iovb == NULL)
 848       {
 849          printk("nicstar%d: can't allocate %dth of %d iovec buffers.\n",
 850                 i, j, NUM_IOVB);
 851          error = 16;
 852          ns_init_card_error(card, error);
 853          return error;
 854       }
 855       skb_queue_tail(&card->iovpool.queue, iovb);
 856       card->iovpool.count++;
 857    }
 858
 859    card->intcnt = 0;
 860
 861    /* Configure NICStAR */
 862    if (card->rct_size == 4096)
 863       ns_cfg_rctsize = NS_CFG_RCTSIZE_4096_ENTRIES;
 864    else /* (card->rct_size == 16384) */
 865       ns_cfg_rctsize = NS_CFG_RCTSIZE_16384_ENTRIES;
 866
 867    card->efbie = 1;
 868
 869    /* Register device */
 870    card->atmdev = atm_dev_register("nicstar", &atm_ops, -1, NULL);
 871    if (card->atmdev == NULL)
 872    {
 873       printk("nicstar%d: can't register device.\n", i);
 874       error = 17;
 875       ns_init_card_error(card, error);
 876       return error;
 877    }
 878
 879    if (ns_parse_mac(mac[i], card->atmdev->esi)) {
 880       nicstar_read_eprom(card->membase, NICSTAR_EPROM_MAC_ADDR_OFFSET,
 881                          card->atmdev->esi, 6);
 882       if (memcmp(card->atmdev->esi, "\x00\x00\x00\x00\x00\x00", 6) == 0) {
 883          nicstar_read_eprom(card->membase, NICSTAR_EPROM_MAC_ADDR_OFFSET_ALT,
 884                          card->atmdev->esi, 6);
 885       }
 886    }
 887
 888    printk("nicstar%d: MAC address %02X:%02X:%02X:%02X:%02X:%02X\n", i,
 889           card->atmdev->esi[0], card->atmdev->esi[1], card->atmdev->esi[2],
 890           card->atmdev->esi[3], card->atmdev->esi[4], card->atmdev->esi[5]);
 891
 892    card->atmdev->dev_data = card;
 893    card->atmdev->ci_range.vpi_bits = card->vpibits;
 894    card->atmdev->ci_range.vci_bits = card->vcibits;
 895    card->atmdev->link_rate = card->max_pcr;
 896    card->atmdev->phy = NULL;
 897
 898 #ifdef CONFIG_ATM_NICSTAR_USE_SUNI
 899    if (card->max_pcr == ATM_OC3_PCR)
 900       suni_init(card->atmdev);
 901 #endif /* CONFIG_ATM_NICSTAR_USE_SUNI */
 902
 903 #ifdef CONFIG_ATM_NICSTAR_USE_IDT77105
 904    if (card->max_pcr == ATM_25_PCR)
 905       idt77105_init(card->atmdev);
 906 #endif /* CONFIG_ATM_NICSTAR_USE_IDT77105 */
 907
 908    if (card->atmdev->phy && card->atmdev->phy->start)
 909       card->atmdev->phy->start(card->atmdev);
 910
 911    writel(NS_CFG_RXPATH |
 912           NS_CFG_SMBUFSIZE |
 913           NS_CFG_LGBUFSIZE |
 914           NS_CFG_EFBIE |
 915           NS_CFG_RSQSIZE |
 916           NS_CFG_VPIBITS |
 917           ns_cfg_rctsize |
 918           NS_CFG_RXINT_NODELAY |
 919           NS_CFG_RAWIE |                /* Only enabled if RCQ_SUPPORT */
 920           NS_CFG_RSQAFIE |
 921           NS_CFG_TXEN |
 922           NS_CFG_TXIE |
 923           NS_CFG_TSQFIE_OPT |           /* Only enabled if ENABLE_TSQFIE */
 924           NS_CFG_PHYIE,
 925           card->membase + CFG);
 926
 927    num_cards++;
 928
 929    return error;
 930 }
 931
 932
 933
 934 static void __devinit ns_init_card_error(ns_dev *card, int error)
 935 {
 936    if (error >= 17)
 937    {
 938       writel(0x00000000, card->membase + CFG);
 939    }
 940    if (error >= 16)
 941    {
 942       struct sk_buff *iovb;
 943       while ((iovb = skb_dequeue(&card->iovpool.queue)) != NULL)
 944          dev_kfree_skb_any(iovb);
 945    }
 946    if (error >= 15)
 947    {
 948       struct sk_buff *sb;
 949       while ((sb = skb_dequeue(&card->sbpool.queue)) != NULL)
 950          dev_kfree_skb_any(sb);
 951       free_scq(card->scq0, NULL);
 952    }
 953    if (error >= 14)
 954    {
 955       struct sk_buff *lb;
 956       while ((lb = skb_dequeue(&card->lbpool.queue)) != NULL)
 957          dev_kfree_skb_any(lb);
 958    }
 959    if (error >= 13)
 960    {
 961       struct sk_buff *hb;
 962       while ((hb = skb_dequeue(&card->hbpool.queue)) != NULL)
 963          dev_kfree_skb_any(hb);
 964    }
 965    if (error >= 12)
 966    {
 967       kfree(card->rsq.org);
 968    }
 969    if (error >= 11)
 970    {
 971       kfree(card->tsq.org);
 972    }
 973    if (error >= 10)
 974    {
 975       free_irq(card->pcidev->irq, card);
 976    }
 977    if (error >= 4)
 978    {
 979       iounmap(card->membase);
 980    }
 981    if (error >= 3)
 982    {
 983       pci_disable_device(card->pcidev);
 984       kfree(card);
 985    }
 986 }
 987
 988
 989
 990 static scq_info *get_scq(int size, u32 scd)
 991 {
 992    scq_info *scq;
 993    int i;
 994
 995    if (size != VBR_SCQSIZE && size != CBR_SCQSIZE)
 996       return NULL;
 997
 998    scq = (scq_info *) kmalloc(sizeof(scq_info), GFP_KERNEL);
 999    if (scq == NULL)
1000       return NULL;
1001    scq->org = kmalloc(2 * size, GFP_KERNEL);
1002    if (scq->org == NULL)
1003    {
1004       kfree(scq);
1005       return NULL;
1006    }
1007    scq->skb = (struct sk_buff **) kmalloc(sizeof(struct sk_buff *) *
1008                                           (size / NS_SCQE_SIZE), GFP_KERNEL);
1009    if (scq->skb == NULL)
1010    {
1011       kfree(scq->org);
1012       kfree(scq);
1013       return NULL;
1014    }
1015    scq->num_entries = size / NS_SCQE_SIZE;
1016    scq->base = (ns_scqe *) ALIGN_ADDRESS(scq->org, size);
1017    scq->next = scq->base;
1018    scq->last = scq->base + (scq->num_entries - 1);
1019    scq->tail = scq->last;
1020    scq->scd = scd;
1021    scq->num_entries = size / NS_SCQE_SIZE;
1022    scq->tbd_count = 0;
1023    init_waitqueue_head(&scq->scqfull_waitq);
1024    scq->full = 0;
1025    spin_lock_init(&scq->lock);
1026
1027    for (i = 0; i < scq->num_entries; i++)
1028       scq->skb[i] = NULL;
1029
1030    return scq;
1031 }
1032
1033
1034
1035 /* For variable rate SCQ vcc must be NULL */
1036 static void free_scq(scq_info *scq, struct atm_vcc *vcc)
1037 {
1038    int i;
1039
1040    if (scq->num_entries == VBR_SCQ_NUM_ENTRIES)
1041       for (i = 0; i < scq->num_entries; i++)
1042       {
1043          if (scq->skb[i] != NULL)
1044          {
1045             vcc = ATM_SKB(scq->skb[i])->vcc;
1046             if (vcc->pop != NULL)
1047                vcc->pop(vcc, scq->skb[i]);
1048             else
1049                dev_kfree_skb_any(scq->skb[i]);
1050          }
1051       }
1052    else /* vcc must be != NULL */
1053    {
1054       if (vcc == NULL)
1055       {
1056          printk("nicstar: free_scq() called with vcc == NULL for fixed rate scq.");
1057          for (i = 0; i < scq->num_entries; i++)
1058             dev_kfree_skb_any(scq->skb[i]);
1059       }
1060       else
1061          for (i = 0; i < scq->num_entries; i++)
1062          {
1063             if (scq->skb[i] != NULL)
1064             {
1065                if (vcc->pop != NULL)
1066                   vcc->pop(vcc, scq->skb[i]);
1067                else
1068                   dev_kfree_skb_any(scq->skb[i]);
1069             }
1070          }
1071    }
1072    kfree(scq->skb);
1073    kfree(scq->org);
1074    kfree(scq);
1075 }
1076
1077
1078
1079 /* The handles passed must be pointers to the sk_buff containing the small
1080    or large buffer(s) cast to u32. */
1081 static void push_rxbufs(ns_dev *card, u32 type, u32 handle1, u32 addr1,
1082                        u32 handle2, u32 addr2)
1083 {
1084    u32 stat;
1085    unsigned long flags;
1086
1087
1088 #ifdef GENERAL_DEBUG
1089    if (!addr1)
1090       printk("nicstar%d: push_rxbufs called with addr1 = 0.\n", card->index);
1091 #endif /* GENERAL_DEBUG */
1092
1093    stat = readl(card->membase + STAT);
1094    card->sbfqc = ns_stat_sfbqc_get(stat);
1095    card->lbfqc = ns_stat_lfbqc_get(stat);
1096    if (type == BUF_SM)
1097    {
1098       if (!addr2)
1099       {
1100          if (card->sm_addr)
1101          {
1102             addr2 = card->sm_addr;
1103             handle2 = card->sm_handle;
1104             card->sm_addr = 0x00000000;
1105             card->sm_handle = 0x00000000;
1106          }
1107          else /* (!sm_addr) */
1108          {
1109             card->sm_addr = addr1;
1110             card->sm_handle = handle1;
1111          }
1112       }
1113    }
1114    else /* type == BUF_LG */
1115    {
1116       if (!addr2)
1117       {
1118          if (card->lg_addr)
1119          {
1120             addr2 = card->lg_addr;
1121             handle2 = card->lg_handle;
1122             card->lg_addr = 0x00000000;
1123             card->lg_handle = 0x00000000;
1124          }
1125          else /* (!lg_addr) */
1126          {
1127             card->lg_addr = addr1;
1128             card->lg_handle = handle1;
1129          }
1130       }
1131    }
1132
1133    if (addr2)
1134    {
1135       if (type == BUF_SM)
1136       {
1137          if (card->sbfqc >= card->sbnr.max)
1138          {
1139             skb_unlink((struct sk_buff *) handle1);
1140             dev_kfree_skb_any((struct sk_buff *) handle1);
1141             skb_unlink((struct sk_buff *) handle2);
1142             dev_kfree_skb_any((struct sk_buff *) handle2);
1143             return;
1144          }
1145          else
1146             card->sbfqc += 2;
1147       }
1148       else /* (type == BUF_LG) */
1149       {
1150          if (card->lbfqc >= card->lbnr.max)
1151          {
1152             skb_unlink((struct sk_buff *) handle1);
1153             dev_kfree_skb_any((struct sk_buff *) handle1);
1154             skb_unlink((struct sk_buff *) handle2);
1155             dev_kfree_skb_any((struct sk_buff *) handle2);
1156             return;
1157          }
1158          else
1159             card->lbfqc += 2;
1160       }
1161
1162       ns_grab_res_lock(card, flags);
1163
1164       while (CMD_BUSY(card));
1165       writel(addr2, card->membase + DR3);
1166       writel(handle2, card->membase + DR2);
1167       writel(addr1, card->membase + DR1);
1168       writel(handle1, card->membase + DR0);
1169       writel(NS_CMD_WRITE_FREEBUFQ | (u32) type, card->membase + CMD);
1170
1171       spin_unlock_irqrestore(&card->res_lock, flags);
1172
1173       XPRINTK("nicstar%d: Pushing %s buffers at 0x%x and 0x%x.\n", card->index,
1174               (type == BUF_SM ? "small" : "large"), addr1, addr2);
1175    }
1176
1177    if (!card->efbie && card->sbfqc >= card->sbnr.min &&
1178        card->lbfqc >= card->lbnr.min)
1179    {
1180       card->efbie = 1;
1181       writel((readl(card->membase + CFG) | NS_CFG_EFBIE), card->membase + CFG);
1182    }
1183
1184    return;
1185 }
1186
1187
1188
1189 static irqreturn_t ns_irq_handler(int irq, void *dev_id, struct pt_regs *regs)
1190 {
1191    u32 stat_r;
1192    ns_dev *card;
1193    struct atm_dev *dev;
1194    unsigned long flags;
1195
1196    card = (ns_dev *) dev_id;
1197    dev = card->atmdev;
1198    card->intcnt++;
1199
1200    PRINTK("nicstar%d: NICStAR generated an interrupt\n", card->index);
1201
1202    ns_grab_int_lock(card, flags);
1203
1204    stat_r = readl(card->membase + STAT);
1205
1206    /* Transmit Status Indicator has been written to T. S. Queue */
1207    if (stat_r & NS_STAT_TSIF)
1208    {
1209       TXPRINTK("nicstar%d: TSI interrupt\n", card->index);
1210       process_tsq(card);
1211       writel(NS_STAT_TSIF, card->membase + STAT);
1212    }
1213
1214    /* Incomplete CS-PDU has been transmitted */
1215    if (stat_r & NS_STAT_TXICP)
1216    {
1217       writel(NS_STAT_TXICP, card->membase + STAT);
1218       TXPRINTK("nicstar%d: Incomplete CS-PDU transmitted.\n",
1219                card->index);
1220    }
1221
1222    /* Transmit Status Queue 7/8 full */
1223    if (stat_r & NS_STAT_TSQF)
1224    {
1225       writel(NS_STAT_TSQF, card->membase + STAT);
1226       PRINTK("nicstar%d: TSQ full.\n", card->index);
1227       process_tsq(card);
1228    }
1229
1230    /* Timer overflow */
1231    if (stat_r & NS_STAT_TMROF)
1232    {
1233       writel(NS_STAT_TMROF, card->membase + STAT);
1234       PRINTK("nicstar%d: Timer overflow.\n", card->index);
1235    }
1236
1237    /* PHY device interrupt signal active */
1238    if (stat_r & NS_STAT_PHYI)
1239    {
1240       writel(NS_STAT_PHYI, card->membase + STAT);
1241       PRINTK("nicstar%d: PHY interrupt.\n", card->index);
1242       if (dev->phy && dev->phy->interrupt) {
1243          dev->phy->interrupt(dev);
1244       }
1245    }
1246
1247    /* Small Buffer Queue is full */
1248    if (stat_r & NS_STAT_SFBQF)
1249    {
1250       writel(NS_STAT_SFBQF, card->membase + STAT);
1251       printk("nicstar%d: Small free buffer queue is full.\n", card->index);
1252    }
1253
1254    /* Large Buffer Queue is full */
1255    if (stat_r & NS_STAT_LFBQF)
1256    {
1257       writel(NS_STAT_LFBQF, card->membase + STAT);
1258       printk("nicstar%d: Large free buffer queue is full.\n", card->index);
1259    }
1260
1261    /* Receive Status Queue is full */
1262    if (stat_r & NS_STAT_RSQF)
1263    {
1264       writel(NS_STAT_RSQF, card->membase + STAT);
1265       printk("nicstar%d: RSQ full.\n", card->index);
1266       process_rsq(card);
1267    }
1268
1269    /* Complete CS-PDU received */
1270    if (stat_r & NS_STAT_EOPDU)
1271    {
1272       RXPRINTK("nicstar%d: End of CS-PDU received.\n", card->index);
1273       process_rsq(card);
1274       writel(NS_STAT_EOPDU, card->membase + STAT);
1275    }
1276
1277    /* Raw cell received */
1278    if (stat_r & NS_STAT_RAWCF)
1279    {
1280       writel(NS_STAT_RAWCF, card->membase + STAT);
1281 #ifndef RCQ_SUPPORT
1282       printk("nicstar%d: Raw cell received and no support yet...\n",
1283              card->index);
1284 #endif /* RCQ_SUPPORT */
1285       /* NOTE: the following procedure may keep a raw cell pending until the
1286                next interrupt. As this preliminary support is only meant to
1287                avoid buffer leakage, this is not an issue. */
1288       while (readl(card->membase + RAWCT) != card->rawch)
1289       {
1290          ns_rcqe *rawcell;
1291
1292          rawcell = (ns_rcqe *) bus_to_virt(card->rawch);
1293          if (ns_rcqe_islast(rawcell))
1294          {
1295             struct sk_buff *oldbuf;
1296
1297             oldbuf = card->rcbuf;
1298             card->rcbuf = (struct sk_buff *) ns_rcqe_nextbufhandle(rawcell);
1299             card->rawch = (u32) virt_to_bus(card->rcbuf->data);
1300             recycle_rx_buf(card, oldbuf);
1301          }
1302          else
1303             card->rawch += NS_RCQE_SIZE;
1304       }
1305    }
1306
1307    /* Small buffer queue is empty */
1308    if (stat_r & NS_STAT_SFBQE)
1309    {
1310       int i;
1311       struct sk_buff *sb;
1312
1313       writel(NS_STAT_SFBQE, card->membase + STAT);
1314       printk("nicstar%d: Small free buffer queue empty.\n",
1315              card->index);
1316       for (i = 0; i < card->sbnr.min; i++)
1317       {
1318          sb = dev_alloc_skb(NS_SMSKBSIZE);
1319          if (sb == NULL)
1320          {
1321             writel(readl(card->membase + CFG) & ~NS_CFG_EFBIE, card->membase + CFG);
1322             card->efbie = 0;
1323             break;
1324          }
1325          skb_queue_tail(&card->sbpool.queue, sb);
1326          skb_reserve(sb, NS_AAL0_HEADER);
1327          push_rxbufs(card, BUF_SM, (u32) sb, (u32) virt_to_bus(sb->data), 0, 0);
1328       }
1329       card->sbfqc = i;
1330       process_rsq(card);
1331    }
1332
1333    /* Large buffer queue empty */
1334    if (stat_r & NS_STAT_LFBQE)
1335    {
1336       int i;
1337       struct sk_buff *lb;
1338
1339       writel(NS_STAT_LFBQE, card->membase + STAT);
1340       printk("nicstar%d: Large free buffer queue empty.\n",
1341              card->index);
1342       for (i = 0; i < card->lbnr.min; i++)
1343       {
1344          lb = dev_alloc_skb(NS_LGSKBSIZE);
1345          if (lb == NULL)
1346          {
1347             writel(readl(card->membase + CFG) & ~NS_CFG_EFBIE, card->membase + CFG);
1348             card->efbie = 0;
1349             break;
1350          }
1351          skb_queue_tail(&card->lbpool.queue, lb);
1352          skb_reserve(lb, NS_SMBUFSIZE);
1353          push_rxbufs(card, BUF_LG, (u32) lb, (u32) virt_to_bus(lb->data), 0, 0);
1354       }
1355       card->lbfqc = i;
1356       process_rsq(card);
1357    }
1358
1359    /* Receive Status Queue is 7/8 full */
1360    if (stat_r & NS_STAT_RSQAF)
1361    {
1362       writel(NS_STAT_RSQAF, card->membase + STAT);
1363       RXPRINTK("nicstar%d: RSQ almost full.\n", card->index);
1364       process_rsq(card);
1365    }
1366
1367    spin_unlock_irqrestore(&card->int_lock, flags);
1368    PRINTK("nicstar%d: end of interrupt service\n", card->index);
1369    return IRQ_HANDLED;
1370 }
1371
1372
1373
1374 static int ns_open(struct atm_vcc *vcc)
1375 {
1376    ns_dev *card;
1377    vc_map *vc;
1378    unsigned long tmpl, modl;
1379    int tcr, tcra;       /* target cell rate, and absolute value */
1380    int n = 0;           /* Number of entries in the TST. Initialized to remove
1381                            the compiler warning. */
1382    u32 u32d[4];
1383    int frscdi = 0;      /* Index of the SCD. Initialized to remove the compiler
1384                            warning. How I wish compilers were clever enough to
1385                            tell which variables can truly be used
1386                            uninitialized... */
1387    int inuse;           /* tx or rx vc already in use by another vcc */
1388    short vpi = vcc->vpi;
1389    int vci = vcc->vci;
1390
1391    card = (ns_dev *) vcc->dev->dev_data;
1392    PRINTK("nicstar%d: opening vpi.vci %d.%d \n", card->index, (int) vpi, vci);
1393    if (vcc->qos.aal != ATM_AAL5 && vcc->qos.aal != ATM_AAL0)
1394    {
1395       PRINTK("nicstar%d: unsupported AAL.\n", card->index);
1396       return -EINVAL;
1397    }
1398
1399    vc = &(card->vcmap[vpi << card->vcibits | vci]);
1400    vcc->dev_data = vc;
1401
1402    inuse = 0;
1403    if (vcc->qos.txtp.traffic_class != ATM_NONE && vc->tx)
1404       inuse = 1;
1405    if (vcc->qos.rxtp.traffic_class != ATM_NONE && vc->rx)
1406       inuse += 2;
1407    if (inuse)
1408    {
1409       printk("nicstar%d: %s vci already in use.\n", card->index,
1410              inuse == 1 ? "tx" : inuse == 2 ? "rx" : "tx and rx");
1411       return -EINVAL;
1412    }
1413
1414    set_bit(ATM_VF_ADDR,&vcc->flags);
1415
1416    /* NOTE: You are not allowed to modify an open connection's QOS. To change
1417       that, remove the ATM_VF_PARTIAL flag checking. There may be other changes
1418       needed to do that. */
1419    if (!test_bit(ATM_VF_PARTIAL,&vcc->flags))
1420    {
1421       scq_info *scq;
1422
1423       set_bit(ATM_VF_PARTIAL,&vcc->flags);
1424       if (vcc->qos.txtp.traffic_class == ATM_CBR)
1425       {
1426          /* Check requested cell rate and availability of SCD */
1427          if (vcc->qos.txtp.max_pcr == 0 && vcc->qos.txtp.pcr == 0 &&
1428              vcc->qos.txtp.min_pcr == 0)
1429          {
1430             PRINTK("nicstar%d: trying to open a CBR vc with cell rate = 0 \n",
1431                    card->index);
1432             clear_bit(ATM_VF_PARTIAL,&vcc->flags);
1433             clear_bit(ATM_VF_ADDR,&vcc->flags);
1434             return -EINVAL;
1435          }
1436
1437          tcr = atm_pcr_goal(&(vcc->qos.txtp));
1438          tcra = tcr >= 0 ? tcr : -tcr;
1439
1440          PRINTK("nicstar%d: target cell rate = %d.\n", card->index,
1441                 vcc->qos.txtp.max_pcr);
1442
1443          tmpl = (unsigned long)tcra * (unsigned long)NS_TST_NUM_ENTRIES;
1444          modl = tmpl % card->max_pcr;
1445
1446          n = (int)(tmpl / card->max_pcr);
1447          if (tcr > 0)
1448          {
1449             if (modl > 0) n++;
1450          }
1451          else if (tcr == 0)
1452          {
1453             if ((n = (card->tst_free_entries - NS_TST_RESERVED)) <= 0)
1454             {
1455                PRINTK("nicstar%d: no CBR bandwidth free.\n", card->index);
1456                clear_bit(ATM_VF_PARTIAL,&vcc->flags);
1457                clear_bit(ATM_VF_ADDR,&vcc->flags);
1458                return -EINVAL;
1459             }
1460          }
1461
1462          if (n == 0)
1463          {
1464             printk("nicstar%d: selected bandwidth < granularity.\n", card->index);
1465             clear_bit(ATM_VF_PARTIAL,&vcc->flags);
1466             clear_bit(ATM_VF_ADDR,&vcc->flags);
1467             return -EINVAL;
1468          }
1469
1470          if (n > (card->tst_free_entries - NS_TST_RESERVED))
1471          {
1472             PRINTK("nicstar%d: not enough free CBR bandwidth.\n", card->index);
1473             clear_bit(ATM_VF_PARTIAL,&vcc->flags);
1474             clear_bit(ATM_VF_ADDR,&vcc->flags);
1475             return -EINVAL;
1476          }
1477          else
1478             card->tst_free_entries -= n;
1479
1480          XPRINTK("nicstar%d: writing %d tst entries.\n", card->index, n);
1481          for (frscdi = 0; frscdi < NS_FRSCD_NUM; frscdi++)
1482          {
1483             if (card->scd2vc[frscdi] == NULL)
1484             {
1485                card->scd2vc[frscdi] = vc;
1486                break;
1487             }
1488          }
1489          if (frscdi == NS_FRSCD_NUM)
1490          {
1491             PRINTK("nicstar%d: no SCD available for CBR channel.\n", card->index);
1492             card->tst_free_entries += n;
1493             clear_bit(ATM_VF_PARTIAL,&vcc->flags);
1494             clear_bit(ATM_VF_ADDR,&vcc->flags);
1495             return -EBUSY;
1496          }
1497
1498          vc->cbr_scd = NS_FRSCD + frscdi * NS_FRSCD_SIZE;
1499
1500          scq = get_scq(CBR_SCQSIZE, vc->cbr_scd);
1501          if (scq == NULL)
1502          {
1503             PRINTK("nicstar%d: can't get fixed rate SCQ.\n", card->index);
1504             card->scd2vc[frscdi] = NULL;
1505             card->tst_free_entries += n;
1506             clear_bit(ATM_VF_PARTIAL,&vcc->flags);
1507             clear_bit(ATM_VF_ADDR,&vcc->flags);
1508             return -ENOMEM;
1509          }
1510          vc->scq = scq;
1511          u32d[0] = (u32) virt_to_bus(scq->base);
1512          u32d[1] = (u32) 0x00000000;
1513          u32d[2] = (u32) 0xffffffff;
1514          u32d[3] = (u32) 0x00000000;
1515          ns_write_sram(card, vc->cbr_scd, u32d, 4);
1516
1517          fill_tst(card, n, vc);
1518       }
1519       else if (vcc->qos.txtp.traffic_class == ATM_UBR)
1520       {
1521          vc->cbr_scd = 0x00000000;
1522          vc->scq = card->scq0;
1523       }
1524
1525       if (vcc->qos.txtp.traffic_class != ATM_NONE)
1526       {
1527          vc->tx = 1;
1528          vc->tx_vcc = vcc;
1529          vc->tbd_count = 0;
1530       }
1531       if (vcc->qos.rxtp.traffic_class != ATM_NONE)
1532       {
1533          u32 status;
1534
1535          vc->rx = 1;
1536          vc->rx_vcc = vcc;
1537          vc->rx_iov = NULL;
1538
1539          /* Open the connection in hardware */
1540          if (vcc->qos.aal == ATM_AAL5)
1541             status = NS_RCTE_AAL5 | NS_RCTE_CONNECTOPEN;
1542          else /* vcc->qos.aal == ATM_AAL0 */
1543             status = NS_RCTE_AAL0 | NS_RCTE_CONNECTOPEN;
1544 #ifdef RCQ_SUPPORT
1545          status |= NS_RCTE_RAWCELLINTEN;
1546 #endif /* RCQ_SUPPORT */
1547          ns_write_sram(card, NS_RCT + (vpi << card->vcibits | vci) *
1548                        NS_RCT_ENTRY_SIZE, &status, 1);
1549       }
1550
1551    }
1552
1553    set_bit(ATM_VF_READY,&vcc->flags);
1554    return 0;
1555 }
1556
1557
1558
1559 static void ns_close(struct atm_vcc *vcc)
1560 {
1561    vc_map *vc;
1562    ns_dev *card;
1563    u32 data;
1564    int i;
1565
1566    vc = vcc->dev_data;
1567    card = vcc->dev->dev_data;
1568    PRINTK("nicstar%d: closing vpi.vci %d.%d \n", card->index,
1569           (int) vcc->vpi, vcc->vci);
1570
1571    clear_bit(ATM_VF_READY,&vcc->flags);
1572
1573    if (vcc->qos.rxtp.traffic_class != ATM_NONE)
1574    {
1575       u32 addr;
1576       unsigned long flags;
1577
1578       addr = NS_RCT + (vcc->vpi << card->vcibits | vcc->vci) * NS_RCT_ENTRY_SIZE;
1579       ns_grab_res_lock(card, flags);
1580       while(CMD_BUSY(card));
1581       writel(NS_CMD_CLOSE_CONNECTION | addr << 2, card->membase + CMD);
1582       spin_unlock_irqrestore(&card->res_lock, flags);
1583
1584       vc->rx = 0;
1585       if (vc->rx_iov != NULL)
1586       {
1587          struct sk_buff *iovb;
1588          u32 stat;
1589
1590          stat = readl(card->membase + STAT);
1591          card->sbfqc = ns_stat_sfbqc_get(stat);
1592          card->lbfqc = ns_stat_lfbqc_get(stat);
1593
1594          PRINTK("nicstar%d: closing a VC with pending rx buffers.\n",
1595                 card->index);
1596          iovb = vc->rx_iov;
1597          recycle_iovec_rx_bufs(card, (struct iovec *) iovb->data,
1598                                NS_SKB(iovb)->iovcnt);
1599          NS_SKB(iovb)->iovcnt = 0;
1600          NS_SKB(iovb)->vcc = NULL;
1601          ns_grab_int_lock(card, flags);
1602          recycle_iov_buf(card, iovb);
1603          spin_unlock_irqrestore(&card->int_lock, flags);
1604          vc->rx_iov = NULL;
1605       }
1606    }
1607
1608    if (vcc->qos.txtp.traffic_class != ATM_NONE)
1609    {
1610       vc->tx = 0;
1611    }
1612
1613    if (vcc->qos.txtp.traffic_class == ATM_CBR)
1614    {
1615       unsigned long flags;
1616       ns_scqe *scqep;
1617       scq_info *scq;
1618
1619       scq = vc->scq;
1620
1621       for (;;)
1622       {
1623          ns_grab_scq_lock(card, scq, flags);
1624          scqep = scq->next;
1625          if (scqep == scq->base)
1626             scqep = scq->last;
1627          else
1628             scqep--;
1629          if (scqep == scq->tail)
1630          {
1631             spin_unlock_irqrestore(&scq->lock, flags);
1632             break;
1633          }
1634          /* If the last entry is not a TSR, place one in the SCQ in order to
1635             be able to completely drain it and then close. */
1636          if (!ns_scqe_is_tsr(scqep) && scq->tail != scq->next)
1637          {
1638             ns_scqe tsr;
1639             u32 scdi, scqi;
1640             u32 data;
1641             int index;
1642
1643             tsr.word_1 = ns_tsr_mkword_1(NS_TSR_INTENABLE);
1644             scdi = (vc->cbr_scd - NS_FRSCD) / NS_FRSCD_SIZE;
1645             scqi = scq->next - scq->base;
1646             tsr.word_2 = ns_tsr_mkword_2(scdi, scqi);
1647             tsr.word_3 = 0x00000000;
1648             tsr.word_4 = 0x00000000;
1649             *scq->next = tsr;
1650             index = (int) scqi;
1651             scq->skb[index] = NULL;
1652             if (scq->next == scq->last)
1653                scq->next = scq->base;
1654             else
1655                scq->next++;
1656             data = (u32) virt_to_bus(scq->next);
1657             ns_write_sram(card, scq->scd, &data, 1);
1658          }
1659          spin_unlock_irqrestore(&scq->lock, flags);
1660          schedule();
1661       }
1662
1663       /* Free all TST entries */
1664       data = NS_TST_OPCODE_VARIABLE;
1665       for (i = 0; i < NS_TST_NUM_ENTRIES; i++)
1666       {
1667          if (card->tste2vc[i] == vc)
1668          {
1669             ns_write_sram(card, card->tst_addr + i, &data, 1);
1670             card->tste2vc[i] = NULL;
1671             card->tst_free_entries++;
1672          }
1673       }
1674
1675       card->scd2vc[(vc->cbr_scd - NS_FRSCD) / NS_FRSCD_SIZE] = NULL;
1676       free_scq(vc->scq, vcc);
1677    }
1678
1679    /* remove all references to vcc before deleting it */
1680    if (vcc->qos.txtp.traffic_class != ATM_NONE)
1681    {
1682      unsigned long flags;
1683      scq_info *scq = card->scq0;
1684
1685      ns_grab_scq_lock(card, scq, flags);
1686
1687      for(i = 0; i < scq->num_entries; i++) {
1688        if(scq->skb[i] && ATM_SKB(scq->skb[i])->vcc == vcc) {
1689         ATM_SKB(scq->skb[i])->vcc = NULL;
1690         atm_return(vcc, scq->skb[i]->truesize);
1691         PRINTK("nicstar: deleted pending vcc mapping\n");
1692        }
1693      }
1694
1695      spin_unlock_irqrestore(&scq->lock, flags);
1696    }
1697
1698    vcc->dev_data = NULL;
1699    clear_bit(ATM_VF_PARTIAL,&vcc->flags);
1700    clear_bit(ATM_VF_ADDR,&vcc->flags);
1701
1702 #ifdef RX_DEBUG
1703    {
1704       u32 stat, cfg;
1705       stat = readl(card->membase + STAT);
1706       cfg = readl(card->membase + CFG);
1707       printk("STAT = 0x%08X  CFG = 0x%08X  \n", stat, cfg);
1708       printk("TSQ: base = 0x%08X  next = 0x%08X  last = 0x%08X  TSQT = 0x%08X \n",
1709              (u32) card->tsq.base, (u32) card->tsq.next,(u32) card->tsq.last,
1710              readl(card->membase + TSQT));
1711       printk("RSQ: base = 0x%08X  next = 0x%08X  last = 0x%08X  RSQT = 0x%08X \n",
1712              (u32) card->rsq.base, (u32) card->rsq.next,(u32) card->rsq.last,
1713              readl(card->membase + RSQT));
1714       printk("Empty free buffer queue interrupt %s \n",
1715              card->efbie ? "enabled" : "disabled");
1716       printk("SBCNT = %d  count = %d   LBCNT = %d count = %d \n",
1717              ns_stat_sfbqc_get(stat), card->sbpool.count,
1718              ns_stat_lfbqc_get(stat), card->lbpool.count);
1719       printk("hbpool.count = %d  iovpool.count = %d \n",
1720              card->hbpool.count, card->iovpool.count);
1721    }
1722 #endif /* RX_DEBUG */
1723 }
1724
1725
1726
1727 static void fill_tst(ns_dev *card, int n, vc_map *vc)
1728 {
1729    u32 new_tst;
1730    unsigned long cl;
1731    int e, r;
1732    u32 data;
1733
1734    /* It would be very complicated to keep the two TSTs synchronized while
1735       assuring that writes are only made to the inactive TST. So, for now I
1736       will use only one TST. If problems occur, I will change this again */
1737
1738    new_tst = card->tst_addr;
1739
1740    /* Fill procedure */
1741
1742    for (e = 0; e < NS_TST_NUM_ENTRIES; e++)
1743    {
1744       if (card->tste2vc[e] == NULL)
1745          break;
1746    }
1747    if (e == NS_TST_NUM_ENTRIES) {
1748       printk("nicstar%d: No free TST entries found. \n", card->index);
1749       return;
1750    }
1751
1752    r = n;
1753    cl = NS_TST_NUM_ENTRIES;
1754    data = ns_tste_make(NS_TST_OPCODE_FIXED, vc->cbr_scd);
1755
1756    while (r > 0)
1757    {
1758       if (cl >= NS_TST_NUM_ENTRIES && card->tste2vc[e] == NULL)
1759       {
1760          card->tste2vc[e] = vc;
1761          ns_write_sram(card, new_tst + e, &data, 1);
1762          cl -= NS_TST_NUM_ENTRIES;
1763          r--;
1764       }
1765
1766       if (++e == NS_TST_NUM_ENTRIES) {
1767          e = 0;
1768       }
1769       cl += n;
1770    }
1771
1772    /* End of fill procedure */
1773
1774    data = ns_tste_make(NS_TST_OPCODE_END, new_tst);
1775    ns_write_sram(card, new_tst + NS_TST_NUM_ENTRIES, &data, 1);
1776    ns_write_sram(card, card->tst_addr + NS_TST_NUM_ENTRIES, &data, 1);
1777    card->tst_addr = new_tst;
1778 }
1779
1780
1781
1782 static int ns_send(struct atm_vcc *vcc, struct sk_buff *skb)
1783 {
1784    ns_dev *card;
1785    vc_map *vc;
1786    scq_info *scq;
1787    unsigned long buflen;
1788    ns_scqe scqe;
1789    u32 flags;           /* TBD flags, not CPU flags */
1790
1791    card = vcc->dev->dev_data;
1792    TXPRINTK("nicstar%d: ns_send() called.\n", card->index);
1793    if ((vc = (vc_map *) vcc->dev_data) == NULL)
1794    {
1795       printk("nicstar%d: vcc->dev_data == NULL on ns_send().\n", card->index);
1796       atomic_inc(&vcc->stats->tx_err);
1797       dev_kfree_skb_any(skb);
1798       return -EINVAL;
1799    }
1800
1801    if (!vc->tx)
1802    {
1803       printk("nicstar%d: Trying to transmit on a non-tx VC.\n", card->index);
1804       atomic_inc(&vcc->stats->tx_err);
1805       dev_kfree_skb_any(skb);
1806       return -EINVAL;
1807    }
1808
1809    if (vcc->qos.aal != ATM_AAL5 && vcc->qos.aal != ATM_AAL0)
1810    {
1811       printk("nicstar%d: Only AAL0 and AAL5 are supported.\n", card->index);
1812       atomic_inc(&vcc->stats->tx_err);
1813       dev_kfree_skb_any(skb);
1814       return -EINVAL;
1815    }
1816
1817    if (skb_shinfo(skb)->nr_frags != 0)
1818    {
1819       printk("nicstar%d: No scatter-gather yet.\n", card->index);
1820       atomic_inc(&vcc->stats->tx_err);
1821       dev_kfree_skb_any(skb);
1822       return -EINVAL;
1823    }
1824
1825    ATM_SKB(skb)->vcc = vcc;
1826
1827    if (vcc->qos.aal == ATM_AAL5)
1828    {
1829       buflen = (skb->len + 47 + 8) / 48 * 48;   /* Multiple of 48 */
1830       flags = NS_TBD_AAL5;
1831       scqe.word_2 = cpu_to_le32((u32) virt_to_bus(skb->data));
1832       scqe.word_3 = cpu_to_le32((u32) skb->len);
1833       scqe.word_4 = ns_tbd_mkword_4(0, (u32) vcc->vpi, (u32) vcc->vci, 0,
1834                            ATM_SKB(skb)->atm_options & ATM_ATMOPT_CLP ? 1 : 0);
1835       flags |= NS_TBD_EOPDU;
1836    }
1837    else /* (vcc->qos.aal == ATM_AAL0) */
1838    {
1839       buflen = ATM_CELL_PAYLOAD;        /* i.e., 48 bytes */
1840       flags = NS_TBD_AAL0;
1841       scqe.word_2 = cpu_to_le32((u32) virt_to_bus(skb->data) + NS_AAL0_HEADER);
1842       scqe.word_3 = cpu_to_le32(0x00000000);
1843       if (*skb->data & 0x02)    /* Payload type 1 - end of pdu */
1844          flags |= NS_TBD_EOPDU;
1845       scqe.word_4 = cpu_to_le32(*((u32 *) skb->data) & ~NS_TBD_VC_MASK);
1846       /* Force the VPI/VCI to be the same as in VCC struct */
1847       scqe.word_4 |= cpu_to_le32((((u32) vcc->vpi) << NS_TBD_VPI_SHIFT |
1848                                  ((u32) vcc->vci) << NS_TBD_VCI_SHIFT) &
1849                                  NS_TBD_VC_MASK);
1850    }
1851
1852    if (vcc->qos.txtp.traffic_class == ATM_CBR)
1853    {
1854       scqe.word_1 = ns_tbd_mkword_1_novbr(flags, (u32) buflen);
1855       scq = ((vc_map *) vcc->dev_data)->scq;
1856    }
1857    else
1858    {
1859       scqe.word_1 = ns_tbd_mkword_1(flags, (u32) 1, (u32) 1, (u32) buflen);
1860       scq = card->scq0;
1861    }
1862
1863    if (push_scqe(card, vc, scq, &scqe, skb) != 0)
1864    {
1865       atomic_inc(&vcc->stats->tx_err);
1866       dev_kfree_skb_any(skb);
1867       return -EIO;
1868    }
1869    atomic_inc(&vcc->stats->tx);
1870
1871    return 0;
1872 }
1873
1874
1875
1876 static int push_scqe(ns_dev *card, vc_map *vc, scq_info *scq, ns_scqe *tbd,
1877                      struct sk_buff *skb)
1878 {
1879    unsigned long flags;
1880    ns_scqe tsr;
1881    u32 scdi, scqi;
1882    int scq_is_vbr;
1883    u32 data;
1884    int index;
1885
1886    ns_grab_scq_lock(card, scq, flags);
1887    while (scq->tail == scq->next)
1888    {
1889       if (in_interrupt()) {
1890          spin_unlock_irqrestore(&scq->lock, flags);
1891          printk("nicstar%d: Error pushing TBD.\n", card->index);
1892          return 1;
1893       }
1894
1895       scq->full = 1;
1896       spin_unlock_irqrestore(&scq->lock, flags);
1897       interruptible_sleep_on_timeout(&scq->scqfull_waitq, SCQFULL_TIMEOUT);
1898       ns_grab_scq_lock(card, scq, flags);
1899
1900       if (scq->full) {
1901          spin_unlock_irqrestore(&scq->lock, flags);
1902          printk("nicstar%d: Timeout pushing TBD.\n", card->index);
1903          return 1;
1904       }
1905    }
1906    *scq->next = *tbd;
1907    index = (int) (scq->next - scq->base);
1908    scq->skb[index] = skb;
1909    XPRINTK("nicstar%d: sending skb at 0x%x (pos %d).\n",
1910            card->index, (u32) skb, index);
1911    XPRINTK("nicstar%d: TBD written:\n0x%x\n0x%x\n0x%x\n0x%x\n at 0x%x.\n",
1912            card->index, le32_to_cpu(tbd->word_1), le32_to_cpu(tbd->word_2),
1913            le32_to_cpu(tbd->word_3), le32_to_cpu(tbd->word_4),
1914            (u32) scq->next);
1915    if (scq->next == scq->last)
1916       scq->next = scq->base;
1917    else
1918       scq->next++;
1919
1920    vc->tbd_count++;
1921    if (scq->num_entries == VBR_SCQ_NUM_ENTRIES)
1922    {
1923       scq->tbd_count++;
1924       scq_is_vbr = 1;
1925    }
1926    else
1927       scq_is_vbr = 0;
1928
1929    if (vc->tbd_count >= MAX_TBD_PER_VC || scq->tbd_count >= MAX_TBD_PER_SCQ)
1930    {
1931       int has_run = 0;
1932
1933       while (scq->tail == scq->next)
1934       {
1935          if (in_interrupt()) {
1936             data = (u32) virt_to_bus(scq->next);
1937             ns_write_sram(card, scq->scd, &data, 1);
1938             spin_unlock_irqrestore(&scq->lock, flags);
1939             printk("nicstar%d: Error pushing TSR.\n", card->index);
1940             return 0;
1941          }
1942
1943          scq->full = 1;
1944          if (has_run++) break;
1945          spin_unlock_irqrestore(&scq->lock, flags);
1946          interruptible_sleep_on_timeout(&scq->scqfull_waitq, SCQFULL_TIMEOUT);
1947          ns_grab_scq_lock(card, scq, flags);
1948       }
1949
1950       if (!scq->full)
1951       {
1952          tsr.word_1 = ns_tsr_mkword_1(NS_TSR_INTENABLE);
1953          if (scq_is_vbr)
1954             scdi = NS_TSR_SCDISVBR;
1955          else
1956             scdi = (vc->cbr_scd - NS_FRSCD) / NS_FRSCD_SIZE;
1957          scqi = scq->next - scq->base;
1958          tsr.word_2 = ns_tsr_mkword_2(scdi, scqi);
1959          tsr.word_3 = 0x00000000;
1960          tsr.word_4 = 0x00000000;
1961
1962          *scq->next = tsr;
1963          index = (int) scqi;
1964          scq->skb[index] = NULL;
1965          XPRINTK("nicstar%d: TSR written:\n0x%x\n0x%x\n0x%x\n0x%x\n at 0x%x.\n",
1966                  card->index, le32_to_cpu(tsr.word_1), le32_to_cpu(tsr.word_2),
1967                  le32_to_cpu(tsr.word_3), le32_to_cpu(tsr.word_4),
1968                  (u32) scq->next);
1969          if (scq->next == scq->last)
1970             scq->next = scq->base;
1971          else
1972             scq->next++;
1973          vc->tbd_count = 0;
1974          scq->tbd_count = 0;
1975       }
1976       else
1977          PRINTK("nicstar%d: Timeout pushing TSR.\n", card->index);
1978    }
1979    data = (u32) virt_to_bus(scq->next);
1980    ns_write_sram(card, scq->scd, &data, 1);
1981
1982    spin_unlock_irqrestore(&scq->lock, flags);
1983
1984    return 0;
1985 }
1986
1987
1988
1989 static void process_tsq(ns_dev *card)
1990 {
1991    u32 scdi;
1992    scq_info *scq;
1993    ns_tsi *previous = NULL, *one_ahead, *two_ahead;
1994    int serviced_entries;   /* flag indicating at least on entry was serviced */
1995
1996    serviced_entries = 0;
1997
1998    if (card->tsq.next == card->tsq.last)
1999       one_ahead = card->tsq.base;
2000    else
2001       one_ahead = card->tsq.next + 1;
2002
2003    if (one_ahead == card->tsq.last)
2004       two_ahead = card->tsq.base;
2005    else
2006       two_ahead = one_ahead + 1;
2007
2008    while (!ns_tsi_isempty(card->tsq.next) || !ns_tsi_isempty(one_ahead) ||
2009           !ns_tsi_isempty(two_ahead))
2010           /* At most two empty, as stated in the 77201 errata */
2011    {
2012       serviced_entries = 1;
2013
2014       /* Skip the one or two possible empty entries */
2015       while (ns_tsi_isempty(card->tsq.next)) {
2016          if (card->tsq.next == card->tsq.last)
2017             card->tsq.next = card->tsq.base;
2018          else
2019             card->tsq.next++;
2020       }
2021
2022       if (!ns_tsi_tmrof(card->tsq.next))
2023       {
2024          scdi = ns_tsi_getscdindex(card->tsq.next);
2025          if (scdi == NS_TSI_SCDISVBR)
2026             scq = card->scq0;
2027          else
2028          {
2029             if (card->scd2vc[scdi] == NULL)
2030             {
2031                printk("nicstar%d: could not find VC from SCD index.\n",
2032                       card->index);
2033                ns_tsi_init(card->tsq.next);
2034                return;
2035             }
2036             scq = card->scd2vc[scdi]->scq;
2037          }
2038          drain_scq(card, scq, ns_tsi_getscqpos(card->tsq.next));
2039          scq->full = 0;
2040          wake_up_interruptible(&(scq->scqfull_waitq));
2041       }
2042
2043       ns_tsi_init(card->tsq.next);
2044       previous = card->tsq.next;
2045       if (card->tsq.next == card->tsq.last)
2046          card->tsq.next = card->tsq.base;
2047       else
2048          card->tsq.next++;
2049
2050       if (card->tsq.next == card->tsq.last)
2051          one_ahead = card->tsq.base;
2052       else
2053          one_ahead = card->tsq.next + 1;
2054
2055       if (one_ahead == card->tsq.last)
2056          two_ahead = card->tsq.base;
2057       else
2058          two_ahead = one_ahead + 1;
2059    }
2060
2061    if (serviced_entries) {
2062       writel((((u32) previous) - ((u32) card->tsq.base)),
2063              card->membase + TSQH);
2064    }
2065 }
2066
2067
2068
2069 static void drain_scq(ns_dev *card, scq_info *scq, int pos)
2070 {
2071    struct atm_vcc *vcc;
2072    struct sk_buff *skb;
2073    int i;
2074    unsigned long flags;
2075
2076    XPRINTK("nicstar%d: drain_scq() called, scq at 0x%x, pos %d.\n",
2077            card->index, (u32) scq, pos);
2078    if (pos >= scq->num_entries)
2079    {
2080       printk("nicstar%d: Bad index on drain_scq().\n", card->index);
2081       return;
2082    }
2083
2084    ns_grab_scq_lock(card, scq, flags);
2085    i = (int) (scq->tail - scq->base);
2086    if (++i == scq->num_entries)
2087       i = 0;
2088    while (i != pos)
2089    {
2090       skb = scq->skb[i];
2091       XPRINTK("nicstar%d: freeing skb at 0x%x (index %d).\n",
2092               card->index, (u32) skb, i);
2093       if (skb != NULL)
2094       {
2095          vcc = ATM_SKB(skb)->vcc;
2096          if (vcc && vcc->pop != NULL) {
2097             vcc->pop(vcc, skb);
2098          } else {
2099             dev_kfree_skb_irq(skb);
2100          }
2101          scq->skb[i] = NULL;
2102       }
2103       if (++i == scq->num_entries)
2104          i = 0;
2105    }
2106    scq->tail = scq->base + pos;
2107    spin_unlock_irqrestore(&scq->lock, flags);
2108 }
2109
2110
2111
2112 static void process_rsq(ns_dev *card)
2113 {
2114    ns_rsqe *previous;
2115
2116    if (!ns_rsqe_valid(card->rsq.next))
2117       return;
2118    while (ns_rsqe_valid(card->rsq.next))
2119    {
2120       dequeue_rx(card, card->rsq.next);
2121       ns_rsqe_init(card->rsq.next);
2122       previous = card->rsq.next;
2123       if (card->rsq.next == card->rsq.last)
2124          card->rsq.next = card->rsq.base;
2125       else
2126          card->rsq.next++;
2127    }
2128    writel((((u32) previous) - ((u32) card->rsq.base)),
2129           card->membase + RSQH);
2130 }
2131
2132
2133
2134 static void dequeue_rx(ns_dev *card, ns_rsqe *rsqe)
2135 {
2136    u32 vpi, vci;
2137    vc_map *vc;
2138    struct sk_buff *iovb;
2139    struct iovec *iov;
2140    struct atm_vcc *vcc;
2141    struct sk_buff *skb;
2142    unsigned short aal5_len;
2143    int len;
2144    u32 stat;
2145
2146    stat = readl(card->membase + STAT);
2147    card->sbfqc = ns_stat_sfbqc_get(stat);
2148    card->lbfqc = ns_stat_lfbqc_get(stat);
2149
2150    skb = (struct sk_buff *) le32_to_cpu(rsqe->buffer_handle);
2151    vpi = ns_rsqe_vpi(rsqe);
2152    vci = ns_rsqe_vci(rsqe);
2153    if (vpi >= 1UL << card->vpibits || vci >= 1UL << card->vcibits)
2154    {
2155       printk("nicstar%d: SDU received for out-of-range vc %d.%d.\n",
2156              card->index, vpi, vci);
2157       recycle_rx_buf(card, skb);
2158       return;
2159    }
2160
2161    vc = &(card->vcmap[vpi << card->vcibits | vci]);
2162    if (!vc->rx)
2163    {
2164       RXPRINTK("nicstar%d: SDU received on non-rx vc %d.%d.\n",
2165              card->index, vpi, vci);
2166       recycle_rx_buf(card, skb);
2167       return;
2168    }
2169
2170    vcc = vc->rx_vcc;
2171
2172    if (vcc->qos.aal == ATM_AAL0)
2173    {
2174       struct sk_buff *sb;
2175       unsigned char *cell;
2176       int i;
2177
2178       cell = skb->data;
2179       for (i = ns_rsqe_cellcount(rsqe); i; i--)
2180       {
2181          if ((sb = dev_alloc_skb(NS_SMSKBSIZE)) == NULL)
2182          {
2183             printk("nicstar%d: Can't allocate buffers for aal0.\n",
2184                    card->index);
2185             atomic_add(i,&vcc->stats->rx_drop);
2186             break;
2187          }
2188          if (!atm_charge(vcc, sb->truesize))
2189          {
2190             RXPRINTK("nicstar%d: atm_charge() dropped aal0 packets.\n",
2191                      card->index);
2192             atomic_add(i-1,&vcc->stats->rx_drop); /* already increased by 1 */
2193             dev_kfree_skb_any(sb);
2194             break;
2195          }
2196          /* Rebuild the header */
2197          *((u32 *) sb->data) = le32_to_cpu(rsqe->word_1) << 4 |
2198                                (ns_rsqe_clp(rsqe) ? 0x00000001 : 0x00000000);
2199          if (i == 1 && ns_rsqe_eopdu(rsqe))
2200             *((u32 *) sb->data) |= 0x00000002;
2201          skb_put(sb, NS_AAL0_HEADER);
2202          memcpy(sb->tail, cell, ATM_CELL_PAYLOAD);
2203          skb_put(sb, ATM_CELL_PAYLOAD);
2204          ATM_SKB(sb)->vcc = vcc;
2205          do_gettimeofday(&sb->stamp);
2206          vcc->push(vcc, sb);
2207          atomic_inc(&vcc->stats->rx);
2208          cell += ATM_CELL_PAYLOAD;
2209       }
2210
2211       recycle_rx_buf(card, skb);
2212       return;
2213    }
2214
2215    /* To reach this point, the AAL layer can only be AAL5 */
2216
2217    if ((iovb = vc->rx_iov) == NULL)
2218    {
2219       iovb = skb_dequeue(&(card->iovpool.queue));
2220       if (iovb == NULL)         /* No buffers in the queue */
2221       {
2222          iovb = alloc_skb(NS_IOVBUFSIZE, GFP_ATOMIC);
2223          if (iovb == NULL)
2224          {
2225             printk("nicstar%d: Out of iovec buffers.\n", card->index);
2226             atomic_inc(&vcc->stats->rx_drop);
2227             recycle_rx_buf(card, skb);
2228             return;
2229          }
2230       }
2231       else
2232          if (--card->iovpool.count < card->iovnr.min)
2233          {
2234             struct sk_buff *new_iovb;
2235             if ((new_iovb = alloc_skb(NS_IOVBUFSIZE, GFP_ATOMIC)) != NULL)
2236             {
2237                skb_queue_tail(&card->iovpool.queue, new_iovb);
2238                card->iovpool.count++;
2239             }
2240          }
2241       vc->rx_iov = iovb;
2242       NS_SKB(iovb)->iovcnt = 0;
2243       iovb->len = 0;
2244       iovb->tail = iovb->data = iovb->head;
2245       NS_SKB(iovb)->vcc = vcc;
2246       /* IMPORTANT: a pointer to the sk_buff containing the small or large
2247                     buffer is stored as iovec base, NOT a pointer to the
2248                     small or large buffer itself. */
2249    }
2250    else if (NS_SKB(iovb)->iovcnt >= NS_MAX_IOVECS)
2251    {
2252       printk("nicstar%d: received too big AAL5 SDU.\n", card->index);
2253       atomic_inc(&vcc->stats->rx_err);
2254       recycle_iovec_rx_bufs(card, (struct iovec *) iovb->data, NS_MAX_IOVECS);
2255       NS_SKB(iovb)->iovcnt = 0;
2256       iovb->len = 0;
2257       iovb->tail = iovb->data = iovb->head;
2258       NS_SKB(iovb)->vcc = vcc;
2259    }
2260    iov = &((struct iovec *) iovb->data)[NS_SKB(iovb)->iovcnt++];
2261    iov->iov_base = (void *) skb;
2262    iov->iov_len = ns_rsqe_cellcount(rsqe) * 48;
2263    iovb->len += iov->iov_len;
2264
2265    if (NS_SKB(iovb)->iovcnt == 1)
2266    {
2267       if (skb->list != &card->sbpool.queue)
2268       {
2269          printk("nicstar%d: Expected a small buffer, and this is not one.\n",
2270                 card->index);
2271          which_list(card, skb);
2272          atomic_inc(&vcc->stats->rx_err);
2273          recycle_rx_buf(card, skb);
2274          vc->rx_iov = NULL;
2275          recycle_iov_buf(card, iovb);
2276          return;
2277       }
2278    }
2279    else /* NS_SKB(iovb)->iovcnt >= 2 */
2280    {
2281       if (skb->list != &card->lbpool.queue)
2282       {
2283          printk("nicstar%d: Expected a large buffer, and this is not one.\n",
2284                 card->index);
2285          which_list(card, skb);
2286          atomic_inc(&vcc->stats->rx_err);
2287          recycle_iovec_rx_bufs(card, (struct iovec *) iovb->data,
2288                                NS_SKB(iovb)->iovcnt);
2289          vc->rx_iov = NULL;
2290          recycle_iov_buf(card, iovb);
2291          return;
2292       }
2293    }
2294
2295    if (ns_rsqe_eopdu(rsqe))
2296    {
2297       /* This works correctly regardless of the endianness of the host */
2298       unsigned char *L1L2 = (unsigned char *)((u32)skb->data +
2299                                               iov->iov_len - 6);
2300       aal5_len = L1L2[0] << 8 | L1L2[1];
2301       len = (aal5_len == 0x0000) ? 0x10000 : aal5_len;
2302       if (ns_rsqe_crcerr(rsqe) ||
2303           len + 8 > iovb->len || len + (47 + 8) < iovb->len)
2304       {
2305          printk("nicstar%d: AAL5 CRC error", card->index);
2306          if (len + 8 > iovb->len || len + (47 + 8) < iovb->len)
2307             printk(" - PDU size mismatch.\n");
2308          else
2309             printk(".\n");
2310          atomic_inc(&vcc->stats->rx_err);
2311          recycle_iovec_rx_bufs(card, (struct iovec *) iovb->data,
2312            NS_SKB(iovb)->iovcnt);
2313          vc->rx_iov = NULL;
2314          recycle_iov_buf(card, iovb);
2315          return;
2316       }
2317
2318       /* By this point we (hopefully) have a complete SDU without errors. */
2319
2320       if (NS_SKB(iovb)->iovcnt == 1)    /* Just a small buffer */
2321       {
2322          /* skb points to a small buffer */
2323          if (!atm_charge(vcc, skb->truesize))
2324          {
2325             push_rxbufs(card, BUF_SM, (u32) skb, (u32) virt_to_bus(skb->data),
2326                         0, 0);
2327             atomic_inc(&vcc->stats->rx_drop);
2328          }
2329          else
2330          {
2331             skb_put(skb, len);
2332             dequeue_sm_buf(card, skb);
2333 #ifdef NS_USE_DESTRUCTORS
2334             skb->destructor = ns_sb_destructor;
2335 #endif /* NS_USE_DESTRUCTORS */
2336             ATM_SKB(skb)->vcc = vcc;
2337             do_gettimeofday(&skb->stamp);
2338             vcc->push(vcc, skb);
2339             atomic_inc(&vcc->stats->rx);
2340          }
2341       }
2342       else if (NS_SKB(iovb)->iovcnt == 2)       /* One small plus one large buffer */
2343       {
2344          struct sk_buff *sb;
2345
2346          sb = (struct sk_buff *) (iov - 1)->iov_base;
2347          /* skb points to a large buffer */
2348
2349          if (len <= NS_SMBUFSIZE)
2350          {
2351             if (!atm_charge(vcc, sb->truesize))
2352             {
2353                push_rxbufs(card, BUF_SM, (u32) sb, (u32) virt_to_bus(sb->data),
2354                            0, 0);
2355                atomic_inc(&vcc->stats->rx_drop);
2356             }
2357             else
2358             {
2359                skb_put(sb, len);
2360                dequeue_sm_buf(card, sb);
2361 #ifdef NS_USE_DESTRUCTORS
2362                sb->destructor = ns_sb_destructor;
2363 #endif /* NS_USE_DESTRUCTORS */
2364                ATM_SKB(sb)->vcc = vcc;
2365                do_gettimeofday(&sb->stamp);
2366                vcc->push(vcc, sb);
2367                atomic_inc(&vcc->stats->rx);
2368             }
2369
2370             push_rxbufs(card, BUF_LG, (u32) skb,
2371                            (u32) virt_to_bus(skb->data), 0, 0);
2372
2373          }
2374          else                   /* len > NS_SMBUFSIZE, the usual case */
2375          {
2376             if (!atm_charge(vcc, skb->truesize))
2377             {
2378                push_rxbufs(card, BUF_LG, (u32) skb,
2379                            (u32) virt_to_bus(skb->data), 0, 0);
2380                atomic_inc(&vcc->stats->rx_drop);
2381             }
2382             else
2383             {
2384                dequeue_lg_buf(card, skb);
2385 #ifdef NS_USE_DESTRUCTORS
2386                skb->destructor = ns_lb_destructor;
2387 #endif /* NS_USE_DESTRUCTORS */
2388                skb_push(skb, NS_SMBUFSIZE);
2389                memcpy(skb->data, sb->data, NS_SMBUFSIZE);
2390                skb_put(skb, len - NS_SMBUFSIZE);
2391                ATM_SKB(skb)->vcc = vcc;
2392                do_gettimeofday(&skb->stamp);
2393                vcc->push(vcc, skb);
2394                atomic_inc(&vcc->stats->rx);
2395             }
2396
2397             push_rxbufs(card, BUF_SM, (u32) sb, (u32) virt_to_bus(sb->data),
2398                         0, 0);
2399
2400          }
2401
2402       }
2403       else                              /* Must push a huge buffer */
2404       {
2405          struct sk_buff *hb, *sb, *lb;
2406          int remaining, tocopy;
2407          int j;
2408
2409          hb = skb_dequeue(&(card->hbpool.queue));
2410          if (hb == NULL)                /* No buffers in the queue */
2411          {
2412
2413             hb = dev_alloc_skb(NS_HBUFSIZE);
2414             if (hb == NULL)
2415             {
2416                printk("nicstar%d: Out of huge buffers.\n", card->index);
2417                atomic_inc(&vcc->stats->rx_drop);
2418                recycle_iovec_rx_bufs(card, (struct iovec *) iovb->data,
2419                                      NS_SKB(iovb)->iovcnt);
2420                vc->rx_iov = NULL;
2421                recycle_iov_buf(card, iovb);
2422                return;
2423             }
2424             else if (card->hbpool.count < card->hbnr.min)
2425             {
2426                struct sk_buff *new_hb;
2427                if ((new_hb = dev_alloc_skb(NS_HBUFSIZE)) != NULL)
2428                {
2429                   skb_queue_tail(&card->hbpool.queue, new_hb);
2430                   card->hbpool.count++;
2431                }
2432             }
2433          }
2434          else
2435          if (--card->hbpool.count < card->hbnr.min)
2436          {
2437             struct sk_buff *new_hb;
2438             if ((new_hb = dev_alloc_skb(NS_HBUFSIZE)) != NULL)
2439             {
2440                skb_queue_tail(&card->hbpool.queue, new_hb);
2441                card->hbpool.count++;
2442             }
2443             if (card->hbpool.count < card->hbnr.min)
2444             {
2445                if ((new_hb = dev_alloc_skb(NS_HBUFSIZE)) != NULL)
2446                {
2447                   skb_queue_tail(&card->hbpool.queue, new_hb);
2448                   card->hbpool.count++;
2449                }
2450             }
2451          }
2452
2453          iov = (struct iovec *) iovb->data;
2454
2455          if (!atm_charge(vcc, hb->truesize))
2456          {
2457             recycle_iovec_rx_bufs(card, iov, NS_SKB(iovb)->iovcnt);
2458             if (card->hbpool.count < card->hbnr.max)
2459             {
2460                skb_queue_tail(&card->hbpool.queue, hb);
2461                card->hbpool.count++;
2462             }
2463             else
2464                dev_kfree_skb_any(hb);
2465             atomic_inc(&vcc->stats->rx_drop);
2466          }
2467          else
2468          {
2469             /* Copy the small buffer to the huge buffer */
2470             sb = (struct sk_buff *) iov->iov_base;
2471             memcpy(hb->data, sb->data, iov->iov_len);
2472             skb_put(hb, iov->iov_len);
2473             remaining = len - iov->iov_len;
2474             iov++;
2475             /* Free the small buffer */
2476             push_rxbufs(card, BUF_SM, (u32) sb, (u32) virt_to_bus(sb->data),
2477                         0, 0);
2478
2479             /* Copy all large buffers to the huge buffer and free them */
2480             for (j = 1; j < NS_SKB(iovb)->iovcnt; j++)
2481             {
2482                lb = (struct sk_buff *) iov->iov_base;
2483                tocopy = min_t(int, remaining, iov->iov_len);
2484                memcpy(hb->tail, lb->data, tocopy);
2485                skb_put(hb, tocopy);
2486                iov++;
2487                remaining -= tocopy;
2488                push_rxbufs(card, BUF_LG, (u32) lb,
2489                            (u32) virt_to_bus(lb->data), 0, 0);
2490             }
2491 #ifdef EXTRA_DEBUG
2492             if (remaining != 0 || hb->len != len)
2493                printk("nicstar%d: Huge buffer len mismatch.\n", card->index);
2494 #endif /* EXTRA_DEBUG */
2495             ATM_SKB(hb)->vcc = vcc;
2496 #ifdef NS_USE_DESTRUCTORS
2497             hb->destructor = ns_hb_destructor;
2498 #endif /* NS_USE_DESTRUCTORS */
2499             do_gettimeofday(&hb->stamp);
2500             vcc->push(vcc, hb);
2501             atomic_inc(&vcc->stats->rx);
2502          }
2503       }
2504
2505       vc->rx_iov = NULL;
2506       recycle_iov_buf(card, iovb);
2507    }
2508
2509 }
2510
2511
2512
2513 #ifdef NS_USE_DESTRUCTORS
2514
2515 static void ns_sb_destructor(struct sk_buff *sb)
2516 {
2517    ns_dev *card;
2518    u32 stat;
2519
2520    card = (ns_dev *) ATM_SKB(sb)->vcc->dev->dev_data;
2521    stat = readl(card->membase + STAT);
2522    card->sbfqc = ns_stat_sfbqc_get(stat);
2523    card->lbfqc = ns_stat_lfbqc_get(stat);
2524
2525    do
2526    {
2527       sb = __dev_alloc_skb(NS_SMSKBSIZE, GFP_KERNEL);
2528       if (sb == NULL)
2529          break;
2530       skb_queue_tail(&card->sbpool.queue, sb);
2531       skb_reserve(sb, NS_AAL0_HEADER);
2532       push_rxbufs(card, BUF_SM, (u32) sb, (u32) virt_to_bus(sb->data), 0, 0);
2533    } while (card->sbfqc < card->sbnr.min);
2534 }
2535
2536
2537
2538 static void ns_lb_destructor(struct sk_buff *lb)
2539 {
2540    ns_dev *card;
2541    u32 stat;
2542
2543    card = (ns_dev *) ATM_SKB(lb)->vcc->dev->dev_data;
2544    stat = readl(card->membase + STAT);
2545    card->sbfqc = ns_stat_sfbqc_get(stat);
2546    card->lbfqc = ns_stat_lfbqc_get(stat);
2547
2548    do
2549    {
2550       lb = __dev_alloc_skb(NS_LGSKBSIZE, GFP_KERNEL);
2551       if (lb == NULL)
2552          break;
2553       skb_queue_tail(&card->lbpool.queue, lb);
2554       skb_reserve(lb, NS_SMBUFSIZE);
2555       push_rxbufs(card, BUF_LG, (u32) lb, (u32) virt_to_bus(lb->data), 0, 0);
2556    } while (card->lbfqc < card->lbnr.min);
2557 }
2558
2559
2560
2561 static void ns_hb_destructor(struct sk_buff *hb)
2562 {
2563    ns_dev *card;
2564
2565    card = (ns_dev *) ATM_SKB(hb)->vcc->dev->dev_data;
2566
2567    while (card->hbpool.count < card->hbnr.init)
2568    {
2569       hb = __dev_alloc_skb(NS_HBUFSIZE, GFP_KERNEL);
2570       if (hb == NULL)
2571          break;
2572       skb_queue_tail(&card->hbpool.queue, hb);
2573       card->hbpool.count++;
2574    }
2575 }
2576
2577 #endif /* NS_USE_DESTRUCTORS */
2578
2579
2580
2581 static void recycle_rx_buf(ns_dev *card, struct sk_buff *skb)
2582 {
2583    if (skb->list == &card->sbpool.queue)
2584       push_rxbufs(card, BUF_SM, (u32) skb, (u32) virt_to_bus(skb->data), 0, 0);
2585    else if (skb->list == &card->lbpool.queue)
2586       push_rxbufs(card, BUF_LG, (u32) skb, (u32) virt_to_bus(skb->data), 0, 0);
2587    else
2588    {
2589       printk("nicstar%d: What kind of rx buffer is this?\n", card->index);
2590       dev_kfree_skb_any(skb);
2591    }
2592 }
2593
2594
2595
2596 static void recycle_iovec_rx_bufs(ns_dev *card, struct iovec *iov, int count)
2597 {
2598    struct sk_buff *skb;
2599
2600    for (; count > 0; count--)
2601    {
2602       skb = (struct sk_buff *) (iov++)->iov_base;
2603       if (skb->list == &card->sbpool.queue)
2604          push_rxbufs(card, BUF_SM, (u32) skb, (u32) virt_to_bus(skb->data),
2605                      0, 0);
2606       else if (skb->list == &card->lbpool.queue)
2607          push_rxbufs(card, BUF_LG, (u32) skb, (u32) virt_to_bus(skb->data),
2608                      0, 0);
2609       else
2610       {
2611          printk("nicstar%d: What kind of rx buffer is this?\n", card->index);
2612          dev_kfree_skb_any(skb);
2613       }
2614    }
2615 }
2616
2617
2618
2619 static void recycle_iov_buf(ns_dev *card, struct sk_buff *iovb)
2620 {
2621    if (card->iovpool.count < card->iovnr.max)
2622    {
2623       skb_queue_tail(&card->iovpool.queue, iovb);
2624       card->iovpool.count++;
2625    }
2626    else
2627       dev_kfree_skb_any(iovb);
2628 }
2629
2630
2631
2632 static void dequeue_sm_buf(ns_dev *card, struct sk_buff *sb)
2633 {
2634    skb_unlink(sb);
2635 #ifdef NS_USE_DESTRUCTORS
2636    if (card->sbfqc < card->sbnr.min)
2637 #else
2638    if (card->sbfqc < card->sbnr.init)
2639    {
2640       struct sk_buff *new_sb;
2641       if ((new_sb = dev_alloc_skb(NS_SMSKBSIZE)) != NULL)
2642       {
2643          skb_queue_tail(&card->sbpool.queue, new_sb);
2644          skb_reserve(new_sb, NS_AAL0_HEADER);
2645          push_rxbufs(card, BUF_SM, (u32) new_sb,
2646                      (u32) virt_to_bus(new_sb->data), 0, 0);
2647       }
2648    }
2649    if (card->sbfqc < card->sbnr.init)
2650 #endif /* NS_USE_DESTRUCTORS */
2651    {
2652       struct sk_buff *new_sb;
2653       if ((new_sb = dev_alloc_skb(NS_SMSKBSIZE)) != NULL)
2654       {
2655          skb_queue_tail(&card->sbpool.queue, new_sb);
2656          skb_reserve(new_sb, NS_AAL0_HEADER);
2657          push_rxbufs(card, BUF_SM, (u32) new_sb,
2658                      (u32) virt_to_bus(new_sb->data), 0, 0);
2659       }
2660    }
2661 }
2662
2663
2664
2665 static void dequeue_lg_buf(ns_dev *card, struct sk_buff *lb)
2666 {
2667    skb_unlink(lb);
2668 #ifdef NS_USE_DESTRUCTORS
2669    if (card->lbfqc < card->lbnr.min)
2670 #else
2671    if (card->lbfqc < card->lbnr.init)
2672    {
2673       struct sk_buff *new_lb;
2674       if ((new_lb = dev_alloc_skb(NS_LGSKBSIZE)) != NULL)
2675       {
2676          skb_queue_tail(&card->lbpool.queue, new_lb);
2677          skb_reserve(new_lb, NS_SMBUFSIZE);
2678          push_rxbufs(card, BUF_LG, (u32) new_lb,
2679                      (u32) virt_to_bus(new_lb->data), 0, 0);
2680       }
2681    }
2682    if (card->lbfqc < card->lbnr.init)
2683 #endif /* NS_USE_DESTRUCTORS */
2684    {
2685       struct sk_buff *new_lb;
2686       if ((new_lb = dev_alloc_skb(NS_LGSKBSIZE)) != NULL)
2687       {
2688          skb_queue_tail(&card->lbpool.queue, new_lb);
2689          skb_reserve(new_lb, NS_SMBUFSIZE);
2690          push_rxbufs(card, BUF_LG, (u32) new_lb,
2691                      (u32) virt_to_bus(new_lb->data), 0, 0);
2692       }
2693    }
2694 }
2695
2696
2697
2698 static int ns_proc_read(struct atm_dev *dev, loff_t *pos, char *page)
2699 {
2700    u32 stat;
2701    ns_dev *card;
2702    int left;
2703
2704    left = (int) *pos;
2705    card = (ns_dev *) dev->dev_data;
2706    stat = readl(card->membase + STAT);
2707    if (!left--)
2708       return sprintf(page, "Pool   count    min   init    max \n");
2709    if (!left--)
2710       return sprintf(page, "Small  %5d  %5d  %5d  %5d \n",
2711                      ns_stat_sfbqc_get(stat), card->sbnr.min, card->sbnr.init,
2712                      card->sbnr.max);
2713    if (!left--)
2714       return sprintf(page, "Large  %5d  %5d  %5d  %5d \n",
2715                      ns_stat_lfbqc_get(stat), card->lbnr.min, card->lbnr.init,
2716                      card->lbnr.max);
2717    if (!left--)
2718       return sprintf(page, "Huge   %5d  %5d  %5d  %5d \n", card->hbpool.count,
2719                      card->hbnr.min, card->hbnr.init, card->hbnr.max);
2720    if (!left--)
2721       return sprintf(page, "Iovec  %5d  %5d  %5d  %5d \n", card->iovpool.count,
2722                      card->iovnr.min, card->iovnr.init, card->iovnr.max);
2723    if (!left--)
2724    {
2725       int retval;
2726       retval = sprintf(page, "Interrupt counter: %u \n", card->intcnt);
2727       card->intcnt = 0;
2728       return retval;
2729    }
2730 #if 0
2731    /* Dump 25.6 Mbps PHY registers */
2732    /* Now there's a 25.6 Mbps PHY driver this code isn't needed. I left it
2733       here just in case it's needed for debugging. */
2734    if (card->max_pcr == ATM_25_PCR && !left--)
2735    {
2736       u32 phy_regs[4];
2737       u32 i;
2738
2739       for (i = 0; i < 4; i++)
2740       {
2741          while (CMD_BUSY(card));
2742          writel(NS_CMD_READ_UTILITY | 0x00000200 | i, card->membase + CMD);
2743          while (CMD_BUSY(card));
2744          phy_regs[i] = readl(card->membase + DR0) & 0x000000FF;
2745       }
2746
2747       return sprintf(page, "PHY regs: 0x%02X 0x%02X 0x%02X 0x%02X \n",
2748                      phy_regs[0], phy_regs[1], phy_regs[2], phy_regs[3]);
2749    }
2750 #endif /* 0 - Dump 25.6 Mbps PHY registers */
2751 #if 0
2752    /* Dump TST */
2753    if (left-- < NS_TST_NUM_ENTRIES)
2754    {
2755       if (card->tste2vc[left + 1] == NULL)
2756          return sprintf(page, "%5d - VBR/UBR \n", left + 1);
2757       else
2758          return sprintf(page, "%5d - %d %d \n", left + 1,
2759                         card->tste2vc[left + 1]->tx_vcc->vpi,
2760                         card->tste2vc[left + 1]->tx_vcc->vci);
2761    }
2762 #endif /* 0 */
2763    return 0;
2764 }
2765
2766
2767
2768 static int ns_ioctl(struct atm_dev *dev, unsigned int cmd, void __user *arg)
2769 {
2770    ns_dev *card;
2771    pool_levels pl;
2772    int btype;
2773    unsigned long flags;
2774
2775    card = dev->dev_data;
2776    switch (cmd)
2777    {
2778       case NS_GETPSTAT:
2779          if (get_user(pl.buftype, &((pool_levels __user *) arg)->buftype))
2780             return -EFAULT;
2781          switch (pl.buftype)
2782          {
2783             case NS_BUFTYPE_SMALL:
2784                pl.count = ns_stat_sfbqc_get(readl(card->membase + STAT));
2785                pl.level.min = card->sbnr.min;
2786                pl.level.init = card->sbnr.init;
2787                pl.level.max = card->sbnr.max;
2788                break;
2789
2790             case NS_BUFTYPE_LARGE:
2791                pl.count = ns_stat_lfbqc_get(readl(card->membase + STAT));
2792                pl.level.min = card->lbnr.min;
2793                pl.level.init = card->lbnr.init;
2794                pl.level.max = card->lbnr.max;
2795                break;
2796
2797             case NS_BUFTYPE_HUGE:
2798                pl.count = card->hbpool.count;
2799                pl.level.min = card->hbnr.min;
2800                pl.level.init = card->hbnr.init;
2801                pl.level.max = card->hbnr.max;
2802                break;
2803
2804             case NS_BUFTYPE_IOVEC:
2805                pl.count = card->iovpool.count;
2806                pl.level.min = card->iovnr.min;
2807                pl.level.init = card->iovnr.init;
2808                pl.level.max = card->iovnr.max;
2809                break;
2810
2811             default:
2812                return -ENOIOCTLCMD;
2813
2814          }
2815          if (!copy_to_user((pool_levels __user *) arg, &pl, sizeof(pl)))
2816             return (sizeof(pl));
2817          else
2818             return -EFAULT;
2819
2820       case NS_SETBUFLEV:
2821          if (!capable(CAP_NET_ADMIN))
2822             return -EPERM;
2823          if (copy_from_user(&pl, (pool_levels __user *) arg, sizeof(pl)))
2824             return -EFAULT;
2825          if (pl.level.min >= pl.level.init || pl.level.init >= pl.level.max)
2826             return -EINVAL;
2827          if (pl.level.min == 0)
2828             return -EINVAL;
2829          switch (pl.buftype)
2830          {
2831             case NS_BUFTYPE_SMALL:
2832                if (pl.level.max > TOP_SB)
2833                   return -EINVAL;
2834                card->sbnr.min = pl.level.min;
2835                card->sbnr.init = pl.level.init;
2836                card->sbnr.max = pl.level.max;
2837                break;
2838
2839             case NS_BUFTYPE_LARGE:
2840                if (pl.level.max > TOP_LB)
2841                   return -EINVAL;
2842                card->lbnr.min = pl.level.min;
2843                card->lbnr.init = pl.level.init;
2844                card->lbnr.max = pl.level.max;
2845                break;
2846
2847             case NS_BUFTYPE_HUGE:
2848                if (pl.level.max > TOP_HB)
2849                   return -EINVAL;
2850                card->hbnr.min = pl.level.min;
2851                card->hbnr.init = pl.level.init;
2852                card->hbnr.max = pl.level.max;
2853                break;
2854
2855             case NS_BUFTYPE_IOVEC:
2856                if (pl.level.max > TOP_IOVB)
2857                   return -EINVAL;
2858                card->iovnr.min = pl.level.min;
2859                card->iovnr.init = pl.level.init;
2860                card->iovnr.max = pl.level.max;
2861                break;
2862
2863             default:
2864                return -EINVAL;
2865
2866          }
2867          return 0;
2868
2869       case NS_ADJBUFLEV:
2870          if (!capable(CAP_NET_ADMIN))
2871             return -EPERM;
2872          btype = (int) arg;     /* an int is the same size as a pointer */
2873          switch (btype)
2874          {
2875             case NS_BUFTYPE_SMALL:
2876                while (card->sbfqc < card->sbnr.init)
2877                {
2878                   struct sk_buff *sb;
2879
2880                   sb = __dev_alloc_skb(NS_SMSKBSIZE, GFP_KERNEL);
2881                   if (sb == NULL)
2882                      return -ENOMEM;
2883                   skb_queue_tail(&card->sbpool.queue, sb);
2884                   skb_reserve(sb, NS_AAL0_HEADER);
2885                   push_rxbufs(card, BUF_SM, (u32) sb, (u32) virt_to_bus(sb->data), 0, 0);
2886                }
2887                break;
2888
2889             case NS_BUFTYPE_LARGE:
2890                while (card->lbfqc < card->lbnr.init)
2891                {
2892                   struct sk_buff *lb;
2893
2894                   lb = __dev_alloc_skb(NS_LGSKBSIZE, GFP_KERNEL);
2895                   if (lb == NULL)
2896                      return -ENOMEM;
2897                   skb_queue_tail(&card->lbpool.queue, lb);
2898                   skb_reserve(lb, NS_SMBUFSIZE);
2899                   push_rxbufs(card, BUF_LG, (u32) lb, (u32) virt_to_bus(lb->data), 0, 0);
2900                }
2901                break;
2902
2903             case NS_BUFTYPE_HUGE:
2904                while (card->hbpool.count > card->hbnr.init)
2905                {
2906                   struct sk_buff *hb;
2907
2908                   ns_grab_int_lock(card, flags);
2909                   hb = skb_dequeue(&card->hbpool.queue);
2910                   card->hbpool.count--;
2911                   spin_unlock_irqrestore(&card->int_lock, flags);
2912                   if (hb == NULL)
2913                      printk("nicstar%d: huge buffer count inconsistent.\n",
2914                             card->index);
2915                   else
2916                      dev_kfree_skb_any(hb);
2917
2918                }
2919                while (card->hbpool.count < card->hbnr.init)
2920                {
2921                   struct sk_buff *hb;
2922
2923                   hb = __dev_alloc_skb(NS_HBUFSIZE, GFP_KERNEL);
2924                   if (hb == NULL)
2925                      return -ENOMEM;
2926                   ns_grab_int_lock(card, flags);
2927                   skb_queue_tail(&card->hbpool.queue, hb);
2928                   card->hbpool.count++;
2929                   spin_unlock_irqrestore(&card->int_lock, flags);
2930                }
2931                break;
2932
2933             case NS_BUFTYPE_IOVEC:
2934                while (card->iovpool.count > card->iovnr.init)
2935                {
2936                   struct sk_buff *iovb;
2937
2938                   ns_grab_int_lock(card, flags);
2939                   iovb = skb_dequeue(&card->iovpool.queue);
2940                   card->iovpool.count--;
2941                   spin_unlock_irqrestore(&card->int_lock, flags);
2942                   if (iovb == NULL)
2943                      printk("nicstar%d: iovec buffer count inconsistent.\n",
2944                             card->index);
2945                   else
2946                      dev_kfree_skb_any(iovb);
2947
2948                }
2949                while (card->iovpool.count < card->iovnr.init)
2950                {
2951                   struct sk_buff *iovb;
2952
2953                   iovb = alloc_skb(NS_IOVBUFSIZE, GFP_KERNEL);
2954                   if (iovb == NULL)
2955                      return -ENOMEM;
2956                   ns_grab_int_lock(card, flags);
2957                   skb_queue_tail(&card->iovpool.queue, iovb);
2958                   card->iovpool.count++;
2959                   spin_unlock_irqrestore(&card->int_lock, flags);
2960                }
2961                break;
2962
2963             default:
2964                return -EINVAL;
2965
2966          }
2967          return 0;
2968
2969       default:
2970          if (dev->phy && dev->phy->ioctl) {
2971             return dev->phy->ioctl(dev, cmd, arg);
2972          }
2973          else {
2974             printk("nicstar%d: %s == NULL \n", card->index,
2975                    dev->phy ? "dev->phy->ioctl" : "dev->phy");
2976             return -ENOIOCTLCMD;
2977          }
2978    }
2979 }
2980
2981
2982
2983 static void which_list(ns_dev *card, struct sk_buff *skb)
2984 {
2985    printk("It's a %s buffer.\n", skb->list == &card->sbpool.queue ?
2986           "small" : skb->list == &card->lbpool.queue ? "large" :
2987           skb->list == &card->hbpool.queue ? "huge" :
2988           skb->list == &card->iovpool.queue ? "iovec" : "unknown");
2989 }
2990
2991
2992
2993 static void ns_poll(unsigned long arg)
2994 {
2995    int i;
2996    ns_dev *card;
2997    unsigned long flags;
2998    u32 stat_r, stat_w;
2999
3000    PRINTK("nicstar: Entering ns_poll().\n");
3001    for (i = 0; i < num_cards; i++)
3002    {
3003       card = cards[i];
3004       if (spin_is_locked(&card->int_lock)) {
3005       /* Probably it isn't worth spinning */
3006          continue;
3007       }
3008       ns_grab_int_lock(card, flags);
3009
3010       stat_w = 0;
3011       stat_r = readl(card->membase + STAT);
3012       if (stat_r & NS_STAT_TSIF)
3013          stat_w |= NS_STAT_TSIF;
3014       if (stat_r & NS_STAT_EOPDU)
3015          stat_w |= NS_STAT_EOPDU;
3016
3017       process_tsq(card);
3018       process_rsq(card);
3019
3020       writel(stat_w, card->membase + STAT);
3021       spin_unlock_irqrestore(&card->int_lock, flags);
3022    }
3023    mod_timer(&ns_timer, jiffies + NS_POLL_PERIOD);
3024    PRINTK("nicstar: Leaving ns_poll().\n");
3025 }
3026
3027
3028
3029 static int ns_parse_mac(char *mac, unsigned char *esi)
3030 {
3031    int i, j;
3032    short byte1, byte0;
3033
3034    if (mac == NULL || esi == NULL)
3035       return -1;
3036    j = 0;
3037    for (i = 0; i < 6; i++)
3038    {
3039       if ((byte1 = ns_h2i(mac[j++])) < 0)
3040          return -1;
3041       if ((byte0 = ns_h2i(mac[j++])) < 0)
3042          return -1;
3043       esi[i] = (unsigned char) (byte1 * 16 + byte0);
3044       if (i < 5)
3045       {
3046          if (mac[j++] != ':')
3047             return -1;
3048       }
3049    }
3050    return 0;
3051 }
3052
3053
3054
3055 static short ns_h2i(char c)
3056 {
3057    if (c >= '0' && c <= '9')
3058       return (short) (c - '0');
3059    if (c >= 'A' && c <= 'F')
3060       return (short) (c - 'A' + 10);
3061    if (c >= 'a' && c <= 'f')
3062       return (short) (c - 'a' + 10);
3063    return -1;
3064 }
3065
3066
3067
3068 static void ns_phy_put(struct atm_dev *dev, unsigned char value,
3069                     unsigned long addr)
3070 {
3071    ns_dev *card;
3072    unsigned long flags;
3073
3074    card = dev->dev_data;
3075    ns_grab_res_lock(card, flags);
3076    while(CMD_BUSY(card));
3077    writel((unsigned long) value, card->membase + DR0);
3078    writel(NS_CMD_WRITE_UTILITY | 0x00000200 | (addr & 0x000000FF),
3079           card->membase + CMD);
3080    spin_unlock_irqrestore(&card->res_lock, flags);
3081 }
3082
3083
3084
3085 static unsigned char ns_phy_get(struct atm_dev *dev, unsigned long addr)
3086 {
3087    ns_dev *card;
3088    unsigned long flags;
3089    unsigned long data;
3090
3091    card = dev->dev_data;
3092    ns_grab_res_lock(card, flags);
3093    while(CMD_BUSY(card));
3094    writel(NS_CMD_READ_UTILITY | 0x00000200 | (addr & 0x000000FF),
3095           card->membase + CMD);
3096    while(CMD_BUSY(card));
3097    data = readl(card->membase + DR0) & 0x000000FF;
3098    spin_unlock_irqrestore(&card->res_lock, flags);
3099    return (unsigned char) data;
3100 }
3101
3102
3103
3104 module_init(nicstar_init);
3105 module_exit(nicstar_cleanup);