release/src/shared/linux_osl.c

   1 /*
   2  * Linux OS Independent Layer
   3  *
   4  * Copyright 2004, Broadcom Corporation
   5  * All Rights Reserved.
   6  *
   7  * THIS SOFTWARE IS OFFERED "AS IS", AND BROADCOM GRANTS NO WARRANTIES OF ANY
   8  * KIND, EXPRESS OR IMPLIED, BY STATUTE, COMMUNICATION OR OTHERWISE. BROADCOM
   9  * SPECIFICALLY DISCLAIMS ANY IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS
  10  * FOR A SPECIFIC PURPOSE OR NONINFRINGEMENT CONCERNING THIS SOFTWARE.
  11  *
  12  * $Id$
  13  */
  14
  15 #define LINUX_OSL
  16
  17 #include <typedefs.h>
  18 #include <bcmendian.h>
  19 #include <linuxver.h>
  20 #include <bcmdefs.h>
  21 #include <osl.h>
  22 #include <bcmutils.h>
  23 #include <linux/delay.h>
  24 #ifdef mips
  25 #include <asm/paccess.h>
  26 #endif /* mips */
  27 #include <pcicfg.h>
  28
  29 #define PCI_CFG_RETRY           10
  30
  31 #define OS_HANDLE_MAGIC         0x1234abcd      /* Magic # to recognise osh */
  32 #define BCM_MEM_FILENAME_LEN    24              /* Mem. filename length */
  33
  34 typedef struct bcm_mem_link {
  35         struct bcm_mem_link *prev;
  36         struct bcm_mem_link *next;
  37         uint    size;
  38         int     line;
  39         char    file[BCM_MEM_FILENAME_LEN];
  40 } bcm_mem_link_t;
  41
  42 struct osl_info {
  43         osl_pubinfo_t pub;
  44         uint magic;
  45         void *pdev;
  46         uint malloced;
  47         uint failed;
  48         uint bustype;
  49         bcm_mem_link_t *dbgmem_list;
  50 #if defined(DSLCPE_DELAY)
  51         shared_osl_t *oshsh; /* osh shared */
  52 #endif
  53 #ifdef BCMDBG_PKT      /* pkt logging for debugging */
  54         pktlist_info_t pktlist;
  55 #endif  /* BCMDBG_PKT */
  56 };
  57
  58 static int16 linuxbcmerrormap[] =  \
  59 {       0,                      /* 0 */
  60         -EINVAL,                /* BCME_ERROR */
  61         -EINVAL,                /* BCME_BADARG */
  62         -EINVAL,                /* BCME_BADOPTION */
  63         -EINVAL,                /* BCME_NOTUP */
  64         -EINVAL,                /* BCME_NOTDOWN */
  65         -EINVAL,                /* BCME_NOTAP */
  66         -EINVAL,                /* BCME_NOTSTA */
  67         -EINVAL,                /* BCME_BADKEYIDX */
  68         -EINVAL,                /* BCME_RADIOOFF */
  69         -EINVAL,                /* BCME_NOTBANDLOCKED */
  70         -EINVAL,                /* BCME_NOCLK */
  71         -EINVAL,                /* BCME_BADRATESET */
  72         -EINVAL,                /* BCME_BADBAND */
  73         -E2BIG,                 /* BCME_BUFTOOSHORT */
  74         -E2BIG,                 /* BCME_BUFTOOLONG */
  75         -EBUSY,                 /* BCME_BUSY */
  76         -EINVAL,                /* BCME_NOTASSOCIATED */
  77         -EINVAL,                /* BCME_BADSSIDLEN */
  78         -EINVAL,                /* BCME_OUTOFRANGECHAN */
  79         -EINVAL,                /* BCME_BADCHAN */
  80         -EFAULT,                /* BCME_BADADDR */
  81         -ENOMEM,                /* BCME_NORESOURCE */
  82         -EOPNOTSUPP,            /* BCME_UNSUPPORTED */
  83         -EMSGSIZE,              /* BCME_BADLENGTH */
  84         -EINVAL,                /* BCME_NOTREADY */
  85         -EPERM,                 /* BCME_NOTPERMITTED */
  86         -ENOMEM,                /* BCME_NOMEM */
  87         -EINVAL,                /* BCME_ASSOCIATED */
  88         -ERANGE,                /* BCME_RANGE */
  89         -EINVAL,                /* BCME_NOTFOUND */
  90         -EINVAL,                /* BCME_WME_NOT_ENABLED */
  91         -EINVAL,                /* BCME_TSPEC_NOTFOUND */
  92         -EINVAL,                /* BCME_ACM_NOTSUPPORTED */
  93         -EINVAL,                /* BCME_NOT_WME_ASSOCIATION */
  94         -EIO,                   /* BCME_SDIO_ERROR */
  95         -ENODEV,                /* BCME_DONGLE_DOWN */
  96         -EINVAL                 /* BCME_VERSION */
  97
  98 /* When an new error code is added to bcmutils.h, add os
  99  * spcecific error translation here as well
 100  */
 101 /* check if BCME_LAST changed since the last time this function was updated */
 102 #if BCME_LAST != -37
 103 #error "You need to add a OS error translation in the linuxbcmerrormap \
 104         for new error code defined in bcmuitls.h"
 105 #endif /* BCME_LAST != -37 */
 106 };
 107
 108 /* translate bcmerrors into linux errors */
 109 int
 110 osl_error(int bcmerror)
 111 {
 112         if (bcmerror > 0)
 113                 bcmerror = 0;
 114         else if (bcmerror < BCME_LAST)
 115                 bcmerror = BCME_ERROR;
 116
 117         /* Array bounds covered by ASSERT in osl_attach */
 118         return linuxbcmerrormap[-bcmerror];
 119 }
 120
 121 osl_t *
 122 osl_attach(void *pdev, uint bustype, bool pkttag)
 123 {
 124         osl_t *osh;
 125
 126         osh = kmalloc(sizeof(osl_t), GFP_ATOMIC);
 127         ASSERT(osh);
 128
 129         bzero(osh, sizeof(osl_t));
 130
 131         /* Check that error map has the right number of entries in it */
 132         ASSERT(ABS(BCME_LAST) == (ARRAYSIZE(linuxbcmerrormap) - 1));
 133
 134         osh->magic = OS_HANDLE_MAGIC;
 135         osh->malloced = 0;
 136         osh->failed = 0;
 137         osh->dbgmem_list = NULL;
 138         osh->pdev = pdev;
 139         osh->pub.pkttag = pkttag;
 140         osh->bustype = bustype;
 141
 142         switch (bustype) {
 143                 case PCI_BUS:
 144                 case SB_BUS:
 145                 case PCMCIA_BUS:
 146                         osh->pub.mmbus = TRUE;
 147                         break;
 148                 case JTAG_BUS:
 149                 case SDIO_BUS:
 150                 case USB_BUS:
 151                         osh->pub.mmbus = FALSE;
 152                         break;
 153                 default:
 154                         ASSERT(FALSE);
 155                         break;
 156         }
 157
 158         return osh;
 159 }
 160
 161 void
 162 osl_detach(osl_t *osh)
 163 {
 164         if (osh == NULL)
 165                 return;
 166
 167         ASSERT(osh->magic == OS_HANDLE_MAGIC);
 168         kfree(osh);
 169 }
 170
 171 /* Return a new packet. zero out pkttag */
 172 void*
 173 osl_pktget(osl_t *osh, uint len)
 174 {
 175         struct sk_buff *skb;
 176
 177         if ((skb = dev_alloc_skb(len))) {
 178         skb_put(skb, len);
 179                 skb->priority = 0;
 180
 181 #ifdef BCMDBG_PKT
 182         pktlist_add(&(osh->pktlist), (void *) skb);
 183 #endif  /* BCMDBG_PKT */
 184
 185                 osh->pub.pktalloced++;
 186         }
 187
 188         return ((void*) skb);
 189 }
 190
 191 /* Free the driver packet. Free the tag if present */
 192 void
 193 osl_pktfree(osl_t *osh, void *p, bool send)
 194 {
 195         struct sk_buff *skb, *nskb;
 196
 197         skb = (struct sk_buff*) p;
 198
 199         if (send && osh->pub.tx_fn)
 200                 osh->pub.tx_fn(osh->pub.tx_ctx, p, 0);
 201
 202         /* perversion: we use skb->next to chain multi-skb packets */
 203         while (skb) {
 204                 nskb = skb->next;
 205                 skb->next = NULL;
 206
 207 #ifdef BCMDBG_PKT
 208                 pktlist_remove(&(osh->pktlist), (void *) skb);
 209 #endif  /* BCMDBG_PKT */
 210
 211                 if (skb->destructor) {
 212                         /* cannot kfree_skb() on hard IRQ (net/core/skbuff.c) if destructor exists
 213                          */
 214                         dev_kfree_skb_any(skb);
 215                 } else {
 216                         /* can free immediately (even in_irq()) if destructor does not exist */
 217                         dev_kfree_skb(skb);
 218                 }
 219
 220                 osh->pub.pktalloced--;
 221
 222                 skb = nskb;
 223         }
 224 }
 225
 226 uint32
 227 osl_pci_read_config(osl_t *osh, uint offset, uint size)
 228 {
 229         uint val;
 230         uint retry = PCI_CFG_RETRY;
 231
 232         ASSERT((osh && (osh->magic == OS_HANDLE_MAGIC)));
 233
 234         /* only 4byte access supported */
 235         ASSERT(size == 4);
 236
 237         do {
 238                 pci_read_config_dword(osh->pdev, offset, &val);
 239                 if (val != 0xffffffff)
 240                         break;
 241         } while (retry--);
 242
 243
 244         return (val);
 245 }
 246
 247 void
 248 osl_pci_write_config(osl_t *osh, uint offset, uint size, uint val)
 249 {
 250         uint retry = PCI_CFG_RETRY;
 251
 252         ASSERT((osh && (osh->magic == OS_HANDLE_MAGIC)));
 253
 254         /* only 4byte access supported */
 255         ASSERT(size == 4);
 256
 257         do {
 258                 pci_write_config_dword(osh->pdev, offset, val);
 259                 if (offset != PCI_BAR0_WIN)
 260                         break;
 261                 if (osl_pci_read_config(osh, offset, size) == val)
 262                         break;
 263         } while (retry--);
 264
 265 }
 266
 267 /* return bus # for the pci device pointed by osh->pdev */
 268 uint
 269 osl_pci_bus(osl_t *osh)
 270 {
 271         ASSERT(osh && (osh->magic == OS_HANDLE_MAGIC) && osh->pdev);
 272
 273         return ((struct pci_dev *)osh->pdev)->bus->number;
 274 }
 275
 276 /* return slot # for the pci device pointed by osh->pdev */
 277 uint
 278 osl_pci_slot(osl_t *osh)
 279 {
 280         ASSERT(osh && (osh->magic == OS_HANDLE_MAGIC) && osh->pdev);
 281
 282         return PCI_SLOT(((struct pci_dev *)osh->pdev)->devfn);
 283 }
 284
 285 static void
 286 osl_pcmcia_attr(osl_t *osh, uint offset, char *buf, int size, bool write)
 287 {
 288 }
 289
 290 void
 291 osl_pcmcia_read_attr(osl_t *osh, uint offset, void *buf, int size)
 292 {
 293         osl_pcmcia_attr(osh, offset, (char *) buf, size, FALSE);
 294 }
 295
 296 void
 297 osl_pcmcia_write_attr(osl_t *osh, uint offset, void *buf, int size)
 298 {
 299         osl_pcmcia_attr(osh, offset, (char *) buf, size, TRUE);
 300 }
 301
 302
 303 #ifdef BCMDBG_MEM
 304
 305 void*
 306 osl_debug_malloc(osl_t *osh, uint size, int line, char* file)
 307 {
 308         bcm_mem_link_t *p;
 309         char* basename;
 310
 311         ASSERT(size);
 312
 313         if ((p = (bcm_mem_link_t*)osl_malloc(osh, sizeof(bcm_mem_link_t) + size)) == NULL)
 314                 return (NULL);
 315
 316         p->size = size;
 317         p->line = line;
 318
 319         basename = strrchr(file, '/');
 320         /* skip the '/' */
 321         if (basename)
 322                 basename++;
 323
 324         if (!basename)
 325                 basename = file;
 326
 327         strncpy(p->file, basename, BCM_MEM_FILENAME_LEN);
 328         p->file[BCM_MEM_FILENAME_LEN - 1] = '\0';
 329
 330         /* link this block */
 331         p->prev = NULL;
 332         p->next = osh->dbgmem_list;
 333         if (p->next)
 334                 p->next->prev = p;
 335         osh->dbgmem_list = p;
 336
 337         return p + 1;
 338 }
 339
 340 void
 341 osl_debug_mfree(osl_t *osh, void *addr, uint size, int line, char* file)
 342 {
 343         bcm_mem_link_t *p = (bcm_mem_link_t *)((int8*)addr - sizeof(bcm_mem_link_t));
 344
 345         ASSERT((osh && (osh->magic == OS_HANDLE_MAGIC)));
 346
 347         if (p->size == 0) {
 348                 printk("osl_debug_mfree: double free on addr %p size %d at line %d file %s\n",
 349                         addr, size, line, file);
 350                 ASSERT(p->size);
 351                 return;
 352         }
 353
 354         if (p->size != size) {
 355                 printk("osl_debug_mfree: dealloc size %d does not match alloc size %d on addr %p"
 356                        " at line %d file %s\n",
 357                        size, p->size, addr, line, file);
 358                 ASSERT(p->size == size);
 359                 return;
 360         }
 361
 362         /* unlink this block */
 363         if (p->prev)
 364                 p->prev->next = p->next;
 365         if (p->next)
 366                 p->next->prev = p->prev;
 367         if (osh->dbgmem_list == p)
 368                 osh->dbgmem_list = p->next;
 369         p->next = p->prev = NULL;
 370
 371         osl_mfree(osh, p, size + sizeof(bcm_mem_link_t));
 372 }
 373
 374 int
 375 osl_debug_memdump(osl_t *osh, struct bcmstrbuf *b)
 376 {
 377         bcm_mem_link_t *p;
 378
 379         ASSERT((osh && (osh->magic == OS_HANDLE_MAGIC)));
 380
 381         bcm_bprintf(b, "   Address\tSize\tFile:line\n");
 382         for (p = osh->dbgmem_list; p; p = p->next)
 383                 bcm_bprintf(b, "0x%08x\t%5d\t%s:%d\n",
 384                         (uintptr)p + sizeof(bcm_mem_link_t), p->size, p->file, p->line);
 385
 386         return 0;
 387 }
 388
 389 #endif  /* BCMDBG_MEM */
 390
 391 void*
 392 osl_malloc(osl_t *osh, uint size)
 393 {
 394         void *addr;
 395
 396         /* only ASSERT if osh is defined */
 397         if (osh)
 398                 ASSERT(osh->magic == OS_HANDLE_MAGIC);
 399
 400         if ((addr = kmalloc(size, GFP_ATOMIC)) == NULL) {
 401                 if (osh)
 402                         osh->failed++;
 403                 return (NULL);
 404         }
 405         if (osh)
 406                 osh->malloced += size;
 407
 408         return (addr);
 409 }
 410
 411 void
 412 osl_mfree(osl_t *osh, void *addr, uint size)
 413 {
 414         if (osh) {
 415                 ASSERT(osh->magic == OS_HANDLE_MAGIC);
 416                 osh->malloced -= size;
 417         }
 418         kfree(addr);
 419 }
 420
 421 uint
 422 osl_malloced(osl_t *osh)
 423 {
 424         ASSERT((osh && (osh->magic == OS_HANDLE_MAGIC)));
 425         return (osh->malloced);
 426 }
 427
 428 uint
 429 osl_malloc_failed(osl_t *osh)
 430 {
 431         ASSERT((osh && (osh->magic == OS_HANDLE_MAGIC)));
 432         return (osh->failed);
 433 }
 434
 435 void*
 436 osl_dma_alloc_consistent(osl_t *osh, uint size, ulong *pap)
 437 {
 438         ASSERT((osh && (osh->magic == OS_HANDLE_MAGIC)));
 439
 440         return (pci_alloc_consistent(osh->pdev, size, (dma_addr_t*)pap));
 441 }
 442
 443 void
 444 osl_dma_free_consistent(osl_t *osh, void *va, uint size, ulong pa)
 445 {
 446         ASSERT((osh && (osh->magic == OS_HANDLE_MAGIC)));
 447
 448         pci_free_consistent(osh->pdev, size, va, (dma_addr_t)pa);
 449 }
 450
 451 uint
 452 osl_dma_map(osl_t *osh, void *va, uint size, int direction)
 453 {
 454         int dir;
 455
 456         ASSERT((osh && (osh->magic == OS_HANDLE_MAGIC)));
 457         dir = (direction == DMA_TX)? PCI_DMA_TODEVICE: PCI_DMA_FROMDEVICE;
 458         return (pci_map_single(osh->pdev, va, size, dir));
 459 }
 460
 461 void
 462 osl_dma_unmap(osl_t *osh, uint pa, uint size, int direction)
 463 {
 464         int dir;
 465
 466         ASSERT((osh && (osh->magic == OS_HANDLE_MAGIC)));
 467         dir = (direction == DMA_TX)? PCI_DMA_TODEVICE: PCI_DMA_FROMDEVICE;
 468         pci_unmap_single(osh->pdev, (uint32)pa, size, dir);
 469 }
 470
 471 #if defined(BINOSL) || defined(CONFIG_BCMDBG_ASSERT)
 472 void
 473 osl_assert(char *exp, char *file, int line)
 474 {
 475         char tempbuf[255];
 476
 477         sprintf(tempbuf, "assertion \"%s\" failed: file \"%s\", line %d\n", exp, file, line);
 478         panic(tempbuf);
 479 }
 480 #endif  /* BCMDBG_ASSERT || BINOSL */
 481
 482 void
 483 osl_delay(uint usec)
 484 {
 485         uint d;
 486
 487         while (usec > 0) {
 488                 d = MIN(usec, 1000);
 489                 udelay(d);
 490                 usec -= d;
 491         }
 492 }
 493
 494 #if defined(DSLCPE_DELAY)
 495
 496 void
 497 osl_oshsh_init(osl_t *osh, shared_osl_t* oshsh)
 498 {
 499         extern unsigned long loops_per_jiffy;
 500         osh->oshsh = oshsh;
 501         osh->oshsh->MIPS = loops_per_jiffy / (500000/HZ);
 502 }
 503
 504 int
 505 in_long_delay(osl_t *osh)
 506 {
 507         return osh->oshsh->long_delay;
 508 }
 509
 510 void
 511 osl_long_delay(osl_t *osh, uint usec, bool yield)
 512 {
 513         uint d;
 514         bool yielded = TRUE;
 515         int usec_to_delay = usec;
 516         unsigned long tick1, tick2, tick_diff = 0;
 517
 518         /* delay at least requested usec */
 519         while (usec_to_delay > 0) {
 520                 if (!yield || !yielded) {
 521                         d = MIN(usec_to_delay, 10);
 522                         udelay(d);
 523                         usec_to_delay -= d;
 524                 }
 525                 if (usec_to_delay > 0) {
 526                         osh->oshsh->long_delay++;
 527                         OSL_GETCYCLES(tick1);
 528                         spin_unlock_bh(osh->oshsh->lock);
 529                         if (usec_to_delay > 0 && !in_irq() && !in_softirq() && !in_interrupt()) {
 530                                 schedule();
 531                                 yielded = TRUE;
 532                         } else {
 533                                 yielded = FALSE;
 534                         }
 535                         spin_lock_bh(osh->oshsh->lock);
 536                         OSL_GETCYCLES(tick2);
 537
 538                         if (yielded) {
 539                                 tick_diff = TICKDIFF(tick2, tick1);
 540                                 tick_diff = (tick_diff * 2)/(osh->oshsh->MIPS);
 541                                 if (tick_diff) {
 542                                         usec_to_delay -= tick_diff;
 543                                 } else
 544                                         yielded = 0;
 545                         }
 546                         osh->oshsh->long_delay--;
 547                         ASSERT(osh->oshsh->long_delay >= 0);
 548                 }
 549         }
 550 }
 551 #endif /* DSLCPE_DELAY */
 552
 553 /* Clone a packet.
 554  * The pkttag contents are NOT cloned.
 555  */
 556 void *
 557 osl_pktdup(osl_t *osh, void *skb)
 558 {
 559         void * p;
 560
 561         if ((p = skb_clone((struct sk_buff*)skb, GFP_ATOMIC)) == NULL)
 562                 return NULL;
 563
 564         /* skb_clone copies skb->cb.. we don't want that */
 565         if (osh->pub.pkttag)
 566                 bzero((void*)((struct sk_buff *)p)->cb, OSL_PKTTAG_SZ);
 567
 568         /* Increment the packet counter */
 569         osh->pub.pktalloced++;
 570 #ifdef BCMDBG_PKT
 571         pktlist_add(&(osh->pktlist), (void *) p);
 572 #endif  /* BCMDBG_PKT */
 573         return (p);
 574 }
 575
 576 uint
 577 osl_pktalloced(osl_t *osh)
 578 {
 579         return (osh->pub.pktalloced);
 580 }
 581
 582 #ifdef BCMDBG_PKT
 583 char *
 584 osl_pktlist_dump(osl_t *osh, char *buf)
 585 {
 586         pktlist_dump(&(osh->pktlist), buf);
 587         return buf;
 588 }
 589
 590 void
 591 osl_pktlist_add(osl_t *osh, void *p)
 592 {
 593         pktlist_add(&(osh->pktlist), p);
 594 }
 595
 596 void
 597 osl_pktlist_remove(osl_t *osh, void *p)
 598 {
 599         pktlist_remove(&(osh->pktlist), p);
 600 }
 601 #endif /* BCMDBG_PKT */
 602
 603 /*
 604  * BINOSL selects the slightly slower function-call-based binary compatible osl.
 605  */
 606 #ifdef BINOSL
 607
 608 int
 609 osl_printf(const char *format, ...)
 610 {
 611         va_list args;
 612         char buf[1024];
 613         int len;
 614
 615         /* sprintf into a local buffer because there *is* no "vprintk()".. */
 616         va_start(args, format);
 617         len = vsnprintf(buf, 1024, format, args);
 618         va_end(args);
 619
 620         if (len > sizeof(buf)) {
 621                 printk("osl_printf: buffer overrun\n");
 622                 return (0);
 623         }
 624
 625         return (printk(buf));
 626 }
 627
 628 int
 629 osl_sprintf(char *buf, const char *format, ...)
 630 {
 631         va_list args;
 632         int rc;
 633
 634         va_start(args, format);
 635         rc = vsprintf(buf, format, args);
 636         va_end(args);
 637         return (rc);
 638 }
 639
 640 int
 641 osl_strcmp(const char *s1, const char *s2)
 642 {
 643         return (strcmp(s1, s2));
 644 }
 645
 646 int
 647 osl_strncmp(const char *s1, const char *s2, uint n)
 648 {
 649         return (strncmp(s1, s2, n));
 650 }
 651
 652 int
 653 osl_strlen(const char *s)
 654 {
 655         return (strlen(s));
 656 }
 657
 658 char*
 659 osl_strcpy(char *d, const char *s)
 660 {
 661         return (strcpy(d, s));
 662 }
 663
 664 char*
 665 osl_strncpy(char *d, const char *s, uint n)
 666 {
 667         return (strncpy(d, s, n));
 668 }
 669
 670 void
 671 bcopy(const void *src, void *dst, int len)
 672 {
 673         memcpy(dst, src, len);
 674 }
 675
 676 int
 677 bcmp(const void *b1, const void *b2, int len)
 678 {
 679         return (memcmp(b1, b2, len));
 680 }
 681
 682 void
 683 bzero(void *b, int len)
 684 {
 685         memset(b, '\0', len);
 686 }
 687
 688 uint32
 689 osl_readl(volatile uint32 *r)
 690 {
 691         return (readl(r));
 692 }
 693
 694 uint16
 695 osl_readw(volatile uint16 *r)
 696 {
 697         return (readw(r));
 698 }
 699
 700 uint8
 701 osl_readb(volatile uint8 *r)
 702 {
 703         return (readb(r));
 704 }
 705
 706 void
 707 osl_writel(uint32 v, volatile uint32 *r)
 708 {
 709         writel(v, r);
 710 }
 711
 712 void
 713 osl_writew(uint16 v, volatile uint16 *r)
 714 {
 715         writew(v, r);
 716 }
 717
 718 void
 719 osl_writeb(uint8 v, volatile uint8 *r)
 720 {
 721         writeb(v, r);
 722 }
 723
 724 void *
 725 osl_uncached(void *va)
 726 {
 727 #ifdef mips
 728         return ((void*)KSEG1ADDR(va));
 729 #else
 730         return ((void*)va);
 731 #endif /* mips */
 732 }
 733
 734 uint
 735 osl_getcycles(void)
 736 {
 737         uint cycles;
 738
 739 #if defined(mips)
 740         cycles = read_c0_count() * 2;
 741 #elif defined(__i386__)
 742         rdtscl(cycles);
 743 #else
 744         cycles = 0;
 745 #endif /* defined(mips) */
 746         return cycles;
 747 }
 748
 749 void *
 750 osl_reg_map(uint32 pa, uint size)
 751 {
 752         return (ioremap_nocache((unsigned long)pa, (unsigned long)size));
 753 }
 754
 755 void
 756 osl_reg_unmap(void *va)
 757 {
 758         iounmap(va);
 759 }
 760
 761 int
 762 osl_busprobe(uint32 *val, uint32 addr)
 763 {
 764 #ifdef mips
 765         return get_dbe(*val, (uint32 *)addr);
 766 #else
 767         *val = readl((uint32 *)(uintptr)addr);
 768         return 0;
 769 #endif /* mips */
 770 }
 771
 772 bool
 773 osl_pktshared(void *skb)
 774 {
 775         return (((struct sk_buff*)skb)->cloned);
 776 }
 777
 778 uchar*
 779 osl_pktdata(osl_t *osh, void *skb)
 780 {
 781         return (((struct sk_buff*)skb)->data);
 782 }
 783
 784 uint
 785 osl_pktlen(osl_t *osh, void *skb)
 786 {
 787         return (((struct sk_buff*)skb)->len);
 788 }
 789
 790 uint
 791 osl_pktheadroom(osl_t *osh, void *skb)
 792 {
 793         return (uint) skb_headroom((struct sk_buff *) skb);
 794 }
 795
 796 uint
 797 osl_pkttailroom(osl_t *osh, void *skb)
 798 {
 799         return (uint) skb_tailroom((struct sk_buff *) skb);
 800 }
 801
 802 void*
 803 osl_pktnext(osl_t *osh, void *skb)
 804 {
 805         return (((struct sk_buff*)skb)->next);
 806 }
 807
 808 void
 809 osl_pktsetnext(void *skb, void *x)
 810 {
 811         ((struct sk_buff*)skb)->next = (struct sk_buff*)x;
 812 }
 813
 814 void
 815 osl_pktsetlen(osl_t *osh, void *skb, uint len)
 816 {
 817         __skb_trim((struct sk_buff*)skb, len);
 818 }
 819
 820 uchar*
 821 osl_pktpush(osl_t *osh, void *skb, int bytes)
 822 {
 823         return (skb_push((struct sk_buff*)skb, bytes));
 824 }
 825
 826 uchar*
 827 osl_pktpull(osl_t *osh, void *skb, int bytes)
 828 {
 829         return (skb_pull((struct sk_buff*)skb, bytes));
 830 }
 831
 832 void*
 833 osl_pkttag(void *skb)
 834 {
 835         return ((void*)(((struct sk_buff*)skb)->cb));
 836 }
 837
 838 void*
 839 osl_pktlink(void *skb)
 840 {
 841         return (((struct sk_buff*)skb)->prev);
 842 }
 843
 844 void
 845 osl_pktsetlink(void *skb, void *x)
 846 {
 847         ((struct sk_buff*)skb)->prev = (struct sk_buff*)x;
 848 }
 849
 850 uint
 851 osl_pktprio(void *skb)
 852 {
 853         return (((struct sk_buff*)skb)->priority);
 854 }
 855
 856 void
 857 osl_pktsetprio(void *skb, uint x)
 858 {
 859         ((struct sk_buff*)skb)->priority = x;
 860 }
 861
 862 /* Convert a driver packet to native(OS) packet
 863  * In the process, packettag is zeroed out before sending up
 864  * IP code depends on skb->cb to be setup correctly with various options
 865  * In our case, that means it should be 0
 866  */
 867 struct sk_buff *
 868 osl_pkt_tonative(osl_t *osh, void *pkt)
 869 {
 870         struct sk_buff *nskb;
 871
 872         if (osh->pub.pkttag)
 873                 bzero((void*)((struct sk_buff *)pkt)->cb, OSL_PKTTAG_SZ);
 874
 875         /* Decrement the packet counter */
 876         for (nskb = (struct sk_buff *)pkt; nskb; nskb = nskb->next) {
 877 #ifdef BCMDBG_PKT
 878                 pktlist_remove(&(osh->pktlist), (void *) nskb);
 879 #endif  /* BCMDBG_PKT */
 880                 osh->pub.pktalloced--;
 881         }
 882
 883         return (struct sk_buff *)pkt;
 884 }
 885
 886 /* Convert a native(OS) packet to driver packet.
 887  * In the process, native packet is destroyed, there is no copying
 888  * Also, a packettag is zeroed out
 889  */
 890 void *
 891 osl_pkt_frmnative(osl_t *osh, struct sk_buff *skb)
 892 {
 893         struct sk_buff *nskb;
 894
 895         if (osh->pub.pkttag)
 896                 bzero((void*)skb->cb, OSL_PKTTAG_SZ);
 897
 898         /* Increment the packet counter */
 899         for (nskb = skb; nskb; nskb = nskb->next) {
 900 #ifdef BCMDBG_PKT
 901                 pktlist_add(&(osh->pktlist), (void *) nskb);
 902 #endif  /* BCMDBG_PKT */
 903                 osh->pub.pktalloced++;
 904         }
 905
 906         return (void *)skb;
 907 }
 908
 909 #endif  /* BINOSL */