openwrt/target/linux/linux-2.4/patches/brcm/001-bcm47xx.patch

   1 diff -Nur linux-2.4.32/arch/mips/bcm947xx/cfe_env.c linux-2.4.32-brcm/arch/mips/bcm947xx/cfe_env.c
   2 --- linux-2.4.32/arch/mips/bcm947xx/cfe_env.c   1970-01-01 01:00:00.000000000 +0100
   3 +++ linux-2.4.32-brcm/arch/mips/bcm947xx/cfe_env.c      2005-12-19 01:56:35.104829500 +0100
   4 @@ -0,0 +1,234 @@
   5 +/*
   6 + * NVRAM variable manipulation (Linux kernel half)
   7 + *
   8 + * Copyright 2001-2003, Broadcom Corporation
   9 + * All Rights Reserved.
  10 + *
  11 + * THIS SOFTWARE IS OFFERED "AS IS", AND BROADCOM GRANTS NO WARRANTIES OF ANY
  12 + * KIND, EXPRESS OR IMPLIED, BY STATUTE, COMMUNICATION OR OTHERWISE. BROADCOM
  13 + * SPECIFICALLY DISCLAIMS ANY IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS
  14 + * FOR A SPECIFIC PURPOSE OR NONINFRINGEMENT CONCERNING THIS SOFTWARE.
  15 + *
  16 + * $Id$
  17 + */
  18 +
  19 +#include <linux/config.h>
  20 +#include <linux/init.h>
  21 +#include <linux/module.h>
  22 +#include <linux/kernel.h>
  23 +#include <linux/string.h>
  24 +#include <asm/io.h>
  25 +#include <asm/uaccess.h>
  26 +
  27 +#include <typedefs.h>
  28 +#include <osl.h>
  29 +#include <bcmendian.h>
  30 +#include <bcmutils.h>
  31 +
  32 +#define NVRAM_SIZE       (0x1ff0)
  33 +static char _nvdata[NVRAM_SIZE] __initdata;
  34 +static char _valuestr[256] __initdata;
  35 +
  36 +/*
  37 + * TLV types.  These codes are used in the "type-length-value"
  38 + * encoding of the items stored in the NVRAM device (flash or EEPROM)
  39 + *
  40 + * The layout of the flash/nvram is as follows:
  41 + *
  42 + * <type> <length> <data ...> <type> <length> <data ...> <type_end>
  43 + *
  44 + * The type code of "ENV_TLV_TYPE_END" marks the end of the list.
  45 + * The "length" field marks the length of the data section, not
  46 + * including the type and length fields.
  47 + *
  48 + * Environment variables are stored as follows:
  49 + *
  50 + * <type_env> <length> <flags> <name> = <value>
  51 + *
  52 + * If bit 0 (low bit) is set, the length is an 8-bit value.
  53 + * If bit 0 (low bit) is clear, the length is a 16-bit value
  54 + *
  55 + * Bit 7 set indicates "user" TLVs.  In this case, bit 0 still
  56 + * indicates the size of the length field.
  57 + *
  58 + * Flags are from the constants below:
  59 + *
  60 + */
  61 +#define ENV_LENGTH_16BITS      0x00    /* for low bit */
  62 +#define ENV_LENGTH_8BITS       0x01
  63 +
  64 +#define ENV_TYPE_USER          0x80
  65 +
  66 +#define ENV_CODE_SYS(n,l) (((n)<<1)|(l))
  67 +#define ENV_CODE_USER(n,l) ((((n)<<1)|(l)) | ENV_TYPE_USER)
  68 +
  69 +/*
  70 + * The actual TLV types we support
  71 + */
  72 +
  73 +#define ENV_TLV_TYPE_END       0x00
  74 +#define ENV_TLV_TYPE_ENV       ENV_CODE_SYS(0,ENV_LENGTH_8BITS)
  75 +
  76 +/*
  77 + * Environment variable flags
  78 + */
  79 +
  80 +#define ENV_FLG_NORMAL         0x00    /* normal read/write */
  81 +#define ENV_FLG_BUILTIN                0x01    /* builtin - not stored in flash */
  82 +#define ENV_FLG_READONLY       0x02    /* read-only - cannot be changed */
  83 +
  84 +#define ENV_FLG_MASK           0xFF    /* mask of attributes we keep */
  85 +#define ENV_FLG_ADMIN          0x100   /* lets us internally override permissions */
  86 +
  87 +
  88 +/*  *********************************************************************
  89 +    *  _nvram_read(buffer,offset,length)
  90 +    *
  91 +    *  Read data from the NVRAM device
  92 +    *
  93 +    *  Input parameters:
  94 +    *             buffer - destination buffer
  95 +    *             offset - offset of data to read
  96 +    *             length - number of bytes to read
  97 +    *
  98 +    *  Return value:
  99 +    *             number of bytes read, or <0 if error occured
 100 +    ********************************************************************* */
 101 +static int
 102 +_nvram_read(unsigned char *nv_buf, unsigned char *buffer, int offset, int length)
 103 +{
 104 +    int i;
 105 +    if (offset > NVRAM_SIZE)
 106 +       return -1;
 107 +
 108 +    for ( i = 0; i < length; i++) {
 109 +       buffer[i] = ((volatile unsigned char*)nv_buf)[offset + i];
 110 +    }
 111 +    return length;
 112 +}
 113 +
 114 +
 115 +static char*
 116 +_strnchr(const char *dest,int c,size_t cnt)
 117 +{
 118 +       while (*dest && (cnt > 0)) {
 119 +       if (*dest == c) return (char *) dest;
 120 +       dest++;
 121 +       cnt--;
 122 +       }
 123 +       return NULL;
 124 +}
 125 +
 126 +
 127 +
 128 +/*
 129 + * Core support API: Externally visible.
 130 + */
 131 +
 132 +/*
 133 + * Get the value of an NVRAM variable
 134 + * @param      name    name of variable to get
 135 + * @return     value of variable or NULL if undefined
 136 + */
 137 +
 138 +char*
 139 +cfe_env_get(unsigned char *nv_buf, char* name)
 140 +{
 141 +    int size;
 142 +    unsigned char *buffer;
 143 +    unsigned char *ptr;
 144 +    unsigned char *envval;
 145 +    unsigned int reclen;
 146 +    unsigned int rectype;
 147 +    int offset;
 148 +    int flg;
 149 +
 150 +    size = NVRAM_SIZE;
 151 +    buffer = &_nvdata[0];
 152 +
 153 +    ptr = buffer;
 154 +    offset = 0;
 155 +
 156 +    /* Read the record type and length */
 157 +    if (_nvram_read(nv_buf, ptr,offset,1) != 1) {
 158 +       goto error;
 159 +    }
 160 +
 161 +    while ((*ptr != ENV_TLV_TYPE_END)  && (size > 1)) {
 162 +
 163 +       /* Adjust pointer for TLV type */
 164 +       rectype = *(ptr);
 165 +       offset++;
 166 +       size--;
 167 +
 168 +       /*
 169 +        * Read the length.  It can be either 1 or 2 bytes
 170 +        * depending on the code
 171 +        */
 172 +       if (rectype & ENV_LENGTH_8BITS) {
 173 +           /* Read the record type and length - 8 bits */
 174 +           if (_nvram_read(nv_buf, ptr,offset,1) != 1) {
 175 +               goto error;
 176 +           }
 177 +           reclen = *(ptr);
 178 +           size--;
 179 +           offset++;
 180 +       }
 181 +       else {
 182 +           /* Read the record type and length - 16 bits, MSB first */
 183 +           if (_nvram_read(nv_buf, ptr,offset,2) != 2) {
 184 +               goto error;
 185 +           }
 186 +           reclen = (((unsigned int) *(ptr)) << 8) + (unsigned int) *(ptr+1);
 187 +           size -= 2;
 188 +           offset += 2;
 189 +       }
 190 +
 191 +       if (reclen > size)
 192 +           break;      /* should not happen, bad NVRAM */
 193 +
 194 +       switch (rectype) {
 195 +           case ENV_TLV_TYPE_ENV:
 196 +               /* Read the TLV data */
 197 +               if (_nvram_read(nv_buf, ptr,offset,reclen) != reclen)
 198 +                   goto error;
 199 +               flg = *ptr++;
 200 +               envval = (unsigned char *) _strnchr(ptr,'=',(reclen-1));
 201 +               if (envval) {
 202 +                   *envval++ = '\0';
 203 +                   memcpy(_valuestr,envval,(reclen-1)-(envval-ptr));
 204 +                   _valuestr[(reclen-1)-(envval-ptr)] = '\0';
 205 +#if 0
 206 +                   printk(KERN_INFO "NVRAM:%s=%s\n", ptr, _valuestr);
 207 +#endif
 208 +                   if(!strcmp(ptr, name)){
 209 +                       return _valuestr;
 210 +                   }
 211 +                   if((strlen(ptr) > 1) && !strcmp(&ptr[1], name))
 212 +                       return _valuestr;
 213 +               }
 214 +               break;
 215 +
 216 +           default:
 217 +               /* Unknown TLV type, skip it. */
 218 +               break;
 219 +           }
 220 +
 221 +       /*
 222 +        * Advance to next TLV
 223 +        */
 224 +
 225 +       size -= (int)reclen;
 226 +       offset += reclen;
 227 +
 228 +       /* Read the next record type */
 229 +       ptr = buffer;
 230 +       if (_nvram_read(nv_buf, ptr,offset,1) != 1)
 231 +           goto error;
 232 +       }
 233 +
 234 +error:
 235 +    return NULL;
 236 +
 237 +}
 238 +
 239 diff -Nur linux-2.4.32/arch/mips/bcm947xx/compressed/Makefile linux-2.4.32-brcm/arch/mips/bcm947xx/compressed/Makefile
 240 --- linux-2.4.32/arch/mips/bcm947xx/compressed/Makefile 1970-01-01 01:00:00.000000000 +0100
 241 +++ linux-2.4.32-brcm/arch/mips/bcm947xx/compressed/Makefile    2005-12-16 23:39:10.668819500 +0100
 242 @@ -0,0 +1,33 @@
 243 +#
 244 +# Makefile for Broadcom BCM947XX boards
 245 +#
 246 +# Copyright 2001-2003, Broadcom Corporation
 247 +# All Rights Reserved.
 248 +#
 249 +# THIS SOFTWARE IS OFFERED "AS IS", AND BROADCOM GRANTS NO WARRANTIES OF ANY
 250 +# KIND, EXPRESS OR IMPLIED, BY STATUTE, COMMUNICATION OR OTHERWISE. BROADCOM
 251 +# SPECIFICALLY DISCLAIMS ANY IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS
 252 +# FOR A SPECIFIC PURPOSE OR NONINFRINGEMENT CONCERNING THIS SOFTWARE.
 253 +#
 254 +# $Id: Makefile,v 1.2 2005/04/02 12:12:57 wbx Exp $
 255 +#
 256 +
 257 +OBJCOPY_ARGS   = -O binary -R .reginfo -R .note -R .comment -R .mdebug -S
 258 +SYSTEM         ?= $(TOPDIR)/vmlinux
 259 +
 260 +all: vmlinuz
 261 +
 262 +# Don't build dependencies, this may die if $(CC) isn't gcc
 263 +dep:
 264 +
 265 +# Create a gzipped version named vmlinuz for compatibility
 266 +vmlinuz: piggy
 267 +       gzip -c9 $< > $@
 268 +
 269 +piggy: $(SYSTEM)
 270 +       $(OBJCOPY) $(OBJCOPY_ARGS) $< $@
 271 +
 272 +mrproper: clean
 273 +
 274 +clean:
 275 +       rm -f vmlinuz piggy
 276 diff -Nur linux-2.4.32/arch/mips/bcm947xx/generic/int-handler.S linux-2.4.32-brcm/arch/mips/bcm947xx/generic/int-handler.S
 277 --- linux-2.4.32/arch/mips/bcm947xx/generic/int-handler.S       1970-01-01 01:00:00.000000000 +0100
 278 +++ linux-2.4.32-brcm/arch/mips/bcm947xx/generic/int-handler.S  2005-12-16 23:39:10.668819500 +0100
 279 @@ -0,0 +1,51 @@
 280 +/*
 281 + * Generic interrupt handler for Broadcom MIPS boards
 282 + *
 283 + * Copyright 2004, Broadcom Corporation
 284 + * All Rights Reserved.
 285 + *
 286 + * THIS SOFTWARE IS OFFERED "AS IS", AND BROADCOM GRANTS NO WARRANTIES OF ANY
 287 + * KIND, EXPRESS OR IMPLIED, BY STATUTE, COMMUNICATION OR OTHERWISE. BROADCOM
 288 + * SPECIFICALLY DISCLAIMS ANY IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS
 289 + * FOR A SPECIFIC PURPOSE OR NONINFRINGEMENT CONCERNING THIS SOFTWARE.
 290 + *
 291 + * $Id: int-handler.S,v 1.1 2005/03/16 13:50:00 wbx Exp $
 292 + */
 293 +
 294 +#include <linux/config.h>
 295 +
 296 +#include <asm/asm.h>
 297 +#include <asm/mipsregs.h>
 298 +#include <asm/regdef.h>
 299 +#include <asm/stackframe.h>
 300 +
 301 +/*
 302 + *     MIPS IRQ        Source
 303 + *      --------        ------
 304 + *             0       Software (ignored)
 305 + *             1        Software (ignored)
 306 + *             2        Combined hardware interrupt (hw0)
 307 + *             3        Hardware
 308 + *             4        Hardware
 309 + *             5        Hardware
 310 + *             6        Hardware
 311 + *             7        R4k timer
 312 + */
 313 +
 314 +       .text
 315 +       .set    noreorder
 316 +       .set    noat
 317 +       .align  5
 318 +       NESTED(brcmIRQ, PT_SIZE, sp)
 319 +       SAVE_ALL
 320 +       CLI
 321 +       .set    at
 322 +    .set    noreorder
 323 +
 324 +       jal         brcm_irq_dispatch
 325 +        move   a0, sp
 326 +
 327 +       j           ret_from_irq
 328 +        nop
 329 +
 330 +       END(brcmIRQ)
 331 diff -Nur linux-2.4.32/arch/mips/bcm947xx/generic/irq.c linux-2.4.32-brcm/arch/mips/bcm947xx/generic/irq.c
 332 --- linux-2.4.32/arch/mips/bcm947xx/generic/irq.c       1970-01-01 01:00:00.000000000 +0100
 333 +++ linux-2.4.32-brcm/arch/mips/bcm947xx/generic/irq.c  2005-12-16 23:39:10.668819500 +0100
 334 @@ -0,0 +1,130 @@
 335 +/*
 336 + * Generic interrupt control functions for Broadcom MIPS boards
 337 + *
 338 + * Copyright 2004, Broadcom Corporation
 339 + * All Rights Reserved.
 340 + *
 341 + * THIS SOFTWARE IS OFFERED "AS IS", AND BROADCOM GRANTS NO WARRANTIES OF ANY
 342 + * KIND, EXPRESS OR IMPLIED, BY STATUTE, COMMUNICATION OR OTHERWISE. BROADCOM
 343 + * SPECIFICALLY DISCLAIMS ANY IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS
 344 + * FOR A SPECIFIC PURPOSE OR NONINFRINGEMENT CONCERNING THIS SOFTWARE.
 345 + *
 346 + * $Id: irq.c,v 1.1 2005/03/16 13:50:00 wbx Exp $
 347 + */
 348 +
 349 +#include <linux/config.h>
 350 +#include <linux/init.h>
 351 +#include <linux/kernel.h>
 352 +#include <linux/types.h>
 353 +#include <linux/interrupt.h>
 354 +#include <linux/irq.h>
 355 +
 356 +#include <asm/irq.h>
 357 +#include <asm/mipsregs.h>
 358 +#include <asm/gdb-stub.h>
 359 +
 360 +#define ALLINTS (IE_IRQ0 | IE_IRQ1 | IE_IRQ2 | IE_IRQ3 | IE_IRQ4 | IE_IRQ5)
 361 +
 362 +extern asmlinkage void brcmIRQ(void);
 363 +extern asmlinkage unsigned int do_IRQ(int irq, struct pt_regs *regs);
 364 +
 365 +void
 366 +brcm_irq_dispatch(struct pt_regs *regs)
 367 +{
 368 +       u32 cause;
 369 +
 370 +       cause = read_c0_cause() &
 371 +               read_c0_status() &
 372 +               CAUSEF_IP;
 373 +
 374 +#ifdef CONFIG_KERNPROF
 375 +       change_c0_status(cause | 1, 1);
 376 +#else
 377 +       clear_c0_status(cause);
 378 +#endif
 379 +
 380 +       if (cause & CAUSEF_IP7)
 381 +               do_IRQ(7, regs);
 382 +       if (cause & CAUSEF_IP2)
 383 +               do_IRQ(2, regs);
 384 +       if (cause & CAUSEF_IP3)
 385 +               do_IRQ(3, regs);
 386 +       if (cause & CAUSEF_IP4)
 387 +               do_IRQ(4, regs);
 388 +       if (cause & CAUSEF_IP5)
 389 +               do_IRQ(5, regs);
 390 +       if (cause & CAUSEF_IP6)
 391 +               do_IRQ(6, regs);
 392 +}
 393 +
 394 +static void
 395 +enable_brcm_irq(unsigned int irq)
 396 +{
 397 +       if (irq < 8)
 398 +               set_c0_status(1 << (irq + 8));
 399 +       else
 400 +               set_c0_status(IE_IRQ0);
 401 +}
 402 +
 403 +static void
 404 +disable_brcm_irq(unsigned int irq)
 405 +{
 406 +       if (irq < 8)
 407 +               clear_c0_status(1 << (irq + 8));
 408 +       else
 409 +               clear_c0_status(IE_IRQ0);
 410 +}
 411 +
 412 +static void
 413 +ack_brcm_irq(unsigned int irq)
 414 +{
 415 +       /* Already done in brcm_irq_dispatch */
 416 +}
 417 +
 418 +static unsigned int
 419 +startup_brcm_irq(unsigned int irq)
 420 +{
 421 +       enable_brcm_irq(irq);
 422 +
 423 +       return 0; /* never anything pending */
 424 +}
 425 +
 426 +static void
 427 +end_brcm_irq(unsigned int irq)
 428 +{
 429 +       if (!(irq_desc[irq].status & (IRQ_DISABLED|IRQ_INPROGRESS)))
 430 +               enable_brcm_irq(irq);
 431 +}
 432 +
 433 +static struct hw_interrupt_type brcm_irq_type = {
 434 +       typename: "MIPS",
 435 +       startup: startup_brcm_irq,
 436 +       shutdown: disable_brcm_irq,
 437 +       enable: enable_brcm_irq,
 438 +       disable: disable_brcm_irq,
 439 +       ack: ack_brcm_irq,
 440 +       end: end_brcm_irq,
 441 +       NULL
 442 +};
 443 +
 444 +void __init
 445 +init_IRQ(void)
 446 +{
 447 +       int i;
 448 +
 449 +       for (i = 0; i < NR_IRQS; i++) {
 450 +               irq_desc[i].status = IRQ_DISABLED;
 451 +               irq_desc[i].action = 0;
 452 +               irq_desc[i].depth = 1;
 453 +               irq_desc[i].handler = &brcm_irq_type;
 454 +       }
 455 +
 456 +       set_except_vector(0, brcmIRQ);
 457 +       change_c0_status(ST0_IM, ALLINTS);
 458 +
 459 +#ifdef CONFIG_REMOTE_DEBUG
 460 +       printk("Breaking into debugger...\n");
 461 +       set_debug_traps();
 462 +       breakpoint();
 463 +#endif
 464 +}
 465 diff -Nur linux-2.4.32/arch/mips/bcm947xx/generic/Makefile linux-2.4.32-brcm/arch/mips/bcm947xx/generic/Makefile
 466 --- linux-2.4.32/arch/mips/bcm947xx/generic/Makefile    1970-01-01 01:00:00.000000000 +0100
 467 +++ linux-2.4.32-brcm/arch/mips/bcm947xx/generic/Makefile       2005-12-16 23:39:10.668819500 +0100
 468 @@ -0,0 +1,15 @@
 469 +#
 470 +# Makefile for the BCM947xx specific kernel interface routines
 471 +# under Linux.
 472 +#
 473 +
 474 +.S.s:
 475 +       $(CPP) $(AFLAGS) $< -o $*.s
 476 +.S.o:
 477 +       $(CC) $(AFLAGS) -c $< -o $*.o
 478 +
 479 +O_TARGET        := brcm.o
 480 +
 481 +obj-y  := int-handler.o irq.o
 482 +
 483 +include $(TOPDIR)/Rules.make
 484 diff -Nur linux-2.4.32/arch/mips/bcm947xx/gpio.c linux-2.4.32-brcm/arch/mips/bcm947xx/gpio.c
 485 --- linux-2.4.32/arch/mips/bcm947xx/gpio.c      1970-01-01 01:00:00.000000000 +0100
 486 +++ linux-2.4.32-brcm/arch/mips/bcm947xx/gpio.c 2005-12-16 23:39:10.668819500 +0100
 487 @@ -0,0 +1,158 @@
 488 +/*
 489 + * GPIO char driver
 490 + *
 491 + * Copyright 2005, Broadcom Corporation
 492 + * All Rights Reserved.
 493 + *
 494 + * THIS SOFTWARE IS OFFERED "AS IS", AND BROADCOM GRANTS NO WARRANTIES OF ANY
 495 + * KIND, EXPRESS OR IMPLIED, BY STATUTE, COMMUNICATION OR OTHERWISE. BROADCOM
 496 + * SPECIFICALLY DISCLAIMS ANY IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS
 497 + * FOR A SPECIFIC PURPOSE OR NONINFRINGEMENT CONCERNING THIS SOFTWARE.
 498 + *
 499 + * $Id$
 500 + */
 501 +
 502 +#include <linux/module.h>
 503 +#include <linux/init.h>
 504 +#include <linux/fs.h>
 505 +#include <linux/miscdevice.h>
 506 +#include <asm/uaccess.h>
 507 +
 508 +#include <typedefs.h>
 509 +#include <bcmutils.h>
 510 +#include <sbutils.h>
 511 +#include <bcmdevs.h>
 512 +
 513 +static sb_t *gpio_sbh;
 514 +static int gpio_major;
 515 +static devfs_handle_t gpio_dir;
 516 +static struct {
 517 +       char *name;
 518 +       devfs_handle_t handle;
 519 +} gpio_file[] = {
 520 +       { "in", NULL },
 521 +       { "out", NULL },
 522 +       { "outen", NULL },
 523 +       { "control", NULL }
 524 +};
 525 +
 526 +static int
 527 +gpio_open(struct inode *inode, struct file * file)
 528 +{
 529 +       if (MINOR(inode->i_rdev) > ARRAYSIZE(gpio_file))
 530 +               return -ENODEV;
 531 +
 532 +       MOD_INC_USE_COUNT;
 533 +       return 0;
 534 +}
 535 +
 536 +static int
 537 +gpio_release(struct inode *inode, struct file * file)
 538 +{
 539 +       MOD_DEC_USE_COUNT;
 540 +       return 0;
 541 +}
 542 +
 543 +static ssize_t
 544 +gpio_read(struct file *file, char *buf, size_t count, loff_t *ppos)
 545 +{
 546 +       u32 val;
 547 +
 548 +       switch (MINOR(file->f_dentry->d_inode->i_rdev)) {
 549 +       case 0:
 550 +               val = sb_gpioin(gpio_sbh);
 551 +               break;
 552 +       case 1:
 553 +               val = sb_gpioout(gpio_sbh, 0, 0, GPIO_DRV_PRIORITY);
 554 +               break;
 555 +       case 2:
 556 +               val = sb_gpioouten(gpio_sbh, 0, 0, GPIO_DRV_PRIORITY);
 557 +               break;
 558 +       case 3:
 559 +               val = sb_gpiocontrol(gpio_sbh, 0, 0, GPIO_DRV_PRIORITY);
 560 +               break;
 561 +       default:
 562 +               return -ENODEV;
 563 +       }
 564 +
 565 +       if (put_user(val, (u32 *) buf))
 566 +               return -EFAULT;
 567 +
 568 +       return sizeof(val);
 569 +}
 570 +
 571 +static ssize_t
 572 +gpio_write(struct file *file, const char *buf, size_t count, loff_t *ppos)
 573 +{
 574 +       u32 val;
 575 +
 576 +       if (get_user(val, (u32 *) buf))
 577 +               return -EFAULT;
 578 +
 579 +       switch (MINOR(file->f_dentry->d_inode->i_rdev)) {
 580 +       case 0:
 581 +               return -EACCES;
 582 +       case 1:
 583 +               sb_gpioout(gpio_sbh, ~0, val, GPIO_DRV_PRIORITY);
 584 +               break;
 585 +       case 2:
 586 +               sb_gpioouten(gpio_sbh, ~0, val, GPIO_DRV_PRIORITY);
 587 +               break;
 588 +       case 3:
 589 +               sb_gpiocontrol(gpio_sbh, ~0, val, GPIO_DRV_PRIORITY);
 590 +               break;
 591 +       default:
 592 +               return -ENODEV;
 593 +       }
 594 +
 595 +       return sizeof(val);
 596 +}
 597 +
 598 +static struct file_operations gpio_fops = {
 599 +       owner:          THIS_MODULE,
 600 +       open:           gpio_open,
 601 +       release:        gpio_release,
 602 +       read:           gpio_read,
 603 +       write:          gpio_write,
 604 +};
 605 +
 606 +static int __init
 607 +gpio_init(void)
 608 +{
 609 +       int i;
 610 +
 611 +       if (!(gpio_sbh = sb_kattach()))
 612 +               return -ENODEV;
 613 +
 614 +       sb_gpiosetcore(gpio_sbh);
 615 +
 616 +       if ((gpio_major = devfs_register_chrdev(0, "gpio", &gpio_fops)) < 0)
 617 +               return gpio_major;
 618 +
 619 +       gpio_dir = devfs_mk_dir(NULL, "gpio", NULL);
 620 +
 621 +       for (i = 0; i < ARRAYSIZE(gpio_file); i++) {
 622 +               gpio_file[i].handle = devfs_register(gpio_dir,
 623 +                                                    gpio_file[i].name,
 624 +                                                    DEVFS_FL_DEFAULT, gpio_major, i,
 625 +                                                    S_IFCHR | S_IRUGO | S_IWUGO,
 626 +                                                    &gpio_fops, NULL);
 627 +       }
 628 +
 629 +       return 0;
 630 +}
 631 +
 632 +static void __exit
 633 +gpio_exit(void)
 634 +{
 635 +       int i;
 636 +
 637 +       for (i = 0; i < ARRAYSIZE(gpio_file); i++)
 638 +               devfs_unregister(gpio_file[i].handle);
 639 +       devfs_unregister(gpio_dir);
 640 +       devfs_unregister_chrdev(gpio_major, "gpio");
 641 +       sb_detach(gpio_sbh);
 642 +}
 643 +
 644 +module_init(gpio_init);
 645 +module_exit(gpio_exit);
 646 diff -Nur linux-2.4.32/arch/mips/bcm947xx/include/bcmdevs.h linux-2.4.32-brcm/arch/mips/bcm947xx/include/bcmdevs.h
 647 --- linux-2.4.32/arch/mips/bcm947xx/include/bcmdevs.h   1970-01-01 01:00:00.000000000 +0100
 648 +++ linux-2.4.32-brcm/arch/mips/bcm947xx/include/bcmdevs.h      2005-12-16 23:39:10.672819750 +0100
 649 @@ -0,0 +1,391 @@
 650 +/*
 651 + * Broadcom device-specific manifest constants.
 652 + *
 653 + * Copyright 2005, Broadcom Corporation
 654 + * All Rights Reserved.
 655 + *
 656 + * THIS SOFTWARE IS OFFERED "AS IS", AND BROADCOM GRANTS NO WARRANTIES OF ANY
 657 + * KIND, EXPRESS OR IMPLIED, BY STATUTE, COMMUNICATION OR OTHERWISE. BROADCOM
 658 + * SPECIFICALLY DISCLAIMS ANY IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS
 659 + * FOR A SPECIFIC PURPOSE OR NONINFRINGEMENT CONCERNING THIS SOFTWARE.
 660 + * $Id$
 661 + */
 662 +
 663 +#ifndef        _BCMDEVS_H
 664 +#define        _BCMDEVS_H
 665 +
 666 +
 667 +/* Known PCI vendor Id's */
 668 +#define        VENDOR_EPIGRAM          0xfeda
 669 +#define        VENDOR_BROADCOM         0x14e4
 670 +#define        VENDOR_3COM             0x10b7
 671 +#define        VENDOR_NETGEAR          0x1385
 672 +#define        VENDOR_DIAMOND          0x1092
 673 +#define        VENDOR_DELL             0x1028
 674 +#define        VENDOR_HP               0x0e11
 675 +#define        VENDOR_APPLE            0x106b
 676 +
 677 +/* PCI Device Id's */
 678 +#define        BCM4210_DEVICE_ID       0x1072          /* never used */
 679 +#define        BCM4211_DEVICE_ID       0x4211
 680 +#define        BCM4230_DEVICE_ID       0x1086          /* never used */
 681 +#define        BCM4231_DEVICE_ID       0x4231
 682 +
 683 +#define        BCM4410_DEVICE_ID       0x4410          /* bcm44xx family pci iline */
 684 +#define        BCM4430_DEVICE_ID       0x4430          /* bcm44xx family cardbus iline */
 685 +#define        BCM4412_DEVICE_ID       0x4412          /* bcm44xx family pci enet */
 686 +#define        BCM4432_DEVICE_ID       0x4432          /* bcm44xx family cardbus enet */
 687 +
 688 +#define        BCM3352_DEVICE_ID       0x3352          /* bcm3352 device id */
 689 +#define        BCM3360_DEVICE_ID       0x3360          /* bcm3360 device id */
 690 +
 691 +#define        EPI41210_DEVICE_ID      0xa0fa          /* bcm4210 */
 692 +#define        EPI41230_DEVICE_ID      0xa10e          /* bcm4230 */
 693 +
 694 +#define        BCM47XX_ILINE_ID        0x4711          /* 47xx iline20 */
 695 +#define        BCM47XX_V90_ID          0x4712          /* 47xx v90 codec */
 696 +#define        BCM47XX_ENET_ID         0x4713          /* 47xx enet */
 697 +#define        BCM47XX_EXT_ID          0x4714          /* 47xx external i/f */
 698 +#define        BCM47XX_USB_ID          0x4715          /* 47xx usb */
 699 +#define        BCM47XX_USBH_ID         0x4716          /* 47xx usb host */
 700 +#define        BCM47XX_USBD_ID         0x4717          /* 47xx usb device */
 701 +#define        BCM47XX_IPSEC_ID        0x4718          /* 47xx ipsec */
 702 +#define        BCM47XX_ROBO_ID         0x4719          /* 47xx/53xx roboswitch core */
 703 +#define        BCM47XX_USB20H_ID       0x471a          /* 47xx usb 2.0 host */
 704 +#define        BCM47XX_USB20D_ID       0x471b          /* 47xx usb 2.0 device */
 705 +
 706 +#define        BCM4710_DEVICE_ID       0x4710          /* 4710 primary function 0 */
 707 +
 708 +#define        BCM4610_DEVICE_ID       0x4610          /* 4610 primary function 0 */
 709 +#define        BCM4610_ILINE_ID        0x4611          /* 4610 iline100 */
 710 +#define        BCM4610_V90_ID          0x4612          /* 4610 v90 codec */
 711 +#define        BCM4610_ENET_ID         0x4613          /* 4610 enet */
 712 +#define        BCM4610_EXT_ID          0x4614          /* 4610 external i/f */
 713 +#define        BCM4610_USB_ID          0x4615          /* 4610 usb */
 714 +
 715 +#define        BCM4402_DEVICE_ID       0x4402          /* 4402 primary function 0 */
 716 +#define        BCM4402_ENET_ID         0x4402          /* 4402 enet */
 717 +#define        BCM4402_V90_ID          0x4403          /* 4402 v90 codec */
 718 +#define        BCM4401_ENET_ID         0x170c          /* 4401b0 production enet cards */
 719 +
 720 +#define        BCM4301_DEVICE_ID       0x4301          /* 4301 primary function 0 */
 721 +#define        BCM4301_D11B_ID         0x4301          /* 4301 802.11b */
 722 +
 723 +#define        BCM4307_DEVICE_ID       0x4307          /* 4307 primary function 0 */
 724 +#define        BCM4307_V90_ID          0x4305          /* 4307 v90 codec */
 725 +#define        BCM4307_ENET_ID         0x4306          /* 4307 enet */
 726 +#define        BCM4307_D11B_ID         0x4307          /* 4307 802.11b */
 727 +
 728 +#define        BCM4306_DEVICE_ID       0x4306          /* 4306 chipcommon chipid */
 729 +#define        BCM4306_D11G_ID         0x4320          /* 4306 802.11g */
 730 +#define        BCM4306_D11G_ID2        0x4325
 731 +#define        BCM4306_D11A_ID         0x4321          /* 4306 802.11a */
 732 +#define        BCM4306_UART_ID         0x4322          /* 4306 uart */
 733 +#define        BCM4306_V90_ID          0x4323          /* 4306 v90 codec */
 734 +#define        BCM4306_D11DUAL_ID      0x4324          /* 4306 dual A+B */
 735 +
 736 +#define        BCM4309_PKG_ID          1               /* 4309 package id */
 737 +
 738 +#define        BCM4303_D11B_ID         0x4303          /* 4303 802.11b */
 739 +#define        BCM4303_PKG_ID          2               /* 4303 package id */
 740 +
 741 +#define        BCM4310_DEVICE_ID       0x4310          /* 4310 chipcommon chipid */
 742 +#define        BCM4310_D11B_ID         0x4311          /* 4310 802.11b */
 743 +#define        BCM4310_UART_ID         0x4312          /* 4310 uart */
 744 +#define        BCM4310_ENET_ID         0x4313          /* 4310 enet */
 745 +#define        BCM4310_USB_ID          0x4315          /* 4310 usb */
 746 +
 747 +#define        BCMGPRS_UART_ID         0x4333          /* Uart id used by 4306/gprs card */
 748 +#define        BCMGPRS2_UART_ID        0x4344          /* Uart id used by 4306/gprs card */
 749 +
 750 +
 751 +#define        BCM4704_DEVICE_ID       0x4704          /* 4704 chipcommon chipid */
 752 +#define        BCM4704_ENET_ID         0x4706          /* 4704 enet (Use 47XX_ENET_ID instead!) */
 753 +
 754 +#define        BCM4317_DEVICE_ID       0x4317          /* 4317 chip common chipid */
 755 +
 756 +#define        BCM4318_DEVICE_ID       0x4318          /* 4318 chip common chipid */
 757 +#define        BCM4318_D11G_ID         0x4318          /* 4318 801.11b/g id */
 758 +#define        BCM4318_D11DUAL_ID      0x4319          /* 4318 801.11a/b/g id */
 759 +#define BCM4318_JTAGM_ID       0x4331          /* 4318 jtagm device id */
 760 +
 761 +#define FPGA_JTAGM_ID          0x4330          /* ??? */
 762 +
 763 +/* Address map */
 764 +#define BCM4710_SDRAM           0x00000000      /* Physical SDRAM */
 765 +#define BCM4710_PCI_MEM         0x08000000      /* Host Mode PCI memory access space (64 MB) */
 766 +#define BCM4710_PCI_CFG         0x0c000000      /* Host Mode PCI configuration space (64 MB) */
 767 +#define BCM4710_PCI_DMA         0x40000000      /* Client Mode PCI memory access space (1 GB) */
 768 +#define BCM4710_SDRAM_SWAPPED   0x10000000      /* Byteswapped Physical SDRAM */
 769 +#define BCM4710_ENUM            0x18000000      /* Beginning of core enumeration space */
 770 +
 771 +/* Core register space */
 772 +#define BCM4710_REG_SDRAM       0x18000000      /* SDRAM core registers */
 773 +#define BCM4710_REG_ILINE20     0x18001000      /* InsideLine20 core registers */
 774 +#define BCM4710_REG_EMAC0       0x18002000      /* Ethernet MAC 0 core registers */
 775 +#define BCM4710_REG_CODEC       0x18003000      /* Codec core registers */
 776 +#define BCM4710_REG_USB         0x18004000      /* USB core registers */
 777 +#define BCM4710_REG_PCI         0x18005000      /* PCI core registers */
 778 +#define BCM4710_REG_MIPS        0x18006000      /* MIPS core registers */
 779 +#define BCM4710_REG_EXTIF       0x18007000      /* External Interface core registers */
 780 +#define BCM4710_REG_EMAC1       0x18008000      /* Ethernet MAC 1 core registers */
 781 +
 782 +#define BCM4710_EXTIF           0x1f000000      /* External Interface base address */
 783 +#define BCM4710_PCMCIA_MEM      0x1f000000      /* External Interface PCMCIA memory access */
 784 +#define BCM4710_PCMCIA_IO       0x1f100000      /* PCMCIA I/O access */
 785 +#define BCM4710_PCMCIA_CONF     0x1f200000      /* PCMCIA configuration */
 786 +#define BCM4710_PROG            0x1f800000      /* Programable interface */
 787 +#define BCM4710_FLASH           0x1fc00000      /* Flash */
 788 +
 789 +#define BCM4710_EJTAG           0xff200000      /* MIPS EJTAG space (2M) */
 790 +
 791 +#define BCM4710_UART            (BCM4710_REG_EXTIF + 0x00000300)
 792 +
 793 +#define BCM4710_EUART           (BCM4710_EXTIF + 0x00800000)
 794 +#define BCM4710_LED             (BCM4710_EXTIF + 0x00900000)
 795 +
 796 +#define        BCM4712_DEVICE_ID       0x4712          /* 4712 chipcommon chipid */
 797 +#define        BCM4712_MIPS_ID         0x4720          /* 4712 base devid */
 798 +#define        BCM4712LARGE_PKG_ID     0               /* 340pin 4712 package id */
 799 +#define        BCM4712SMALL_PKG_ID     1               /* 200pin 4712 package id */
 800 +#define        BCM4712MID_PKG_ID       2               /* 225pin 4712 package id */
 801 +
 802 +#define        SDIOH_FPGA_ID           0x4380          /* sdio host fpga */
 803 +
 804 +#define BCM5365_DEVICE_ID       0x5365          /* 5365 chipcommon chipid */
 805 +#define        BCM5350_DEVICE_ID       0x5350          /* bcm5350 chipcommon chipid */
 806 +#define        BCM5352_DEVICE_ID       0x5352          /* bcm5352 chipcommon chipid */
 807 +
 808 +#define        BCM4320_DEVICE_ID       0x4320          /* bcm4320 chipcommon chipid */
 809 +
 810 +/* PCMCIA vendor Id's */
 811 +
 812 +#define        VENDOR_BROADCOM_PCMCIA  0x02d0
 813 +
 814 +/* SDIO vendor Id's */
 815 +#define        VENDOR_BROADCOM_SDIO    0x00BF
 816 +
 817 +
 818 +/* boardflags */
 819 +#define        BFL_BTCOEXIST           0x0001  /* This board implements Bluetooth coexistance */
 820 +#define        BFL_PACTRL              0x0002  /* This board has gpio 9 controlling the PA */
 821 +#define        BFL_AIRLINEMODE         0x0004  /* This board implements gpio13 radio disable indication */
 822 +#define        BFL_ENETROBO            0x0010  /* This board has robo switch or core */
 823 +#define        BFL_CCKHIPWR            0x0040  /* Can do high-power CCK transmission */
 824 +#define        BFL_ENETADM             0x0080  /* This board has ADMtek switch */
 825 +#define        BFL_ENETVLAN            0x0100  /* This board has vlan capability */
 826 +#define        BFL_AFTERBURNER         0x0200  /* This board supports Afterburner mode */
 827 +#define BFL_NOPCI              0x0400  /* This board leaves PCI floating */
 828 +#define BFL_FEM                        0x0800  /* This board supports the Front End Module */
 829 +#define BFL_EXTLNA             0x1000  /* This board has an external LNA */
 830 +#define BFL_HGPA               0x2000  /* This board has a high gain PA */
 831 +#define        BFL_BTCMOD              0x4000  /* This board' BTCOEXIST is in the alternate gpios */
 832 +#define        BFL_ALTIQ               0x8000  /* Alternate I/Q settings */
 833 +
 834 +/* board specific GPIO assignment, gpio 0-3 are also customer-configurable led */
 835 +#define BOARD_GPIO_HWRAD_B     0x010   /* bit 4 is HWRAD input on 4301 */
 836 +#define        BOARD_GPIO_BTCMOD_IN    0x010   /* bit 4 is the alternate BT Coexistance Input */
 837 +#define        BOARD_GPIO_BTCMOD_OUT   0x020   /* bit 5 is the alternate BT Coexistance Out */
 838 +#define        BOARD_GPIO_BTC_IN       0x080   /* bit 7 is BT Coexistance Input */
 839 +#define        BOARD_GPIO_BTC_OUT      0x100   /* bit 8 is BT Coexistance Out */
 840 +#define        BOARD_GPIO_PACTRL       0x200   /* bit 9 controls the PA on new 4306 boards */
 841 +#define        PCI_CFG_GPIO_SCS        0x10    /* PCI config space bit 4 for 4306c0 slow clock source */
 842 +#define PCI_CFG_GPIO_HWRAD     0x20    /* PCI config space GPIO 13 for hw radio disable */
 843 +#define PCI_CFG_GPIO_XTAL      0x40    /* PCI config space GPIO 14 for Xtal powerup */
 844 +#define PCI_CFG_GPIO_PLL       0x80    /* PCI config space GPIO 15 for PLL powerdown */
 845 +
 846 +/* Bus types */
 847 +#define        SB_BUS                  0       /* Silicon Backplane */
 848 +#define        PCI_BUS                 1       /* PCI target */
 849 +#define        PCMCIA_BUS              2       /* PCMCIA target */
 850 +#define SDIO_BUS               3       /* SDIO target */
 851 +#define JTAG_BUS               4       /* JTAG */
 852 +
 853 +/* Allows optimization for single-bus support */
 854 +#ifdef BCMBUSTYPE
 855 +#define BUSTYPE(bus) (BCMBUSTYPE)
 856 +#else
 857 +#define BUSTYPE(bus) (bus)
 858 +#endif
 859 +
 860 +/* power control defines */
 861 +#define PLL_DELAY              150             /* us pll on delay */
 862 +#define FREF_DELAY             200             /* us fref change delay */
 863 +#define MIN_SLOW_CLK           32              /* us Slow clock period */
 864 +#define        XTAL_ON_DELAY           1000            /* us crystal power-on delay */
 865 +
 866 +/* Reference Board Types */
 867 +
 868 +#define        BU4710_BOARD            0x0400
 869 +#define        VSIM4710_BOARD          0x0401
 870 +#define        QT4710_BOARD            0x0402
 871 +
 872 +#define        BU4610_BOARD            0x0403
 873 +#define        VSIM4610_BOARD          0x0404
 874 +
 875 +#define        BU4307_BOARD            0x0405
 876 +#define        BCM94301CB_BOARD        0x0406
 877 +#define        BCM94301PC_BOARD        0x0406          /* Pcmcia 5v card */
 878 +#define        BCM94301MP_BOARD        0x0407
 879 +#define        BCM94307MP_BOARD        0x0408
 880 +#define        BCMAP4307_BOARD         0x0409
 881 +
 882 +#define        BU4309_BOARD            0x040a
 883 +#define        BCM94309CB_BOARD        0x040b
 884 +#define        BCM94309MP_BOARD        0x040c
 885 +#define        BCM4309AP_BOARD         0x040d
 886 +
 887 +#define        BCM94302MP_BOARD        0x040e
 888 +
 889 +#define        VSIM4310_BOARD          0x040f
 890 +#define        BU4711_BOARD            0x0410
 891 +#define        BCM94310U_BOARD         0x0411
 892 +#define        BCM94310AP_BOARD        0x0412
 893 +#define        BCM94310MP_BOARD        0x0414
 894 +
 895 +#define        BU4306_BOARD            0x0416
 896 +#define        BCM94306CB_BOARD        0x0417
 897 +#define        BCM94306MP_BOARD        0x0418
 898 +
 899 +#define        BCM94710D_BOARD         0x041a
 900 +#define        BCM94710R1_BOARD        0x041b
 901 +#define        BCM94710R4_BOARD        0x041c
 902 +#define        BCM94710AP_BOARD        0x041d
 903 +
 904 +
 905 +#define        BU2050_BOARD            0x041f
 906 +
 907 +
 908 +#define        BCM94309G_BOARD         0x0421
 909 +
 910 +#define        BCM94301PC3_BOARD       0x0422          /* Pcmcia 3.3v card */
 911 +
 912 +#define        BU4704_BOARD            0x0423
 913 +#define        BU4702_BOARD            0x0424
 914 +
 915 +#define        BCM94306PC_BOARD        0x0425          /* pcmcia 3.3v 4306 card */
 916 +
 917 +#define        BU4317_BOARD            0x0426
 918 +
 919 +
 920 +#define        BCM94702MN_BOARD        0x0428
 921 +
 922 +/* BCM4702 1U CompactPCI Board */
 923 +#define        BCM94702CPCI_BOARD      0x0429
 924 +
 925 +/* BCM4702 with BCM95380 VLAN Router */
 926 +#define        BCM95380RR_BOARD        0x042a
 927 +
 928 +/* cb4306 with SiGe PA */
 929 +#define        BCM94306CBSG_BOARD      0x042b
 930 +
 931 +/* mp4301 with 2050 radio */
 932 +#define        BCM94301MPL_BOARD       0x042c
 933 +
 934 +/* cb4306 with SiGe PA */
 935 +#define        PCSG94306_BOARD         0x042d
 936 +
 937 +/* bu4704 with sdram */
 938 +#define        BU4704SD_BOARD          0x042e
 939 +
 940 +/* Dual 11a/11g Router */
 941 +#define        BCM94704AGR_BOARD       0x042f
 942 +
 943 +/* 11a-only minipci */
 944 +#define        BCM94308MP_BOARD        0x0430
 945 +
 946 +
 947 +
 948 +/* BCM94317 boards */
 949 +#define BCM94317CB_BOARD       0x0440
 950 +#define BCM94317MP_BOARD       0x0441
 951 +#define BCM94317PCMCIA_BOARD   0x0442
 952 +#define BCM94317SDIO_BOARD     0x0443
 953 +
 954 +#define BU4712_BOARD           0x0444
 955 +#define        BU4712SD_BOARD          0x045d
 956 +#define        BU4712L_BOARD           0x045f
 957 +
 958 +/* BCM4712 boards */
 959 +#define BCM94712AP_BOARD       0x0445
 960 +#define BCM94712P_BOARD                0x0446
 961 +
 962 +/* BCM4318 boards */
 963 +#define BU4318_BOARD           0x0447
 964 +#define CB4318_BOARD           0x0448
 965 +#define MPG4318_BOARD          0x0449
 966 +#define MP4318_BOARD           0x044a
 967 +#define SD4318_BOARD           0x044b
 968 +
 969 +/* BCM63XX boards */
 970 +#define BCM96338_BOARD         0x6338
 971 +#define BCM96345_BOARD         0x6345
 972 +#define BCM96348_BOARD         0x6348
 973 +
 974 +/* Another mp4306 with SiGe */
 975 +#define        BCM94306P_BOARD         0x044c
 976 +
 977 +/* CF-like 4317 modules */
 978 +#define        BCM94317CF_BOARD        0x044d
 979 +
 980 +/* mp4303 */
 981 +#define        BCM94303MP_BOARD        0x044e
 982 +
 983 +/* mpsgh4306 */
 984 +#define        BCM94306MPSGH_BOARD     0x044f
 985 +
 986 +/* BRCM 4306 w/ Front End Modules */
 987 +#define BCM94306MPM            0x0450
 988 +#define BCM94306MPL            0x0453
 989 +
 990 +/* 4712agr */
 991 +#define        BCM94712AGR_BOARD       0x0451
 992 +
 993 +/* The real CF 4317 board */
 994 +#define        CFI4317_BOARD           0x0452
 995 +
 996 +/* pcmcia 4303 */
 997 +#define        PC4303_BOARD            0x0454
 998 +
 999 +/* 5350K */
1000 +#define        BCM95350K_BOARD         0x0455
1001 +
1002 +/* 5350R */
1003 +#define        BCM95350R_BOARD         0x0456
1004 +
1005 +/* 4306mplna */
1006 +#define        BCM94306MPLNA_BOARD     0x0457
1007 +
1008 +/* 4320 boards */
1009 +#define        BU4320_BOARD            0x0458
1010 +#define        BU4320S_BOARD           0x0459
1011 +#define        BCM94320PH_BOARD        0x045a
1012 +
1013 +/* 4306mph */
1014 +#define        BCM94306MPH_BOARD       0x045b
1015 +
1016 +/* 4306pciv */
1017 +#define        BCM94306PCIV_BOARD      0x045c
1018 +
1019 +#define        BU4712SD_BOARD          0x045d
1020 +
1021 +#define        BCM94320PFLSH_BOARD     0x045e
1022 +
1023 +#define        BU4712L_BOARD           0x045f
1024 +#define        BCM94712LGR_BOARD       0x0460
1025 +#define        BCM94320R_BOARD         0x0461
1026 +
1027 +#define        BU5352_BOARD            0x0462
1028 +
1029 +#define        BCM94318MPGH_BOARD      0x0463
1030 +
1031 +
1032 +#define        BCM95352GR_BOARD        0x0467
1033 +
1034 +/* bcm95351agr */
1035 +#define        BCM95351AGR_BOARD       0x0470
1036 +
1037 +/* # of GPIO pins */
1038 +#define GPIO_NUMPINS           16
1039 +
1040 +#endif /* _BCMDEVS_H */
1041 diff -Nur linux-2.4.32/arch/mips/bcm947xx/include/bcmendian.h linux-2.4.32-brcm/arch/mips/bcm947xx/include/bcmendian.h
1042 --- linux-2.4.32/arch/mips/bcm947xx/include/bcmendian.h 1970-01-01 01:00:00.000000000 +0100
1043 +++ linux-2.4.32-brcm/arch/mips/bcm947xx/include/bcmendian.h    2005-12-16 23:39:10.672819750 +0100
1044 @@ -0,0 +1,152 @@
1045 +/*
1046 + * local version of endian.h - byte order defines
1047 + *
1048 + * Copyright 2005, Broadcom Corporation
1049 + * All Rights Reserved.
1050 + *
1051 + * THIS SOFTWARE IS OFFERED "AS IS", AND BROADCOM GRANTS NO WARRANTIES OF ANY
1052 + * KIND, EXPRESS OR IMPLIED, BY STATUTE, COMMUNICATION OR OTHERWISE. BROADCOM
1053 + * SPECIFICALLY DISCLAIMS ANY IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS
1054 + * FOR A SPECIFIC PURPOSE OR NONINFRINGEMENT CONCERNING THIS SOFTWARE.
1055 + *
1056 + *  $Id$
1057 +*/
1058 +
1059 +#ifndef _BCMENDIAN_H_
1060 +#define _BCMENDIAN_H_
1061 +
1062 +#include <typedefs.h>
1063 +
1064 +/* Byte swap a 16 bit value */
1065 +#define BCMSWAP16(val) \
1066 +       ((uint16)( \
1067 +               (((uint16)(val) & (uint16)0x00ffU) << 8) | \
1068 +               (((uint16)(val) & (uint16)0xff00U) >> 8) ))
1069 +
1070 +/* Byte swap a 32 bit value */
1071 +#define BCMSWAP32(val) \
1072 +       ((uint32)( \
1073 +               (((uint32)(val) & (uint32)0x000000ffUL) << 24) | \
1074 +               (((uint32)(val) & (uint32)0x0000ff00UL) <<  8) | \
1075 +               (((uint32)(val) & (uint32)0x00ff0000UL) >>  8) | \
1076 +               (((uint32)(val) & (uint32)0xff000000UL) >> 24) ))
1077 +
1078 +/* 2 Byte swap a 32 bit value */
1079 +#define BCMSWAP32BY16(val) \
1080 +       ((uint32)( \
1081 +               (((uint32)(val) & (uint32)0x0000ffffUL) << 16) | \
1082 +               (((uint32)(val) & (uint32)0xffff0000UL) >> 16) ))
1083 +
1084 +
1085 +static INLINE uint16
1086 +bcmswap16(uint16 val)
1087 +{
1088 +       return BCMSWAP16(val);
1089 +}
1090 +
1091 +static INLINE uint32
1092 +bcmswap32(uint32 val)
1093 +{
1094 +       return BCMSWAP32(val);
1095 +}
1096 +
1097 +static INLINE uint32
1098 +bcmswap32by16(uint32 val)
1099 +{
1100 +       return BCMSWAP32BY16(val);
1101 +}
1102 +
1103 +/* buf - start of buffer of shorts to swap */
1104 +/* len  - byte length of buffer */
1105 +static INLINE void
1106 +bcmswap16_buf(uint16 *buf, uint len)
1107 +{
1108 +       len = len/2;
1109 +
1110 +       while(len--){
1111 +               *buf = bcmswap16(*buf);
1112 +               buf++;
1113 +       }
1114 +}
1115 +
1116 +#ifndef hton16
1117 +#ifndef IL_BIGENDIAN
1118 +#define HTON16(i) BCMSWAP16(i)
1119 +#define        hton16(i) bcmswap16(i)
1120 +#define        hton32(i) bcmswap32(i)
1121 +#define        ntoh16(i) bcmswap16(i)
1122 +#define        ntoh32(i) bcmswap32(i)
1123 +#define ltoh16(i) (i)
1124 +#define ltoh32(i) (i)
1125 +#define htol16(i) (i)
1126 +#define htol32(i) (i)
1127 +#else
1128 +#define HTON16(i) (i)
1129 +#define        hton16(i) (i)
1130 +#define        hton32(i) (i)
1131 +#define        ntoh16(i) (i)
1132 +#define        ntoh32(i) (i)
1133 +#define        ltoh16(i) bcmswap16(i)
1134 +#define        ltoh32(i) bcmswap32(i)
1135 +#define htol16(i) bcmswap16(i)
1136 +#define htol32(i) bcmswap32(i)
1137 +#endif
1138 +#endif
1139 +
1140 +#ifndef IL_BIGENDIAN
1141 +#define ltoh16_buf(buf, i)
1142 +#define htol16_buf(buf, i)
1143 +#else
1144 +#define ltoh16_buf(buf, i) bcmswap16_buf((uint16*)buf, i)
1145 +#define htol16_buf(buf, i) bcmswap16_buf((uint16*)buf, i)
1146 +#endif
1147 +
1148 +/*
1149 +* load 16-bit value from unaligned little endian byte array.
1150 +*/
1151 +static INLINE uint16
1152 +ltoh16_ua(uint8 *bytes)
1153 +{
1154 +       return (bytes[1]<<8)+bytes[0];
1155 +}
1156 +
1157 +/*
1158 +* load 32-bit value from unaligned little endian byte array.
1159 +*/
1160 +static INLINE uint32
1161 +ltoh32_ua(uint8 *bytes)
1162 +{
1163 +       return (bytes[3]<<24)+(bytes[2]<<16)+(bytes[1]<<8)+bytes[0];
1164 +}
1165 +
1166 +/*
1167 +* load 16-bit value from unaligned big(network) endian byte array.
1168 +*/
1169 +static INLINE uint16
1170 +ntoh16_ua(uint8 *bytes)
1171 +{
1172 +       return (bytes[0]<<8)+bytes[1];
1173 +}
1174 +
1175 +/*
1176 +* load 32-bit value from unaligned big(network) endian byte array.
1177 +*/
1178 +static INLINE uint32
1179 +ntoh32_ua(uint8 *bytes)
1180 +{
1181 +       return (bytes[0]<<24)+(bytes[1]<<16)+(bytes[2]<<8)+bytes[3];
1182 +}
1183 +
1184 +#define ltoh_ua(ptr) ( \
1185 +       sizeof(*(ptr)) == sizeof(uint8) ?  *(uint8 *)ptr : \
1186 +       sizeof(*(ptr)) == sizeof(uint16) ? (((uint8 *)ptr)[1]<<8)+((uint8 *)ptr)[0] : \
1187 +       (((uint8 *)ptr)[3]<<24)+(((uint8 *)ptr)[2]<<16)+(((uint8 *)ptr)[1]<<8)+((uint8 *)ptr)[0] \
1188 +)
1189 +
1190 +#define ntoh_ua(ptr) ( \
1191 +       sizeof(*(ptr)) == sizeof(uint8) ?  *(uint8 *)ptr : \
1192 +       sizeof(*(ptr)) == sizeof(uint16) ? (((uint8 *)ptr)[0]<<8)+((uint8 *)ptr)[1] : \
1193 +       (((uint8 *)ptr)[0]<<24)+(((uint8 *)ptr)[1]<<16)+(((uint8 *)ptr)[2]<<8)+((uint8 *)ptr)[3] \
1194 +)
1195 +
1196 +#endif /* _BCMENDIAN_H_ */
1197 diff -Nur linux-2.4.32/arch/mips/bcm947xx/include/bcmenet47xx.h linux-2.4.32-brcm/arch/mips/bcm947xx/include/bcmenet47xx.h
1198 --- linux-2.4.32/arch/mips/bcm947xx/include/bcmenet47xx.h       1970-01-01 01:00:00.000000000 +0100
1199 +++ linux-2.4.32-brcm/arch/mips/bcm947xx/include/bcmenet47xx.h  2005-12-16 23:39:10.700821500 +0100
1200 @@ -0,0 +1,229 @@
1201 +/*
1202 + * Hardware-specific definitions for
1203 + * Broadcom BCM47XX 10/100 Mbps Ethernet cores.
1204 + *
1205 + * Copyright 2005, Broadcom Corporation
1206 + * All Rights Reserved.
1207 + *
1208 + * This is UNPUBLISHED PROPRIETARY SOURCE CODE of Broadcom Corporation;
1209 + * the contents of this file may not be disclosed to third parties, copied
1210 + * or duplicated in any form, in whole or in part, without the prior
1211 + * written permission of Broadcom Corporation.
1212 + * $Id$
1213 + */
1214 +
1215 +#ifndef        _bcmenet_47xx_h_
1216 +#define        _bcmenet_47xx_h_
1217 +
1218 +#include <bcmenetmib.h>
1219 +#include <bcmenetrxh.h>
1220 +#include <bcmenetphy.h>
1221 +
1222 +#define        BCMENET_NFILTERS        64              /* # ethernet address filter entries */
1223 +#define        BCMENET_MCHASHBASE      0x200           /* multicast hash filter base address */
1224 +#define        BCMENET_MCHASHSIZE      256             /* multicast hash filter size in bytes */
1225 +#define        BCMENET_MAX_DMA         4096            /* chip has 12 bits of DMA addressing */
1226 +
1227 +/* power management event wakeup pattern constants */
1228 +#define        BCMENET_NPMP            4               /* chip supports 4 wakeup patterns */
1229 +#define        BCMENET_PMPBASE         0x400           /* wakeup pattern base address */
1230 +#define        BCMENET_PMPSIZE         0x80            /* 128bytes each pattern */
1231 +#define        BCMENET_PMMBASE         0x600           /* wakeup mask base address */
1232 +#define        BCMENET_PMMSIZE         0x10            /* 128bits each mask */
1233 +
1234 +/* cpp contortions to concatenate w/arg prescan */
1235 +#ifndef PAD
1236 +#define        _PADLINE(line)  pad ## line
1237 +#define        _XSTR(line)     _PADLINE(line)
1238 +#define        PAD             _XSTR(__LINE__)
1239 +#endif /* PAD */
1240 +
1241 +/*
1242 + * Host Interface Registers
1243 + */
1244 +typedef volatile struct _bcmenettregs {
1245 +       /* Device and Power Control */
1246 +       uint32  devcontrol;
1247 +       uint32  PAD[2];
1248 +       uint32  biststatus;
1249 +       uint32  wakeuplength;
1250 +       uint32  PAD[3];
1251 +
1252 +       /* Interrupt Control */
1253 +       uint32  intstatus;
1254 +       uint32  intmask;
1255 +       uint32  gptimer;
1256 +       uint32  PAD[23];
1257 +
1258 +       /* Ethernet MAC Address Filtering Control */
1259 +       uint32  PAD[2];
1260 +       uint32  enetftaddr;
1261 +       uint32  enetftdata;
1262 +       uint32  PAD[2];
1263 +
1264 +       /* Ethernet MAC Control */
1265 +       uint32  emactxmaxburstlen;
1266 +       uint32  emacrxmaxburstlen;
1267 +       uint32  emaccontrol;
1268 +       uint32  emacflowcontrol;
1269 +
1270 +       uint32  PAD[20];
1271 +
1272 +       /* DMA Lazy Interrupt Control */
1273 +       uint32  intrecvlazy;
1274 +       uint32  PAD[63];
1275 +
1276 +       /* DMA engine */
1277 +       dma32regp_t     dmaregs;
1278 +       dma32diag_t     dmafifo;
1279 +       uint32  PAD[116];
1280 +
1281 +       /* EMAC Registers */
1282 +       uint32 rxconfig;
1283 +       uint32 rxmaxlength;
1284 +       uint32 txmaxlength;
1285 +       uint32 PAD;
1286 +       uint32 mdiocontrol;
1287 +       uint32 mdiodata;
1288 +       uint32 emacintmask;
1289 +       uint32 emacintstatus;
1290 +       uint32 camdatalo;
1291 +       uint32 camdatahi;
1292 +       uint32 camcontrol;
1293 +       uint32 enetcontrol;
1294 +       uint32 txcontrol;
1295 +       uint32 txwatermark;
1296 +       uint32 mibcontrol;
1297 +       uint32 PAD[49];
1298 +
1299 +       /* EMAC MIB counters */
1300 +       bcmenetmib_t    mib;
1301 +
1302 +       uint32  PAD[585];
1303 +
1304 +       /* Sonics SiliconBackplane config registers */
1305 +       sbconfig_t      sbconfig;
1306 +} bcmenetregs_t;
1307 +
1308 +/* device control */
1309 +#define        DC_PM           ((uint32)1 << 7)        /* pattern filtering enable */
1310 +#define        DC_IP           ((uint32)1 << 10)       /* internal ephy present (rev >= 1) */
1311 +#define        DC_ER           ((uint32)1 << 15)       /* ephy reset */
1312 +#define        DC_MP           ((uint32)1 << 16)       /* mii phy mode enable */
1313 +#define        DC_CO           ((uint32)1 << 17)       /* mii phy mode: enable clocks */
1314 +#define        DC_PA_MASK      0x7c0000                /* mii phy mode: mdc/mdio phy address */
1315 +#define        DC_PA_SHIFT     18
1316 +#define        DC_FS_MASK      0x03800000              /* fifo size (rev >= 8) */
1317 +#define        DC_FS_SHIFT     23
1318 +#define        DC_FS_4K        0                       /* 4Kbytes */
1319 +#define        DC_FS_512       1                       /* 512bytes */
1320 +
1321 +/* wakeup length */
1322 +#define        WL_P0_MASK      0x7f                    /* pattern 0 */
1323 +#define        WL_D0           ((uint32)1 << 7)
1324 +#define        WL_P1_MASK      0x7f00                  /* pattern 1 */
1325 +#define        WL_P1_SHIFT     8
1326 +#define        WL_D1           ((uint32)1 << 15)
1327 +#define        WL_P2_MASK      0x7f0000                /* pattern 2 */
1328 +#define        WL_P2_SHIFT     16
1329 +#define        WL_D2           ((uint32)1 << 23)
1330 +#define        WL_P3_MASK      0x7f000000              /* pattern 3 */
1331 +#define        WL_P3_SHIFT     24
1332 +#define        WL_D3           ((uint32)1 << 31)
1333 +
1334 +/* intstatus and intmask */
1335 +#define        I_PME           ((uint32)1 << 6)        /* power management event */
1336 +#define        I_TO            ((uint32)1 << 7)        /* general purpose timeout */
1337 +#define        I_PC            ((uint32)1 << 10)       /* descriptor error */
1338 +#define        I_PD            ((uint32)1 << 11)       /* data error */
1339 +#define        I_DE            ((uint32)1 << 12)       /* descriptor protocol error */
1340 +#define        I_RU            ((uint32)1 << 13)       /* receive descriptor underflow */
1341 +#define        I_RO            ((uint32)1 << 14)       /* receive fifo overflow */
1342 +#define        I_XU            ((uint32)1 << 15)       /* transmit fifo underflow */
1343 +#define        I_RI            ((uint32)1 << 16)       /* receive interrupt */
1344 +#define        I_XI            ((uint32)1 << 24)       /* transmit interrupt */
1345 +#define        I_EM            ((uint32)1 << 26)       /* emac interrupt */
1346 +#define        I_MW            ((uint32)1 << 27)       /* mii write */
1347 +#define        I_MR            ((uint32)1 << 28)       /* mii read */
1348 +
1349 +/* emaccontrol */
1350 +#define        EMC_CG          ((uint32)1 << 0)        /* crc32 generation enable */
1351 +#define        EMC_EP          ((uint32)1 << 2)        /* onchip ephy: powerdown (rev >= 1) */
1352 +#define        EMC_ED          ((uint32)1 << 3)        /* onchip ephy: energy detected (rev >= 1) */
1353 +#define        EMC_LC_MASK     0xe0                    /* onchip ephy: led control (rev >= 1) */
1354 +#define        EMC_LC_SHIFT    5
1355 +
1356 +/* emacflowcontrol */
1357 +#define        EMF_RFH_MASK    0xff                    /* rx fifo hi water mark */
1358 +#define        EMF_PG          ((uint32)1 << 15)       /* enable pause frame generation */
1359 +
1360 +/* interrupt receive lazy */
1361 +#define        IRL_TO_MASK     0x00ffffff              /* timeout */
1362 +#define        IRL_FC_MASK     0xff000000              /* frame count */
1363 +#define        IRL_FC_SHIFT    24                      /* frame count */
1364 +
1365 +/* emac receive config */
1366 +#define        ERC_DB          ((uint32)1 << 0)        /* disable broadcast */
1367 +#define        ERC_AM          ((uint32)1 << 1)        /* accept all multicast */
1368 +#define        ERC_RDT         ((uint32)1 << 2)        /* receive disable while transmitting */
1369 +#define        ERC_PE          ((uint32)1 << 3)        /* promiscuous enable */
1370 +#define        ERC_LE          ((uint32)1 << 4)        /* loopback enable */
1371 +#define        ERC_FE          ((uint32)1 << 5)        /* enable flow control */
1372 +#define        ERC_UF          ((uint32)1 << 6)        /* accept unicast flow control frame */
1373 +#define        ERC_RF          ((uint32)1 << 7)        /* reject filter */
1374 +#define        ERC_CA          ((uint32)1 << 8)        /* cam absent */
1375 +
1376 +/* emac mdio control */
1377 +#define        MC_MF_MASK      0x7f                    /* mdc frequency */
1378 +#define        MC_PE           ((uint32)1 << 7)        /* mii preamble enable */
1379 +
1380 +/* emac mdio data */
1381 +#define        MD_DATA_MASK    0xffff                  /* r/w data */
1382 +#define        MD_TA_MASK      0x30000                 /* turnaround value */
1383 +#define        MD_TA_SHIFT     16
1384 +#define        MD_TA_VALID     (2 << MD_TA_SHIFT)      /* valid ta */
1385 +#define        MD_RA_MASK      0x7c0000                /* register address */
1386 +#define        MD_RA_SHIFT     18
1387 +#define        MD_PMD_MASK     0xf800000               /* physical media device */
1388 +#define        MD_PMD_SHIFT    23
1389 +#define        MD_OP_MASK      0x30000000              /* opcode */
1390 +#define        MD_OP_SHIFT     28
1391 +#define        MD_OP_WRITE     (1 << MD_OP_SHIFT)      /* write op */
1392 +#define        MD_OP_READ      (2 << MD_OP_SHIFT)      /* read op */
1393 +#define        MD_SB_MASK      0xc0000000              /* start bits */
1394 +#define        MD_SB_SHIFT     30
1395 +#define        MD_SB_START     (0x1 << MD_SB_SHIFT)    /* start of frame */
1396 +
1397 +/* emac intstatus and intmask */
1398 +#define        EI_MII          ((uint32)1 << 0)        /* mii mdio interrupt */
1399 +#define        EI_MIB          ((uint32)1 << 1)        /* mib interrupt */
1400 +#define        EI_FLOW         ((uint32)1 << 2)        /* flow control interrupt */
1401 +
1402 +/* emac cam data high */
1403 +#define        CD_V            ((uint32)1 << 16)       /* valid bit */
1404 +
1405 +/* emac cam control */
1406 +#define        CC_CE           ((uint32)1 << 0)        /* cam enable */
1407 +#define        CC_MS           ((uint32)1 << 1)        /* mask select */
1408 +#define        CC_RD           ((uint32)1 << 2)        /* read */
1409 +#define        CC_WR           ((uint32)1 << 3)        /* write */
1410 +#define        CC_INDEX_MASK   0x3f0000                /* index */
1411 +#define        CC_INDEX_SHIFT  16
1412 +#define        CC_CB           ((uint32)1 << 31)       /* cam busy */
1413 +
1414 +/* emac ethernet control */
1415 +#define        EC_EE           ((uint32)1 << 0)        /* emac enable */
1416 +#define        EC_ED           ((uint32)1 << 1)        /* emac disable */
1417 +#define        EC_ES           ((uint32)1 << 2)        /* emac soft reset */
1418 +#define        EC_EP           ((uint32)1 << 3)        /* external phy select */
1419 +
1420 +/* emac transmit control */
1421 +#define        EXC_FD          ((uint32)1 << 0)        /* full duplex */
1422 +#define        EXC_FM          ((uint32)1 << 1)        /* flowmode */
1423 +#define        EXC_SB          ((uint32)1 << 2)        /* single backoff enable */
1424 +#define        EXC_SS          ((uint32)1 << 3)        /* small slottime */
1425 +
1426 +/* emac mib control */
1427 +#define        EMC_RZ          ((uint32)1 << 0)        /* autoclear on read */
1428 +
1429 +#endif /* _bcmenet_47xx_h_ */
1430 diff -Nur linux-2.4.32/arch/mips/bcm947xx/include/bcmenetmib.h linux-2.4.32-brcm/arch/mips/bcm947xx/include/bcmenetmib.h
1431 --- linux-2.4.32/arch/mips/bcm947xx/include/bcmenetmib.h        1970-01-01 01:00:00.000000000 +0100
1432 +++ linux-2.4.32-brcm/arch/mips/bcm947xx/include/bcmenetmib.h   2005-12-16 23:39:10.700821500 +0100
1433 @@ -0,0 +1,81 @@
1434 +/*
1435 + * Hardware-specific MIB definition for
1436 + * Broadcom Home Networking Division
1437 + * BCM44XX and BCM47XX 10/100 Mbps Ethernet cores.
1438 + *
1439 + * Copyright 2005, Broadcom Corporation
1440 + * All Rights Reserved.
1441 + *
1442 + * This is UNPUBLISHED PROPRIETARY SOURCE CODE of Broadcom Corporation;
1443 + * the contents of this file may not be disclosed to third parties, copied
1444 + * or duplicated in any form, in whole or in part, without the prior
1445 + * written permission of Broadcom Corporation.
1446 + * $Id$
1447 + */
1448 +
1449 +#ifndef _bcmenetmib_h_
1450 +#define _bcmenetmib_h_
1451 +
1452 +/* cpp contortions to concatenate w/arg prescan */
1453 +#ifndef PAD
1454 +#define        _PADLINE(line)  pad ## line
1455 +#define        _XSTR(line)     _PADLINE(line)
1456 +#define        PAD             _XSTR(__LINE__)
1457 +#endif /* PAD */
1458 +
1459 +/*
1460 + * EMAC MIB Registers
1461 + */
1462 +typedef volatile struct {
1463 +       uint32 tx_good_octets;
1464 +       uint32 tx_good_pkts;
1465 +       uint32 tx_octets;
1466 +       uint32 tx_pkts;
1467 +       uint32 tx_broadcast_pkts;
1468 +       uint32 tx_multicast_pkts;
1469 +       uint32 tx_len_64;
1470 +       uint32 tx_len_65_to_127;
1471 +       uint32 tx_len_128_to_255;
1472 +       uint32 tx_len_256_to_511;
1473 +       uint32 tx_len_512_to_1023;
1474 +       uint32 tx_len_1024_to_max;
1475 +       uint32 tx_jabber_pkts;
1476 +       uint32 tx_oversize_pkts;
1477 +       uint32 tx_fragment_pkts;
1478 +       uint32 tx_underruns;
1479 +       uint32 tx_total_cols;
1480 +       uint32 tx_single_cols;
1481 +       uint32 tx_multiple_cols;
1482 +       uint32 tx_excessive_cols;
1483 +       uint32 tx_late_cols;
1484 +       uint32 tx_defered;
1485 +       uint32 tx_carrier_lost;
1486 +       uint32 tx_pause_pkts;
1487 +       uint32 PAD[8];
1488 +
1489 +       uint32 rx_good_octets;
1490 +       uint32 rx_good_pkts;
1491 +       uint32 rx_octets;
1492 +       uint32 rx_pkts;
1493 +       uint32 rx_broadcast_pkts;
1494 +       uint32 rx_multicast_pkts;
1495 +       uint32 rx_len_64;
1496 +       uint32 rx_len_65_to_127;
1497 +       uint32 rx_len_128_to_255;
1498 +       uint32 rx_len_256_to_511;
1499 +       uint32 rx_len_512_to_1023;
1500 +       uint32 rx_len_1024_to_max;
1501 +       uint32 rx_jabber_pkts;
1502 +       uint32 rx_oversize_pkts;
1503 +       uint32 rx_fragment_pkts;
1504 +       uint32 rx_missed_pkts;
1505 +       uint32 rx_crc_align_errs;
1506 +       uint32 rx_undersize;
1507 +       uint32 rx_crc_errs;
1508 +       uint32 rx_align_errs;
1509 +       uint32 rx_symbol_errs;
1510 +       uint32 rx_pause_pkts;
1511 +       uint32 rx_nonpause_pkts;
1512 +} bcmenetmib_t;
1513 +
1514 +#endif /* _bcmenetmib_h_ */
1515 diff -Nur linux-2.4.32/arch/mips/bcm947xx/include/bcmenetphy.h linux-2.4.32-brcm/arch/mips/bcm947xx/include/bcmenetphy.h
1516 --- linux-2.4.32/arch/mips/bcm947xx/include/bcmenetphy.h        1970-01-01 01:00:00.000000000 +0100
1517 +++ linux-2.4.32-brcm/arch/mips/bcm947xx/include/bcmenetphy.h   2005-12-16 23:39:10.700821500 +0100
1518 @@ -0,0 +1,58 @@
1519 +/*
1520 + * Misc Broadcom BCM47XX MDC/MDIO enet phy definitions.
1521 + *
1522 + * Copyright 2005, Broadcom Corporation
1523 + * All Rights Reserved.
1524 + *
1525 + * This is UNPUBLISHED PROPRIETARY SOURCE CODE of Broadcom Corporation;
1526 + * the contents of this file may not be disclosed to third parties, copied
1527 + * or duplicated in any form, in whole or in part, without the prior
1528 + * written permission of Broadcom Corporation.
1529 + * $Id$
1530 + */
1531 +
1532 +#ifndef        _bcmenetphy_h_
1533 +#define        _bcmenetphy_h_
1534 +
1535 +/* phy address */
1536 +#define        MAXEPHY         32                      /* mdio phy addresses are 5bit quantities */
1537 +#define        EPHY_MASK       0x1f
1538 +#define        EPHY_NONE       31                      /* nvram: no phy present at all */
1539 +#define        EPHY_NOREG      30                      /* nvram: no local phy regs */
1540 +
1541 +/* just a few phy registers */
1542 +#define        CTL_RESET       (1 << 15)               /* reset */
1543 +#define        CTL_LOOP        (1 << 14)               /* loopback */
1544 +#define        CTL_SPEED       (1 << 13)               /* speed selection 0=10, 1=100 */
1545 +#define        CTL_ANENAB      (1 << 12)               /* autonegotiation enable */
1546 +#define        CTL_RESTART     (1 << 9)                /* restart autonegotiation */
1547 +#define        CTL_DUPLEX      (1 << 8)                /* duplex mode 0=half, 1=full */
1548 +
1549 +#define        ADV_10FULL      (1 << 6)                /* autonegotiate advertise 10full */
1550 +#define        ADV_10HALF      (1 << 5)                /* autonegotiate advertise 10half */
1551 +#define        ADV_100FULL     (1 << 8)                /* autonegotiate advertise 100full */
1552 +#define        ADV_100HALF     (1 << 7)                /* autonegotiate advertise 100half */
1553 +
1554 +/* link partner ability register */
1555 +#define LPA_SLCT       0x001f                  /* same as advertise selector */
1556 +#define LPA_10HALF     0x0020                  /* can do 10mbps half-duplex */
1557 +#define LPA_10FULL     0x0040                  /* can do 10mbps full-duplex */
1558 +#define LPA_100HALF    0x0080                  /* can do 100mbps half-duplex */
1559 +#define LPA_100FULL    0x0100                  /* can do 100mbps full-duplex */
1560 +#define LPA_100BASE4   0x0200                  /* can do 100mbps 4k packets */
1561 +#define LPA_RESV       0x1c00                  /* unused */
1562 +#define LPA_RFAULT     0x2000                  /* link partner faulted */
1563 +#define LPA_LPACK      0x4000                  /* link partner acked us */
1564 +#define LPA_NPAGE      0x8000                  /* next page bit */
1565 +
1566 +#define LPA_DUPLEX     (LPA_10FULL | LPA_100FULL)
1567 +#define LPA_100                (LPA_100FULL | LPA_100HALF | LPA_100BASE4)
1568 +
1569 +#define        STAT_REMFAULT   (1 << 4)                /* remote fault */
1570 +#define        STAT_LINK       (1 << 2)                /* link status */
1571 +#define        STAT_JAB        (1 << 1)                /* jabber detected */
1572 +#define        AUX_FORCED      (1 << 2)                /* forced 10/100 */
1573 +#define        AUX_SPEED       (1 << 1)                /* speed 0=10mbps 1=100mbps */
1574 +#define        AUX_DUPLEX      (1 << 0)                /* duplex 0=half 1=full */
1575 +
1576 +#endif /* _bcmenetphy_h_ */
1577 diff -Nur linux-2.4.32/arch/mips/bcm947xx/include/bcmenetrxh.h linux-2.4.32-brcm/arch/mips/bcm947xx/include/bcmenetrxh.h
1578 --- linux-2.4.32/arch/mips/bcm947xx/include/bcmenetrxh.h        1970-01-01 01:00:00.000000000 +0100
1579 +++ linux-2.4.32-brcm/arch/mips/bcm947xx/include/bcmenetrxh.h   2005-12-16 23:39:10.700821500 +0100
1580 @@ -0,0 +1,43 @@
1581 +/*
1582 + * Hardware-specific Receive Data Header for the
1583 + * Broadcom Home Networking Division
1584 + * BCM44XX and BCM47XX 10/100 Mbps Ethernet cores.
1585 + *
1586 + * Copyright 2005, Broadcom Corporation
1587 + * All Rights Reserved.
1588 + *
1589 + * This is UNPUBLISHED PROPRIETARY SOURCE CODE of Broadcom Corporation;
1590 + * the contents of this file may not be disclosed to third parties, copied
1591 + * or duplicated in any form, in whole or in part, without the prior
1592 + * written permission of Broadcom Corporation.
1593 + * $Id$
1594 + */
1595 +
1596 +#ifndef _bcmenetrxh_h_
1597 +#define        _bcmenetrxh_h_
1598 +
1599 +/*
1600 + * The Ethernet MAC core returns an 8-byte Receive Frame Data Header
1601 + * with every frame consisting of
1602 + * 16bits of frame length, followed by
1603 + * 16bits of EMAC rx descriptor info, followed by 32bits of undefined.
1604 + */
1605 +typedef volatile struct {
1606 +       uint16  len;
1607 +       uint16  flags;
1608 +       uint16  pad[12];
1609 +} bcmenetrxh_t;
1610 +
1611 +#define        RXHDR_LEN       28
1612 +
1613 +#define        RXF_L           ((uint16)1 << 11)       /* last buffer in a frame */
1614 +#define        RXF_MISS        ((uint16)1 << 7)        /* received due to promisc mode */
1615 +#define        RXF_BRDCAST     ((uint16)1 << 6)        /* dest is broadcast address */
1616 +#define        RXF_MULT        ((uint16)1 << 5)        /* dest is multicast address */
1617 +#define        RXF_LG          ((uint16)1 << 4)        /* frame length > rxmaxlength */
1618 +#define        RXF_NO          ((uint16)1 << 3)        /* odd number of nibbles */
1619 +#define        RXF_RXER        ((uint16)1 << 2)        /* receive symbol error */
1620 +#define        RXF_CRC         ((uint16)1 << 1)        /* crc error */
1621 +#define        RXF_OV          ((uint16)1 << 0)        /* fifo overflow */
1622 +
1623 +#endif /* _bcmenetrxh_h_ */
1624 diff -Nur linux-2.4.32/arch/mips/bcm947xx/include/bcmnvram.h linux-2.4.32-brcm/arch/mips/bcm947xx/include/bcmnvram.h
1625 --- linux-2.4.32/arch/mips/bcm947xx/include/bcmnvram.h  1970-01-01 01:00:00.000000000 +0100
1626 +++ linux-2.4.32-brcm/arch/mips/bcm947xx/include/bcmnvram.h     2005-12-16 23:39:10.700821500 +0100
1627 @@ -0,0 +1,141 @@
1628 +/*
1629 + * NVRAM variable manipulation
1630 + *
1631 + * Copyright 2005, Broadcom Corporation
1632 + * All Rights Reserved.
1633 + *
1634 + * THIS SOFTWARE IS OFFERED "AS IS", AND BROADCOM GRANTS NO WARRANTIES OF ANY
1635 + * KIND, EXPRESS OR IMPLIED, BY STATUTE, COMMUNICATION OR OTHERWISE. BROADCOM
1636 + * SPECIFICALLY DISCLAIMS ANY IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS
1637 + * FOR A SPECIFIC PURPOSE OR NONINFRINGEMENT CONCERNING THIS SOFTWARE.
1638 + *
1639 + * $Id$
1640 + */
1641 +
1642 +#ifndef _bcmnvram_h_
1643 +#define _bcmnvram_h_
1644 +
1645 +#ifndef _LANGUAGE_ASSEMBLY
1646 +
1647 +#include <typedefs.h>
1648 +
1649 +struct nvram_header {
1650 +       uint32 magic;
1651 +       uint32 len;
1652 +       uint32 crc_ver_init;    /* 0:7 crc, 8:15 ver, 16:31 sdram_init */
1653 +       uint32 config_refresh;  /* 0:15 sdram_config, 16:31 sdram_refresh */
1654 +       uint32 config_ncdl;     /* ncdl values for memc */
1655 +};
1656 +
1657 +struct nvram_tuple {
1658 +       char *name;
1659 +       char *value;
1660 +       struct nvram_tuple *next;
1661 +};
1662 +
1663 +/*
1664 + * Initialize NVRAM access. May be unnecessary or undefined on certain
1665 + * platforms.
1666 + */
1667 +extern int BCMINIT(nvram_init)(void *sbh);
1668 +
1669 +/*
1670 + * Disable NVRAM access. May be unnecessary or undefined on certain
1671 + * platforms.
1672 + */
1673 +extern void BCMINIT(nvram_exit)(void *sbh);
1674 +
1675 +/*
1676 + * Get the value of an NVRAM variable. The pointer returned may be
1677 + * invalid after a set.
1678 + * @param      name    name of variable to get
1679 + * @return     value of variable or NULL if undefined
1680 + */
1681 +extern char * BCMINIT(nvram_get)(const char *name);
1682 +
1683 +/*
1684 + * Read the reset GPIO value from the nvram and set the GPIO
1685 + * as input
1686 + */
1687 +extern int BCMINITFN(nvram_resetgpio_init)(void *sbh);
1688 +
1689 +/*
1690 + * Get the value of an NVRAM variable.
1691 + * @param      name    name of variable to get
1692 + * @return     value of variable or NUL if undefined
1693 + */
1694 +#define nvram_safe_get(name) (BCMINIT(nvram_get)(name) ? : "")
1695 +
1696 +/*
1697 + * Match an NVRAM variable.
1698 + * @param      name    name of variable to match
1699 + * @param      match   value to compare against value of variable
1700 + * @return     TRUE if variable is defined and its value is string equal
1701 + *             to match or FALSE otherwise
1702 + */
1703 +static INLINE int
1704 +nvram_match(char *name, char *match) {
1705 +       const char *value = BCMINIT(nvram_get)(name);
1706 +       return (value && !strcmp(value, match));
1707 +}
1708 +
1709 +/*
1710 + * Inversely match an NVRAM variable.
1711 + * @param      name    name of variable to match
1712 + * @param      match   value to compare against value of variable
1713 + * @return     TRUE if variable is defined and its value is not string
1714 + *             equal to invmatch or FALSE otherwise
1715 + */
1716 +static INLINE int
1717 +nvram_invmatch(char *name, char *invmatch) {
1718 +       const char *value = BCMINIT(nvram_get)(name);
1719 +       return (value && strcmp(value, invmatch));
1720 +}
1721 +
1722 +/*
1723 + * Set the value of an NVRAM variable. The name and value strings are
1724 + * copied into private storage. Pointers to previously set values
1725 + * may become invalid. The new value may be immediately
1726 + * retrieved but will not be permanently stored until a commit.
1727 + * @param      name    name of variable to set
1728 + * @param      value   value of variable
1729 + * @return     0 on success and errno on failure
1730 + */
1731 +extern int BCMINIT(nvram_set)(const char *name, const char *value);
1732 +
1733 +/*
1734 + * Unset an NVRAM variable. Pointers to previously set values
1735 + * remain valid until a set.
1736 + * @param      name    name of variable to unset
1737 + * @return     0 on success and errno on failure
1738 + * NOTE: use nvram_commit to commit this change to flash.
1739 + */
1740 +extern int BCMINIT(nvram_unset)(const char *name);
1741 +
1742 +/*
1743 + * Commit NVRAM variables to permanent storage. All pointers to values
1744 + * may be invalid after a commit.
1745 + * NVRAM values are undefined after a commit.
1746 + * @return     0 on success and errno on failure
1747 + */
1748 +extern int BCMINIT(nvram_commit)(void);
1749 +
1750 +/*
1751 + * Get all NVRAM variables (format name=value\0 ... \0\0).
1752 + * @param      buf     buffer to store variables
1753 + * @param      count   size of buffer in bytes
1754 + * @return     0 on success and errno on failure
1755 + */
1756 +extern int BCMINIT(nvram_getall)(char *buf, int count);
1757 +
1758 +#endif /* _LANGUAGE_ASSEMBLY */
1759 +
1760 +#define NVRAM_MAGIC            0x48534C46      /* 'FLSH' */
1761 +#define NVRAM_VERSION          1
1762 +#define NVRAM_HEADER_SIZE      20
1763 +#define NVRAM_SPACE            0x8000
1764 +
1765 +#define NVRAM_MAX_VALUE_LEN 255
1766 +#define NVRAM_MAX_PARAM_LEN 64
1767 +
1768 +#endif /* _bcmnvram_h_ */
1769 diff -Nur linux-2.4.32/arch/mips/bcm947xx/include/bcmparams.h linux-2.4.32-brcm/arch/mips/bcm947xx/include/bcmparams.h
1770 --- linux-2.4.32/arch/mips/bcm947xx/include/bcmparams.h 1970-01-01 01:00:00.000000000 +0100
1771 +++ linux-2.4.32-brcm/arch/mips/bcm947xx/include/bcmparams.h    2005-12-16 23:39:10.700821500 +0100
1772 @@ -0,0 +1,25 @@
1773 +/*
1774 + * Misc system wide parameters.
1775 + *
1776 + * Copyright 2005, Broadcom Corporation
1777 + * All Rights Reserved.
1778 + *
1779 + * THIS SOFTWARE IS OFFERED "AS IS", AND BROADCOM GRANTS NO WARRANTIES OF ANY
1780 + * KIND, EXPRESS OR IMPLIED, BY STATUTE, COMMUNICATION OR OTHERWISE. BROADCOM
1781 + * SPECIFICALLY DISCLAIMS ANY IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS
1782 + * FOR A SPECIFIC PURPOSE OR NONINFRINGEMENT CONCERNING THIS SOFTWARE.
1783 + * $Id$
1784 + */
1785 +
1786 +#ifndef        _bcmparams_h_
1787 +#define        _bcmparams_h_
1788 +
1789 +#define VLAN_MAXVID    15      /* Max. VLAN ID supported/allowed */
1790 +
1791 +#define VLAN_NUMPRIS   8       /* # of prio, start from 0 */
1792 +
1793 +#define DEV_NUMIFS     16      /* Max. # of devices/interfaces supported */
1794 +
1795 +#define WL_MAXBSSCFG   16      /* maximum number of BSS Configs we can configure */
1796 +
1797 +#endif
1798 diff -Nur linux-2.4.32/arch/mips/bcm947xx/include/bcmsrom.h linux-2.4.32-brcm/arch/mips/bcm947xx/include/bcmsrom.h
1799 --- linux-2.4.32/arch/mips/bcm947xx/include/bcmsrom.h   1970-01-01 01:00:00.000000000 +0100
1800 +++ linux-2.4.32-brcm/arch/mips/bcm947xx/include/bcmsrom.h      2005-12-16 23:39:10.704821750 +0100
1801 @@ -0,0 +1,23 @@
1802 +/*
1803 + * Misc useful routines to access NIC local SROM/OTP .
1804 + *
1805 + * Copyright 2005, Broadcom Corporation
1806 + * All Rights Reserved.
1807 + *
1808 + * THIS SOFTWARE IS OFFERED "AS IS", AND BROADCOM GRANTS NO WARRANTIES OF ANY
1809 + * KIND, EXPRESS OR IMPLIED, BY STATUTE, COMMUNICATION OR OTHERWISE. BROADCOM
1810 + * SPECIFICALLY DISCLAIMS ANY IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS
1811 + * FOR A SPECIFIC PURPOSE OR NONINFRINGEMENT CONCERNING THIS SOFTWARE.
1812 + *
1813 + * $Id$
1814 + */
1815 +
1816 +#ifndef        _bcmsrom_h_
1817 +#define        _bcmsrom_h_
1818 +
1819 +extern int srom_var_init(void *sbh, uint bus, void *curmap, osl_t *osh, char **vars, int *count);
1820 +
1821 +extern int srom_read(uint bus, void *curmap, osl_t *osh, uint byteoff, uint nbytes, uint16 *buf);
1822 +extern int srom_write(uint bus, void *curmap, osl_t *osh, uint byteoff, uint nbytes, uint16 *buf);
1823 +
1824 +#endif /* _bcmsrom_h_ */
1825 diff -Nur linux-2.4.32/arch/mips/bcm947xx/include/bcmutils.h linux-2.4.32-brcm/arch/mips/bcm947xx/include/bcmutils.h
1826 --- linux-2.4.32/arch/mips/bcm947xx/include/bcmutils.h  1970-01-01 01:00:00.000000000 +0100
1827 +++ linux-2.4.32-brcm/arch/mips/bcm947xx/include/bcmutils.h     2005-12-16 23:39:10.704821750 +0100
1828 @@ -0,0 +1,313 @@
1829 +/*
1830 + * Misc useful os-independent macros and functions.
1831 + *
1832 + * Copyright 2005, Broadcom Corporation
1833 + * All Rights Reserved.
1834 + *
1835 + * THIS SOFTWARE IS OFFERED "AS IS", AND BROADCOM GRANTS NO WARRANTIES OF ANY
1836 + * KIND, EXPRESS OR IMPLIED, BY STATUTE, COMMUNICATION OR OTHERWISE. BROADCOM
1837 + * SPECIFICALLY DISCLAIMS ANY IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS
1838 + * FOR A SPECIFIC PURPOSE OR NONINFRINGEMENT CONCERNING THIS SOFTWARE.
1839 + * $Id$
1840 + */
1841 +
1842 +#ifndef        _bcmutils_h_
1843 +#define        _bcmutils_h_
1844 +
1845 +/*** driver-only section ***/
1846 +#ifdef BCMDRIVER
1847 +#include <osl.h>
1848 +
1849 +#define _BCM_U 0x01    /* upper */
1850 +#define _BCM_L 0x02    /* lower */
1851 +#define _BCM_D 0x04    /* digit */
1852 +#define _BCM_C 0x08    /* cntrl */
1853 +#define _BCM_P 0x10    /* punct */
1854 +#define _BCM_S 0x20    /* white space (space/lf/tab) */
1855 +#define _BCM_X 0x40    /* hex digit */
1856 +#define _BCM_SP        0x80    /* hard space (0x20) */
1857 +
1858 +#define GPIO_PIN_NOTDEFINED    0x20
1859 +
1860 +extern unsigned char bcm_ctype[];
1861 +#define bcm_ismask(x) (bcm_ctype[(int)(unsigned char)(x)])
1862 +
1863 +#define bcm_isalnum(c) ((bcm_ismask(c)&(_BCM_U|_BCM_L|_BCM_D)) != 0)
1864 +#define bcm_isalpha(c) ((bcm_ismask(c)&(_BCM_U|_BCM_L)) != 0)
1865 +#define bcm_iscntrl(c) ((bcm_ismask(c)&(_BCM_C)) != 0)
1866 +#define bcm_isdigit(c) ((bcm_ismask(c)&(_BCM_D)) != 0)
1867 +#define bcm_isgraph(c) ((bcm_ismask(c)&(_BCM_P|_BCM_U|_BCM_L|_BCM_D)) != 0)
1868 +#define bcm_islower(c) ((bcm_ismask(c)&(_BCM_L)) != 0)
1869 +#define bcm_isprint(c) ((bcm_ismask(c)&(_BCM_P|_BCM_U|_BCM_L|_BCM_D|_BCM_SP)) != 0)
1870 +#define bcm_ispunct(c) ((bcm_ismask(c)&(_BCM_P)) != 0)
1871 +#define bcm_isspace(c) ((bcm_ismask(c)&(_BCM_S)) != 0)
1872 +#define bcm_isupper(c) ((bcm_ismask(c)&(_BCM_U)) != 0)
1873 +#define bcm_isxdigit(c)        ((bcm_ismask(c)&(_BCM_D|_BCM_X)) != 0)
1874 +
1875 +/*
1876 + * Spin at most 'us' microseconds while 'exp' is true.
1877 + * Caller should explicitly test 'exp' when this completes
1878 + * and take appropriate error action if 'exp' is still true.
1879 + */
1880 +#define SPINWAIT(exp, us) { \
1881 +       uint countdown = (us) + 9; \
1882 +       while ((exp) && (countdown >= 10)) {\
1883 +               OSL_DELAY(10); \
1884 +               countdown -= 10; \
1885 +       } \
1886 +}
1887 +
1888 +/* generic osl packet queue */
1889 +struct pktq {
1890 +       void *head;     /* first packet to dequeue */
1891 +       void *tail;     /* last packet to dequeue */
1892 +       uint len;       /* number of queued packets */
1893 +       uint maxlen;    /* maximum number of queued packets */
1894 +       bool priority;  /* enqueue by packet priority */
1895 +       uint8 prio_map[MAXPRIO+1]; /* user priority to packet enqueue policy map */
1896 +};
1897 +#define DEFAULT_QLEN   128
1898 +
1899 +#define        pktq_len(q)     ((q)->len)
1900 +#define        pktq_avail(q)   ((q)->maxlen - (q)->len)
1901 +#define        pktq_head(q)    ((q)->head)
1902 +#define        pktq_full(q)    ((q)->len >= (q)->maxlen)
1903 +#define        _pktq_pri(q, pri)       ((q)->prio_map[pri])
1904 +#define        pktq_tailpri(q) ((q)->tail ? _pktq_pri(q, PKTPRIO((q)->tail)) : _pktq_pri(q, 0))
1905 +
1906 +/* externs */
1907 +/* packet */
1908 +extern uint pktcopy(osl_t *osh, void *p, uint offset, int len, uchar *buf);
1909 +extern uint pkttotlen(osl_t *osh, void *);
1910 +extern void pktq_init(struct pktq *q, uint maxlen, const uint8 prio_map[]);
1911 +extern void pktenq(struct pktq *q, void *p, bool lifo);
1912 +extern void *pktdeq(struct pktq *q);
1913 +extern void *pktdeqtail(struct pktq *q);
1914 +/* string */
1915 +extern uint bcm_atoi(char *s);
1916 +extern uchar bcm_toupper(uchar c);
1917 +extern ulong bcm_strtoul(char *cp, char **endp, uint base);
1918 +extern char *bcmstrstr(char *haystack, char *needle);
1919 +extern char *bcmstrcat(char *dest, const char *src);
1920 +extern ulong wchar2ascii(char *abuf, ushort *wbuf, ushort wbuflen, ulong abuflen);
1921 +/* ethernet address */
1922 +extern char *bcm_ether_ntoa(char *ea, char *buf);
1923 +extern int bcm_ether_atoe(char *p, char *ea);
1924 +/* delay */
1925 +extern void bcm_mdelay(uint ms);
1926 +/* variable access */
1927 +extern char *getvar(char *vars, char *name);
1928 +extern int getintvar(char *vars, char *name);
1929 +extern uint getgpiopin(char *vars, char *pin_name, uint def_pin);
1930 +#define        bcmlog(fmt, a1, a2)
1931 +#define        bcmdumplog(buf, size)   *buf = '\0'
1932 +#define        bcmdumplogent(buf, idx) -1
1933 +
1934 +#endif /* #ifdef BCMDRIVER */
1935 +
1936 +/*** driver/apps-shared section ***/
1937 +
1938 +#define BCME_STRLEN            64
1939 +#define VALID_BCMERROR(e)  ((e <= 0) && (e >= BCME_LAST))
1940 +
1941 +
1942 +/*
1943 + * error codes could be added but the defined ones shouldn't be changed/deleted
1944 + * these error codes are exposed to the user code
1945 + * when ever a new error code is added to this list
1946 + * please update errorstring table with the related error string and
1947 + * update osl files with os specific errorcode map
1948 +*/
1949 +
1950 +#define BCME_ERROR                     -1      /* Error generic */
1951 +#define BCME_BADARG                    -2      /* Bad Argument */
1952 +#define BCME_BADOPTION                 -3      /* Bad option */
1953 +#define BCME_NOTUP                     -4      /* Not up */
1954 +#define BCME_NOTDOWN                   -5      /* Not down */
1955 +#define BCME_NOTAP                     -6      /* Not AP */
1956 +#define BCME_NOTSTA                    -7      /* Not STA  */
1957 +#define BCME_BADKEYIDX                 -8      /* BAD Key Index */
1958 +#define BCME_RADIOOFF                  -9      /* Radio Off */
1959 +#define BCME_NOTBANDLOCKED             -10     /* Not  bandlocked */
1960 +#define BCME_NOCLK                     -11     /* No Clock*/
1961 +#define BCME_BADRATESET                        -12     /* BAD RateSet*/
1962 +#define BCME_BADBAND                   -13     /* BAD Band */
1963 +#define BCME_BUFTOOSHORT               -14     /* Buffer too short */
1964 +#define BCME_BUFTOOLONG                        -15     /* Buffer too Long */
1965 +#define BCME_BUSY                      -16     /* Busy*/
1966 +#define BCME_NOTASSOCIATED             -17     /* Not associated*/
1967 +#define BCME_BADSSIDLEN                        -18     /* BAD SSID Len */
1968 +#define BCME_OUTOFRANGECHAN            -19     /* Out of Range Channel*/
1969 +#define BCME_BADCHAN                   -20     /* BAD Channel */
1970 +#define BCME_BADADDR                   -21     /* BAD Address*/
1971 +#define BCME_NORESOURCE                        -22     /* No resources*/
1972 +#define BCME_UNSUPPORTED               -23     /* Unsupported*/
1973 +#define BCME_BADLEN                    -24     /* Bad Length*/
1974 +#define BCME_NOTREADY                  -25     /* Not ready Yet*/
1975 +#define BCME_EPERM                     -26     /* Not Permitted */
1976 +#define BCME_NOMEM                     -27     /* No Memory */
1977 +#define BCME_ASSOCIATED                        -28     /* Associated */
1978 +#define BCME_RANGE                     -29     /* Range Error*/
1979 +#define BCME_NOTFOUND                  -30     /* Not found */
1980 +#define BCME_LAST                      BCME_NOTFOUND
1981 +
1982 +#ifndef ABS
1983 +#define        ABS(a)                  (((a)<0)?-(a):(a))
1984 +#endif
1985 +
1986 +#ifndef MIN
1987 +#define        MIN(a, b)               (((a)<(b))?(a):(b))
1988 +#endif
1989 +
1990 +#ifndef MAX
1991 +#define        MAX(a, b)               (((a)>(b))?(a):(b))
1992 +#endif
1993 +
1994 +#define CEIL(x, y)             (((x) + ((y)-1)) / (y))
1995 +#define        ROUNDUP(x, y)           ((((x)+((y)-1))/(y))*(y))
1996 +#define        ISALIGNED(a, x)         (((a) & ((x)-1)) == 0)
1997 +#define        ISPOWEROF2(x)           ((((x)-1)&(x))==0)
1998 +#define VALID_MASK(mask)       !((mask) & ((mask) + 1))
1999 +#define        OFFSETOF(type, member)  ((uint)(uintptr)&((type *)0)->member)
2000 +#define ARRAYSIZE(a)           (sizeof(a)/sizeof(a[0]))
2001 +
2002 +/* bit map related macros */
2003 +#ifndef setbit
2004 +#define        NBBY    8       /* 8 bits per byte */
2005 +#define        setbit(a,i)     (((uint8 *)a)[(i)/NBBY] |= 1<<((i)%NBBY))
2006 +#define        clrbit(a,i)     (((uint8 *)a)[(i)/NBBY] &= ~(1<<((i)%NBBY)))
2007 +#define        isset(a,i)      (((uint8 *)a)[(i)/NBBY] & (1<<((i)%NBBY)))
2008 +#define        isclr(a,i)      ((((uint8 *)a)[(i)/NBBY] & (1<<((i)%NBBY))) == 0)
2009 +#endif
2010 +
2011 +#define        NBITS(type)     (sizeof(type) * 8)
2012 +#define NBITVAL(bits)  (1 << (bits))
2013 +#define MAXBITVAL(bits)        ((1 << (bits)) - 1)
2014 +
2015 +/* crc defines */
2016 +#define CRC8_INIT_VALUE  0xff          /* Initial CRC8 checksum value */
2017 +#define CRC8_GOOD_VALUE  0x9f          /* Good final CRC8 checksum value */
2018 +#define CRC16_INIT_VALUE 0xffff                /* Initial CRC16 checksum value */
2019 +#define CRC16_GOOD_VALUE 0xf0b8                /* Good final CRC16 checksum value */
2020 +#define CRC32_INIT_VALUE 0xffffffff    /* Initial CRC32 checksum value */
2021 +#define CRC32_GOOD_VALUE 0xdebb20e3    /* Good final CRC32 checksum value */
2022 +
2023 +/* bcm_format_flags() bit description structure */
2024 +typedef struct bcm_bit_desc {
2025 +       uint32  bit;
2026 +       char*   name;
2027 +} bcm_bit_desc_t;
2028 +
2029 +/* tag_ID/length/value_buffer tuple */
2030 +typedef struct bcm_tlv {
2031 +       uint8   id;
2032 +       uint8   len;
2033 +       uint8   data[1];
2034 +} bcm_tlv_t;
2035 +
2036 +/* Check that bcm_tlv_t fits into the given buflen */
2037 +#define bcm_valid_tlv(elt, buflen) ((buflen) >= 2 && (int)(buflen) >= (int)(2 + (elt)->len))
2038 +
2039 +/* buffer length for ethernet address from bcm_ether_ntoa() */
2040 +#define ETHER_ADDR_STR_LEN     18
2041 +
2042 +/* unaligned load and store macros */
2043 +#ifdef IL_BIGENDIAN
2044 +static INLINE uint32
2045 +load32_ua(uint8 *a)
2046 +{
2047 +       return ((a[0] << 24) | (a[1] << 16) | (a[2] << 8) | a[3]);
2048 +}
2049 +
2050 +static INLINE void
2051 +store32_ua(uint8 *a, uint32 v)
2052 +{
2053 +       a[0] = (v >> 24) & 0xff;
2054 +       a[1] = (v >> 16) & 0xff;
2055 +       a[2] = (v >> 8) & 0xff;
2056 +       a[3] = v & 0xff;
2057 +}
2058 +
2059 +static INLINE uint16
2060 +load16_ua(uint8 *a)
2061 +{
2062 +       return ((a[0] << 8) | a[1]);
2063 +}
2064 +
2065 +static INLINE void
2066 +store16_ua(uint8 *a, uint16 v)
2067 +{
2068 +       a[0] = (v >> 8) & 0xff;
2069 +       a[1] = v & 0xff;
2070 +}
2071 +
2072 +#else
2073 +
2074 +static INLINE uint32
2075 +load32_ua(uint8 *a)
2076 +{
2077 +       return ((a[3] << 24) | (a[2] << 16) | (a[1] << 8) | a[0]);
2078 +}
2079 +
2080 +static INLINE void
2081 +store32_ua(uint8 *a, uint32 v)
2082 +{
2083 +       a[3] = (v >> 24) & 0xff;
2084 +       a[2] = (v >> 16) & 0xff;
2085 +       a[1] = (v >> 8) & 0xff;
2086 +       a[0] = v & 0xff;
2087 +}
2088 +
2089 +static INLINE uint16
2090 +load16_ua(uint8 *a)
2091 +{
2092 +       return ((a[1] << 8) | a[0]);
2093 +}
2094 +
2095 +static INLINE void
2096 +store16_ua(uint8 *a, uint16 v)
2097 +{
2098 +       a[1] = (v >> 8) & 0xff;
2099 +       a[0] = v & 0xff;
2100 +}
2101 +
2102 +#endif
2103 +
2104 +/* externs */
2105 +/* crc */
2106 +extern uint8 hndcrc8(uint8 *p, uint nbytes, uint8 crc);
2107 +extern uint16 hndcrc16(uint8 *p, uint nbytes, uint16 crc);
2108 +extern uint32 hndcrc32(uint8 *p, uint nbytes, uint32 crc);
2109 +/* format/print */
2110 +/* IE parsing */
2111 +extern bcm_tlv_t *bcm_next_tlv(bcm_tlv_t *elt, int *buflen);
2112 +extern bcm_tlv_t *bcm_parse_tlvs(void *buf, int buflen, uint key);
2113 +extern bcm_tlv_t *bcm_parse_ordered_tlvs(void *buf, int buflen, uint key);
2114 +
2115 +/* bcmerror*/
2116 +extern const char *bcmerrorstr(int bcmerror);
2117 +
2118 +/* multi-bool data type: set of bools, mbool is true if any is set */
2119 +typedef uint32 mbool;
2120 +#define mboolset(mb, bit)              (mb |= bit)             /* set one bool */
2121 +#define mboolclr(mb, bit)              (mb &= ~bit)            /* clear one bool */
2122 +#define mboolisset(mb, bit)            ((mb & bit) != 0)       /* TRUE if one bool is set */
2123 +#define        mboolmaskset(mb, mask, val)     ((mb) = (((mb) & ~(mask)) | (val)))
2124 +
2125 +/* power conversion */
2126 +extern uint16 bcm_qdbm_to_mw(uint8 qdbm);
2127 +extern uint8 bcm_mw_to_qdbm(uint16 mw);
2128 +
2129 +/* generic datastruct to help dump routines */
2130 +struct fielddesc {
2131 +       char    *nameandfmt;
2132 +       uint32  offset;
2133 +       uint32  len;
2134 +};
2135 +
2136 +typedef  uint32 (*readreg_rtn)(void *arg0, void *arg1, uint32 offset);
2137 +extern uint bcmdumpfields(readreg_rtn func_ptr, void *arg0, void *arg1, struct fielddesc *str, char *buf, uint32 bufsize);
2138 +
2139 +extern uint bcm_mkiovar(char *name, char *data, uint datalen, char *buf, uint len);
2140 +
2141 +#endif /* _bcmutils_h_ */
2142 diff -Nur linux-2.4.32/arch/mips/bcm947xx/include/bitfuncs.h linux-2.4.32-brcm/arch/mips/bcm947xx/include/bitfuncs.h
2143 --- linux-2.4.32/arch/mips/bcm947xx/include/bitfuncs.h  1970-01-01 01:00:00.000000000 +0100
2144 +++ linux-2.4.32-brcm/arch/mips/bcm947xx/include/bitfuncs.h     2005-12-16 23:39:10.704821750 +0100
2145 @@ -0,0 +1,85 @@
2146 +/*
2147 + * bit manipulation utility functions
2148 + *
2149 + * Copyright 2005, Broadcom Corporation
2150 + * All Rights Reserved.
2151 + *
2152 + * THIS SOFTWARE IS OFFERED "AS IS", AND BROADCOM GRANTS NO WARRANTIES OF ANY
2153 + * KIND, EXPRESS OR IMPLIED, BY STATUTE, COMMUNICATION OR OTHERWISE. BROADCOM
2154 + * SPECIFICALLY DISCLAIMS ANY IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS
2155 + * FOR A SPECIFIC PURPOSE OR NONINFRINGEMENT CONCERNING THIS SOFTWARE.
2156 + * $Id$
2157 + */
2158 +
2159 +#ifndef _BITFUNCS_H
2160 +#define _BITFUNCS_H
2161 +
2162 +#include <typedefs.h>
2163 +
2164 +/* local prototypes */
2165 +static INLINE uint32 find_msbit(uint32 x);
2166 +
2167 +
2168 +/*
2169 + * find_msbit: returns index of most significant set bit in x, with index
2170 + *   range defined as 0-31.  NOTE: returns zero if input is zero.
2171 + */
2172 +
2173 +#if defined(USE_PENTIUM_BSR) && defined(__GNUC__)
2174 +
2175 +/*
2176 + * Implementation for Pentium processors and gcc.  Note that this
2177 + * instruction is actually very slow on some processors (e.g., family 5,
2178 + * model 2, stepping 12, "Pentium 75 - 200"), so we use the generic
2179 + * implementation instead.
2180 + */
2181 +static INLINE uint32 find_msbit(uint32 x)
2182 +{
2183 +       uint msbit;
2184 +        __asm__("bsrl %1,%0"
2185 +                :"=r" (msbit)
2186 +                :"r" (x));
2187 +        return msbit;
2188 +}
2189 +
2190 +#else
2191 +
2192 +/*
2193 + * Generic Implementation
2194 + */
2195 +
2196 +#define DB_POW_MASK16  0xffff0000
2197 +#define DB_POW_MASK8   0x0000ff00
2198 +#define DB_POW_MASK4   0x000000f0
2199 +#define DB_POW_MASK2   0x0000000c
2200 +#define DB_POW_MASK1   0x00000002
2201 +
2202 +static INLINE uint32 find_msbit(uint32 x)
2203 +{
2204 +       uint32 temp_x = x;
2205 +       uint msbit = 0;
2206 +       if (temp_x & DB_POW_MASK16) {
2207 +               temp_x >>= 16;
2208 +               msbit = 16;
2209 +       }
2210 +       if (temp_x & DB_POW_MASK8) {
2211 +               temp_x >>= 8;
2212 +               msbit += 8;
2213 +       }
2214 +       if (temp_x & DB_POW_MASK4) {
2215 +               temp_x >>= 4;
2216 +               msbit += 4;
2217 +       }
2218 +       if (temp_x & DB_POW_MASK2) {
2219 +               temp_x >>= 2;
2220 +               msbit += 2;
2221 +       }
2222 +       if (temp_x & DB_POW_MASK1) {
2223 +               msbit += 1;
2224 +       }
2225 +       return(msbit);
2226 +}
2227 +
2228 +#endif
2229 +
2230 +#endif /* _BITFUNCS_H */
2231 diff -Nur linux-2.4.32/arch/mips/bcm947xx/include/cfe_osl.h linux-2.4.32-brcm/arch/mips/bcm947xx/include/cfe_osl.h
2232 --- linux-2.4.32/arch/mips/bcm947xx/include/cfe_osl.h   1970-01-01 01:00:00.000000000 +0100
2233 +++ linux-2.4.32-brcm/arch/mips/bcm947xx/include/cfe_osl.h      2005-12-16 23:39:10.704821750 +0100
2234 @@ -0,0 +1,191 @@
2235 +/*
2236 + * CFE boot loader OS Abstraction Layer.
2237 + *
2238 + * Copyright 2005, Broadcom Corporation
2239 + * All Rights Reserved.
2240 + *
2241 + * This is UNPUBLISHED PROPRIETARY SOURCE CODE of Broadcom Corporation;
2242 + * the contents of this file may not be disclosed to third parties, copied
2243 + * or duplicated in any form, in whole or in part, without the prior
2244 + * written permission of Broadcom Corporation.
2245 + *
2246 + * $Id$
2247 + */
2248 +
2249 +#ifndef _cfe_osl_h_
2250 +#define _cfe_osl_h_
2251 +
2252 +#include <lib_types.h>
2253 +#include <lib_string.h>
2254 +#include <lib_printf.h>
2255 +#include <lib_malloc.h>
2256 +#include <cpu_config.h>
2257 +#include <cfe_timer.h>
2258 +#include <cfe_iocb.h>
2259 +#include <cfe_devfuncs.h>
2260 +#include <addrspace.h>
2261 +
2262 +#include <typedefs.h>
2263 +
2264 +/* dump string */
2265 +extern int (*xprinthook)(const char *str);
2266 +#define puts(str) do { if (xprinthook) xprinthook(str); } while (0)
2267 +
2268 +/* assert and panic */
2269 +#define        ASSERT(exp)             do {} while (0)
2270 +
2271 +/* PCMCIA attribute space access macros */
2272 +#define        OSL_PCMCIA_READ_ATTR(osh, offset, buf, size) \
2273 +       bzero(buf, size)
2274 +#define        OSL_PCMCIA_WRITE_ATTR(osh, offset, buf, size) \
2275 +       do {} while (0)
2276 +
2277 +/* PCI configuration space access macros */
2278 +#define        OSL_PCI_READ_CONFIG(loc, offset, size) \
2279 +       (offset == 8 ? 0 : 0xffffffff)
2280 +#define        OSL_PCI_WRITE_CONFIG(loc, offset, size, val) \
2281 +       do {} while (0)
2282 +
2283 +/* PCI device bus # and slot # */
2284 +#define OSL_PCI_BUS(osh)       (0)
2285 +#define OSL_PCI_SLOT(osh)      (0)
2286 +
2287 +/* register access macros */
2288 +#define wreg32(r, v)           (*(volatile uint32*)(r) = (uint32)(v))
2289 +#define rreg32(r)              (*(volatile uint32*)(r))
2290 +#ifdef IL_BIGENDIAN
2291 +#define wreg16(r, v)           (*(volatile uint16*)((ulong)(r)^2) = (uint16)(v))
2292 +#define rreg16(r)              (*(volatile uint16*)((ulong)(r)^2))
2293 +#define wreg8(r, v)            (*(volatile uint8*)((ulong)(r)^3) = (uint8)(v))
2294 +#define rreg8(r)               (*(volatile uint8*)((ulong)(r)^3))
2295 +#else
2296 +#define wreg16(r, v)           (*(volatile uint16*)(r) = (uint16)(v))
2297 +#define rreg16(r)              (*(volatile uint16*)(r))
2298 +#define wreg8(r, v)            (*(volatile uint8*)(r) = (uint8)(v))
2299 +#define rreg8(r)               (*(volatile uint8*)(r))
2300 +#endif
2301 +#define R_REG(r) ({ \
2302 +       __typeof(*(r)) __osl_v; \
2303 +       switch (sizeof(*(r))) { \
2304 +       case sizeof(uint8):     __osl_v = rreg8((r)); break; \
2305 +       case sizeof(uint16):    __osl_v = rreg16((r)); break; \
2306 +       case sizeof(uint32):    __osl_v = rreg32((r)); break; \
2307 +       } \
2308 +       __osl_v; \
2309 +})
2310 +#define W_REG(r, v) do { \
2311 +       switch (sizeof(*(r))) { \
2312 +       case sizeof(uint8):     wreg8((r), (v)); break; \
2313 +       case sizeof(uint16):    wreg16((r), (v)); break; \
2314 +       case sizeof(uint32):    wreg32((r), (v)); break; \
2315 +       } \
2316 +} while (0)
2317 +#define        AND_REG(r, v)           W_REG((r), R_REG(r) & (v))
2318 +#define        OR_REG(r, v)            W_REG((r), R_REG(r) | (v))
2319 +
2320 +/* bcopy, bcmp, and bzero */
2321 +#define bcmp(b1, b2, len)      lib_memcmp((b1), (b2), (len))
2322 +
2323 +#define osl_attach(pdev)       ((osl_t*)pdev)
2324 +#define osl_detach(osh)
2325 +
2326 +/* general purpose memory allocation */
2327 +#define        MALLOC(osh, size)       KMALLOC((size),0)
2328 +#define        MFREE(osh, addr, size)  KFREE((addr))
2329 +#define        MALLOCED(osh)           (0)
2330 +#define        MALLOC_DUMP(osh, buf, sz)
2331 +#define        MALLOC_FAILED(osh)      (0)
2332 +
2333 +/* uncached virtual address */
2334 +#define        OSL_UNCACHED(va)        ((void*)UNCADDR((ulong)(va)))
2335 +
2336 +/* host/bus architecture-specific address byte swap */
2337 +#define BUS_SWAP32(v)          (v)
2338 +
2339 +/* get processor cycle count */
2340 +#define OSL_GETCYCLES(x)       ((x) = 0)
2341 +
2342 +/* microsecond delay */
2343 +#define        OSL_DELAY(usec)         cfe_usleep((cfe_cpu_speed/CPUCFG_CYCLESPERCPUTICK/1000000*(usec)))
2344 +
2345 +#define OSL_ERROR(bcmerror)    osl_error(bcmerror)
2346 +
2347 +/* map/unmap physical to virtual I/O */
2348 +#define        REG_MAP(pa, size)       ((void*)UNCADDR((ulong)(pa)))
2349 +#define        REG_UNMAP(va)           do {} while (0)
2350 +
2351 +/* dereference an address that may cause a bus exception */
2352 +#define        BUSPROBE(val, addr)     osl_busprobe(&(val), (uint32)(addr))
2353 +extern int osl_busprobe(uint32 *val, uint32 addr);
2354 +
2355 +/* allocate/free shared (dma-able) consistent (uncached) memory */
2356 +#define        DMA_CONSISTENT_ALIGN    4096
2357 +#define        DMA_ALLOC_CONSISTENT(osh, size, pap) \
2358 +       osl_dma_alloc_consistent((size), (pap))
2359 +#define        DMA_FREE_CONSISTENT(osh, va, size, pa) \
2360 +       osl_dma_free_consistent((void*)(va))
2361 +extern void *osl_dma_alloc_consistent(uint size, ulong *pap);
2362 +extern void osl_dma_free_consistent(void *va);
2363 +
2364 +/* map/unmap direction */
2365 +#define        DMA_TX                  1
2366 +#define        DMA_RX                  2
2367 +
2368 +/* map/unmap shared (dma-able) memory */
2369 +#define        DMA_MAP(osh, va, size, direction, lb) ({ \
2370 +       cfe_flushcache(CFE_CACHE_FLUSH_D); \
2371 +       PHYSADDR((ulong)(va)); \
2372 +})
2373 +#define        DMA_UNMAP(osh, pa, size, direction, p) \
2374 +       do {} while (0)
2375 +
2376 +/* shared (dma-able) memory access macros */
2377 +#define        R_SM(r)                 *(r)
2378 +#define        W_SM(r, v)              (*(r) = (v))
2379 +#define        BZERO_SM(r, len)        lib_memset((r), '\0', (len))
2380 +
2381 +/* generic packet structure */
2382 +#define LBUFSZ         4096
2383 +#define LBDATASZ       (LBUFSZ - sizeof(struct lbuf))
2384 +struct lbuf {
2385 +       struct lbuf     *next;          /* pointer to next lbuf if in a chain */
2386 +       struct lbuf     *link;          /* pointer to next lbuf if in a list */
2387 +       uchar           *head;          /* start of buffer */
2388 +       uchar           *end;           /* end of buffer */
2389 +       uchar           *data;          /* start of data */
2390 +       uchar           *tail;          /* end of data */
2391 +       uint            len;            /* nbytes of data */
2392 +       void            *cookie;        /* generic cookie */
2393 +};
2394 +
2395 +/* the largest reasonable packet buffer driver uses for ethernet MTU in bytes */
2396 +#define        PKTBUFSZ        2048
2397 +
2398 +/* packet primitives */
2399 +#define        PKTGET(osh, len, send)          ((void*)osl_pktget((len)))
2400 +#define        PKTFREE(osh, lb, send)          osl_pktfree((struct lbuf*)(lb))
2401 +#define        PKTDATA(osh, lb)                (((struct lbuf*)(lb))->data)
2402 +#define        PKTLEN(osh, lb)                 (((struct lbuf*)(lb))->len)
2403 +#define PKTHEADROOM(osh, lb)           (PKTDATA(osh,lb)-(((struct lbuf*)(lb))->head))
2404 +#define PKTTAILROOM(osh, lb)           ((((struct lbuf*)(lb))->end)-(((struct lbuf*)(lb))->tail))
2405 +#define        PKTNEXT(osh, lb)                (((struct lbuf*)(lb))->next)
2406 +#define        PKTSETNEXT(lb, x)               (((struct lbuf*)(lb))->next = (struct lbuf*)(x))
2407 +#define        PKTSETLEN(osh, lb, len)         osl_pktsetlen((struct lbuf*)(lb), (len))
2408 +#define        PKTPUSH(osh, lb, bytes)         osl_pktpush((struct lbuf*)(lb), (bytes))
2409 +#define        PKTPULL(osh, lb, bytes)         osl_pktpull((struct lbuf*)(lb), (bytes))
2410 +#define        PKTDUP(osh, lb)                 osl_pktdup((struct lbuf*)(lb))
2411 +#define        PKTCOOKIE(lb)                   (((struct lbuf*)(lb))->cookie)
2412 +#define        PKTSETCOOKIE(lb, x)             (((struct lbuf*)(lb))->cookie = (void*)(x))
2413 +#define        PKTLINK(lb)                     (((struct lbuf*)(lb))->link)
2414 +#define        PKTSETLINK(lb, x)               (((struct lbuf*)(lb))->link = (struct lbuf*)(x))
2415 +#define        PKTPRIO(lb)                     (0)
2416 +#define        PKTSETPRIO(lb, x)               do {} while (0)
2417 +extern struct lbuf *osl_pktget(uint len);
2418 +extern void osl_pktfree(struct lbuf *lb);
2419 +extern void osl_pktsetlen(struct lbuf *lb, uint len);
2420 +extern uchar *osl_pktpush(struct lbuf *lb, uint bytes);
2421 +extern uchar *osl_pktpull(struct lbuf *lb, uint bytes);
2422 +extern struct lbuf *osl_pktdup(struct lbuf *lb);
2423 +extern int osl_error(int bcmerror);
2424 +
2425 +#endif /* _cfe_osl_h_ */
2426 diff -Nur linux-2.4.32/arch/mips/bcm947xx/include/epivers.h linux-2.4.32-brcm/arch/mips/bcm947xx/include/epivers.h
2427 --- linux-2.4.32/arch/mips/bcm947xx/include/epivers.h   1970-01-01 01:00:00.000000000 +0100
2428 +++ linux-2.4.32-brcm/arch/mips/bcm947xx/include/epivers.h      2005-12-16 23:39:10.704821750 +0100
2429 @@ -0,0 +1,69 @@
2430 +/*
2431 + * Copyright 2005, Broadcom Corporation
2432 + * All Rights Reserved.
2433 + *
2434 + * THIS SOFTWARE IS OFFERED "AS IS", AND BROADCOM GRANTS NO WARRANTIES OF ANY
2435 + * KIND, EXPRESS OR IMPLIED, BY STATUTE, COMMUNICATION OR OTHERWISE. BROADCOM
2436 + * SPECIFICALLY DISCLAIMS ANY IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS
2437 + * FOR A SPECIFIC PURPOSE OR NONINFRINGEMENT CONCERNING THIS SOFTWARE.
2438 + *
2439 + * $Id$
2440 + *
2441 +*/
2442 +
2443 +#ifndef _epivers_h_
2444 +#define _epivers_h_
2445 +
2446 +#ifdef linux
2447 +#include <linux/config.h>
2448 +#endif
2449 +
2450 +/* Vendor Name, ASCII, 32 chars max */
2451 +#ifdef COMPANYNAME
2452 +#define        HPNA_VENDOR             COMPANYNAME
2453 +#else
2454 +#define        HPNA_VENDOR             "Broadcom Corporation"
2455 +#endif
2456 +
2457 +/* Driver Date, ASCII, 32 chars max */
2458 +#define HPNA_DRV_BUILD_DATE    __DATE__
2459 +
2460 +/* Hardware Manufacture Date, ASCII, 32 chars max */
2461 +#define HPNA_HW_MFG_DATE       "Not Specified"
2462 +
2463 +/* See documentation for Device Type values, 32 values max */
2464 +#ifndef        HPNA_DEV_TYPE
2465 +
2466 +#if    defined(CONFIG_BRCM_VJ)
2467 +#define HPNA_DEV_TYPE          { CDCF_V0_DEVICE_DISPLAY }
2468 +
2469 +#elif  defined(CONFIG_BCRM_93725)
2470 +#define HPNA_DEV_TYPE          { CDCF_V0_DEVICE_CM_BRIDGE, CDCF_V0_DEVICE_DISPLAY }
2471 +
2472 +#else
2473 +#define HPNA_DEV_TYPE          { CDCF_V0_DEVICE_PCINIC }
2474 +
2475 +#endif
2476 +
2477 +#endif /* !HPNA_DEV_TYPE */
2478 +
2479 +
2480 +#define        EPI_MAJOR_VERSION       3
2481 +
2482 +#define        EPI_MINOR_VERSION       130
2483 +
2484 +#define        EPI_RC_NUMBER           20
2485 +
2486 +#define        EPI_INCREMENTAL_NUMBER  0
2487 +
2488 +#define        EPI_BUILD_NUMBER        0
2489 +
2490 +#define        EPI_VERSION             3,130,20,0
2491 +
2492 +#define        EPI_VERSION_NUM         0x03821400
2493 +
2494 +/* Driver Version String, ASCII, 32 chars max */
2495 +#define        EPI_VERSION_STR         "3.130.20.0"
2496 +#define        EPI_ROUTER_VERSION_STR  "3.131.20.0"
2497 +
2498 +#endif /* _epivers_h_ */
2499 diff -Nur linux-2.4.32/arch/mips/bcm947xx/include/epivers.h.in linux-2.4.32-brcm/arch/mips/bcm947xx/include/epivers.h.in
2500 --- linux-2.4.32/arch/mips/bcm947xx/include/epivers.h.in        1970-01-01 01:00:00.000000000 +0100
2501 +++ linux-2.4.32-brcm/arch/mips/bcm947xx/include/epivers.h.in   2005-12-16 23:39:10.704821750 +0100
2502 @@ -0,0 +1,69 @@
2503 +/*
2504 + * Copyright 2005, Broadcom Corporation
2505 + * All Rights Reserved.
2506 + *
2507 + * THIS SOFTWARE IS OFFERED "AS IS", AND BROADCOM GRANTS NO WARRANTIES OF ANY
2508 + * KIND, EXPRESS OR IMPLIED, BY STATUTE, COMMUNICATION OR OTHERWISE. BROADCOM
2509 + * SPECIFICALLY DISCLAIMS ANY IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS
2510 + * FOR A SPECIFIC PURPOSE OR NONINFRINGEMENT CONCERNING THIS SOFTWARE.
2511 + *
2512 + * $Id$
2513 + *
2514 +*/
2515 +
2516 +#ifndef _epivers_h_
2517 +#define _epivers_h_
2518 +
2519 +#ifdef linux
2520 +#include <linux/config.h>
2521 +#endif
2522 +
2523 +/* Vendor Name, ASCII, 32 chars max */
2524 +#ifdef COMPANYNAME
2525 +#define        HPNA_VENDOR             COMPANYNAME
2526 +#else
2527 +#define        HPNA_VENDOR             "Broadcom Corporation"
2528 +#endif
2529 +
2530 +/* Driver Date, ASCII, 32 chars max */
2531 +#define HPNA_DRV_BUILD_DATE    __DATE__
2532 +
2533 +/* Hardware Manufacture Date, ASCII, 32 chars max */
2534 +#define HPNA_HW_MFG_DATE       "Not Specified"
2535 +
2536 +/* See documentation for Device Type values, 32 values max */
2537 +#ifndef        HPNA_DEV_TYPE
2538 +
2539 +#if    defined(CONFIG_BRCM_VJ)
2540 +#define HPNA_DEV_TYPE          { CDCF_V0_DEVICE_DISPLAY }
2541 +
2542 +#elif  defined(CONFIG_BCRM_93725)
2543 +#define HPNA_DEV_TYPE          { CDCF_V0_DEVICE_CM_BRIDGE, CDCF_V0_DEVICE_DISPLAY }
2544 +
2545 +#else
2546 +#define HPNA_DEV_TYPE          { CDCF_V0_DEVICE_PCINIC }
2547 +
2548 +#endif
2549 +
2550 +#endif /* !HPNA_DEV_TYPE */
2551 +
2552 +
2553 +#define        EPI_MAJOR_VERSION       @EPI_MAJOR_VERSION@
2554 +
2555 +#define        EPI_MINOR_VERSION       @EPI_MINOR_VERSION@
2556 +
2557 +#define        EPI_RC_NUMBER           @EPI_RC_NUMBER@
2558 +
2559 +#define        EPI_INCREMENTAL_NUMBER  @EPI_INCREMENTAL_NUMBER@
2560 +
2561 +#define        EPI_BUILD_NUMBER        @EPI_BUILD_NUMBER@
2562 +
2563 +#define        EPI_VERSION             @EPI_VERSION@
2564 +
2565 +#define        EPI_VERSION_NUM         @EPI_VERSION_NUM@
2566 +
2567 +/* Driver Version String, ASCII, 32 chars max */
2568 +#define        EPI_VERSION_STR         "@EPI_VERSION_STR@"
2569 +#define        EPI_ROUTER_VERSION_STR  "@EPI_ROUTER_VERSION_STR@"
2570 +
2571 +#endif /* _epivers_h_ */
2572 diff -Nur linux-2.4.32/arch/mips/bcm947xx/include/etsockio.h linux-2.4.32-brcm/arch/mips/bcm947xx/include/etsockio.h
2573 --- linux-2.4.32/arch/mips/bcm947xx/include/etsockio.h  1970-01-01 01:00:00.000000000 +0100
2574 +++ linux-2.4.32-brcm/arch/mips/bcm947xx/include/etsockio.h     2005-12-16 23:39:10.704821750 +0100
2575 @@ -0,0 +1,59 @@
2576 +/*
2577 + * Driver-specific socket ioctls
2578 + * used by BSD, Linux, and PSOS
2579 + * Broadcom BCM44XX 10/100Mbps Ethernet Device Driver
2580 + *
2581 + * Copyright 2005, Broadcom Corporation
2582 + * All Rights Reserved.
2583 + *
2584 + * THIS SOFTWARE IS OFFERED "AS IS", AND BROADCOM GRANTS NO WARRANTIES OF ANY
2585 + * KIND, EXPRESS OR IMPLIED, BY STATUTE, COMMUNICATION OR OTHERWISE. BROADCOM
2586 + * SPECIFICALLY DISCLAIMS ANY IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS
2587 + * FOR A SPECIFIC PURPOSE OR NONINFRINGEMENT CONCERNING THIS SOFTWARE.
2588 + *
2589 + * $Id$
2590 + */
2591 +
2592 +#ifndef _etsockio_h_
2593 +#define _etsockio_h_
2594 +
2595 +/* THESE MUST BE CONTIGUOUS AND CONSISTENT WITH VALUES IN ETC.H */
2596 +
2597 +
2598 +#if defined(linux)
2599 +#define SIOCSETCUP             (SIOCDEVPRIVATE + 0)
2600 +#define SIOCSETCDOWN           (SIOCDEVPRIVATE + 1)
2601 +#define SIOCSETCLOOP           (SIOCDEVPRIVATE + 2)
2602 +#define SIOCGETCDUMP           (SIOCDEVPRIVATE + 3)
2603 +#define SIOCSETCSETMSGLEVEL    (SIOCDEVPRIVATE + 4)
2604 +#define SIOCSETCPROMISC                (SIOCDEVPRIVATE + 5)
2605 +#define SIOCSETCTXDOWN         (SIOCDEVPRIVATE + 6)    /* obsolete */
2606 +#define SIOCSETCSPEED          (SIOCDEVPRIVATE + 7)
2607 +#define SIOCTXGEN              (SIOCDEVPRIVATE + 8)
2608 +#define SIOCGETCPHYRD          (SIOCDEVPRIVATE + 9)
2609 +#define SIOCSETCPHYWR          (SIOCDEVPRIVATE + 10)
2610 +#define SIOCSETCQOS            (SIOCDEVPRIVATE + 11)
2611 +
2612 +#else  /* !linux */
2613 +
2614 +#define SIOCSETCUP             _IOWR('e', 130 + 0, struct ifreq)
2615 +#define SIOCSETCDOWN           _IOWR('e', 130 + 1, struct ifreq)
2616 +#define SIOCSETCLOOP           _IOWR('e', 130 + 2, struct ifreq)
2617 +#define SIOCGETCDUMP           _IOWR('e', 130 + 3, struct ifreq)
2618 +#define SIOCSETCSETMSGLEVEL    _IOWR('e', 130 + 4, struct ifreq)
2619 +#define SIOCSETCPROMISC                _IOWR('e', 130 + 5, struct ifreq)
2620 +#define SIOCSETCTXDOWN         _IOWR('e', 130 + 6, struct ifreq)       /* obsolete */
2621 +#define SIOCSETCSPEED          _IOWR('e', 130 + 7, struct ifreq)
2622 +#define SIOCTXGEN              _IOWR('e', 130 + 8, struct ifreq)
2623 +
2624 +#endif
2625 +
2626 +/* arg to SIOCTXGEN */
2627 +struct txg {
2628 +       uint32 num;             /* number of frames to send */
2629 +       uint32 delay;           /* delay in microseconds between sending each */
2630 +       uint32 size;            /* size of ether frame to send */
2631 +       uchar buf[1514];        /* starting ether frame data */
2632 +};
2633 +
2634 +#endif
2635 diff -Nur linux-2.4.32/arch/mips/bcm947xx/include/flash.h linux-2.4.32-brcm/arch/mips/bcm947xx/include/flash.h
2636 --- linux-2.4.32/arch/mips/bcm947xx/include/flash.h     1970-01-01 01:00:00.000000000 +0100
2637 +++ linux-2.4.32-brcm/arch/mips/bcm947xx/include/flash.h        2005-12-16 23:39:10.704821750 +0100
2638 @@ -0,0 +1,188 @@
2639 +/*
2640 + * flash.h: Common definitions for flash access.
2641 + *
2642 + * Copyright 2005, Broadcom Corporation
2643 + * All Rights Reserved.
2644 + *
2645 + * THIS SOFTWARE IS OFFERED "AS IS", AND BROADCOM GRANTS NO WARRANTIES OF ANY
2646 + * KIND, EXPRESS OR IMPLIED, BY STATUTE, COMMUNICATION OR OTHERWISE. BROADCOM
2647 + * SPECIFICALLY DISCLAIMS ANY IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS
2648 + * FOR A SPECIFIC PURPOSE OR NONINFRINGEMENT CONCERNING THIS SOFTWARE.
2649 + *
2650 + * $Id$
2651 + */
2652 +
2653 +/* Types of flashes we know about */
2654 +typedef enum _flash_type {OLD, BSC, SCS, AMD, SST, SFLASH} flash_type_t;
2655 +
2656 +/* Commands to write/erase the flases */
2657 +typedef struct _flash_cmds{
2658 +       flash_type_t    type;
2659 +       bool            need_unlock;
2660 +       uint16          pre_erase;
2661 +       uint16          erase_block;
2662 +       uint16          erase_chip;
2663 +       uint16          write_word;
2664 +       uint16          write_buf;
2665 +       uint16          clear_csr;
2666 +       uint16          read_csr;
2667 +       uint16          read_id;
2668 +       uint16          confirm;
2669 +       uint16          read_array;
2670 +} flash_cmds_t;
2671 +
2672 +#define        UNLOCK_CMD_WORDS        2
2673 +
2674 +typedef struct _unlock_cmd {
2675 +  uint         addr[UNLOCK_CMD_WORDS];
2676 +  uint16       cmd[UNLOCK_CMD_WORDS];
2677 +} unlock_cmd_t;
2678 +
2679 +/* Flash descriptors */
2680 +typedef struct _flash_desc {
2681 +       uint16          mfgid;          /* Manufacturer Id */
2682 +       uint16          devid;          /* Device Id */
2683 +       uint            size;           /* Total size in bytes */
2684 +       uint            width;          /* Device width in bytes */
2685 +       flash_type_t    type;           /* Device type old, S, J */
2686 +       uint            bsize;          /* Block size */
2687 +       uint            nb;             /* Number of blocks */
2688 +       uint            ff;             /* First full block */
2689 +       uint            lf;             /* Last full block */
2690 +       uint            nsub;           /* Number of subblocks */
2691 +       uint            *subblocks;     /* Offsets for subblocks */
2692 +       char            *desc;          /* Description */
2693 +} flash_desc_t;
2694 +
2695 +
2696 +#ifdef DECLARE_FLASHES
2697 +flash_cmds_t sflash_cmd_t =
2698 +       { SFLASH,       0,      0x00,   0x00,   0x00,   0x00,   0x00,   0x00,   0x00,   0x00,   0x00,   0x00 };
2699 +
2700 +flash_cmds_t flash_cmds[] = {
2701 +/*       type          needu   preera  eraseb  erasech write   wbuf    clcsr   rdcsr   rdid    confrm  read */
2702 +       { BSC,          0,      0x00,   0x20,   0x00,   0x40,   0x00,   0x50,   0x70,   0x90,   0xd0,   0xff },
2703 +       { SCS,          0,      0x00,   0x20,   0x00,   0x40,   0xe8,   0x50,   0x70,   0x90,   0xd0,   0xff },
2704 +       { AMD,          1,      0x80,   0x30,   0x10,   0xa0,   0x00,   0x00,   0x00,   0x90,   0x00,   0xf0 },
2705 +       { SST,          1,      0x80,   0x50,   0x10,   0xa0,   0x00,   0x00,   0x00,   0x90,   0x00,   0xf0 },
2706 +       { 0 }
2707 +};
2708 +
2709 +unlock_cmd_t unlock_cmd_amd = {
2710 +#ifdef MIPSEB
2711 +/* addr: */    { 0x0aa8,       0x0556},
2712 +#else
2713 +/* addr: */    { 0x0aaa,       0x0554},
2714 +#endif
2715 +/* data: */    { 0xaa,         0x55}
2716 +};
2717 +
2718 +unlock_cmd_t unlock_cmd_sst = {
2719 +#ifdef MIPSEB
2720 +/* addr: */    { 0xaaa8,       0x5556},
2721 +#else
2722 +/* addr: */    { 0xaaaa,       0x5554},
2723 +#endif
2724 +/* data: */    { 0xaa,         0x55}
2725 +};
2726 +
2727 +#define AMD_CMD 0xaaa
2728 +#define SST_CMD 0xaaaa
2729 +
2730 +/* intel unlock block cmds */
2731 +#define INTEL_UNLOCK1  0x60
2732 +#define INTEL_UNLOCK2  0xD0
2733 +
2734 +/* Just eight blocks of 8KB byte each */
2735 +
2736 +uint blk8x8k[] = { 0x00000000,
2737 +                  0x00002000,
2738 +                  0x00004000,
2739 +                  0x00006000,
2740 +                  0x00008000,
2741 +                  0x0000a000,
2742 +                  0x0000c000,
2743 +                  0x0000e000,
2744 +                  0x00010000
2745 +};
2746 +
2747 +/* Funky AMD arrangement for 29xx800's */
2748 +uint amd800[] = { 0x00000000,          /* 16KB */
2749 +                 0x00004000,           /* 32KB */
2750 +                 0x0000c000,           /* 8KB */
2751 +                 0x0000e000,           /* 8KB */
2752 +                 0x00010000,           /* 8KB */
2753 +                 0x00012000,           /* 8KB */
2754 +                 0x00014000,           /* 32KB */
2755 +                 0x0001c000,           /* 16KB */
2756 +                 0x00020000
2757 +};
2758 +
2759 +/* AMD arrangement for 29xx160's */
2760 +uint amd4112[] = { 0x00000000,         /* 32KB */
2761 +                  0x00008000,          /* 8KB */
2762 +                  0x0000a000,          /* 8KB */
2763 +                  0x0000c000,          /* 16KB */
2764 +                  0x00010000
2765 +};
2766 +uint amd2114[] = { 0x00000000,         /* 16KB */
2767 +                  0x00004000,          /* 8KB */
2768 +                  0x00006000,          /* 8KB */
2769 +                  0x00008000,          /* 32KB */
2770 +                  0x00010000
2771 +};
2772 +
2773 +
2774 +flash_desc_t sflash_desc =
2775 +       { 0, 0, 0, 0,   SFLASH, 0, 0,  0, 0,  0, NULL,    "SFLASH" };
2776 +
2777 +flash_desc_t flashes[] = {
2778 +       { 0x00b0, 0x00d0, 0x0200000, 2, SCS, 0x10000, 32,  0, 31,  0, NULL,    "Intel 28F160S3/5 1Mx16" },
2779 +       { 0x00b0, 0x00d4, 0x0400000, 2, SCS, 0x10000, 64,  0, 63,  0, NULL,    "Intel 28F320S3/5 2Mx16" },
2780 +       { 0x0089, 0x8890, 0x0200000, 2, BSC, 0x10000, 32,  0, 30,  8, blk8x8k, "Intel 28F160B3 1Mx16 TopB" },
2781 +       { 0x0089, 0x8891, 0x0200000, 2, BSC, 0x10000, 32,  1, 31,  8, blk8x8k, "Intel 28F160B3 1Mx16 BotB" },
2782 +       { 0x0089, 0x8896, 0x0400000, 2, BSC, 0x10000, 64,  0, 62,  8, blk8x8k, "Intel 28F320B3 2Mx16 TopB" },
2783 +       { 0x0089, 0x8897, 0x0400000, 2, BSC, 0x10000, 64,  1, 63,  8, blk8x8k, "Intel 28F320B3 2Mx16 BotB" },
2784 +       { 0x0089, 0x8898, 0x0800000, 2, BSC, 0x10000, 128, 0, 126, 8, blk8x8k, "Intel 28F640B3 4Mx16 TopB" },
2785 +       { 0x0089, 0x8899, 0x0800000, 2, BSC, 0x10000, 128, 1, 127, 8, blk8x8k, "Intel 28F640B3 4Mx16 BotB" },
2786 +       { 0x0089, 0x88C2, 0x0200000, 2, BSC, 0x10000, 32,  0, 30,  8, blk8x8k, "Intel 28F160C3 1Mx16 TopB" },
2787 +       { 0x0089, 0x88C3, 0x0200000, 2, BSC, 0x10000, 32,  1, 31,  8, blk8x8k, "Intel 28F160C3 1Mx16 BotB" },
2788 +       { 0x0089, 0x88C4, 0x0400000, 2, BSC, 0x10000, 64,  0, 62,  8, blk8x8k, "Intel 28F320C3 2Mx16 TopB" },
2789 +       { 0x0089, 0x88C5, 0x0400000, 2, BSC, 0x10000, 64,  1, 63,  8, blk8x8k, "Intel 28F320C3 2Mx16 BotB" },
2790 +       { 0x0089, 0x88CC, 0x0800000, 2, BSC, 0x10000, 128, 0, 126, 8, blk8x8k, "Intel 28F640C3 4Mx16 TopB" },
2791 +       { 0x0089, 0x88CD, 0x0800000, 2, BSC, 0x10000, 128, 1, 127, 8, blk8x8k, "Intel 28F640C3 4Mx16 BotB" },
2792 +       { 0x0089, 0x0014, 0x0400000, 2, SCS, 0x20000, 32,  0, 31,  0, NULL,    "Intel 28F320J5 2Mx16" },
2793 +       { 0x0089, 0x0015, 0x0800000, 2, SCS, 0x20000, 64,  0, 63,  0, NULL,    "Intel 28F640J5 4Mx16" },
2794 +       { 0x0089, 0x0016, 0x0400000, 2, SCS, 0x20000, 32,  0, 31,  0, NULL,    "Intel 28F320J3 2Mx16" },
2795 +       { 0x0089, 0x0017, 0x0800000, 2, SCS, 0x20000, 64,  0, 63,  0, NULL,    "Intel 28F640J3 4Mx16" },
2796 +       { 0x0089, 0x0018, 0x1000000, 2, SCS, 0x20000, 128, 0, 127, 0, NULL,    "Intel 28F128J3 8Mx16" },
2797 +       { 0x00b0, 0x00e3, 0x0400000, 2, BSC, 0x10000, 64,  1, 63,  8, blk8x8k, "Sharp 28F320BJE 2Mx16 BotB" },
2798 +       { 0x0001, 0x224a, 0x0100000, 2, AMD, 0x10000, 16,  0, 13,  8, amd800,  "AMD 29DL800BT 512Kx16 TopB" },
2799 +       { 0x0001, 0x22cb, 0x0100000, 2, AMD, 0x10000, 16,  2, 15,  8, amd800,  "AMD 29DL800BB 512Kx16 BotB" },
2800 +       { 0x0001, 0x22c4, 0x0200000, 2, AMD, 0x10000, 32,  0, 30,  4, amd2114, "AMD 29lv160DT 1Mx16 TopB" },
2801 +       { 0x0001, 0x2249, 0x0200000, 2, AMD, 0x10000, 32,  1, 31,  4, amd4112, "AMD 29lv160DB 1Mx16 BotB" },
2802 +       { 0x0001, 0x22f6, 0x0400000, 2, AMD, 0x10000, 64,  0, 62,  8, blk8x8k, "AMD 29lv320DT 2Mx16 TopB" },
2803 +       { 0x0001, 0x22f9, 0x0400000, 2, AMD, 0x10000, 64,  1, 63,  8, blk8x8k, "AMD 29lv320DB 2Mx16 BotB" },
2804 +       { 0x0001, 0x227e, 0x0400000, 2, AMD, 0x10000, 64,  0, 62,  8, blk8x8k, "AMD 29lv320MT 2Mx16 TopB" },
2805 +       { 0x0001, 0x2200, 0x0400000, 2, AMD, 0x10000, 64,  1, 63,  8, blk8x8k, "AMD 29lv320MB 2Mx16 BotB" },
2806 +       { 0x0020, 0x22CA, 0x0400000, 2, AMD, 0x10000, 64,  0, 62,  4, amd4112, "ST 29w320DT 2Mx16 TopB" },
2807 +       { 0x0020, 0x22CB, 0x0400000, 2, AMD, 0x10000, 64,  1, 63,  4, amd2114, "ST 29w320DB 2Mx16 BotB" },
2808 +       { 0x00C2, 0x00A7, 0x0400000, 2, AMD, 0x10000, 64,  0, 62,  4, amd4112, "MX29LV320T 2Mx16 TopB" },
2809 +       { 0x00C2, 0x00A8, 0x0400000, 2, AMD, 0x10000, 64,  1, 63,  4, amd2114, "MX29LV320B 2Mx16 BotB" },
2810 +       { 0x0004, 0x22F6, 0x0400000, 2, AMD, 0x10000, 64,  0, 62,  4, amd4112, "MBM29LV320TE 2Mx16 TopB" },
2811 +       { 0x0004, 0x22F9, 0x0400000, 2, AMD, 0x10000, 64,  1, 63,  4, amd2114, "MBM29LV320BE 2Mx16 BotB" },
2812 +       { 0x0098, 0x009A, 0x0400000, 2, AMD, 0x10000, 64,  0, 62,  4, amd4112, "TC58FVT321 2Mx16 TopB" },
2813 +       { 0x0098, 0x009C, 0x0400000, 2, AMD, 0x10000, 64,  1, 63,  4, amd2114, "TC58FVB321 2Mx16 BotB" },
2814 +       { 0x00C2, 0x22A7, 0x0400000, 2, AMD, 0x10000, 64,  0, 62,  4, amd4112, "MX29LV320T 2Mx16 TopB" },
2815 +       { 0x00C2, 0x22A8, 0x0400000, 2, AMD, 0x10000, 64,  1, 63,  4, amd2114, "MX29LV320B 2Mx16 BotB" },
2816 +       { 0x00BF, 0x2783, 0x0400000, 2, SST, 0x10000, 64,  0, 63,  0, NULL,    "SST39VF320 2Mx16" },
2817 +       { 0,      0,      0,         0, OLD, 0,       0,   0, 0,   0, NULL,    NULL },
2818 +};
2819 +
2820 +#else
2821 +
2822 +extern flash_cmds_t flash_cmds[];
2823 +extern unlock_cmd_t unlock_cmd;
2824 +extern flash_desc_t flashes[];
2825 +
2826 +#endif
2827 diff -Nur linux-2.4.32/arch/mips/bcm947xx/include/flashutl.h linux-2.4.32-brcm/arch/mips/bcm947xx/include/flashutl.h
2828 --- linux-2.4.32/arch/mips/bcm947xx/include/flashutl.h  1970-01-01 01:00:00.000000000 +0100
2829 +++ linux-2.4.32-brcm/arch/mips/bcm947xx/include/flashutl.h     2005-12-16 23:39:10.708822000 +0100
2830 @@ -0,0 +1,27 @@
2831 +/*
2832 + * BCM47XX FLASH driver interface
2833 + *
2834 + * Copyright 2005, Broadcom Corporation
2835 + * All Rights Reserved.
2836 + *
2837 + * THIS SOFTWARE IS OFFERED "AS IS", AND BROADCOM GRANTS NO WARRANTIES OF ANY
2838 + * KIND, EXPRESS OR IMPLIED, BY STATUTE, COMMUNICATION OR OTHERWISE. BROADCOM
2839 + * SPECIFICALLY DISCLAIMS ANY IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS
2840 + * FOR A SPECIFIC PURPOSE OR NONINFRINGEMENT CONCERNING THIS SOFTWARE.
2841 + * $Id$
2842 + */
2843 +
2844 +#ifndef _flashutl_h_
2845 +#define _flashutl_h_
2846 +
2847 +
2848 +#ifndef _LANGUAGE_ASSEMBLY
2849 +
2850 +int    sysFlashInit(char *flash_str);
2851 +int sysFlashRead(uint off, uchar *dst, uint bytes);
2852 +int sysFlashWrite(uint off, uchar *src, uint bytes);
2853 +void nvWrite(unsigned short *data, unsigned int len);
2854 +
2855 +#endif /* _LANGUAGE_ASSEMBLY */
2856 +
2857 +#endif /* _flashutl_h_ */
2858 diff -Nur linux-2.4.32/arch/mips/bcm947xx/include/hnddma.h linux-2.4.32-brcm/arch/mips/bcm947xx/include/hnddma.h
2859 --- linux-2.4.32/arch/mips/bcm947xx/include/hnddma.h    1970-01-01 01:00:00.000000000 +0100
2860 +++ linux-2.4.32-brcm/arch/mips/bcm947xx/include/hnddma.h       2005-12-16 23:39:10.708822000 +0100
2861 @@ -0,0 +1,71 @@
2862 +/*
2863 + * Generic Broadcom Home Networking Division (HND) DMA engine SW interface
2864 + * This supports the following chips: BCM42xx, 44xx, 47xx .
2865 + *
2866 + * Copyright 2005, Broadcom Corporation
2867 + * All Rights Reserved.
2868 + *
2869 + * THIS SOFTWARE IS OFFERED "AS IS", AND BROADCOM GRANTS NO WARRANTIES OF ANY
2870 + * KIND, EXPRESS OR IMPLIED, BY STATUTE, COMMUNICATION OR OTHERWISE. BROADCOM
2871 + * SPECIFICALLY DISCLAIMS ANY IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS
2872 + * FOR A SPECIFIC PURPOSE OR NONINFRINGEMENT CONCERNING THIS SOFTWARE.
2873 + * $Id$
2874 + */
2875 +
2876 +#ifndef        _hnddma_h_
2877 +#define        _hnddma_h_
2878 +
2879 +/* export structure */
2880 +typedef volatile struct {
2881 +       /* rx error counters */
2882 +       uint            rxgiants;       /* rx giant frames */
2883 +       uint            rxnobuf;        /* rx out of dma descriptors */
2884 +       /* tx error counters */
2885 +       uint            txnobuf;        /* tx out of dma descriptors */
2886 +} hnddma_t;
2887 +
2888 +#ifndef di_t
2889 +#define        di_t    void
2890 +#endif
2891 +
2892 +#ifndef osl_t
2893 +#define osl_t void
2894 +#endif
2895 +
2896 +/* externs */
2897 +extern void * dma_attach(osl_t *osh, char *name, sb_t *sbh, void *dmaregstx, void *dmaregsrx,
2898 +                        uint ntxd, uint nrxd, uint rxbufsize, uint nrxpost, uint rxoffset, uint *msg_level);
2899 +extern void dma_detach(di_t *di);
2900 +extern void dma_txreset(di_t *di);
2901 +extern void dma_rxreset(di_t *di);
2902 +extern void dma_txinit(di_t *di);
2903 +extern bool dma_txenabled(di_t *di);
2904 +extern void dma_rxinit(di_t *di);
2905 +extern void dma_rxenable(di_t *di);
2906 +extern bool dma_rxenabled(di_t *di);
2907 +extern void dma_txsuspend(di_t *di);
2908 +extern void dma_txresume(di_t *di);
2909 +extern bool dma_txsuspended(di_t *di);
2910 +extern bool dma_txsuspendedidle(di_t *di);
2911 +extern bool dma_txstopped(di_t *di);
2912 +extern bool dma_rxstopped(di_t *di);
2913 +extern int dma_txfast(di_t *di, void *p, uint32 coreflags);
2914 +extern void dma_fifoloopbackenable(di_t *di);
2915 +extern void *dma_rx(di_t *di);
2916 +extern void dma_rxfill(di_t *di);
2917 +extern void dma_txreclaim(di_t *di, bool forceall);
2918 +extern void dma_rxreclaim(di_t *di);
2919 +extern uintptr dma_getvar(di_t *di, char *name);
2920 +extern void *dma_getnexttxp(di_t *di, bool forceall);
2921 +extern void *dma_peeknexttxp(di_t *di);
2922 +extern void *dma_getnextrxp(di_t *di, bool forceall);
2923 +extern void dma_txblock(di_t *di);
2924 +extern void dma_txunblock(di_t *di);
2925 +extern uint dma_txactive(di_t *di);
2926 +extern void dma_txrotate(di_t *di);
2927 +
2928 +extern void dma_rxpiomode(dma32regs_t *);
2929 +extern void dma_txpioloopback(dma32regs_t *);
2930 +
2931 +
2932 +#endif /* _hnddma_h_ */
2933 diff -Nur linux-2.4.32/arch/mips/bcm947xx/include/hndmips.h linux-2.4.32-brcm/arch/mips/bcm947xx/include/hndmips.h
2934 --- linux-2.4.32/arch/mips/bcm947xx/include/hndmips.h   1970-01-01 01:00:00.000000000 +0100
2935 +++ linux-2.4.32-brcm/arch/mips/bcm947xx/include/hndmips.h      2005-12-16 23:39:10.708822000 +0100
2936 @@ -0,0 +1,16 @@
2937 +/*
2938 + * Alternate include file for HND sbmips.h since CFE also ships with
2939 + * a sbmips.h.
2940 + *
2941 + * Copyright 2005, Broadcom Corporation
2942 + * All Rights Reserved.
2943 + *
2944 + * THIS SOFTWARE IS OFFERED "AS IS", AND BROADCOM GRANTS NO WARRANTIES OF ANY
2945 + * KIND, EXPRESS OR IMPLIED, BY STATUTE, COMMUNICATION OR OTHERWISE. BROADCOM
2946 + * SPECIFICALLY DISCLAIMS ANY IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS
2947 + * FOR A SPECIFIC PURPOSE OR NONINFRINGEMENT CONCERNING THIS SOFTWARE.
2948 + *
2949 + * $Id$
2950 + */
2951 +
2952 +#include "sbmips.h"
2953 diff -Nur linux-2.4.32/arch/mips/bcm947xx/include/linux_osl.h linux-2.4.32-brcm/arch/mips/bcm947xx/include/linux_osl.h
2954 --- linux-2.4.32/arch/mips/bcm947xx/include/linux_osl.h 1970-01-01 01:00:00.000000000 +0100
2955 +++ linux-2.4.32-brcm/arch/mips/bcm947xx/include/linux_osl.h    2005-12-16 23:39:10.708822000 +0100
2956 @@ -0,0 +1,371 @@
2957 +/*
2958 + * Linux OS Independent Layer
2959 + *
2960 + * Copyright 2005, Broadcom Corporation
2961 + * All Rights Reserved.
2962 + *
2963 + * THIS SOFTWARE IS OFFERED "AS IS", AND BROADCOM GRANTS NO WARRANTIES OF ANY
2964 + * KIND, EXPRESS OR IMPLIED, BY STATUTE, COMMUNICATION OR OTHERWISE. BROADCOM
2965 + * SPECIFICALLY DISCLAIMS ANY IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS
2966 + * FOR A SPECIFIC PURPOSE OR NONINFRINGEMENT CONCERNING THIS SOFTWARE.
2967 + *
2968 + * $Id$
2969 + */
2970 +
2971 +#ifndef _linux_osl_h_
2972 +#define _linux_osl_h_
2973 +
2974 +#include <typedefs.h>
2975 +
2976 +/* use current 2.4.x calling conventions */
2977 +#include <linuxver.h>
2978 +
2979 +/* assert and panic */
2980 +#ifdef __GNUC__
2981 +#define GCC_VERSION (__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__)
2982 +#if GCC_VERSION > 30100
2983 +#define        ASSERT(exp)             do {} while (0)
2984 +#else
2985 +/* ASSERT could causes segmentation fault on GCC3.1, use empty instead*/
2986 +#define        ASSERT(exp)
2987 +#endif
2988 +#endif
2989 +
2990 +/* microsecond delay */
2991 +#define        OSL_DELAY(usec)         osl_delay(usec)
2992 +extern void osl_delay(uint usec);
2993 +
2994 +/* PCMCIA attribute space access macros */
2995 +#if defined(CONFIG_PCMCIA) || defined(CONFIG_PCMCIA_MODULE)
2996 +struct pcmcia_dev {
2997 +       dev_link_t link;        /* PCMCIA device pointer */
2998 +       dev_node_t node;        /* PCMCIA node structure */
2999 +       void *base;             /* Mapped attribute memory window */
3000 +       size_t size;            /* Size of window */
3001 +       void *drv;              /* Driver data */
3002 +};
3003 +#endif
3004 +#define        OSL_PCMCIA_READ_ATTR(osh, offset, buf, size) \
3005 +       osl_pcmcia_read_attr((osh), (offset), (buf), (size))
3006 +#define        OSL_PCMCIA_WRITE_ATTR(osh, offset, buf, size) \
3007 +       osl_pcmcia_write_attr((osh), (offset), (buf), (size))
3008 +extern void osl_pcmcia_read_attr(osl_t *osh, uint offset, void *buf, int size);
3009 +extern void osl_pcmcia_write_attr(osl_t *osh, uint offset, void *buf, int size);
3010 +
3011 +/* PCI configuration space access macros */
3012 +#define        OSL_PCI_READ_CONFIG(osh, offset, size) \
3013 +       osl_pci_read_config((osh), (offset), (size))
3014 +#define        OSL_PCI_WRITE_CONFIG(osh, offset, size, val) \
3015 +       osl_pci_write_config((osh), (offset), (size), (val))
3016 +extern uint32 osl_pci_read_config(osl_t *osh, uint size, uint offset);
3017 +extern void osl_pci_write_config(osl_t *osh, uint offset, uint size, uint val);
3018 +
3019 +/* PCI device bus # and slot # */
3020 +#define OSL_PCI_BUS(osh)       osl_pci_bus(osh)
3021 +#define OSL_PCI_SLOT(osh)      osl_pci_slot(osh)
3022 +extern uint osl_pci_bus(osl_t *osh);
3023 +extern uint osl_pci_slot(osl_t *osh);
3024 +
3025 +/* OSL initialization */
3026 +extern osl_t *osl_attach(void *pdev);
3027 +extern void osl_detach(osl_t *osh);
3028 +
3029 +/* host/bus architecture-specific byte swap */
3030 +#define BUS_SWAP32(v)          (v)
3031 +
3032 +/* general purpose memory allocation */
3033 +
3034 +#if defined(BCMDBG_MEM)
3035 +
3036 +#define        MALLOC(osh, size)       osl_debug_malloc((osh), (size), __LINE__, __FILE__)
3037 +#define        MFREE(osh, addr, size)  osl_debug_mfree((osh), (addr), (size), __LINE__, __FILE__)
3038 +#define MALLOCED(osh)          osl_malloced((osh))
3039 +#define        MALLOC_DUMP(osh, buf, sz) osl_debug_memdump((osh), (buf), (sz))
3040 +extern void *osl_debug_malloc(osl_t *osh, uint size, int line, char* file);
3041 +extern void osl_debug_mfree(osl_t *osh, void *addr, uint size, int line, char* file);
3042 +extern char *osl_debug_memdump(osl_t *osh, char *buf, uint sz);
3043 +
3044 +#else
3045 +
3046 +#define        MALLOC(osh, size)       osl_malloc((osh), (size))
3047 +#define        MFREE(osh, addr, size)  osl_mfree((osh), (addr), (size))
3048 +#define MALLOCED(osh)          osl_malloced((osh))
3049 +
3050 +#endif /* BCMDBG_MEM */
3051 +
3052 +#define        MALLOC_FAILED(osh)      osl_malloc_failed((osh))
3053 +
3054 +extern void *osl_malloc(osl_t *osh, uint size);
3055 +extern void osl_mfree(osl_t *osh, void *addr, uint size);
3056 +extern uint osl_malloced(osl_t *osh);
3057 +extern uint osl_malloc_failed(osl_t *osh);
3058 +
3059 +/* allocate/free shared (dma-able) consistent memory */
3060 +#define        DMA_CONSISTENT_ALIGN    PAGE_SIZE
3061 +#define        DMA_ALLOC_CONSISTENT(osh, size, pap) \
3062 +       osl_dma_alloc_consistent((osh), (size), (pap))
3063 +#define        DMA_FREE_CONSISTENT(osh, va, size, pa) \
3064 +       osl_dma_free_consistent((osh), (void*)(va), (size), (pa))
3065 +extern void *osl_dma_alloc_consistent(osl_t *osh, uint size, ulong *pap);
3066 +extern void osl_dma_free_consistent(osl_t *osh, void *va, uint size, ulong pa);
3067 +
3068 +/* map/unmap direction */
3069 +#define        DMA_TX  1
3070 +#define        DMA_RX  2
3071 +
3072 +/* map/unmap shared (dma-able) memory */
3073 +#define        DMA_MAP(osh, va, size, direction, p) \
3074 +       osl_dma_map((osh), (va), (size), (direction))
3075 +#define        DMA_UNMAP(osh, pa, size, direction, p) \
3076 +       osl_dma_unmap((osh), (pa), (size), (direction))
3077 +extern uint osl_dma_map(osl_t *osh, void *va, uint size, int direction);
3078 +extern void osl_dma_unmap(osl_t *osh, uint pa, uint size, int direction);
3079 +
3080 +/* register access macros */
3081 +#if defined(BCMJTAG)
3082 +#include <bcmjtag.h>
3083 +#define        R_REG(r)        bcmjtag_read(NULL, (uint32)(r), sizeof (*(r)))
3084 +#define        W_REG(r, v)     bcmjtag_write(NULL, (uint32)(r), (uint32)(v), sizeof (*(r)))
3085 +#endif
3086 +
3087 +/*
3088 + * BINOSL selects the slightly slower function-call-based binary compatible osl.
3089 + * Macros expand to calls to functions defined in linux_osl.c .
3090 + */
3091 +#ifndef BINOSL
3092 +
3093 +/* string library, kernel mode */
3094 +#define        printf(fmt, args...)    printk(fmt, ## args)
3095 +#include <linux/kernel.h>
3096 +#include <linux/string.h>
3097 +
3098 +/* register access macros */
3099 +#if !defined(BCMJTAG)
3100 +#ifndef IL_BIGENDIAN
3101 +#define R_REG(r) ( \
3102 +       sizeof(*(r)) == sizeof(uint8) ? readb((volatile uint8*)(r)) : \
3103 +       sizeof(*(r)) == sizeof(uint16) ? readw((volatile uint16*)(r)) : \
3104 +       readl((volatile uint32*)(r)) \
3105 +)
3106 +#define W_REG(r, v) do { \
3107 +       switch (sizeof(*(r))) { \
3108 +       case sizeof(uint8):     writeb((uint8)(v), (volatile uint8*)(r)); break; \
3109 +       case sizeof(uint16):    writew((uint16)(v), (volatile uint16*)(r)); break; \
3110 +       case sizeof(uint32):    writel((uint32)(v), (volatile uint32*)(r)); break; \
3111 +       } \
3112 +} while (0)
3113 +#else  /* IL_BIGENDIAN */
3114 +#define R_REG(r) ({ \
3115 +       __typeof(*(r)) __osl_v; \
3116 +       switch (sizeof(*(r))) { \
3117 +       case sizeof(uint8):     __osl_v = readb((volatile uint8*)((uint32)r^3)); break; \
3118 +       case sizeof(uint16):    __osl_v = readw((volatile uint16*)((uint32)r^2)); break; \
3119 +       case sizeof(uint32):    __osl_v = readl((volatile uint32*)(r)); break; \
3120 +       } \
3121 +       __osl_v; \
3122 +})
3123 +#define W_REG(r, v) do { \
3124 +       switch (sizeof(*(r))) { \
3125 +       case sizeof(uint8):     writeb((uint8)(v), (volatile uint8*)((uint32)r^3)); break; \
3126 +       case sizeof(uint16):    writew((uint16)(v), (volatile uint16*)((uint32)r^2)); break; \
3127 +       case sizeof(uint32):    writel((uint32)(v), (volatile uint32*)(r)); break; \
3128 +       } \
3129 +} while (0)
3130 +#endif
3131 +#endif
3132 +
3133 +#define        AND_REG(r, v)           W_REG((r), R_REG(r) & (v))
3134 +#define        OR_REG(r, v)            W_REG((r), R_REG(r) | (v))
3135 +
3136 +/* bcopy, bcmp, and bzero */
3137 +#define        bcopy(src, dst, len)    memcpy((dst), (src), (len))
3138 +#define        bcmp(b1, b2, len)       memcmp((b1), (b2), (len))
3139 +#define        bzero(b, len)           memset((b), '\0', (len))
3140 +
3141 +/* uncached virtual address */
3142 +#ifdef mips
3143 +#define OSL_UNCACHED(va)       KSEG1ADDR((va))
3144 +#include <asm/addrspace.h>
3145 +#else
3146 +#define OSL_UNCACHED(va)       (va)
3147 +#endif
3148 +
3149 +/* get processor cycle count */
3150 +#if defined(mips)
3151 +#define        OSL_GETCYCLES(x)        ((x) = read_c0_count() * 2)
3152 +#elif defined(__i386__)
3153 +#define        OSL_GETCYCLES(x)        rdtscl((x))
3154 +#else
3155 +#define OSL_GETCYCLES(x)       ((x) = 0)
3156 +#endif
3157 +
3158 +/* dereference an address that may cause a bus exception */
3159 +#ifdef mips
3160 +#if defined(MODULE) && (LINUX_VERSION_CODE < KERNEL_VERSION(2,4,17))
3161 +#define BUSPROBE(val, addr)    panic("get_dbe() will not fixup a bus exception when compiled into a module")
3162 +#else
3163 +#define        BUSPROBE(val, addr)     get_dbe((val), (addr))
3164 +#include <asm/paccess.h>
3165 +#endif
3166 +#else
3167 +#define        BUSPROBE(val, addr)     ({ (val) = R_REG((addr)); 0; })
3168 +#endif
3169 +
3170 +/* map/unmap physical to virtual I/O */
3171 +#define        REG_MAP(pa, size)       ioremap_nocache((unsigned long)(pa), (unsigned long)(size))
3172 +#define        REG_UNMAP(va)           iounmap((void *)(va))
3173 +
3174 +/* shared (dma-able) memory access macros */
3175 +#define        R_SM(r)                 *(r)
3176 +#define        W_SM(r, v)              (*(r) = (v))
3177 +#define        BZERO_SM(r, len)        memset((r), '\0', (len))
3178 +
3179 +/* packet primitives */
3180 +#define        PKTGET(osh, len, send)          osl_pktget((osh), (len), (send))
3181 +#define        PKTFREE(osh, skb, send)         osl_pktfree((skb))
3182 +#define        PKTDATA(osh, skb)               (((struct sk_buff*)(skb))->data)
3183 +#define        PKTLEN(osh, skb)                (((struct sk_buff*)(skb))->len)
3184 +#define PKTHEADROOM(osh, skb)          (PKTDATA(osh,skb)-(((struct sk_buff*)(skb))->head))
3185 +#define PKTTAILROOM(osh, skb)          ((((struct sk_buff*)(skb))->end)-(((struct sk_buff*)(skb))->tail))
3186 +#define        PKTNEXT(osh, skb)               (((struct sk_buff*)(skb))->next)
3187 +#define        PKTSETNEXT(skb, x)              (((struct sk_buff*)(skb))->next = (struct sk_buff*)(x))
3188 +#define        PKTSETLEN(osh, skb, len)        __skb_trim((struct sk_buff*)(skb), (len))
3189 +#define        PKTPUSH(osh, skb, bytes)        skb_push((struct sk_buff*)(skb), (bytes))
3190 +#define        PKTPULL(osh, skb, bytes)        skb_pull((struct sk_buff*)(skb), (bytes))
3191 +#define        PKTDUP(osh, skb)                skb_clone((struct sk_buff*)(skb), GFP_ATOMIC)
3192 +#define        PKTCOOKIE(skb)                  ((void*)((struct sk_buff*)(skb))->csum)
3193 +#define        PKTSETCOOKIE(skb, x)            (((struct sk_buff*)(skb))->csum = (uint)(x))
3194 +#define        PKTLINK(skb)                    (((struct sk_buff*)(skb))->prev)
3195 +#define        PKTSETLINK(skb, x)              (((struct sk_buff*)(skb))->prev = (struct sk_buff*)(x))
3196 +#define        PKTPRIO(skb)                    (((struct sk_buff*)(skb))->priority)
3197 +#define        PKTSETPRIO(skb, x)              (((struct sk_buff*)(skb))->priority = (x))
3198 +extern void *osl_pktget(osl_t *osh, uint len, bool send);
3199 +extern void osl_pktfree(void *skb);
3200 +
3201 +#else  /* BINOSL */
3202 +
3203 +/* string library */
3204 +#ifndef LINUX_OSL
3205 +#undef printf
3206 +#define        printf(fmt, args...)            osl_printf((fmt), ## args)
3207 +#undef sprintf
3208 +#define sprintf(buf, fmt, args...)     osl_sprintf((buf), (fmt), ## args)
3209 +#undef strcmp
3210 +#define        strcmp(s1, s2)                  osl_strcmp((s1), (s2))
3211 +#undef strncmp
3212 +#define        strncmp(s1, s2, n)              osl_strncmp((s1), (s2), (n))
3213 +#undef strlen
3214 +#define strlen(s)                      osl_strlen((s))
3215 +#undef strcpy
3216 +#define        strcpy(d, s)                    osl_strcpy((d), (s))
3217 +#undef strncpy
3218 +#define        strncpy(d, s, n)                osl_strncpy((d), (s), (n))
3219 +#endif
3220 +extern int osl_printf(const char *format, ...);
3221 +extern int osl_sprintf(char *buf, const char *format, ...);
3222 +extern int osl_strcmp(const char *s1, const char *s2);
3223 +extern int osl_strncmp(const char *s1, const char *s2, uint n);
3224 +extern int osl_strlen(const char *s);
3225 +extern char* osl_strcpy(char *d, const char *s);
3226 +extern char* osl_strncpy(char *d, const char *s, uint n);
3227 +
3228 +/* register access macros */
3229 +#if !defined(BCMJTAG)
3230 +#define R_REG(r) ( \
3231 +       sizeof(*(r)) == sizeof(uint8) ? osl_readb((volatile uint8*)(r)) : \
3232 +       sizeof(*(r)) == sizeof(uint16) ? osl_readw((volatile uint16*)(r)) : \
3233 +       osl_readl((volatile uint32*)(r)) \
3234 +)
3235 +#define W_REG(r, v) do { \
3236 +       switch (sizeof(*(r))) { \
3237 +       case sizeof(uint8):     osl_writeb((uint8)(v), (volatile uint8*)(r)); break; \
3238 +       case sizeof(uint16):    osl_writew((uint16)(v), (volatile uint16*)(r)); break; \
3239 +       case sizeof(uint32):    osl_writel((uint32)(v), (volatile uint32*)(r)); break; \
3240 +       } \
3241 +} while (0)
3242 +#endif
3243 +
3244 +#define        AND_REG(r, v)           W_REG((r), R_REG(r) & (v))
3245 +#define        OR_REG(r, v)            W_REG((r), R_REG(r) | (v))
3246 +extern uint8 osl_readb(volatile uint8 *r);
3247 +extern uint16 osl_readw(volatile uint16 *r);
3248 +extern uint32 osl_readl(volatile uint32 *r);
3249 +extern void osl_writeb(uint8 v, volatile uint8 *r);
3250 +extern void osl_writew(uint16 v, volatile uint16 *r);
3251 +extern void osl_writel(uint32 v, volatile uint32 *r);
3252 +
3253 +/* bcopy, bcmp, and bzero */
3254 +extern void bcopy(const void *src, void *dst, int len);
3255 +extern int bcmp(const void *b1, const void *b2, int len);
3256 +extern void bzero(void *b, int len);
3257 +
3258 +/* uncached virtual address */
3259 +#define OSL_UNCACHED(va)       osl_uncached((va))
3260 +extern void *osl_uncached(void *va);
3261 +
3262 +/* get processor cycle count */
3263 +#define OSL_GETCYCLES(x)       ((x) = osl_getcycles())
3264 +extern uint osl_getcycles(void);
3265 +
3266 +/* dereference an address that may target abort */
3267 +#define        BUSPROBE(val, addr)     osl_busprobe(&(val), (addr))
3268 +extern int osl_busprobe(uint32 *val, uint32 addr);
3269 +
3270 +/* map/unmap physical to virtual */
3271 +#define        REG_MAP(pa, size)       osl_reg_map((pa), (size))
3272 +#define        REG_UNMAP(va)           osl_reg_unmap((va))
3273 +extern void *osl_reg_map(uint32 pa, uint size);
3274 +extern void osl_reg_unmap(void *va);
3275 +
3276 +/* shared (dma-able) memory access macros */
3277 +#define        R_SM(r)                 *(r)
3278 +#define        W_SM(r, v)              (*(r) = (v))
3279 +#define        BZERO_SM(r, len)        bzero((r), (len))
3280 +
3281 +/* packet primitives */
3282 +#define        PKTGET(osh, len, send)          osl_pktget((osh), (len), (send))
3283 +#define        PKTFREE(osh, skb, send)         osl_pktfree((skb))
3284 +#define        PKTDATA(osh, skb)               osl_pktdata((osh), (skb))
3285 +#define        PKTLEN(osh, skb)                osl_pktlen((osh), (skb))
3286 +#define PKTHEADROOM(osh, skb)          osl_pktheadroom((osh), (skb))
3287 +#define PKTTAILROOM(osh, skb)          osl_pkttailroom((osh), (skb))
3288 +#define        PKTNEXT(osh, skb)               osl_pktnext((osh), (skb))
3289 +#define        PKTSETNEXT(skb, x)              osl_pktsetnext((skb), (x))
3290 +#define        PKTSETLEN(osh, skb, len)        osl_pktsetlen((osh), (skb), (len))
3291 +#define        PKTPUSH(osh, skb, bytes)        osl_pktpush((osh), (skb), (bytes))
3292 +#define        PKTPULL(osh, skb, bytes)        osl_pktpull((osh), (skb), (bytes))
3293 +#define        PKTDUP(osh, skb)                osl_pktdup((osh), (skb))
3294 +#define        PKTCOOKIE(skb)                  osl_pktcookie((skb))
3295 +#define        PKTSETCOOKIE(skb, x)            osl_pktsetcookie((skb), (x))
3296 +#define        PKTLINK(skb)                    osl_pktlink((skb))
3297 +#define        PKTSETLINK(skb, x)              osl_pktsetlink((skb), (x))
3298 +#define        PKTPRIO(skb)                    osl_pktprio((skb))
3299 +#define        PKTSETPRIO(skb, x)              osl_pktsetprio((skb), (x))
3300 +extern void *osl_pktget(osl_t *osh, uint len, bool send);
3301 +extern void osl_pktfree(void *skb);
3302 +extern uchar *osl_pktdata(osl_t *osh, void *skb);
3303 +extern uint osl_pktlen(osl_t *osh, void *skb);
3304 +extern uint osl_pktheadroom(osl_t *osh, void *skb);
3305 +extern uint osl_pkttailroom(osl_t *osh, void *skb);
3306 +extern void *osl_pktnext(osl_t *osh, void *skb);
3307 +extern void osl_pktsetnext(void *skb, void *x);
3308 +extern void osl_pktsetlen(osl_t *osh, void *skb, uint len);
3309 +extern uchar *osl_pktpush(osl_t *osh, void *skb, int bytes);
3310 +extern uchar *osl_pktpull(osl_t *osh, void *skb, int bytes);
3311 +extern void *osl_pktdup(osl_t *osh, void *skb);
3312 +extern void *osl_pktcookie(void *skb);
3313 +extern void osl_pktsetcookie(void *skb, void *x);
3314 +extern void *osl_pktlink(void *skb);
3315 +extern void osl_pktsetlink(void *skb, void *x);
3316 +extern uint osl_pktprio(void *skb);
3317 +extern void osl_pktsetprio(void *skb, uint x);
3318 +
3319 +#endif /* BINOSL */
3320 +
3321 +#define OSL_ERROR(bcmerror)    osl_error(bcmerror)
3322 +extern int osl_error(int bcmerror);
3323 +
3324 +/* the largest reasonable packet buffer driver uses for ethernet MTU in bytes */
3325 +#define        PKTBUFSZ        2048
3326 +
3327 +#endif /* _linux_osl_h_ */
3328 diff -Nur linux-2.4.32/arch/mips/bcm947xx/include/linuxver.h linux-2.4.32-brcm/arch/mips/bcm947xx/include/linuxver.h
3329 --- linux-2.4.32/arch/mips/bcm947xx/include/linuxver.h  1970-01-01 01:00:00.000000000 +0100
3330 +++ linux-2.4.32-brcm/arch/mips/bcm947xx/include/linuxver.h     2005-12-16 23:39:10.748824500 +0100
3331 @@ -0,0 +1,411 @@
3332 +/*
3333 + * Linux-specific abstractions to gain some independence from linux kernel versions.
3334 + * Pave over some 2.2 versus 2.4 versus 2.6 kernel differences.
3335 + *
3336 + * Copyright 2005, Broadcom Corporation
3337 + * All Rights Reserved.
3338 + *
3339 + * THIS SOFTWARE IS OFFERED "AS IS", AND BROADCOM GRANTS NO WARRANTIES OF ANY
3340 + * KIND, EXPRESS OR IMPLIED, BY STATUTE, COMMUNICATION OR OTHERWISE. BROADCOM
3341 + * SPECIFICALLY DISCLAIMS ANY IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS
3342 + * FOR A SPECIFIC PURPOSE OR NONINFRINGEMENT CONCERNING THIS SOFTWARE.
3343 + *
3344 + * $Id$
3345 + */
3346 +
3347 +#ifndef _linuxver_h_
3348 +#define _linuxver_h_
3349 +
3350 +#include <linux/config.h>
3351 +#include <linux/version.h>
3352 +
3353 +#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,3,0))
3354 +/* __NO_VERSION__ must be defined for all linkables except one in 2.2 */
3355 +#ifdef __UNDEF_NO_VERSION__
3356 +#undef __NO_VERSION__
3357 +#else
3358 +#define __NO_VERSION__
3359 +#endif
3360 +#endif
3361 +
3362 +#if defined(MODULE) && defined(MODVERSIONS)
3363 +#include <linux/modversions.h>
3364 +#endif
3365 +
3366 +#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,5,0)
3367 +#include <linux/moduleparam.h>
3368 +#endif
3369 +
3370 +
3371 +#if LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0)
3372 +#define module_param(_name_, _type_, _perm_)   MODULE_PARM(_name_, "i")
3373 +#define module_param_string(_name_, _string_, _size_, _perm_)  MODULE_PARM(_string_, "c" __MODULE_STRING(_size_))
3374 +#endif
3375 +
3376 +/* linux/malloc.h is deprecated, use linux/slab.h instead. */
3377 +#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,4,9))
3378 +#include <linux/malloc.h>
3379 +#else
3380 +#include <linux/slab.h>
3381 +#endif
3382 +
3383 +#include <linux/types.h>
3384 +#include <linux/init.h>
3385 +#include <linux/mm.h>
3386 +#include <linux/string.h>
3387 +#include <linux/pci.h>
3388 +#include <linux/interrupt.h>
3389 +#include <linux/netdevice.h>
3390 +#include <asm/io.h>
3391 +
3392 +#if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,41))
3393 +#include <linux/workqueue.h>
3394 +#else
3395 +#include <linux/tqueue.h>
3396 +#ifndef work_struct
3397 +#define work_struct tq_struct
3398 +#endif
3399 +#ifndef INIT_WORK
3400 +#define INIT_WORK(_work, _func, _data) INIT_TQUEUE((_work), (_func), (_data))
3401 +#endif
3402 +#ifndef schedule_work
3403 +#define schedule_work(_work) schedule_task((_work))
3404 +#endif
3405 +#ifndef flush_scheduled_work
3406 +#define flush_scheduled_work() flush_scheduled_tasks()
3407 +#endif
3408 +#endif
3409 +
3410 +#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,0))
3411 +/* Some distributions have their own 2.6.x compatibility layers */
3412 +#ifndef IRQ_NONE
3413 +typedef void irqreturn_t;
3414 +#define IRQ_NONE
3415 +#define IRQ_HANDLED
3416 +#define IRQ_RETVAL(x)
3417 +#endif
3418 +#else
3419 +typedef irqreturn_t (*FN_ISR) (int irq, void *dev_id, struct pt_regs *ptregs);
3420 +#endif
3421 +
3422 +#if defined(CONFIG_PCMCIA) || defined(CONFIG_PCMCIA_MODULE)
3423 +
3424 +#include <pcmcia/version.h>
3425 +#include <pcmcia/cs_types.h>
3426 +#include <pcmcia/cs.h>
3427 +#include <pcmcia/cistpl.h>
3428 +#include <pcmcia/cisreg.h>
3429 +#include <pcmcia/ds.h>
3430 +
3431 +#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,5,69))
3432 +/* In 2.5 (as of 2.5.69 at least) there is a cs_error exported which
3433 + * does this, but it's not in 2.4 so we do our own for now. */
3434 +static inline void
3435 +cs_error(client_handle_t handle, int func, int ret)
3436 +{
3437 +       error_info_t err = { func, ret };
3438 +       CardServices(ReportError, handle, &err);
3439 +}
3440 +#endif
3441 +
3442 +#endif /* CONFIG_PCMCIA */
3443 +
3444 +#ifndef __exit
3445 +#define __exit
3446 +#endif
3447 +#ifndef __devexit
3448 +#define __devexit
3449 +#endif
3450 +#ifndef __devinit
3451 +#define __devinit      __init
3452 +#endif
3453 +#ifndef __devinitdata
3454 +#define __devinitdata
3455 +#endif
3456 +#ifndef __devexit_p
3457 +#define __devexit_p(x) x
3458 +#endif
3459 +
3460 +#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,4,0))
3461 +
3462 +#define pci_get_drvdata(dev)           (dev)->sysdata
3463 +#define pci_set_drvdata(dev, value)    (dev)->sysdata=(value)
3464 +
3465 +/*
3466 + * New-style (2.4.x) PCI/hot-pluggable PCI/CardBus registration
3467 + */
3468 +
3469 +struct pci_device_id {
3470 +       unsigned int vendor, device;            /* Vendor and device ID or PCI_ANY_ID */
3471 +       unsigned int subvendor, subdevice;      /* Subsystem ID's or PCI_ANY_ID */
3472 +       unsigned int class, class_mask;         /* (class,subclass,prog-if) triplet */
3473 +       unsigned long driver_data;              /* Data private to the driver */
3474 +};
3475 +
3476 +struct pci_driver {
3477 +       struct list_head node;
3478 +       char *name;
3479 +       const struct pci_device_id *id_table;   /* NULL if wants all devices */
3480 +       int (*probe)(struct pci_dev *dev, const struct pci_device_id *id);      /* New device inserted */
3481 +       void (*remove)(struct pci_dev *dev);    /* Device removed (NULL if not a hot-plug capable driver) */
3482 +       void (*suspend)(struct pci_dev *dev);   /* Device suspended */
3483 +       void (*resume)(struct pci_dev *dev);    /* Device woken up */
3484 +};
3485 +
3486 +#define MODULE_DEVICE_TABLE(type, name)
3487 +#define PCI_ANY_ID (~0)
3488 +
3489 +/* compatpci.c */
3490 +#define pci_module_init pci_register_driver
3491 +extern int pci_register_driver(struct pci_driver *drv);
3492 +extern void pci_unregister_driver(struct pci_driver *drv);
3493 +
3494 +#endif /* PCI registration */
3495 +
3496 +#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,2,18))
3497 +#ifdef MODULE
3498 +#define module_init(x) int init_module(void) { return x(); }
3499 +#define module_exit(x) void cleanup_module(void) { x(); }
3500 +#else
3501 +#define module_init(x) __initcall(x);
3502 +#define module_exit(x) __exitcall(x);
3503 +#endif
3504 +#endif
3505 +
3506 +#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,3,48))
3507 +#define list_for_each(pos, head) \
3508 +       for (pos = (head)->next; pos != (head); pos = pos->next)
3509 +#endif
3510 +
3511 +#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,3,13))
3512 +#define pci_resource_start(dev, bar)   ((dev)->base_address[(bar)])
3513 +#elif (LINUX_VERSION_CODE < KERNEL_VERSION(2,3,44))
3514 +#define pci_resource_start(dev, bar)   ((dev)->resource[(bar)].start)
3515 +#endif
3516 +
3517 +#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,3,23))
3518 +#define pci_enable_device(dev) do { } while (0)
3519 +#endif
3520 +
3521 +#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,3,14))
3522 +#define net_device device
3523 +#endif
3524 +
3525 +#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,3,42))
3526 +
3527 +/*
3528 + * DMA mapping
3529 + *
3530 + * See linux/Documentation/DMA-mapping.txt
3531 + */
3532 +
3533 +#ifndef PCI_DMA_TODEVICE
3534 +#define        PCI_DMA_TODEVICE        1
3535 +#define        PCI_DMA_FROMDEVICE      2
3536 +#endif
3537 +
3538 +typedef u32 dma_addr_t;
3539 +
3540 +/* Pure 2^n version of get_order */
3541 +static inline int get_order(unsigned long size)
3542 +{
3543 +       int order;
3544 +
3545 +       size = (size-1) >> (PAGE_SHIFT-1);
3546 +       order = -1;
3547 +       do {
3548 +               size >>= 1;
3549 +               order++;
3550 +       } while (size);
3551 +       return order;
3552 +}
3553 +
3554 +static inline void *pci_alloc_consistent(struct pci_dev *hwdev, size_t size,
3555 +                                        dma_addr_t *dma_handle)
3556 +{
3557 +       void *ret;
3558 +       int gfp = GFP_ATOMIC | GFP_DMA;
3559 +
3560 +       ret = (void *)__get_free_pages(gfp, get_order(size));
3561 +
3562 +       if (ret != NULL) {
3563 +               memset(ret, 0, size);
3564 +               *dma_handle = virt_to_bus(ret);
3565 +       }
3566 +       return ret;
3567 +}
3568 +static inline void pci_free_consistent(struct pci_dev *hwdev, size_t size,
3569 +                                      void *vaddr, dma_addr_t dma_handle)
3570 +{
3571 +       free_pages((unsigned long)vaddr, get_order(size));
3572 +}
3573 +#ifdef ILSIM
3574 +extern uint pci_map_single(void *dev, void *va, uint size, int direction);
3575 +extern void pci_unmap_single(void *dev, uint pa, uint size, int direction);
3576 +#else
3577 +#define pci_map_single(cookie, address, size, dir)     virt_to_bus(address)
3578 +#define pci_unmap_single(cookie, address, size, dir)
3579 +#endif
3580 +
3581 +#endif /* DMA mapping */
3582 +
3583 +#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,3,43))
3584 +
3585 +#define dev_kfree_skb_any(a)           dev_kfree_skb(a)
3586 +#define netif_down(dev)                        do { (dev)->start = 0; } while(0)
3587 +
3588 +/* pcmcia-cs provides its own netdevice compatibility layer */
3589 +#ifndef _COMPAT_NETDEVICE_H
3590 +
3591 +/*
3592 + * SoftNet
3593 + *
3594 + * For pre-softnet kernels we need to tell the upper layer not to
3595 + * re-enter start_xmit() while we are in there. However softnet
3596 + * guarantees not to enter while we are in there so there is no need
3597 + * to do the netif_stop_queue() dance unless the transmit queue really
3598 + * gets stuck. This should also improve performance according to tests
3599 + * done by Aman Singla.
3600 + */
3601 +
3602 +#define dev_kfree_skb_irq(a)           dev_kfree_skb(a)
3603 +#define netif_wake_queue(dev)          do { clear_bit(0, &(dev)->tbusy); mark_bh(NET_BH); } while(0)
3604 +#define netif_stop_queue(dev)          set_bit(0, &(dev)->tbusy)
3605 +
3606 +static inline void netif_start_queue(struct net_device *dev)
3607 +{
3608 +       dev->tbusy = 0;
3609 +       dev->interrupt = 0;
3610 +       dev->start = 1;
3611 +}
3612 +
3613 +#define netif_queue_stopped(dev)       (dev)->tbusy
3614 +#define netif_running(dev)             (dev)->start
3615 +
3616 +#endif /* _COMPAT_NETDEVICE_H */
3617 +
3618 +#define netif_device_attach(dev)       netif_start_queue(dev)
3619 +#define netif_device_detach(dev)       netif_stop_queue(dev)
3620 +
3621 +/* 2.4.x renamed bottom halves to tasklets */
3622 +#define tasklet_struct                         tq_struct
3623 +static inline void tasklet_schedule(struct tasklet_struct *tasklet)
3624 +{
3625 +       queue_task(tasklet, &tq_immediate);
3626 +       mark_bh(IMMEDIATE_BH);
3627 +}
3628 +
3629 +static inline void tasklet_init(struct tasklet_struct *tasklet,
3630 +                               void (*func)(unsigned long),
3631 +                               unsigned long data)
3632 +{
3633 +       tasklet->next = NULL;
3634 +       tasklet->sync = 0;
3635 +       tasklet->routine = (void (*)(void *))func;
3636 +       tasklet->data = (void *)data;
3637 +}
3638 +#define tasklet_kill(tasklet)                  {do{} while(0);}
3639 +
3640 +/* 2.4.x introduced del_timer_sync() */
3641 +#define del_timer_sync(timer) del_timer(timer)
3642 +
3643 +#else
3644 +
3645 +#define netif_down(dev)
3646 +
3647 +#endif /* SoftNet */
3648 +
3649 +#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,4,3))
3650 +
3651 +/*
3652 + * Emit code to initialise a tq_struct's routine and data pointers
3653 + */
3654 +#define PREPARE_TQUEUE(_tq, _routine, _data)                   \
3655 +       do {                                                    \
3656 +               (_tq)->routine = _routine;                      \
3657 +               (_tq)->data = _data;                            \
3658 +       } while (0)
3659 +
3660 +/*
3661 + * Emit code to initialise all of a tq_struct
3662 + */
3663 +#define INIT_TQUEUE(_tq, _routine, _data)                      \
3664 +       do {                                                    \
3665 +               INIT_LIST_HEAD(&(_tq)->list);                   \
3666 +               (_tq)->sync = 0;                                \
3667 +               PREPARE_TQUEUE((_tq), (_routine), (_data));     \
3668 +       } while (0)
3669 +
3670 +#endif
3671 +
3672 +#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,4,6))
3673 +
3674 +/* Power management related routines */
3675 +
3676 +static inline int
3677 +pci_save_state(struct pci_dev *dev, u32 *buffer)
3678 +{
3679 +       int i;
3680 +       if (buffer) {
3681 +               for (i = 0; i < 16; i++)
3682 +                       pci_read_config_dword(dev, i * 4,&buffer[i]);
3683 +       }
3684 +       return 0;
3685 +}
3686 +
3687 +static inline int
3688 +pci_restore_state(struct pci_dev *dev, u32 *buffer)
3689 +{
3690 +       int i;
3691 +
3692 +       if (buffer) {
3693 +               for (i = 0; i < 16; i++)
3694 +                       pci_write_config_dword(dev,i * 4, buffer[i]);
3695 +       }
3696 +       /*
3697 +        * otherwise, write the context information we know from bootup.
3698 +        * This works around a problem where warm-booting from Windows
3699 +        * combined with a D3(hot)->D0 transition causes PCI config
3700 +        * header data to be forgotten.
3701 +        */
3702 +       else {
3703 +               for (i = 0; i < 6; i ++)
3704 +                       pci_write_config_dword(dev,
3705 +                                              PCI_BASE_ADDRESS_0 + (i * 4),
3706 +                                              pci_resource_start(dev, i));
3707 +               pci_write_config_byte(dev, PCI_INTERRUPT_LINE, dev->irq);
3708 +       }
3709 +       return 0;
3710 +}
3711 +
3712 +#endif /* PCI power management */
3713 +
3714 +/* Old cp0 access macros deprecated in 2.4.19 */
3715 +#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,4,19))
3716 +#define read_c0_count() read_32bit_cp0_register(CP0_COUNT)
3717 +#endif
3718 +
3719 +/* Module refcount handled internally in 2.6.x */
3720 +#ifndef SET_MODULE_OWNER
3721 +#define SET_MODULE_OWNER(dev)          do {} while (0)
3722 +#define OLD_MOD_INC_USE_COUNT          MOD_INC_USE_COUNT
3723 +#define OLD_MOD_DEC_USE_COUNT          MOD_DEC_USE_COUNT
3724 +#else
3725 +#define OLD_MOD_INC_USE_COUNT          do {} while (0)
3726 +#define OLD_MOD_DEC_USE_COUNT          do {} while (0)
3727 +#endif
3728 +
3729 +#ifndef SET_NETDEV_DEV
3730 +#define SET_NETDEV_DEV(net, pdev)      do {} while (0)
3731 +#endif
3732 +
3733 +#ifndef HAVE_FREE_NETDEV
3734 +#define free_netdev(dev)               kfree(dev)
3735 +#endif
3736 +
3737 +#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,0))
3738 +/* struct packet_type redefined in 2.6.x */
3739 +#define af_packet_priv                 data
3740 +#endif
3741 +
3742 +#endif /* _linuxver_h_ */
3743 diff -Nur linux-2.4.32/arch/mips/bcm947xx/include/min_osl.h linux-2.4.32-brcm/arch/mips/bcm947xx/include/min_osl.h
3744 --- linux-2.4.32/arch/mips/bcm947xx/include/min_osl.h   1970-01-01 01:00:00.000000000 +0100
3745 +++ linux-2.4.32-brcm/arch/mips/bcm947xx/include/min_osl.h      2005-12-16 23:39:10.748824500 +0100
3746 @@ -0,0 +1,126 @@
3747 +/*
3748 + * HND Minimal OS Abstraction Layer.
3749 + *
3750 + * Copyright 2005, Broadcom Corporation
3751 + * All Rights Reserved.
3752 + *
3753 + * THIS SOFTWARE IS OFFERED "AS IS", AND BROADCOM GRANTS NO WARRANTIES OF ANY
3754 + * KIND, EXPRESS OR IMPLIED, BY STATUTE, COMMUNICATION OR OTHERWISE. BROADCOM
3755 + * SPECIFICALLY DISCLAIMS ANY IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS
3756 + * FOR A SPECIFIC PURPOSE OR NONINFRINGEMENT CONCERNING THIS SOFTWARE.
3757 + *
3758 + * $Id$
3759 + */
3760 +
3761 +#ifndef _min_osl_h_
3762 +#define _min_osl_h_
3763 +
3764 +#include <typedefs.h>
3765 +#include <sbconfig.h>
3766 +#include <mipsinc.h>
3767 +
3768 +/* Cache support */
3769 +extern void caches_on(void);
3770 +extern void blast_dcache(void);
3771 +extern void blast_icache(void);
3772 +
3773 +/* uart output */
3774 +extern void putc(int c);
3775 +
3776 +/* lib functions */
3777 +extern int printf(const char *fmt, ...);
3778 +extern int sprintf(char *buf, const char *fmt, ...);
3779 +extern int strcmp(const char *s1, const char *s2);
3780 +extern int strncmp(const char *s1, const char *s2, uint n);
3781 +extern char *strcpy(char *dest, const char *src);
3782 +extern char *strncpy(char *dest, const char *src, uint n);
3783 +extern uint strlen(const char *s);
3784 +extern char *strchr(const char *str,int c);
3785 +extern char *strrchr(const char *str, int c);
3786 +extern char *strcat(char *d, const char *s);
3787 +extern void *memset(void *dest, int c, uint n);
3788 +extern void *memcpy(void *dest, const void *src, uint n);
3789 +extern int memcmp(const void *s1, const void *s2, uint n);
3790 +#define        bcopy(src, dst, len)    memcpy((dst), (src), (len))
3791 +#define        bcmp(b1, b2, len)       memcmp((b1), (b2), (len))
3792 +#define        bzero(b, len)           memset((b), '\0', (len))
3793 +
3794 +/* assert & debugging */
3795 +#define        ASSERT(exp)             do {} while (0)
3796 +
3797 +/* PCMCIA attribute space access macros */
3798 +#define        OSL_PCMCIA_READ_ATTR(osh, offset, buf, size) \
3799 +       ASSERT(0)
3800 +#define        OSL_PCMCIA_WRITE_ATTR(osh, offset, buf, size) \
3801 +       ASSERT(0)
3802 +
3803 +/* PCI configuration space access macros */
3804 +#define        OSL_PCI_READ_CONFIG(loc, offset, size) \
3805 +       (offset == 8 ? 0 : 0xffffffff)
3806 +#define        OSL_PCI_WRITE_CONFIG(loc, offset, size, val) \
3807 +       do {} while (0)
3808 +
3809 +/* PCI device bus # and slot # */
3810 +#define OSL_PCI_BUS(osh)       (0)
3811 +#define OSL_PCI_SLOT(osh)      (0)
3812 +
3813 +/* register access macros */
3814 +#define wreg32(r, v)           (*(volatile uint32*)(r) = (uint32)(v))
3815 +#define rreg32(r)              (*(volatile uint32*)(r))
3816 +#define wreg16(r, v)           (*(volatile uint16*)(r) = (uint16)(v))
3817 +#define rreg16(r)              (*(volatile uint16*)(r))
3818 +#define wreg8(r, v)            (*(volatile uint8*)(r) = (uint8)(v))
3819 +#define rreg8(r)               (*(volatile uint8*)(r))
3820 +#define R_REG(r) ({ \
3821 +       __typeof(*(r)) __osl_v; \
3822 +       switch (sizeof(*(r))) { \
3823 +       case sizeof(uint8):     __osl_v = rreg8((r)); break; \
3824 +       case sizeof(uint16):    __osl_v = rreg16((r)); break; \
3825 +       case sizeof(uint32):    __osl_v = rreg32((r)); break; \
3826 +       } \
3827 +       __osl_v; \
3828 +})
3829 +#define W_REG(r, v) do { \
3830 +       switch (sizeof(*(r))) { \
3831 +       case sizeof(uint8):     wreg8((r), (v)); break; \
3832 +       case sizeof(uint16):    wreg16((r), (v)); break; \
3833 +       case sizeof(uint32):    wreg32((r), (v)); break; \
3834 +       } \
3835 +} while (0)
3836 +#define        AND_REG(r, v)           W_REG((r), R_REG(r) & (v))
3837 +#define        OR_REG(r, v)            W_REG((r), R_REG(r) | (v))
3838 +
3839 +/* general purpose memory allocation */
3840 +#define        MALLOC(osh, size)       malloc(size)
3841 +#define        MFREE(osh, addr, size)  free(addr)
3842 +#define        MALLOCED(osh)           0
3843 +#define        MALLOC_FAILED(osh)      0
3844 +#define        MALLOC_DUMP(osh, buf, sz)
3845 +extern int free(void *ptr);
3846 +extern void *malloc(uint size);
3847 +
3848 +/* uncached virtual address */
3849 +#define        OSL_UNCACHED(va)        ((void*)KSEG1ADDR((ulong)(va)))
3850 +
3851 +/* host/bus architecture-specific address byte swap */
3852 +#define BUS_SWAP32(v)          (v)
3853 +
3854 +/* microsecond delay */
3855 +#define        OSL_DELAY(usec)         udelay(usec)
3856 +extern void udelay(uint32 usec);
3857 +
3858 +/* map/unmap physical to virtual I/O */
3859 +#define        REG_MAP(pa, size)       ((void*)KSEG1ADDR((ulong)(pa)))
3860 +#define        REG_UNMAP(va)           do {} while (0)
3861 +
3862 +/* dereference an address that may cause a bus exception */
3863 +#define        BUSPROBE(val, addr)     (uint32 *)(addr) = (val)
3864 +
3865 +/* Misc stubs */
3866 +#define osl_attach(pdev)       ((osl_t*)pdev)
3867 +#define osl_detach(osh)
3868 +extern void *osl_init(void);
3869 +#define OSL_ERROR(bcmerror)    osl_error(bcmerror)
3870 +extern int osl_error(int);
3871 +
3872 +#endif /* _min_osl_h_ */
3873 diff -Nur linux-2.4.32/arch/mips/bcm947xx/include/mipsinc.h linux-2.4.32-brcm/arch/mips/bcm947xx/include/mipsinc.h
3874 --- linux-2.4.32/arch/mips/bcm947xx/include/mipsinc.h   1970-01-01 01:00:00.000000000 +0100
3875 +++ linux-2.4.32-brcm/arch/mips/bcm947xx/include/mipsinc.h      2005-12-16 23:39:10.748824500 +0100
3876 @@ -0,0 +1,552 @@
3877 +/*
3878 + * HND Run Time Environment for standalone MIPS programs.
3879 + *
3880 + * Copyright 2005, Broadcom Corporation
3881 + * All Rights Reserved.
3882 + *
3883 + * THIS SOFTWARE IS OFFERED "AS IS", AND BROADCOM GRANTS NO WARRANTIES OF ANY
3884 + * KIND, EXPRESS OR IMPLIED, BY STATUTE, COMMUNICATION OR OTHERWISE. BROADCOM
3885 + * SPECIFICALLY DISCLAIMS ANY IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS
3886 + * FOR A SPECIFIC PURPOSE OR NONINFRINGEMENT CONCERNING THIS SOFTWARE.
3887 + *
3888 + * $Id$
3889 + */
3890 +
3891 +#ifndef        _MISPINC_H
3892 +#define _MISPINC_H
3893 +
3894 +
3895 +/* MIPS defines */
3896 +
3897 +#ifdef _LANGUAGE_ASSEMBLY
3898 +
3899 +/*
3900 + * Symbolic register names for 32 bit ABI
3901 + */
3902 +#define zero   $0      /* wired zero */
3903 +#define AT     $1      /* assembler temp - uppercase because of ".set at" */
3904 +#define v0     $2      /* return value */
3905 +#define v1     $3
3906 +#define a0     $4      /* argument registers */
3907 +#define a1     $5
3908 +#define a2     $6
3909 +#define a3     $7
3910 +#define t0     $8      /* caller saved */
3911 +#define t1     $9
3912 +#define t2     $10
3913 +#define t3     $11
3914 +#define t4     $12
3915 +#define t5     $13
3916 +#define t6     $14
3917 +#define t7     $15
3918 +#define s0     $16     /* callee saved */
3919 +#define s1     $17
3920 +#define s2     $18
3921 +#define s3     $19
3922 +#define s4     $20
3923 +#define s5     $21
3924 +#define s6     $22
3925 +#define s7     $23
3926 +#define t8     $24     /* caller saved */
3927 +#define t9     $25
3928 +#define jp     $25     /* PIC jump register */
3929 +#define k0     $26     /* kernel scratch */
3930 +#define k1     $27
3931 +#define gp     $28     /* global pointer */
3932 +#define sp     $29     /* stack pointer */
3933 +#define fp     $30     /* frame pointer */
3934 +#define s8     $30     /* same like fp! */
3935 +#define ra     $31     /* return address */
3936 +
3937 +
3938 +/*
3939 + * CP0 Registers
3940 + */
3941 +
3942 +#define C0_INX         $0
3943 +#define C0_RAND                $1
3944 +#define C0_TLBLO0      $2
3945 +#define C0_TLBLO       C0_TLBLO0
3946 +#define C0_TLBLO1      $3
3947 +#define C0_CTEXT       $4
3948 +#define C0_PGMASK      $5
3949 +#define C0_WIRED       $6
3950 +#define C0_BADVADDR    $8
3951 +#define C0_COUNT       $9
3952 +#define C0_TLBHI       $10
3953 +#define C0_COMPARE     $11
3954 +#define C0_SR          $12
3955 +#define C0_STATUS      C0_SR
3956 +#define C0_CAUSE       $13
3957 +#define C0_EPC         $14
3958 +#define C0_PRID                $15
3959 +#define C0_CONFIG      $16
3960 +#define C0_LLADDR      $17
3961 +#define C0_WATCHLO     $18
3962 +#define C0_WATCHHI     $19
3963 +#define C0_XCTEXT      $20
3964 +#define C0_DIAGNOSTIC  $22
3965 +#define C0_BROADCOM    C0_DIAGNOSTIC
3966 +#define        C0_PERFORMANCE  $25
3967 +#define C0_ECC         $26
3968 +#define C0_CACHEERR    $27
3969 +#define C0_TAGLO       $28
3970 +#define C0_TAGHI       $29
3971 +#define C0_ERREPC      $30
3972 +#define C0_DESAVE      $31
3973 +
3974 +/*
3975 + * LEAF - declare leaf routine
3976 + */
3977 +#define LEAF(symbol)                           \
3978 +               .globl  symbol;                 \
3979 +               .align  2;                      \
3980 +               .type   symbol,@function;       \
3981 +               .ent    symbol,0;               \
3982 +symbol:                .frame  sp,0,ra
3983 +
3984 +/*
3985 + * END - mark end of function
3986 + */
3987 +#define END(function)                          \
3988 +               .end    function;               \
3989 +               .size   function,.-function
3990 +
3991 +#define _ULCAST_
3992 +
3993 +#else
3994 +
3995 +/*
3996 + * The following macros are especially useful for __asm__
3997 + * inline assembler.
3998 + */
3999 +#ifndef __STR
4000 +#define __STR(x) #x
4001 +#endif
4002 +#ifndef STR
4003 +#define STR(x) __STR(x)
4004 +#endif
4005 +
4006 +#define _ULCAST_ (unsigned long)
4007 +
4008 +
4009 +/*
4010 + * CP0 Registers
4011 + */
4012 +
4013 +#define C0_INX         0               /* CP0: TLB Index */
4014 +#define C0_RAND                1               /* CP0: TLB Random */
4015 +#define C0_TLBLO0      2               /* CP0: TLB EntryLo0 */
4016 +#define C0_TLBLO       C0_TLBLO0       /* CP0: TLB EntryLo0 */
4017 +#define C0_TLBLO1      3               /* CP0: TLB EntryLo1 */
4018 +#define C0_CTEXT       4               /* CP0: Context */
4019 +#define C0_PGMASK      5               /* CP0: TLB PageMask */
4020 +#define C0_WIRED       6               /* CP0: TLB Wired */
4021 +#define C0_BADVADDR    8               /* CP0: Bad Virtual Address */
4022 +#define C0_COUNT       9               /* CP0: Count */
4023 +#define C0_TLBHI       10              /* CP0: TLB EntryHi */
4024 +#define C0_COMPARE     11              /* CP0: Compare */
4025 +#define C0_SR          12              /* CP0: Processor Status */
4026 +#define C0_STATUS      C0_SR           /* CP0: Processor Status */
4027 +#define C0_CAUSE       13              /* CP0: Exception Cause */
4028 +#define C0_EPC         14              /* CP0: Exception PC */
4029 +#define C0_PRID                15              /* CP0: Processor Revision Indentifier */
4030 +#define C0_CONFIG      16              /* CP0: Config */
4031 +#define C0_LLADDR      17              /* CP0: LLAddr */
4032 +#define C0_WATCHLO     18              /* CP0: WatchpointLo */
4033 +#define C0_WATCHHI     19              /* CP0: WatchpointHi */
4034 +#define C0_XCTEXT      20              /* CP0: XContext */
4035 +#define C0_DIAGNOSTIC  22              /* CP0: Diagnostic */
4036 +#define C0_BROADCOM    C0_DIAGNOSTIC   /* CP0: Broadcom Register */
4037 +#define        C0_PERFORMANCE  25              /* CP0: Performance Counter/Control Registers */
4038 +#define C0_ECC         26              /* CP0: ECC */
4039 +#define C0_CACHEERR    27              /* CP0: CacheErr */
4040 +#define C0_TAGLO       28              /* CP0: TagLo */
4041 +#define C0_TAGHI       29              /* CP0: TagHi */
4042 +#define C0_ERREPC      30              /* CP0: ErrorEPC */
4043 +#define C0_DESAVE      31              /* CP0: DebugSave */
4044 +
4045 +#endif /* _LANGUAGE_ASSEMBLY */
4046 +
4047 +/*
4048 + * Memory segments (32bit kernel mode addresses)
4049 + */
4050 +#undef KUSEG
4051 +#undef KSEG0
4052 +#undef KSEG1
4053 +#undef KSEG2
4054 +#undef KSEG3
4055 +#define KUSEG          0x00000000
4056 +#define KSEG0          0x80000000
4057 +#define KSEG1          0xa0000000
4058 +#define KSEG2          0xc0000000
4059 +#define KSEG3          0xe0000000
4060 +#define PHYSADDR_MASK  0x1fffffff
4061 +
4062 +/*
4063 + * Map an address to a certain kernel segment
4064 + */
4065 +#undef PHYSADDR
4066 +#undef KSEG0ADDR
4067 +#undef KSEG1ADDR
4068 +#undef KSEG2ADDR
4069 +#undef KSEG3ADDR
4070 +
4071 +#define PHYSADDR(a)    (_ULCAST_(a) & PHYSADDR_MASK)
4072 +#define KSEG0ADDR(a)   ((_ULCAST_(a) & PHYSADDR_MASK) | KSEG0)
4073 +#define KSEG1ADDR(a)   ((_ULCAST_(a) & PHYSADDR_MASK) | KSEG1)
4074 +#define KSEG2ADDR(a)   ((_ULCAST_(a) & PHYSADDR_MASK) | KSEG2)
4075 +#define KSEG3ADDR(a)   ((_ULCAST_(a) & PHYSADDR_MASK) | KSEG3)
4076 +
4077 +
4078 +#ifndef        Index_Invalidate_I
4079 +/*
4080 + * Cache Operations
4081 + */
4082 +#define Index_Invalidate_I     0x00
4083 +#define Index_Writeback_Inv_D  0x01
4084 +#define Index_Invalidate_SI    0x02
4085 +#define Index_Writeback_Inv_SD 0x03
4086 +#define Index_Load_Tag_I       0x04
4087 +#define Index_Load_Tag_D       0x05
4088 +#define Index_Load_Tag_SI      0x06
4089 +#define Index_Load_Tag_SD      0x07
4090 +#define Index_Store_Tag_I      0x08
4091 +#define Index_Store_Tag_D      0x09
4092 +#define Index_Store_Tag_SI     0x0A
4093 +#define Index_Store_Tag_SD     0x0B
4094 +#define Create_Dirty_Excl_D    0x0d
4095 +#define Create_Dirty_Excl_SD   0x0f
4096 +#define Hit_Invalidate_I       0x10
4097 +#define Hit_Invalidate_D       0x11
4098 +#define Hit_Invalidate_SI      0x12
4099 +#define Hit_Invalidate_SD      0x13
4100 +#define Fill_I                 0x14
4101 +#define Hit_Writeback_Inv_D    0x15
4102 +                                       /* 0x16 is unused */
4103 +#define Hit_Writeback_Inv_SD   0x17
4104 +#define R5K_Page_Invalidate_S  0x17
4105 +#define Hit_Writeback_I                0x18
4106 +#define Hit_Writeback_D                0x19
4107 +                                       /* 0x1a is unused */
4108 +#define Hit_Writeback_SD       0x1b
4109 +                                       /* 0x1c is unused */
4110 +                                       /* 0x1e is unused */
4111 +#define Hit_Set_Virtual_SI     0x1e
4112 +#define Hit_Set_Virtual_SD     0x1f
4113 +#endif
4114 +
4115 +
4116 +/*
4117 + * R4x00 interrupt enable / cause bits
4118 + */
4119 +#define IE_SW0                 (_ULCAST_(1) <<  8)
4120 +#define IE_SW1                 (_ULCAST_(1) <<  9)
4121 +#define IE_IRQ0                        (_ULCAST_(1) << 10)
4122 +#define IE_IRQ1                        (_ULCAST_(1) << 11)
4123 +#define IE_IRQ2                        (_ULCAST_(1) << 12)
4124 +#define IE_IRQ3                        (_ULCAST_(1) << 13)
4125 +#define IE_IRQ4                        (_ULCAST_(1) << 14)
4126 +#define IE_IRQ5                        (_ULCAST_(1) << 15)
4127 +
4128 +#ifndef        ST0_UM
4129 +/*
4130 + * Bitfields in the mips32 cp0 status register
4131 + */
4132 +#define ST0_IE                 0x00000001
4133 +#define ST0_EXL                        0x00000002
4134 +#define ST0_ERL                        0x00000004
4135 +#define ST0_UM                 0x00000010
4136 +#define ST0_SWINT0             0x00000100
4137 +#define ST0_SWINT1             0x00000200
4138 +#define ST0_HWINT0             0x00000400
4139 +#define ST0_HWINT1             0x00000800
4140 +#define ST0_HWINT2             0x00001000
4141 +#define ST0_HWINT3             0x00002000
4142 +#define ST0_HWINT4             0x00004000
4143 +#define ST0_HWINT5             0x00008000
4144 +#define ST0_IM                 0x0000ff00
4145 +#define ST0_NMI                        0x00080000
4146 +#define ST0_SR                 0x00100000
4147 +#define ST0_TS                 0x00200000
4148 +#define ST0_BEV                        0x00400000
4149 +#define ST0_RE                 0x02000000
4150 +#define ST0_RP                 0x08000000
4151 +#define ST0_CU                 0xf0000000
4152 +#define ST0_CU0                        0x10000000
4153 +#define ST0_CU1                        0x20000000
4154 +#define ST0_CU2                        0x40000000
4155 +#define ST0_CU3                        0x80000000
4156 +#endif
4157 +
4158 +
4159 +/*
4160 + * Bitfields in the mips32 cp0 cause register
4161 + */
4162 +#define C_EXC                  0x0000007c
4163 +#define C_EXC_SHIFT            2
4164 +#define C_INT                  0x0000ff00
4165 +#define C_INT_SHIFT            8
4166 +#define C_SW0                  (_ULCAST_(1) <<  8)
4167 +#define C_SW1                  (_ULCAST_(1) <<  9)
4168 +#define C_IRQ0                 (_ULCAST_(1) << 10)
4169 +#define C_IRQ1                 (_ULCAST_(1) << 11)
4170 +#define C_IRQ2                 (_ULCAST_(1) << 12)
4171 +#define C_IRQ3                 (_ULCAST_(1) << 13)
4172 +#define C_IRQ4                 (_ULCAST_(1) << 14)
4173 +#define C_IRQ5                 (_ULCAST_(1) << 15)
4174 +#define C_WP                   0x00400000
4175 +#define C_IV                   0x00800000
4176 +#define C_CE                   0x30000000
4177 +#define C_CE_SHIFT             28
4178 +#define C_BD                   0x80000000
4179 +
4180 +/* Values in C_EXC */
4181 +#define EXC_INT                        0
4182 +#define EXC_TLBM               1
4183 +#define EXC_TLBL               2
4184 +#define EXC_TLBS               3
4185 +#define EXC_AEL                        4
4186 +#define EXC_AES                        5
4187 +#define EXC_IBE                        6
4188 +#define EXC_DBE                        7
4189 +#define EXC_SYS                        8
4190 +#define EXC_BPT                        9
4191 +#define EXC_RI                 10
4192 +#define EXC_CU                 11
4193 +#define EXC_OV                 12
4194 +#define EXC_TR                 13
4195 +#define EXC_WATCH              23
4196 +#define EXC_MCHK               24
4197 +
4198 +
4199 +/*
4200 + * Bits in the cp0 config register.
4201 + */
4202 +#define CONF_CM_CACHABLE_NO_WA         0
4203 +#define CONF_CM_CACHABLE_WA            1
4204 +#define CONF_CM_UNCACHED               2
4205 +#define CONF_CM_CACHABLE_NONCOHERENT   3
4206 +#define CONF_CM_CACHABLE_CE            4
4207 +#define CONF_CM_CACHABLE_COW           5
4208 +#define CONF_CM_CACHABLE_CUW           6
4209 +#define CONF_CM_CACHABLE_ACCELERATED   7
4210 +#define CONF_CM_CMASK                  7
4211 +#define CONF_CU                                (_ULCAST_(1) <<  3)
4212 +#define CONF_DB                                (_ULCAST_(1) <<  4)
4213 +#define CONF_IB                                (_ULCAST_(1) <<  5)
4214 +#define CONF_SE                                (_ULCAST_(1) << 12)
4215 +#define CONF_SC                                (_ULCAST_(1) << 17)
4216 +#define CONF_AC                                (_ULCAST_(1) << 23)
4217 +#define CONF_HALT                      (_ULCAST_(1) << 25)
4218 +
4219 +
4220 +/*
4221 + * Bits in the cp0 config register select 1.
4222 + */
4223 +#define CONF1_FP               0x00000001      /* FPU present */
4224 +#define CONF1_EP               0x00000002      /* EJTAG present */
4225 +#define CONF1_CA               0x00000004      /* mips16 implemented */
4226 +#define CONF1_WR               0x00000008      /* Watch registers present */
4227 +#define CONF1_PC               0x00000010      /* Performance counters present */
4228 +#define CONF1_DA_SHIFT         7               /* D$ associativity */
4229 +#define CONF1_DA_MASK          0x00000380
4230 +#define CONF1_DA_BASE          1
4231 +#define CONF1_DL_SHIFT         10              /* D$ line size */
4232 +#define CONF1_DL_MASK          0x00001c00
4233 +#define CONF1_DL_BASE          2
4234 +#define CONF1_DS_SHIFT         13              /* D$ sets/way */
4235 +#define CONF1_DS_MASK          0x0000e000
4236 +#define CONF1_DS_BASE          64
4237 +#define CONF1_IA_SHIFT         16              /* I$ associativity */
4238 +#define CONF1_IA_MASK          0x00070000
4239 +#define CONF1_IA_BASE          1
4240 +#define CONF1_IL_SHIFT         19              /* I$ line size */
4241 +#define CONF1_IL_MASK          0x00380000
4242 +#define CONF1_IL_BASE          2
4243 +#define CONF1_IS_SHIFT         22              /* Instruction cache sets/way */
4244 +#define CONF1_IS_MASK          0x01c00000
4245 +#define CONF1_IS_BASE          64
4246 +#define CONF1_MS_MASK          0x7e000000      /* Number of tlb entries */
4247 +#define CONF1_MS_SHIFT         25
4248 +
4249 +/* PRID register */
4250 +#define PRID_COPT_MASK         0xff000000
4251 +#define PRID_COMP_MASK         0x00ff0000
4252 +#define PRID_IMP_MASK          0x0000ff00
4253 +#define PRID_REV_MASK          0x000000ff
4254 +
4255 +#define PRID_COMP_LEGACY       0x000000
4256 +#define PRID_COMP_MIPS         0x010000
4257 +#define PRID_COMP_BROADCOM     0x020000
4258 +#define PRID_COMP_ALCHEMY      0x030000
4259 +#define PRID_COMP_SIBYTE       0x040000
4260 +#define PRID_IMP_BCM4710       0x4000
4261 +#define PRID_IMP_BCM3302       0x9000
4262 +#define PRID_IMP_BCM3303       0x9100
4263 +
4264 +#define PRID_IMP_UNKNOWN       0xff00
4265 +
4266 +#define BCM330X(id) \
4267 +       (((id & (PRID_COMP_MASK | PRID_IMP_MASK)) == (PRID_COMP_BROADCOM | PRID_IMP_BCM3302)) \
4268 +       || ((id & (PRID_COMP_MASK | PRID_IMP_MASK)) == (PRID_COMP_BROADCOM | PRID_IMP_BCM3303)))
4269 +
4270 +/* Bits in C0_BROADCOM */
4271 +#define BRCM_PFC_AVAIL         0x20000000      /* PFC is available */
4272 +#define BRCM_DC_ENABLE         0x40000000      /* Enable Data $ */
4273 +#define BRCM_IC_ENABLE         0x80000000      /* Enable Instruction $ */
4274 +#define BRCM_PFC_ENABLE                0x00400000      /* Obsolete? Enable PFC (at least on 4310) */
4275 +
4276 +/* PreFetch Cache aka Read Ahead Cache */
4277 +
4278 +#define PFC_CR0                        0xff400000      /* control reg 0 */
4279 +#define PFC_CR1                        0xff400004      /* control reg 1 */
4280 +
4281 +/* PFC operations */
4282 +#define PFC_I                  0x00000001      /* Enable PFC use for instructions */
4283 +#define PFC_D                  0x00000002      /* Enable PFC use for data */
4284 +#define PFC_PFI                        0x00000004      /* Enable seq. prefetch for instructions */
4285 +#define PFC_PFD                        0x00000008      /* Enable seq. prefetch for data */
4286 +#define PFC_CINV               0x00000010      /* Enable selective (i/d) cacheop flushing */
4287 +#define PFC_NCH                        0x00000020      /* Disable flushing based on cacheops */
4288 +#define PFC_DPF                        0x00000040      /* Enable directional prefetching */
4289 +#define PFC_FLUSH              0x00000100      /* Flush the PFC */
4290 +#define PFC_BRR                        0x40000000      /* Bus error indication */
4291 +#define PFC_PWR                        0x80000000      /* Disable power saving (clock gating) */
4292 +
4293 +/* Handy defaults */
4294 +#define PFC_DISABLED           0
4295 +#define PFC_AUTO                       0xffffffff      /* auto select the default mode */
4296 +#define PFC_INST               (PFC_I | PFC_PFI | PFC_CINV)
4297 +#define PFC_INST_NOPF          (PFC_I | PFC_CINV)
4298 +#define PFC_DATA               (PFC_D | PFC_PFD | PFC_CINV)
4299 +#define PFC_DATA_NOPF          (PFC_D | PFC_CINV)
4300 +#define PFC_I_AND_D            (PFC_INST | PFC_DATA)
4301 +#define PFC_I_AND_D_NOPF       (PFC_INST_NOPF | PFC_DATA_NOPF)
4302 +
4303 +
4304 +/*
4305 + * These are the UART port assignments, expressed as offsets from the base
4306 + * register.  These assignments should hold for any serial port based on
4307 + * a 8250, 16450, or 16550(A).
4308 + */
4309 +
4310 +#define UART_RX                0       /* In:  Receive buffer (DLAB=0) */
4311 +#define UART_TX                0       /* Out: Transmit buffer (DLAB=0) */
4312 +#define UART_DLL       0       /* Out: Divisor Latch Low (DLAB=1) */
4313 +#define UART_DLM       1       /* Out: Divisor Latch High (DLAB=1) */
4314 +#define UART_LCR       3       /* Out: Line Control Register */
4315 +#define UART_MCR       4       /* Out: Modem Control Register */
4316 +#define UART_LSR       5       /* In:  Line Status Register */
4317 +#define UART_MSR       6       /* In:  Modem Status Register */
4318 +#define UART_SCR       7       /* I/O: Scratch Register */
4319 +#define UART_LCR_DLAB  0x80    /* Divisor latch access bit */
4320 +#define UART_LCR_WLEN8 0x03    /* Wordlength: 8 bits */
4321 +#define UART_MCR_LOOP  0x10    /* Enable loopback test mode */
4322 +#define UART_LSR_THRE  0x20    /* Transmit-hold-register empty */
4323 +#define UART_LSR_RXRDY 0x01    /* Receiver ready */
4324 +
4325 +
4326 +#ifndef        _LANGUAGE_ASSEMBLY
4327 +
4328 +/*
4329 + * Macros to access the system control coprocessor
4330 + */
4331 +
4332 +#define MFC0(source, sel)                                      \
4333 +({                                                             \
4334 +       int __res;                                              \
4335 +       __asm__ __volatile__(                                   \
4336 +       ".set\tnoreorder\n\t"                                   \
4337 +       ".set\tnoat\n\t"                                        \
4338 +       ".word\t"STR(0x40010000 | ((source)<<11) | (sel))"\n\t" \
4339 +       "move\t%0,$1\n\t"                                       \
4340 +       ".set\tat\n\t"                                          \
4341 +       ".set\treorder"                                         \
4342 +       :"=r" (__res)                                           \
4343 +       :                                                       \
4344 +       :"$1");                                                 \
4345 +       __res;                                                  \
4346 +})
4347 +
4348 +#define MTC0(source, sel, value)                               \
4349 +do {                                                           \
4350 +       __asm__ __volatile__(                                   \
4351 +       ".set\tnoreorder\n\t"                                   \
4352 +       ".set\tnoat\n\t"                                        \
4353 +       "move\t$1,%z0\n\t"                                      \
4354 +       ".word\t"STR(0x40810000 | ((source)<<11) | (sel))"\n\t" \
4355 +       ".set\tat\n\t"                                          \
4356 +       ".set\treorder"                                         \
4357 +       :                                                       \
4358 +       :"jr" (value)                                           \
4359 +       :"$1");                                                 \
4360 +} while (0)
4361 +
4362 +#define get_c0_count()                                         \
4363 +({                                                             \
4364 +       int __res;                                              \
4365 +       __asm__ __volatile__(                                   \
4366 +       ".set\tnoreorder\n\t"                                   \
4367 +       ".set\tnoat\n\t"                                        \
4368 +       "mfc0\t%0,$9\n\t"                                       \
4369 +       ".set\tat\n\t"                                          \
4370 +       ".set\treorder"                                         \
4371 +       :"=r" (__res));                                         \
4372 +       __res;                                                  \
4373 +})
4374 +
4375 +static INLINE void icache_probe(uint32 config1, uint *size, uint *lsize)
4376 +{
4377 +       uint lsz, sets, ways;
4378 +
4379 +       /* Instruction Cache Size = Associativity * Line Size * Sets Per Way */
4380 +       if ((lsz = ((config1 & CONF1_IL_MASK) >> CONF1_IL_SHIFT)))
4381 +               lsz = CONF1_IL_BASE << lsz;
4382 +       sets = CONF1_IS_BASE << ((config1 & CONF1_IS_MASK) >> CONF1_IS_SHIFT);
4383 +       ways = CONF1_IA_BASE + ((config1 & CONF1_IA_MASK) >> CONF1_IA_SHIFT);
4384 +       *size = lsz * sets * ways;
4385 +       *lsize = lsz;
4386 +}
4387 +
4388 +static INLINE void dcache_probe(uint32 config1, uint *size, uint *lsize)
4389 +{
4390 +       uint lsz, sets, ways;
4391 +
4392 +       /* Data Cache Size = Associativity * Line Size * Sets Per Way */
4393 +       if ((lsz = ((config1 & CONF1_DL_MASK) >> CONF1_DL_SHIFT)))
4394 +               lsz = CONF1_DL_BASE << lsz;
4395 +       sets = CONF1_DS_BASE << ((config1 & CONF1_DS_MASK) >> CONF1_DS_SHIFT);
4396 +       ways = CONF1_DA_BASE + ((config1 & CONF1_DA_MASK) >> CONF1_DA_SHIFT);
4397 +       *size = lsz * sets * ways;
4398 +       *lsize = lsz;
4399 +}
4400 +
4401 +#define cache_op(base, op)                     \
4402 +       __asm__ __volatile__("                  \
4403 +               .set noreorder;                 \
4404 +               .set mips3;                     \
4405 +               cache %1, (%0);                 \
4406 +               .set mips0;                     \
4407 +               .set reorder"                   \
4408 +               :                               \
4409 +               : "r" (base),                   \
4410 +                 "i" (op));
4411 +
4412 +#define cache_unroll4(base, delta, op)         \
4413 +       __asm__ __volatile__("                  \
4414 +               .set noreorder;                 \
4415 +               .set mips3;                     \
4416 +               cache %1,0(%0);                 \
4417 +               cache %1,delta(%0);             \
4418 +               cache %1,(2 * delta)(%0);       \
4419 +               cache %1,(3 * delta)(%0);       \
4420 +               .set mips0;                     \
4421 +               .set reorder"                   \
4422 +               :                               \
4423 +               : "r" (base),                   \
4424 +                 "i" (op));
4425 +
4426 +#endif /* !_LANGUAGE_ASSEMBLY */
4427 +
4428 +#endif /* _MISPINC_H */
4429 diff -Nur linux-2.4.32/arch/mips/bcm947xx/include/nvports.h linux-2.4.32-brcm/arch/mips/bcm947xx/include/nvports.h
4430 --- linux-2.4.32/arch/mips/bcm947xx/include/nvports.h   1970-01-01 01:00:00.000000000 +0100
4431 +++ linux-2.4.32-brcm/arch/mips/bcm947xx/include/nvports.h      2005-12-16 23:39:10.748824500 +0100
4432 @@ -0,0 +1,55 @@
4433 +/*
4434 + * BCM53xx RoboSwitch utility functions
4435 + *
4436 + * Copyright (C) 2002 Broadcom Corporation
4437 + * $Id$
4438 + */
4439 +
4440 +#ifndef _nvports_h_
4441 +#define _nvports_h_
4442 +
4443 +#define uint32 unsigned long
4444 +#define uint16 unsigned short
4445 +#define uint unsigned int
4446 +#define uint8 unsigned char
4447 +#define uint64 unsigned long long
4448 +
4449 +enum FORCE_PORT {
4450 +       FORCE_OFF,
4451 +       FORCE_10H,
4452 +       FORCE_10F,
4453 +       FORCE_100H,
4454 +       FORCE_100F,
4455 +       FORCE_DOWN,
4456 +       POWER_OFF
4457 +};
4458 +
4459 +typedef struct _PORT_ATTRIBS
4460 +{
4461 +       uint    autoneg;
4462 +       uint    force;
4463 +       uint    native;
4464 +} PORT_ATTRIBS;
4465 +
4466 +extern uint
4467 +nvExistsPortAttrib(char *attrib, uint portno);
4468 +
4469 +extern int
4470 +nvExistsAnyForcePortAttrib(uint portno);
4471 +
4472 +extern void
4473 +nvSetPortAttrib(char *attrib, uint portno);
4474 +
4475 +extern void
4476 +nvUnsetPortAttrib(char *attrib, uint portno);
4477 +
4478 +extern void
4479 +nvUnsetAllForcePortAttrib(uint portno);
4480 +
4481 +extern PORT_ATTRIBS
4482 +nvGetSwitchPortAttribs(uint portno);
4483 +
4484 +#endif /* _nvports_h_ */
4485 +
4486 +
4487 +
4488 diff -Nur linux-2.4.32/arch/mips/bcm947xx/include/osl.h linux-2.4.32-brcm/arch/mips/bcm947xx/include/osl.h
4489 --- linux-2.4.32/arch/mips/bcm947xx/include/osl.h       1970-01-01 01:00:00.000000000 +0100
4490 +++ linux-2.4.32-brcm/arch/mips/bcm947xx/include/osl.h  2005-12-16 23:39:10.748824500 +0100
4491 @@ -0,0 +1,42 @@
4492 +/*
4493 + * OS Abstraction Layer
4494 + *
4495 + * Copyright 2005, Broadcom Corporation
4496 + * All Rights Reserved.
4497 + *
4498 + * THIS SOFTWARE IS OFFERED "AS IS", AND BROADCOM GRANTS NO WARRANTIES OF ANY
4499 + * KIND, EXPRESS OR IMPLIED, BY STATUTE, COMMUNICATION OR OTHERWISE. BROADCOM
4500 + * SPECIFICALLY DISCLAIMS ANY IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS
4501 + * FOR A SPECIFIC PURPOSE OR NONINFRINGEMENT CONCERNING THIS SOFTWARE.
4502 + * $Id$
4503 + */
4504 +
4505 +#ifndef _osl_h_
4506 +#define _osl_h_
4507 +
4508 +/* osl handle type forward declaration */
4509 +typedef struct os_handle osl_t;
4510 +
4511 +#if defined(linux)
4512 +#include <linux_osl.h>
4513 +#elif defined(NDIS)
4514 +#include <ndis_osl.h>
4515 +#elif defined(_CFE_)
4516 +#include <cfe_osl.h>
4517 +#elif defined(_HNDRTE_)
4518 +#include <hndrte_osl.h>
4519 +#elif defined(_MINOSL_)
4520 +#include <min_osl.h>
4521 +#elif PMON
4522 +#include <pmon_osl.h>
4523 +#elif defined(MACOSX)
4524 +#include <macosx_osl.h>
4525 +#else
4526 +#error "Unsupported OSL requested"
4527 +#endif
4528 +
4529 +/* handy */
4530 +#define        SET_REG(r, mask, val)   W_REG((r), ((R_REG(r) & ~(mask)) | (val)))
4531 +#define        MAXPRIO         7       /* 0-7 */
4532 +
4533 +#endif /* _osl_h_ */
4534 diff -Nur linux-2.4.32/arch/mips/bcm947xx/include/pcicfg.h linux-2.4.32-brcm/arch/mips/bcm947xx/include/pcicfg.h
4535 --- linux-2.4.32/arch/mips/bcm947xx/include/pcicfg.h    1970-01-01 01:00:00.000000000 +0100
4536 +++ linux-2.4.32-brcm/arch/mips/bcm947xx/include/pcicfg.h       2005-12-16 23:39:10.752824750 +0100
4537 @@ -0,0 +1,451 @@
4538 +/*
4539 + * pcicfg.h: PCI configuration  constants and structures.
4540 + *
4541 + * Copyright 2005, Broadcom Corporation
4542 + * All Rights Reserved.
4543 + *
4544 + * THIS SOFTWARE IS OFFERED "AS IS", AND BROADCOM GRANTS NO WARRANTIES OF ANY
4545 + * KIND, EXPRESS OR IMPLIED, BY STATUTE, COMMUNICATION OR OTHERWISE. BROADCOM
4546 + * SPECIFICALLY DISCLAIMS ANY IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS
4547 + * FOR A SPECIFIC PURPOSE OR NONINFRINGEMENT CONCERNING THIS SOFTWARE.
4548 + *
4549 + * $Id$
4550 + */
4551 +
4552 +#ifndef        _h_pci_
4553 +#define        _h_pci_
4554 +
4555 +/* The following inside ifndef's so we don't collide with NTDDK.H */
4556 +#ifndef PCI_MAX_BUS
4557 +#define PCI_MAX_BUS            0x100
4558 +#endif
4559 +#ifndef PCI_MAX_DEVICES
4560 +#define PCI_MAX_DEVICES                0x20
4561 +#endif
4562 +#ifndef PCI_MAX_FUNCTION
4563 +#define PCI_MAX_FUNCTION       0x8
4564 +#endif
4565 +
4566 +#ifndef PCI_INVALID_VENDORID
4567 +#define PCI_INVALID_VENDORID   0xffff
4568 +#endif
4569 +#ifndef PCI_INVALID_DEVICEID
4570 +#define PCI_INVALID_DEVICEID   0xffff
4571 +#endif
4572 +
4573 +
4574 +/* Convert between bus-slot-function-register and config addresses */
4575 +
4576 +#define        PCICFG_BUS_SHIFT        16      /* Bus shift */
4577 +#define        PCICFG_SLOT_SHIFT       11      /* Slot shift */
4578 +#define        PCICFG_FUN_SHIFT        8       /* Function shift */
4579 +#define        PCICFG_OFF_SHIFT        0       /* Register shift */
4580 +
4581 +#define        PCICFG_BUS_MASK         0xff    /* Bus mask */
4582 +#define        PCICFG_SLOT_MASK        0x1f    /* Slot mask */
4583 +#define        PCICFG_FUN_MASK         7       /* Function mask */
4584 +#define        PCICFG_OFF_MASK         0xff    /* Bus mask */
4585 +
4586 +#define        PCI_CONFIG_ADDR(b, s, f, o)                                     \
4587 +               ((((b) & PCICFG_BUS_MASK) << PCICFG_BUS_SHIFT)          \
4588 +                | (((s) & PCICFG_SLOT_MASK) << PCICFG_SLOT_SHIFT)      \
4589 +                | (((f) & PCICFG_FUN_MASK) << PCICFG_FUN_SHIFT)        \
4590 +                | (((o) & PCICFG_OFF_MASK) << PCICFG_OFF_SHIFT))
4591 +
4592 +#define        PCI_CONFIG_BUS(a)       (((a) >> PCICFG_BUS_SHIFT) & PCICFG_BUS_MASK)
4593 +#define        PCI_CONFIG_SLOT(a)      (((a) >> PCICFG_SLOT_SHIFT) & PCICFG_SLOT_MASK)
4594 +#define        PCI_CONFIG_FUN(a)       (((a) >> PCICFG_FUN_SHIFT) & PCICFG_FUN_MASK)
4595 +#define        PCI_CONFIG_OFF(a)       (((a) >> PCICFG_OFF_SHIFT) & PCICFG_OFF_MASK)
4596 +
4597 +/* PCIE Config space accessing MACROS*/
4598 +
4599 +#define        PCIECFG_BUS_SHIFT       24      /* Bus shift */
4600 +#define        PCIECFG_SLOT_SHIFT      19      /* Slot/Device shift */
4601 +#define        PCIECFG_FUN_SHIFT       16      /* Function shift */
4602 +#define        PCIECFG_OFF_SHIFT       0       /* Register shift */
4603 +
4604 +#define        PCIECFG_BUS_MASK        0xff    /* Bus mask */
4605 +#define        PCIECFG_SLOT_MASK       0x1f    /* Slot/Device mask */
4606 +#define        PCIECFG_FUN_MASK        7       /* Function mask */
4607 +#define        PCIECFG_OFF_MASK        0x3ff   /* Register mask */
4608 +
4609 +#define        PCIE_CONFIG_ADDR(b, s, f, o)                                    \
4610 +               ((((b) & PCIECFG_BUS_MASK) << PCIECFG_BUS_SHIFT)                \
4611 +                | (((s) & PCIECFG_SLOT_MASK) << PCIECFG_SLOT_SHIFT)    \
4612 +                | (((f) & PCIECFG_FUN_MASK) << PCIECFG_FUN_SHIFT)      \
4613 +                | (((o) & PCIECFG_OFF_MASK) << PCIECFG_OFF_SHIFT))
4614 +
4615 +#define        PCIE_CONFIG_BUS(a)      (((a) >> PCIECFG_BUS_SHIFT) & PCIECFG_BUS_MASK)
4616 +#define        PCIE_CONFIG_SLOT(a)     (((a) >> PCIECFG_SLOT_SHIFT) & PCIECFG_SLOT_MASK)
4617 +#define        PCIE_CONFIG_FUN(a)      (((a) >> PCIECFG_FUN_SHIFT) & PCIECFG_FUN_MASK)
4618 +#define        PCIE_CONFIG_OFF(a)      (((a) >> PCIECFG_OFF_SHIFT) & PCIECFG_OFF_MASK)
4619 +
4620 +
4621 +/* The actual config space */
4622 +
4623 +#define        PCI_BAR_MAX             6
4624 +
4625 +#define        PCI_ROM_BAR             8
4626 +
4627 +#define        PCR_RSVDA_MAX           2
4628 +
4629 +/* pci config status reg has a bit to indicate that capability ptr is present*/
4630 +
4631 +#define PCI_CAPPTR_PRESENT     0x0010
4632 +
4633 +typedef struct _pci_config_regs {
4634 +    unsigned short     vendor;
4635 +    unsigned short     device;
4636 +    unsigned short     command;
4637 +    unsigned short     status;
4638 +    unsigned char      rev_id;
4639 +    unsigned char      prog_if;
4640 +    unsigned char      sub_class;
4641 +    unsigned char      base_class;
4642 +    unsigned char      cache_line_size;
4643 +    unsigned char      latency_timer;
4644 +    unsigned char      header_type;
4645 +    unsigned char      bist;
4646 +    unsigned long      base[PCI_BAR_MAX];
4647 +    unsigned long      cardbus_cis;
4648 +    unsigned short     subsys_vendor;
4649 +    unsigned short     subsys_id;
4650 +    unsigned long      baserom;
4651 +    unsigned long      rsvd_a[PCR_RSVDA_MAX];
4652 +    unsigned char      int_line;
4653 +    unsigned char      int_pin;
4654 +    unsigned char      min_gnt;
4655 +    unsigned char      max_lat;
4656 +    unsigned char      dev_dep[192];
4657 +} pci_config_regs;
4658 +
4659 +#define        SZPCR           (sizeof (pci_config_regs))
4660 +#define        MINSZPCR        64              /* offsetof (dev_dep[0] */
4661 +
4662 +/* A structure for the config registers is nice, but in most
4663 + * systems the config space is not memory mapped, so we need
4664 + * filed offsetts. :-(
4665 + */
4666 +#define        PCI_CFG_VID             0
4667 +#define        PCI_CFG_DID             2
4668 +#define        PCI_CFG_CMD             4
4669 +#define        PCI_CFG_STAT            6
4670 +#define        PCI_CFG_REV             8
4671 +#define        PCI_CFG_PROGIF          9
4672 +#define        PCI_CFG_SUBCL           0xa
4673 +#define        PCI_CFG_BASECL          0xb
4674 +#define        PCI_CFG_CLSZ            0xc
4675 +#define        PCI_CFG_LATTIM          0xd
4676 +#define        PCI_CFG_HDR             0xe
4677 +#define        PCI_CFG_BIST            0xf
4678 +#define        PCI_CFG_BAR0            0x10
4679 +#define        PCI_CFG_BAR1            0x14
4680 +#define        PCI_CFG_BAR2            0x18
4681 +#define        PCI_CFG_BAR3            0x1c
4682 +#define        PCI_CFG_BAR4            0x20
4683 +#define        PCI_CFG_BAR5            0x24
4684 +#define        PCI_CFG_CIS             0x28
4685 +#define        PCI_CFG_SVID            0x2c
4686 +#define        PCI_CFG_SSID            0x2e
4687 +#define        PCI_CFG_ROMBAR          0x30
4688 +#define PCI_CFG_CAPPTR         0x34
4689 +#define        PCI_CFG_INT             0x3c
4690 +#define        PCI_CFG_PIN             0x3d
4691 +#define        PCI_CFG_MINGNT          0x3e
4692 +#define        PCI_CFG_MAXLAT          0x3f
4693 +
4694 +/* Classes and subclasses */
4695 +
4696 +typedef enum {
4697 +    PCI_CLASS_OLD = 0,
4698 +    PCI_CLASS_DASDI,
4699 +    PCI_CLASS_NET,
4700 +    PCI_CLASS_DISPLAY,
4701 +    PCI_CLASS_MMEDIA,
4702 +    PCI_CLASS_MEMORY,
4703 +    PCI_CLASS_BRIDGE,
4704 +    PCI_CLASS_COMM,
4705 +    PCI_CLASS_BASE,
4706 +    PCI_CLASS_INPUT,
4707 +    PCI_CLASS_DOCK,
4708 +    PCI_CLASS_CPU,
4709 +    PCI_CLASS_SERIAL,
4710 +    PCI_CLASS_INTELLIGENT = 0xe,
4711 +    PCI_CLASS_SATELLITE,
4712 +    PCI_CLASS_CRYPT,
4713 +    PCI_CLASS_DSP,
4714 +    PCI_CLASS_MAX
4715 +} pci_classes;
4716 +
4717 +typedef enum {
4718 +    PCI_DASDI_SCSI,
4719 +    PCI_DASDI_IDE,
4720 +    PCI_DASDI_FLOPPY,
4721 +    PCI_DASDI_IPI,
4722 +    PCI_DASDI_RAID,
4723 +    PCI_DASDI_OTHER = 0x80
4724 +} pci_dasdi_subclasses;
4725 +
4726 +typedef enum {
4727 +    PCI_NET_ETHER,
4728 +    PCI_NET_TOKEN,
4729 +    PCI_NET_FDDI,
4730 +    PCI_NET_ATM,
4731 +    PCI_NET_OTHER = 0x80
4732 +} pci_net_subclasses;
4733 +
4734 +typedef enum {
4735 +    PCI_DISPLAY_VGA,
4736 +    PCI_DISPLAY_XGA,
4737 +    PCI_DISPLAY_3D,
4738 +    PCI_DISPLAY_OTHER = 0x80
4739 +} pci_display_subclasses;
4740 +
4741 +typedef enum {
4742 +    PCI_MMEDIA_VIDEO,
4743 +    PCI_MMEDIA_AUDIO,
4744 +    PCI_MMEDIA_PHONE,
4745 +    PCI_MEDIA_OTHER = 0x80
4746 +} pci_mmedia_subclasses;
4747 +
4748 +typedef enum {
4749 +    PCI_MEMORY_RAM,
4750 +    PCI_MEMORY_FLASH,
4751 +    PCI_MEMORY_OTHER = 0x80
4752 +} pci_memory_subclasses;
4753 +
4754 +typedef enum {
4755 +    PCI_BRIDGE_HOST,
4756 +    PCI_BRIDGE_ISA,
4757 +    PCI_BRIDGE_EISA,
4758 +    PCI_BRIDGE_MC,
4759 +    PCI_BRIDGE_PCI,
4760 +    PCI_BRIDGE_PCMCIA,
4761 +    PCI_BRIDGE_NUBUS,
4762 +    PCI_BRIDGE_CARDBUS,
4763 +    PCI_BRIDGE_RACEWAY,
4764 +    PCI_BRIDGE_OTHER = 0x80
4765 +} pci_bridge_subclasses;
4766 +
4767 +typedef enum {
4768 +    PCI_COMM_UART,
4769 +    PCI_COMM_PARALLEL,
4770 +    PCI_COMM_MULTIUART,
4771 +    PCI_COMM_MODEM,
4772 +    PCI_COMM_OTHER = 0x80
4773 +} pci_comm_subclasses;
4774 +
4775 +typedef enum {
4776 +    PCI_BASE_PIC,
4777 +    PCI_BASE_DMA,
4778 +    PCI_BASE_TIMER,
4779 +    PCI_BASE_RTC,
4780 +    PCI_BASE_PCI_HOTPLUG,
4781 +    PCI_BASE_OTHER = 0x80
4782 +} pci_base_subclasses;
4783 +
4784 +typedef enum {
4785 +    PCI_INPUT_KBD,
4786 +    PCI_INPUT_PEN,
4787 +    PCI_INPUT_MOUSE,
4788 +    PCI_INPUT_SCANNER,
4789 +    PCI_INPUT_GAMEPORT,
4790 +    PCI_INPUT_OTHER = 0x80
4791 +} pci_input_subclasses;
4792 +
4793 +typedef enum {
4794 +    PCI_DOCK_GENERIC,
4795 +    PCI_DOCK_OTHER = 0x80
4796 +} pci_dock_subclasses;
4797 +
4798 +typedef enum {
4799 +    PCI_CPU_386,
4800 +    PCI_CPU_486,
4801 +    PCI_CPU_PENTIUM,
4802 +    PCI_CPU_ALPHA = 0x10,
4803 +    PCI_CPU_POWERPC = 0x20,
4804 +    PCI_CPU_MIPS = 0x30,
4805 +    PCI_CPU_COPROC = 0x40,
4806 +    PCI_CPU_OTHER = 0x80
4807 +} pci_cpu_subclasses;
4808 +
4809 +typedef enum {
4810 +    PCI_SERIAL_IEEE1394,
4811 +    PCI_SERIAL_ACCESS,
4812 +    PCI_SERIAL_SSA,
4813 +    PCI_SERIAL_USB,
4814 +    PCI_SERIAL_FIBER,
4815 +    PCI_SERIAL_SMBUS,
4816 +    PCI_SERIAL_OTHER = 0x80
4817 +} pci_serial_subclasses;
4818 +
4819 +typedef enum {
4820 +    PCI_INTELLIGENT_I2O,
4821 +} pci_intelligent_subclasses;
4822 +
4823 +typedef enum {
4824 +    PCI_SATELLITE_TV,
4825 +    PCI_SATELLITE_AUDIO,
4826 +    PCI_SATELLITE_VOICE,
4827 +    PCI_SATELLITE_DATA,
4828 +    PCI_SATELLITE_OTHER = 0x80
4829 +} pci_satellite_subclasses;
4830 +
4831 +typedef enum {
4832 +    PCI_CRYPT_NETWORK,
4833 +    PCI_CRYPT_ENTERTAINMENT,
4834 +    PCI_CRYPT_OTHER = 0x80
4835 +} pci_crypt_subclasses;
4836 +
4837 +typedef enum {
4838 +    PCI_DSP_DPIO,
4839 +    PCI_DSP_OTHER = 0x80
4840 +} pci_dsp_subclasses;
4841 +
4842 +/* Header types */
4843 +typedef enum {
4844 +       PCI_HEADER_NORMAL,
4845 +       PCI_HEADER_BRIDGE,
4846 +       PCI_HEADER_CARDBUS
4847 +} pci_header_types;
4848 +
4849 +
4850 +/* Overlay for a PCI-to-PCI bridge */
4851 +
4852 +#define        PPB_RSVDA_MAX           2
4853 +#define        PPB_RSVDD_MAX           8
4854 +
4855 +typedef struct _ppb_config_regs {
4856 +    unsigned short     vendor;
4857 +    unsigned short     device;
4858 +    unsigned short     command;
4859 +    unsigned short     status;
4860 +    unsigned char      rev_id;
4861 +    unsigned char      prog_if;
4862 +    unsigned char      sub_class;
4863 +    unsigned char      base_class;
4864 +    unsigned char      cache_line_size;
4865 +    unsigned char      latency_timer;
4866 +    unsigned char      header_type;
4867 +    unsigned char      bist;
4868 +    unsigned long      rsvd_a[PPB_RSVDA_MAX];
4869 +    unsigned char      prim_bus;
4870 +    unsigned char      sec_bus;
4871 +    unsigned char      sub_bus;
4872 +    unsigned char      sec_lat;
4873 +    unsigned char      io_base;
4874 +    unsigned char      io_lim;
4875 +    unsigned short     sec_status;
4876 +    unsigned short     mem_base;
4877 +    unsigned short     mem_lim;
4878 +    unsigned short     pf_mem_base;
4879 +    unsigned short     pf_mem_lim;
4880 +    unsigned long      pf_mem_base_hi;
4881 +    unsigned long      pf_mem_lim_hi;
4882 +    unsigned short     io_base_hi;
4883 +    unsigned short     io_lim_hi;
4884 +    unsigned short     subsys_vendor;
4885 +    unsigned short     subsys_id;
4886 +    unsigned long      rsvd_b;
4887 +    unsigned char      rsvd_c;
4888 +    unsigned char      int_pin;
4889 +    unsigned short     bridge_ctrl;
4890 +    unsigned char      chip_ctrl;
4891 +    unsigned char      diag_ctrl;
4892 +    unsigned short     arb_ctrl;
4893 +    unsigned long      rsvd_d[PPB_RSVDD_MAX];
4894 +    unsigned char      dev_dep[192];
4895 +} ppb_config_regs;
4896 +
4897 +
4898 +/* PCI CAPABILITY DEFINES */
4899 +#define PCI_CAP_POWERMGMTCAP_ID                0x01
4900 +#define PCI_CAP_MSICAP_ID              0x05
4901 +#define PCI_CAP_PCIECAP_ID             0x10
4902 +
4903 +/* Data structure to define the Message Signalled Interrupt facility
4904 + * Valid for PCI and PCIE configurations */
4905 +typedef struct _pciconfig_cap_msi {
4906 +       unsigned char capID;
4907 +       unsigned char nextptr;
4908 +       unsigned short msgctrl;
4909 +       unsigned int msgaddr;
4910 +} pciconfig_cap_msi;
4911 +
4912 +/* Data structure to define the Power managment facility
4913 + * Valid for PCI and PCIE configurations */
4914 +typedef struct _pciconfig_cap_pwrmgmt {
4915 +       unsigned char capID;
4916 +       unsigned char nextptr;
4917 +       unsigned short pme_cap;
4918 +       unsigned short  pme_sts_ctrl;
4919 +       unsigned char  pme_bridge_ext;
4920 +       unsigned char  data;
4921 +} pciconfig_cap_pwrmgmt;
4922 +
4923 +/* Data structure to define the PCIE capability */
4924 +typedef struct _pciconfig_cap_pcie {
4925 +       unsigned char capID;
4926 +       unsigned char nextptr;
4927 +       unsigned short pcie_cap;
4928 +       unsigned int  dev_cap;
4929 +       unsigned short dev_ctrl;
4930 +       unsigned short dev_status;
4931 +       unsigned int  link_cap;
4932 +       unsigned short link_ctrl;
4933 +       unsigned short link_status;
4934 +} pciconfig_cap_pcie;
4935 +
4936 +/* PCIE Enhanced CAPABILITY DEFINES */
4937 +#define PCIE_EXTCFG_OFFSET     0x100
4938 +#define PCIE_ADVERRREP_CAPID   0x0001
4939 +#define PCIE_VC_CAPID          0x0002
4940 +#define PCIE_DEVSNUM_CAPID     0x0003
4941 +#define PCIE_PWRBUDGET_CAPID   0x0004
4942 +
4943 +/* Header to define the PCIE specific capabilities in the extended config space */
4944 +typedef struct _pcie_enhanced_caphdr {
4945 +       unsigned short capID;
4946 +       unsigned short cap_ver : 4;
4947 +       unsigned short next_ptr : 12;
4948 +} pcie_enhanced_caphdr;
4949 +
4950 +
4951 +/* Everything below is BRCM HND proprietary */
4952 +
4953 +#define        PCI_BAR0_WIN            0x80    /* backplane addres space accessed by BAR0 */
4954 +#define        PCI_BAR1_WIN            0x84    /* backplane addres space accessed by BAR1 */
4955 +#define        PCI_SPROM_CONTROL       0x88    /* sprom property control */
4956 +#define        PCI_BAR1_CONTROL        0x8c    /* BAR1 region burst control */
4957 +#define        PCI_INT_STATUS          0x90    /* PCI and other cores interrupts */
4958 +#define        PCI_INT_MASK            0x94    /* mask of PCI and other cores interrupts */
4959 +#define PCI_TO_SB_MB           0x98    /* signal backplane interrupts */
4960 +#define PCI_BACKPLANE_ADDR     0xA0    /* address an arbitrary location on the system backplane */
4961 +#define PCI_BACKPLANE_DATA     0xA4    /* data at the location specified by above address register */
4962 +#define        PCI_GPIO_IN             0xb0    /* pci config space gpio input (>=rev3) */
4963 +#define        PCI_GPIO_OUT            0xb4    /* pci config space gpio output (>=rev3) */
4964 +#define        PCI_GPIO_OUTEN          0xb8    /* pci config space gpio output enable (>=rev3) */
4965 +
4966 +#define        PCI_BAR0_SPROM_OFFSET   (4 * 1024)      /* bar0 + 4K accesses external sprom */
4967 +#define        PCI_BAR0_PCIREGS_OFFSET (6 * 1024)      /* bar0 + 6K accesses pci core registers */
4968 +
4969 +/* PCI_INT_STATUS */
4970 +#define        PCI_SBIM_STATUS_SERR    0x4     /* backplane SBErr interrupt status */
4971 +
4972 +/* PCI_INT_MASK */
4973 +#define        PCI_SBIM_SHIFT          8       /* backplane core interrupt mask bits offset */
4974 +#define        PCI_SBIM_MASK           0xff00  /* backplane core interrupt mask */
4975 +#define        PCI_SBIM_MASK_SERR      0x4     /* backplane SBErr interrupt mask */
4976 +
4977 +/* PCI_SPROM_CONTROL */
4978 +#define        SPROM_BLANK             0x04    /* indicating a blank sprom */
4979 +#define SPROM_WRITEEN          0x10    /* sprom write enable */
4980 +#define SPROM_BOOTROM_WE       0x20    /* external bootrom write enable */
4981 +
4982 +#define        SPROM_SIZE              256     /* sprom size in 16-bit */
4983 +#define SPROM_CRC_RANGE                64      /* crc cover range in 16-bit */
4984 +
4985 +/* PCI_CFG_CMD_STAT */
4986 +#define PCI_CFG_CMD_STAT_TA    0x08000000      /* target abort status */
4987 +
4988 +#endif
4989 diff -Nur linux-2.4.32/arch/mips/bcm947xx/include/pmon_osl.h linux-2.4.32-brcm/arch/mips/bcm947xx/include/pmon_osl.h
4990 --- linux-2.4.32/arch/mips/bcm947xx/include/pmon_osl.h  1970-01-01 01:00:00.000000000 +0100
4991 +++ linux-2.4.32-brcm/arch/mips/bcm947xx/include/pmon_osl.h     2005-12-16 23:39:10.752824750 +0100
4992 @@ -0,0 +1,126 @@
4993 +/*
4994 + * MIPS PMON boot loader OS Abstraction Layer.
4995 + *
4996 + * Copyright 2005, Broadcom Corporation
4997 + * All Rights Reserved.
4998 + *
4999 + * This is UNPUBLISHED PROPRIETARY SOURCE CODE of Broadcom Corporation;
5000 + * the contents of this file may not be disclosed to third parties, copied
5001 + * or duplicated in any form, in whole or in part, without the prior
5002 + * written permission of Broadcom Corporation.
5003 + * $Id$
5004 + */
5005 +
5006 +#ifndef _pmon_osl_h_
5007 +#define _pmon_osl_h_
5008 +
5009 +#include <typedefs.h>
5010 +#include <mips.h>
5011 +#include <string.h>
5012 +#include <utypes.h>
5013 +
5014 +extern int printf(char *fmt,...);
5015 +extern int sprintf(char *dst,char *fmt,...);
5016 +
5017 +#define        OSL_UNCACHED(va)        phy2k1(log2phy((va)))
5018 +#define        REG_MAP(pa, size)       phy2k1((pa))
5019 +#define        REG_UNMAP(va)           /* nop */
5020 +
5021 +/* Common macros */
5022 +
5023 +#define BUSPROBE(val, addr) ((val) = *(addr))
5024 +
5025 +#define        ASSERT(exp)
5026 +
5027 +#define        OSL_PCMCIA_READ_ATTR(osh, offset, buf, size) bzero(buf, size)
5028 +#define        OSL_PCMCIA_WRITE_ATTR(osh, offset, buf, size)
5029 +
5030 +/* kludge */
5031 +#define        OSL_PCI_READ_CONFIG(loc, offset, size)  ((offset == 8)? 0: 0xffffffff)
5032 +#define        OSL_PCI_WRITE_CONFIG(loc, offset, size, val)    ASSERT(0)
5033 +
5034 +#define wreg32(r,v)    (*(volatile uint32 *)(r) = (v))
5035 +#define rreg32(r)      (*(volatile uint32 *)(r))
5036 +#ifdef IL_BIGENDIAN
5037 +#define wreg16(r,v)    (*(volatile uint16 *)((uint32)r^2) = (v))
5038 +#define rreg16(r)      (*(volatile uint16 *)((uint32)r^2))
5039 +#else
5040 +#define wreg16(r,v)    (*(volatile uint16 *)(r) = (v))
5041 +#define rreg16(r)      (*(volatile uint16 *)(r))
5042 +#endif
5043 +
5044 +#include <memory.h>
5045 +#define        bcopy(src, dst, len)    memcpy(dst, src, len)
5046 +#define        bcmp(b1, b2, len)       memcmp(b1, b2, len)
5047 +#define        bzero(b, len)           memset(b, '\0', len)
5048 +
5049 +/* register access macros */
5050 +#define        R_REG(r)        ((sizeof *(r) == sizeof (uint32))? rreg32(r): rreg16(r))
5051 +#define        W_REG(r,v)      ((sizeof *(r) == sizeof (uint32))? wreg32(r,(uint32)v): wreg16(r,(uint16)v))
5052 +#define        AND_REG(r, v)   W_REG((r), R_REG(r) & (v))
5053 +#define        OR_REG(r, v)    W_REG((r), R_REG(r) | (v))
5054 +
5055 +#define        R_SM(r)                 *(r)
5056 +#define        W_SM(r, v)              (*(r) = (v))
5057 +#define        BZERO_SM(r, len)        memset(r, '\0', len)
5058 +
5059 +/* Host/Bus architecture specific swap. Noop for little endian systems, possible swap on big endian */
5060 +#define BUS_SWAP32(v)  (v)
5061 +
5062 +#define        OSL_DELAY(usec)         delay_us(usec)
5063 +extern void delay_us(uint usec);
5064 +
5065 +#define OSL_GETCYCLES(x) ((x) = 0)
5066 +
5067 +#define osl_attach(pdev)       (pdev)
5068 +#define osl_detach(osh)
5069 +
5070 +#define        MALLOC(osh, size)       malloc(size)
5071 +#define        MFREE(osh, addr, size)  free(addr)
5072 +#define        MALLOCED(osh)           (0)
5073 +#define        MALLOC_DUMP(osh, buf, sz)
5074 +#define        MALLOC_FAILED(osh)
5075 +extern void *malloc();
5076 +extern void free(void *addr);
5077 +
5078 +#define        DMA_CONSISTENT_ALIGN    sizeof (int)
5079 +#define        DMA_ALLOC_CONSISTENT(osh, size, pap)    et_dma_alloc_consistent(osh, size, pap)
5080 +#define        DMA_FREE_CONSISTENT(osh, va, size, pa)
5081 +extern void* et_dma_alloc_consistent(void *osh, uint size, ulong *pap);
5082 +#define        DMA_TX 0
5083 +#define        DMA_RX 1
5084 +
5085 +#define        DMA_MAP(osh, va, size, direction, p)    osl_dma_map(osh, (void*)va, size, direction)
5086 +#define        DMA_UNMAP(osh, pa, size, direction, p)  /* nop */
5087 +extern void* osl_dma_map(void *osh, void *va, uint size, uint direction);
5088 +
5089 +struct lbuf {
5090 +       struct lbuf *next;      /* pointer to next lbuf on freelist */
5091 +       uchar *buf;             /* pointer to buffer */
5092 +       uint len;               /* nbytes of data */
5093 +};
5094 +
5095 +/* the largest reasonable packet buffer driver uses for ethernet MTU in bytes */
5096 +#define        PKTBUFSZ        2048
5097 +
5098 +/* packet primitives */
5099 +#define        PKTGET(drv, len, send)          et_pktget(drv, len, send)
5100 +#define        PKTFREE(drv, lb, send)          et_pktfree(drv, (struct lbuf*)lb, send)
5101 +#define        PKTDATA(drv, lb)                ((uchar*)OSL_UNCACHED(((struct lbuf*)lb)->buf))
5102 +#define        PKTLEN(drv, lb)                 ((struct lbuf*)lb)->len
5103 +#define PKTHEADROOM(drv, lb)           (0)
5104 +#define PKTTAILROOM(drv, lb)           (0)
5105 +#define        PKTNEXT(drv, lb)                NULL
5106 +#define        PKTSETNEXT(lb, x)               ASSERT(0)
5107 +#define        PKTSETLEN(drv, lb, bytes)       ((struct lbuf*)lb)->len = bytes
5108 +#define        PKTPUSH(drv, lb, bytes)         ASSERT(0)
5109 +#define        PKTPULL(drv, lb, bytes)         ASSERT(0)
5110 +#define        PKTDUP(drv, lb)                 ASSERT(0)
5111 +#define        PKTLINK(lb)                     ((struct lbuf*)lb)->next
5112 +#define        PKTSETLINK(lb, x)               ((struct lbuf*)lb)->next = (struct lbuf*)x
5113 +#define        PKTPRIO(lb)                     (0)
5114 +#define        PKTSETPRIO(lb, x)               do {} while (0)
5115 +extern void *et_pktget(void *drv, uint len, bool send);
5116 +extern void et_pktfree(void *drv, struct lbuf *lb, bool send);
5117 +
5118 +#endif /* _pmon_osl_h_ */
5119 diff -Nur linux-2.4.32/arch/mips/bcm947xx/include/proto/802.11.h linux-2.4.32-brcm/arch/mips/bcm947xx/include/proto/802.11.h
5120 --- linux-2.4.32/arch/mips/bcm947xx/include/proto/802.11.h      1970-01-01 01:00:00.000000000 +0100
5121 +++ linux-2.4.32-brcm/arch/mips/bcm947xx/include/proto/802.11.h 2005-12-16 23:39:10.752824750 +0100
5122 @@ -0,0 +1,930 @@
5123 +/*
5124 + * Copyright 2005, Broadcom Corporation
5125 + * All Rights Reserved.
5126 + *
5127 + * THIS SOFTWARE IS OFFERED "AS IS", AND BROADCOM GRANTS NO WARRANTIES OF ANY
5128 + * KIND, EXPRESS OR IMPLIED, BY STATUTE, COMMUNICATION OR OTHERWISE. BROADCOM
5129 + * SPECIFICALLY DISCLAIMS ANY IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS
5130 + * FOR A SPECIFIC PURPOSE OR NONINFRINGEMENT CONCERNING THIS SOFTWARE.
5131 + *
5132 + * Fundamental types and constants relating to 802.11
5133 + *
5134 + * $Id$
5135 + */
5136 +
5137 +#ifndef _802_11_H_
5138 +#define _802_11_H_
5139 +
5140 +#ifndef _TYPEDEFS_H_
5141 +#include <typedefs.h>
5142 +#endif
5143 +
5144 +#ifndef _NET_ETHERNET_H_
5145 +#include <proto/ethernet.h>
5146 +#endif
5147 +
5148 +#include <proto/wpa.h>
5149 +
5150 +
5151 +/* enable structure packing */
5152 +#if defined(__GNUC__)
5153 +#define        PACKED  __attribute__((packed))
5154 +#else
5155 +#pragma pack(1)
5156 +#define        PACKED
5157 +#endif
5158 +
5159 +#define DOT11_TU_TO_US                 1024    /* 802.11 Time Unit is 1024 microseconds */
5160 +
5161 +/* Generic 802.11 frame constants */
5162 +#define DOT11_A3_HDR_LEN               24
5163 +#define DOT11_A4_HDR_LEN               30
5164 +#define DOT11_MAC_HDR_LEN              DOT11_A3_HDR_LEN
5165 +#define DOT11_FCS_LEN                  4
5166 +#define DOT11_ICV_LEN                  4
5167 +#define DOT11_ICV_AES_LEN              8
5168 +#define DOT11_QOS_LEN                  2
5169 +
5170 +#define DOT11_KEY_INDEX_SHIFT          6
5171 +#define DOT11_IV_LEN                   4
5172 +#define DOT11_IV_TKIP_LEN              8
5173 +#define DOT11_IV_AES_OCB_LEN           4
5174 +#define DOT11_IV_AES_CCM_LEN           8
5175 +
5176 +/* Includes MIC */
5177 +#define DOT11_MAX_MPDU_BODY_LEN                2304
5178 +/* A4 header + QoS + CCMP + PDU + ICV + FCS = 2352 */
5179 +#define DOT11_MAX_MPDU_LEN             (DOT11_A4_HDR_LEN + \
5180 +                                        DOT11_QOS_LEN + \
5181 +                                        DOT11_IV_AES_CCM_LEN + \
5182 +                                        DOT11_MAX_MPDU_BODY_LEN + \
5183 +                                        DOT11_ICV_LEN + \
5184 +                                        DOT11_FCS_LEN)
5185 +
5186 +#define DOT11_MAX_SSID_LEN             32
5187 +
5188 +/* dot11RTSThreshold */
5189 +#define DOT11_DEFAULT_RTS_LEN          2347
5190 +#define DOT11_MAX_RTS_LEN              2347
5191 +
5192 +/* dot11FragmentationThreshold */
5193 +#define DOT11_MIN_FRAG_LEN             256
5194 +#define DOT11_MAX_FRAG_LEN             2346    /* Max frag is also limited by aMPDUMaxLength of the attached PHY */
5195 +#define DOT11_DEFAULT_FRAG_LEN         2346
5196 +
5197 +/* dot11BeaconPeriod */
5198 +#define DOT11_MIN_BEACON_PERIOD                1
5199 +#define DOT11_MAX_BEACON_PERIOD                0xFFFF
5200 +
5201 +/* dot11DTIMPeriod */
5202 +#define DOT11_MIN_DTIM_PERIOD          1
5203 +#define DOT11_MAX_DTIM_PERIOD          0xFF
5204 +
5205 +/* 802.2 LLC/SNAP header used by 802.11 per 802.1H */
5206 +#define DOT11_LLC_SNAP_HDR_LEN 8
5207 +#define DOT11_OUI_LEN                  3
5208 +struct dot11_llc_snap_header {
5209 +       uint8   dsap;                           /* always 0xAA */
5210 +       uint8   ssap;                           /* always 0xAA */
5211 +       uint8   ctl;                            /* always 0x03 */
5212 +       uint8   oui[DOT11_OUI_LEN];             /* RFC1042: 0x00 0x00 0x00
5213 +                                                  Bridge-Tunnel: 0x00 0x00 0xF8 */
5214 +       uint16  type;                           /* ethertype */
5215 +} PACKED;
5216 +
5217 +/* RFC1042 header used by 802.11 per 802.1H */
5218 +#define RFC1042_HDR_LEN                        (ETHER_HDR_LEN + DOT11_LLC_SNAP_HDR_LEN)
5219 +
5220 +/* Generic 802.11 MAC header */
5221 +/*
5222 + * N.B.: This struct reflects the full 4 address 802.11 MAC header.
5223 + *              The fields are defined such that the shorter 1, 2, and 3
5224 + *              address headers just use the first k fields.
5225 + */
5226 +struct dot11_header {
5227 +       uint16                  fc;             /* frame control */
5228 +       uint16                  durid;          /* duration/ID */
5229 +       struct ether_addr       a1;             /* address 1 */
5230 +       struct ether_addr       a2;             /* address 2 */
5231 +       struct ether_addr       a3;             /* address 3 */
5232 +       uint16                  seq;            /* sequence control */
5233 +       struct ether_addr       a4;             /* address 4 */
5234 +} PACKED;
5235 +
5236 +/* Control frames */
5237 +
5238 +struct dot11_rts_frame {
5239 +       uint16                  fc;             /* frame control */
5240 +       uint16                  durid;          /* duration/ID */
5241 +       struct ether_addr       ra;             /* receiver address */
5242 +       struct ether_addr       ta;             /* transmitter address */
5243 +} PACKED;
5244 +#define        DOT11_RTS_LEN           16
5245 +
5246 +struct dot11_cts_frame {
5247 +       uint16                  fc;             /* frame control */
5248 +       uint16                  durid;          /* duration/ID */
5249 +       struct ether_addr       ra;             /* receiver address */
5250 +} PACKED;
5251 +#define        DOT11_CTS_LEN           10
5252 +
5253 +struct dot11_ack_frame {
5254 +       uint16                  fc;             /* frame control */
5255 +       uint16                  durid;          /* duration/ID */
5256 +       struct ether_addr       ra;             /* receiver address */
5257 +} PACKED;
5258 +#define        DOT11_ACK_LEN           10
5259 +
5260 +struct dot11_ps_poll_frame {
5261 +       uint16                  fc;             /* frame control */
5262 +       uint16                  durid;          /* AID */
5263 +       struct ether_addr       bssid;          /* receiver address, STA in AP */
5264 +       struct ether_addr       ta;             /* transmitter address */
5265 +} PACKED;
5266 +#define        DOT11_PS_POLL_LEN       16
5267 +
5268 +struct dot11_cf_end_frame {
5269 +       uint16                  fc;             /* frame control */
5270 +       uint16                  durid;          /* duration/ID */
5271 +       struct ether_addr       ra;             /* receiver address */
5272 +       struct ether_addr       bssid;          /* transmitter address, STA in AP */
5273 +} PACKED;
5274 +#define        DOT11_CS_END_LEN        16
5275 +
5276 +/* Management frame header */
5277 +struct dot11_management_header {
5278 +       uint16                  fc;             /* frame control */
5279 +       uint16                  durid;          /* duration/ID */
5280 +       struct ether_addr       da;             /* receiver address */
5281 +       struct ether_addr       sa;             /* transmitter address */
5282 +       struct ether_addr       bssid;          /* BSS ID */
5283 +       uint16                  seq;            /* sequence control */
5284 +} PACKED;
5285 +#define        DOT11_MGMT_HDR_LEN      24
5286 +
5287 +/* Management frame payloads */
5288 +
5289 +struct dot11_bcn_prb {
5290 +       uint32                  timestamp[2];
5291 +       uint16                  beacon_interval;
5292 +       uint16                  capability;
5293 +} PACKED;
5294 +#define        DOT11_BCN_PRB_LEN       12
5295 +
5296 +struct dot11_auth {
5297 +       uint16                  alg;            /* algorithm */
5298 +       uint16                  seq;            /* sequence control */
5299 +       uint16                  status;         /* status code */
5300 +} PACKED;
5301 +#define DOT11_AUTH_FIXED_LEN   6               /* length of auth frame without challenge info elt */
5302 +
5303 +struct dot11_assoc_req {
5304 +       uint16                  capability;     /* capability information */
5305 +       uint16                  listen;         /* listen interval */
5306 +} PACKED;
5307 +#define DOT11_ASSOC_REQ_FIXED_LEN      4       /* length of assoc frame without info elts */
5308 +
5309 +struct dot11_reassoc_req {
5310 +       uint16                  capability;     /* capability information */
5311 +       uint16                  listen;         /* listen interval */
5312 +       struct ether_addr       ap;             /* Current AP address */
5313 +} PACKED;
5314 +#define DOT11_REASSOC_REQ_FIXED_LEN    10      /* length of assoc frame without info elts */
5315 +
5316 +struct dot11_assoc_resp {
5317 +       uint16                  capability;     /* capability information */
5318 +       uint16                  status;         /* status code */
5319 +       uint16                  aid;            /* association ID */
5320 +} PACKED;
5321 +
5322 +struct dot11_action_measure {
5323 +       uint8   category;
5324 +       uint8   action;
5325 +       uint8   token;
5326 +       uint8   data[1];
5327 +} PACKED;
5328 +#define DOT11_ACTION_MEASURE_LEN       3
5329 +
5330 +struct dot11_action_switch_channel {
5331 +       uint8   category;
5332 +       uint8   action;
5333 +       uint8   data[5]; /* for switch IE */
5334 +} PACKED;
5335 +
5336 +/**************
5337 +  802.11h related definitions.
5338 +**************/
5339 +typedef struct {
5340 +       uint8 id;
5341 +       uint8 len;
5342 +       uint8 power;
5343 +} dot11_power_cnst_t;
5344 +
5345 +typedef struct {
5346 +       uint8 min;
5347 +       uint8 max;
5348 +} dot11_power_cap_t;
5349 +
5350 +typedef struct {
5351 +       uint8 id;
5352 +       uint8 len;
5353 +       uint8 tx_pwr;
5354 +       uint8 margin;
5355 +} dot11_tpc_rep_t;
5356 +#define DOT11_MNG_IE_TPC_REPORT_LEN    2       /* length of IE data, not including 2 byte header */
5357 +
5358 +typedef struct {
5359 +       uint8 id;
5360 +       uint8 len;
5361 +       uint8 first_channel;
5362 +       uint8 num_channels;
5363 +} dot11_supp_channels_t;
5364 +
5365 +/* csa mode type */
5366 +#define DOT11_CSA_MODE_ADVISORY                0
5367 +#define DOT11_CSA_MODE_NO_TX           1
5368 +struct dot11_channel_switch {
5369 +       uint8 id;
5370 +       uint8 len;
5371 +       uint8 mode;
5372 +       uint8 channel;
5373 +       uint8 count;
5374 +}  PACKED;
5375 +typedef struct dot11_channel_switch dot11_channel_switch_t;
5376 +
5377 +/* length of IE data, not including 2 byte header */
5378 +#define DOT11_SWITCH_IE_LEN             3
5379 +
5380 +/* 802.11h Measurement Request/Report IEs */
5381 +/* Measurement Type field */
5382 +#define DOT11_MEASURE_TYPE_BASIC       0
5383 +#define DOT11_MEASURE_TYPE_CCA                 1
5384 +#define DOT11_MEASURE_TYPE_RPI         2
5385 +
5386 +/* Measurement Mode field */
5387 +
5388 +/* Measurement Request Modes */
5389 +#define DOT11_MEASURE_MODE_ENABLE      (1<<1)
5390 +#define DOT11_MEASURE_MODE_REQUEST     (1<<2)
5391 +#define DOT11_MEASURE_MODE_REPORT      (1<<3)
5392 +/* Measurement Report Modes */
5393 +#define DOT11_MEASURE_MODE_LATE        (1<<0)
5394 +#define DOT11_MEASURE_MODE_INCAPABLE   (1<<1)
5395 +#define DOT11_MEASURE_MODE_REFUSED     (1<<2)
5396 +/* Basic Measurement Map bits */
5397 +#define DOT11_MEASURE_BASIC_MAP_BSS    ((uint8)(1<<0))
5398 +#define DOT11_MEASURE_BASIC_MAP_OFDM   ((uint8)(1<<1))
5399 +#define DOT11_MEASURE_BASIC_MAP_UKNOWN ((uint8)(1<<2))
5400 +#define DOT11_MEASURE_BASIC_MAP_RADAR  ((uint8)(1<<3))
5401 +#define DOT11_MEASURE_BASIC_MAP_UNMEAS ((uint8)(1<<4))
5402 +
5403 +typedef struct {
5404 +       uint8 id;
5405 +       uint8 len;
5406 +       uint8 token;
5407 +       uint8 mode;
5408 +       uint8 type;
5409 +       uint8 channel;
5410 +       uint8 start_time[8];
5411 +       uint16 duration;
5412 +} dot11_meas_req_t;
5413 +#define DOT11_MNG_IE_MREQ_LEN 14
5414 +/* length of Measure Request IE data not including variable len */
5415 +#define DOT11_MNG_IE_MREQ_FIXED_LEN 3
5416 +
5417 +struct dot11_meas_rep {
5418 +       uint8 id;
5419 +       uint8 len;
5420 +       uint8 token;
5421 +       uint8 mode;
5422 +       uint8 type;
5423 +       union
5424 +       {
5425 +               struct {
5426 +                       uint8 channel;
5427 +                       uint8 start_time[8];
5428 +                       uint16 duration;
5429 +                       uint8 map;
5430 +               } PACKED basic;
5431 +               uint8 data[1];
5432 +       } PACKED rep;
5433 +} PACKED;
5434 +typedef struct dot11_meas_rep dot11_meas_rep_t;
5435 +
5436 +/* length of Measure Report IE data not including variable len */
5437 +#define DOT11_MNG_IE_MREP_FIXED_LEN    3
5438 +
5439 +struct dot11_meas_rep_basic {
5440 +       uint8 channel;
5441 +       uint8 start_time[8];
5442 +       uint16 duration;
5443 +       uint8 map;
5444 +} PACKED;
5445 +typedef struct dot11_meas_rep_basic dot11_meas_rep_basic_t;
5446 +#define DOT11_MEASURE_BASIC_REP_LEN    12
5447 +
5448 +struct dot11_quiet {
5449 +       uint8 id;
5450 +       uint8 len;
5451 +       uint8 count;    /* TBTTs until beacon interval in quiet starts */
5452 +       uint8 period;   /* Beacon intervals between periodic quiet periods ? */
5453 +       uint16 duration;/* Length of quiet period, in TU's */
5454 +       uint16 offset;  /* TU's offset from TBTT in Count field */
5455 +} PACKED;
5456 +typedef struct dot11_quiet dot11_quiet_t;
5457 +
5458 +typedef struct {
5459 +       uint8 channel;
5460 +       uint8 map;
5461 +} chan_map_tuple_t;
5462 +
5463 +typedef struct {
5464 +       uint8 id;
5465 +       uint8 len;
5466 +       uint8 eaddr[ETHER_ADDR_LEN];
5467 +       uint8 interval;
5468 +       chan_map_tuple_t map[1];
5469 +} dot11_ibss_dfs_t;
5470 +
5471 +/* WME Elements */
5472 +#define WME_OUI                        "\x00\x50\xf2"
5473 +#define WME_VER                        1
5474 +#define WME_TYPE               2
5475 +#define WME_SUBTYPE_IE         0       /* Information Element */
5476 +#define WME_SUBTYPE_PARAM_IE   1       /* Parameter Element */
5477 +#define WME_SUBTYPE_TSPEC      2       /* Traffic Specification */
5478 +
5479 +/* WME Access Category Indices (ACIs) */
5480 +#define AC_BE                  0       /* Best Effort */
5481 +#define AC_BK                  1       /* Background */
5482 +#define AC_VI                  2       /* Video */
5483 +#define AC_VO                  3       /* Voice */
5484 +#define AC_MAX                 4
5485 +
5486 +/* WME Information Element (IE) */
5487 +struct wme_ie {
5488 +       uint8 oui[3];
5489 +       uint8 type;
5490 +       uint8 subtype;
5491 +       uint8 version;
5492 +       uint8 acinfo;
5493 +} PACKED;
5494 +typedef struct wme_ie wme_ie_t;
5495 +#define WME_IE_LEN 7
5496 +
5497 +struct wme_acparam {
5498 +       uint8   ACI;
5499 +       uint8   ECW;
5500 +       uint16  TXOP;           /* stored in network order (ls octet first) */
5501 +} PACKED;
5502 +typedef struct wme_acparam wme_acparam_t;
5503 +
5504 +/* WME Parameter Element (PE) */
5505 +struct wme_params {
5506 +       uint8 oui[3];
5507 +       uint8 type;
5508 +       uint8 subtype;
5509 +       uint8 version;
5510 +       uint8 acinfo;
5511 +       uint8 rsvd;
5512 +       wme_acparam_t acparam[4];
5513 +} PACKED;
5514 +typedef struct wme_params wme_params_t;
5515 +#define WME_PARAMS_IE_LEN      24
5516 +
5517 +/* acinfo */
5518 +#define WME_COUNT_MASK         0x0f
5519 +/* ACI */
5520 +#define WME_AIFS_MASK  0x0f
5521 +#define WME_ACM_MASK   0x10
5522 +#define WME_ACI_MASK   0x60
5523 +#define WME_ACI_SHIFT  5
5524 +/* ECW */
5525 +#define WME_CWMIN_MASK 0x0f
5526 +#define WME_CWMAX_MASK 0xf0
5527 +#define WME_CWMAX_SHIFT        4
5528 +
5529 +#define WME_TXOP_UNITS 32
5530 +
5531 +/* AP: default params to be announced in the Beacon Frames/Probe Responses Table 12 WME Draft*/
5532 +/* AP:  default params to be Used in the AP Side Table 14 WME Draft January 2004 802.11-03-504r5 */
5533 +#define WME_AC_BK_ACI_STA       0x27
5534 +#define WME_AC_BK_ECW_STA       0xA4
5535 +#define WME_AC_BK_TXOP_STA      0x0000
5536 +#define WME_AC_BE_ACI_STA       0x03
5537 +#define WME_AC_BE_ECW_STA       0xA4
5538 +#define WME_AC_BE_TXOP_STA      0x0000
5539 +#define WME_AC_VI_ACI_STA       0x42
5540 +#define WME_AC_VI_ECW_STA       0x43
5541 +#define WME_AC_VI_TXOP_STA      0x005e
5542 +#define WME_AC_VO_ACI_STA       0x62
5543 +#define WME_AC_VO_ECW_STA       0x32
5544 +#define WME_AC_VO_TXOP_STA      0x002f
5545 +
5546 +#define WME_AC_BK_ACI_AP        0x27
5547 +#define WME_AC_BK_ECW_AP        0xA4
5548 +#define WME_AC_BK_TXOP_AP       0x0000
5549 +#define WME_AC_BE_ACI_AP        0x03
5550 +#define WME_AC_BE_ECW_AP        0x64
5551 +#define WME_AC_BE_TXOP_AP       0x0000
5552 +#define WME_AC_VI_ACI_AP        0x41
5553 +#define WME_AC_VI_ECW_AP        0x43
5554 +#define WME_AC_VI_TXOP_AP       0x005e
5555 +#define WME_AC_VO_ACI_AP        0x61
5556 +#define WME_AC_VO_ECW_AP        0x32
5557 +#define WME_AC_VO_TXOP_AP       0x002f
5558 +
5559 +/* WME Traffic Specification (TSPEC) element */
5560 +#define WME_SUBTYPE_TSPEC 2
5561 +#define WME_TSPEC_HDR_LEN              2
5562 +#define WME_TSPEC_BODY_OFF             2
5563 +struct wme_tspec {
5564 +       uint8 oui[DOT11_OUI_LEN];       /* WME_OUI */
5565 +       uint8 type;                     /* WME_TYPE */
5566 +       uint8 subtype;                  /* WME_SUBTYPE_TSPEC */
5567 +       uint8 version;                  /* WME_VERSION */
5568 +       uint16 ts_info;                 /* TS Info */
5569 +       uint16 nom_msdu_size;           /* (Nominal or fixed) MSDU Size (bytes) */
5570 +       uint16 max_msdu_size;           /* Maximum MSDU Size (bytes) */
5571 +       uint32 min_service_interval;    /* Minimum Service Interval (us) */
5572 +       uint32 max_service_interval;    /* Maximum Service Interval (us) */
5573 +       uint32 inactivity_interval;     /* Inactivity Interval (us) */
5574 +       uint32 service_start;           /* Service Start Time (us) */
5575 +       uint32 min_rate;                /* Minimum Data Rate (bps) */
5576 +       uint32 mean_rate;               /* Mean Data Rate (bps) */
5577 +       uint32 max_burst_size;          /* Maximum Burst Size (bytes) */
5578 +       uint32 min_phy_rate;            /* Minimum PHY Rate (bps) */
5579 +       uint32 peak_rate;               /* Peak Data Rate (bps) */
5580 +       uint32 delay_bound;             /* Delay Bound (us) */
5581 +       uint16 surplus_bandwidth;       /* Surplus Bandwidth Allowance Factor */
5582 +       uint16 medium_time;             /* Medium Time (32 us/s periods) */
5583 +} PACKED;
5584 +typedef struct wme_tspec wme_tspec_t;
5585 +#define WME_TSPEC_LEN 56               /* not including 2-byte header */
5586 +
5587 +/* ts_info */
5588 +/* 802.1D priority is duplicated - bits 13-11 AND bits 3-1 */
5589 +#define TS_INFO_PRIO_SHIFT_HI          11
5590 +#define TS_INFO_PRIO_MASK_HI           (0x7 << TS_INFO_PRIO_SHIFT_HI)
5591 +#define TS_INFO_PRIO_SHIFT_LO          1
5592 +#define TS_INFO_PRIO_MASK_LO           (0x7 << TS_INFO_PRIO_SHIFT_LO)
5593 +#define TS_INFO_CONTENTION_SHIFT       7
5594 +#define TS_INFO_CONTENTION_MASK                (0x1 << TS_INFO_CONTENTION_SHIFT)
5595 +#define TS_INFO_DIRECTION_SHIFT                5
5596 +#define TS_INFO_DIRECTION_MASK         (0x3 << TS_INFO_DIRECTION_SHIFT)
5597 +#define TS_INFO_UPLINK                 (0 << TS_INFO_DIRECTION_SHIFT)
5598 +#define TS_INFO_DOWNLINK               (1 << TS_INFO_DIRECTION_SHIFT)
5599 +#define TS_INFO_BIDIRECTIONAL          (3 << TS_INFO_DIRECTION_SHIFT)
5600 +
5601 +/* nom_msdu_size */
5602 +#define FIXED_MSDU_SIZE 0x8000         /* MSDU size is fixed */
5603 +#define MSDU_SIZE_MASK 0x7fff          /* (Nominal or fixed) MSDU size */
5604 +
5605 +/* surplus_bandwidth */
5606 +/* Represented as 3 bits of integer, binary point, 13 bits fraction */
5607 +#define        INTEGER_SHIFT   13
5608 +#define FRACTION_MASK  0x1FFF
5609 +
5610 +/* Management Notification Frame */
5611 +struct dot11_management_notification {
5612 +       uint8 category;                 /* DOT11_ACTION_NOTIFICATION */
5613 +       uint8 action;
5614 +       uint8 token;
5615 +       uint8 status;
5616 +       uint8 data[1];                  /* Elements */
5617 +} PACKED;
5618 +#define DOT11_MGMT_NOTIFICATION_LEN 4  /* Fixed length */
5619 +
5620 +/* WME Action Codes */
5621 +#define WME_SETUP_REQUEST      0
5622 +#define WME_SETUP_RESPONSE     1
5623 +#define WME_TEARDOWN           2
5624 +
5625 +/* WME Setup Response Status Codes */
5626 +#define WME_ADMISSION_ACCEPTED 0
5627 +#define WME_INVALID_PARAMETERS 1
5628 +#define WME_ADMISSION_REFUSED  3
5629 +
5630 +/* Macro to take a pointer to a beacon or probe response
5631 + * header and return the char* pointer to the SSID info element
5632 + */
5633 +#define BCN_PRB_SSID(hdr) ((char*)(hdr) + DOT11_MGMT_HDR_LEN + DOT11_BCN_PRB_LEN)
5634 +
5635 +/* Authentication frame payload constants */
5636 +#define DOT11_OPEN_SYSTEM      0
5637 +#define DOT11_SHARED_KEY       1
5638 +#define DOT11_CHALLENGE_LEN    128
5639 +
5640 +/* Frame control macros */
5641 +#define FC_PVER_MASK           0x3
5642 +#define FC_PVER_SHIFT          0
5643 +#define FC_TYPE_MASK           0xC
5644 +#define FC_TYPE_SHIFT          2
5645 +#define FC_SUBTYPE_MASK                0xF0
5646 +#define FC_SUBTYPE_SHIFT       4
5647 +#define FC_TODS                        0x100
5648 +#define FC_TODS_SHIFT          8
5649 +#define FC_FROMDS              0x200
5650 +#define FC_FROMDS_SHIFT                9
5651 +#define FC_MOREFRAG            0x400
5652 +#define FC_MOREFRAG_SHIFT      10
5653 +#define FC_RETRY               0x800
5654 +#define FC_RETRY_SHIFT         11
5655 +#define FC_PM                  0x1000
5656 +#define FC_PM_SHIFT            12
5657 +#define FC_MOREDATA            0x2000
5658 +#define FC_MOREDATA_SHIFT      13
5659 +#define FC_WEP                 0x4000
5660 +#define FC_WEP_SHIFT           14
5661 +#define FC_ORDER               0x8000
5662 +#define FC_ORDER_SHIFT         15
5663 +
5664 +/* sequence control macros */
5665 +#define SEQNUM_SHIFT           4
5666 +#define FRAGNUM_MASK           0xF
5667 +
5668 +/* Frame Control type/subtype defs */
5669 +
5670 +/* FC Types */
5671 +#define FC_TYPE_MNG            0
5672 +#define FC_TYPE_CTL            1
5673 +#define FC_TYPE_DATA           2
5674 +
5675 +/* Management Subtypes */
5676 +#define FC_SUBTYPE_ASSOC_REQ           0
5677 +#define FC_SUBTYPE_ASSOC_RESP          1
5678 +#define FC_SUBTYPE_REASSOC_REQ         2
5679 +#define FC_SUBTYPE_REASSOC_RESP                3
5680 +#define FC_SUBTYPE_PROBE_REQ           4
5681 +#define FC_SUBTYPE_PROBE_RESP          5
5682 +#define FC_SUBTYPE_BEACON              8
5683 +#define FC_SUBTYPE_ATIM                        9
5684 +#define FC_SUBTYPE_DISASSOC            10
5685 +#define FC_SUBTYPE_AUTH                        11
5686 +#define FC_SUBTYPE_DEAUTH              12
5687 +#define FC_SUBTYPE_ACTION              13
5688 +
5689 +/* Control Subtypes */
5690 +#define FC_SUBTYPE_PS_POLL             10
5691 +#define FC_SUBTYPE_RTS                 11
5692 +#define FC_SUBTYPE_CTS                 12
5693 +#define FC_SUBTYPE_ACK                 13
5694 +#define FC_SUBTYPE_CF_END              14
5695 +#define FC_SUBTYPE_CF_END_ACK          15
5696 +
5697 +/* Data Subtypes */
5698 +#define FC_SUBTYPE_DATA                        0
5699 +#define FC_SUBTYPE_DATA_CF_ACK         1
5700 +#define FC_SUBTYPE_DATA_CF_POLL                2
5701 +#define FC_SUBTYPE_DATA_CF_ACK_POLL    3
5702 +#define FC_SUBTYPE_NULL                        4
5703 +#define FC_SUBTYPE_CF_ACK              5
5704 +#define FC_SUBTYPE_CF_POLL             6
5705 +#define FC_SUBTYPE_CF_ACK_POLL         7
5706 +#define FC_SUBTYPE_QOS_DATA            8
5707 +#define FC_SUBTYPE_QOS_NULL            12
5708 +
5709 +/* type-subtype combos */
5710 +#define FC_KIND_MASK           (FC_TYPE_MASK | FC_SUBTYPE_MASK)
5711 +
5712 +#define FC_KIND(t, s) (((t) << FC_TYPE_SHIFT) | ((s) << FC_SUBTYPE_SHIFT))
5713 +
5714 +#define FC_ASSOC_REQ   FC_KIND(FC_TYPE_MNG, FC_SUBTYPE_ASSOC_REQ)
5715 +#define FC_ASSOC_RESP  FC_KIND(FC_TYPE_MNG, FC_SUBTYPE_ASSOC_RESP)
5716 +#define FC_REASSOC_REQ FC_KIND(FC_TYPE_MNG, FC_SUBTYPE_REASSOC_REQ)
5717 +#define FC_REASSOC_RESP        FC_KIND(FC_TYPE_MNG, FC_SUBTYPE_REASSOC_RESP)
5718 +#define FC_PROBE_REQ   FC_KIND(FC_TYPE_MNG, FC_SUBTYPE_PROBE_REQ)
5719 +#define FC_PROBE_RESP  FC_KIND(FC_TYPE_MNG, FC_SUBTYPE_PROBE_RESP)
5720 +#define FC_BEACON      FC_KIND(FC_TYPE_MNG, FC_SUBTYPE_BEACON)
5721 +#define FC_DISASSOC    FC_KIND(FC_TYPE_MNG, FC_SUBTYPE_DISASSOC)
5722 +#define FC_AUTH                FC_KIND(FC_TYPE_MNG, FC_SUBTYPE_AUTH)
5723 +#define FC_DEAUTH      FC_KIND(FC_TYPE_MNG, FC_SUBTYPE_DEAUTH)
5724 +#define FC_ACTION      FC_KIND(FC_TYPE_MNG, FC_SUBTYPE_ACTION)
5725 +
5726 +#define FC_PS_POLL     FC_KIND(FC_TYPE_CTL, FC_SUBTYPE_PS_POLL)
5727 +#define FC_RTS         FC_KIND(FC_TYPE_CTL, FC_SUBTYPE_RTS)
5728 +#define FC_CTS         FC_KIND(FC_TYPE_CTL, FC_SUBTYPE_CTS)
5729 +#define FC_ACK         FC_KIND(FC_TYPE_CTL, FC_SUBTYPE_ACK)
5730 +#define FC_CF_END      FC_KIND(FC_TYPE_CTL, FC_SUBTYPE_CF_END)
5731 +#define FC_CF_END_ACK  FC_KIND(FC_TYPE_CTL, FC_SUBTYPE_CF_END_ACK)
5732 +
5733 +#define FC_DATA                FC_KIND(FC_TYPE_DATA, FC_SUBTYPE_DATA)
5734 +#define FC_NULL_DATA   FC_KIND(FC_TYPE_DATA, FC_SUBTYPE_NULL)
5735 +#define FC_DATA_CF_ACK FC_KIND(FC_TYPE_DATA, FC_SUBTYPE_DATA_CF_ACK)
5736 +#define FC_QOS_DATA    FC_KIND(FC_TYPE_DATA, FC_SUBTYPE_QOS_DATA)
5737 +#define FC_QOS_NULL    FC_KIND(FC_TYPE_DATA, FC_SUBTYPE_QOS_NULL)
5738 +
5739 +/* QoS Control Field */
5740 +
5741 +/* 802.1D Tag */
5742 +#define QOS_PRIO_SHIFT         0
5743 +#define QOS_PRIO_MASK          0x0007
5744 +#define QOS_PRIO(qos)          (((qos) & QOS_PRIO_MASK) >> QOS_PRIO_SHIFT)
5745 +
5746 +#define QOS_TID_SHIFT          0
5747 +#define QOS_TID_MASK           0x000f
5748 +#define QOS_TID(qos)           (((qos) & QOS_TID_MASK) >> QOS_TID_SHIFT)
5749 +
5750 +/* Ack Policy (0 means Acknowledge) */
5751 +#define QOS_ACK_SHIFT          5
5752 +#define QOS_ACK_MASK           0x0060
5753 +#define QOS_ACK(qos)           (((qos) & QOS_ACK_MASK) >> QOS_ACK_SHIFT)
5754 +
5755 +/* Management Frames */
5756 +
5757 +/* Management Frame Constants */
5758 +
5759 +/* Fixed fields */
5760 +#define DOT11_MNG_AUTH_ALGO_LEN                2
5761 +#define DOT11_MNG_AUTH_SEQ_LEN         2
5762 +#define DOT11_MNG_BEACON_INT_LEN       2
5763 +#define DOT11_MNG_CAP_LEN              2
5764 +#define DOT11_MNG_AP_ADDR_LEN          6
5765 +#define DOT11_MNG_LISTEN_INT_LEN       2
5766 +#define DOT11_MNG_REASON_LEN           2
5767 +#define DOT11_MNG_AID_LEN              2
5768 +#define DOT11_MNG_STATUS_LEN           2
5769 +#define DOT11_MNG_TIMESTAMP_LEN                8
5770 +
5771 +/* DUR/ID field in assoc resp is 0xc000 | AID */
5772 +#define DOT11_AID_MASK                 0x3fff
5773 +
5774 +/* Reason Codes */
5775 +#define DOT11_RC_RESERVED                      0
5776 +#define DOT11_RC_UNSPECIFIED                   1       /* Unspecified reason */
5777 +#define DOT11_RC_AUTH_INVAL                    2       /* Previous authentication no longer valid */
5778 +#define DOT11_RC_DEAUTH_LEAVING                        3       /* Deauthenticated because sending station is
5779 +                                                          leaving (or has left) IBSS or ESS */
5780 +#define DOT11_RC_INACTIVITY                    4       /* Disassociated due to inactivity */
5781 +#define DOT11_RC_BUSY                          5       /* Disassociated because AP is unable to handle
5782 +                                                          all currently associated stations */
5783 +#define DOT11_RC_INVAL_CLASS_2                 6       /* Class 2 frame received from
5784 +                                                          nonauthenticated station */
5785 +#define DOT11_RC_INVAL_CLASS_3                 7       /* Class 3 frame received from
5786 +                                                          nonassociated station */
5787 +#define DOT11_RC_DISASSOC_LEAVING              8       /* Disassociated because sending station is
5788 +                                                          leaving (or has left) BSS */
5789 +#define DOT11_RC_NOT_AUTH                      9       /* Station requesting (re)association is
5790 +                                                          not authenticated with responding station */
5791 +#define DOT11_RC_MAX                           23      /* Reason codes > 23 are reserved */
5792 +
5793 +/* Status Codes */
5794 +#define DOT11_STATUS_SUCCESS                   0       /* Successful */
5795 +#define DOT11_STATUS_FAILURE                   1       /* Unspecified failure */
5796 +#define DOT11_STATUS_CAP_MISMATCH              10      /* Cannot support all requested capabilities
5797 +                                                          in the Capability Information field */
5798 +#define DOT11_STATUS_REASSOC_FAIL              11      /* Reassociation denied due to inability to
5799 +                                                          confirm that association exists */
5800 +#define DOT11_STATUS_ASSOC_FAIL                        12      /* Association denied due to reason outside
5801 +                                                          the scope of this standard */
5802 +#define DOT11_STATUS_AUTH_MISMATCH             13      /* Responding station does not support the
5803 +                                                          specified authentication algorithm */
5804 +#define DOT11_STATUS_AUTH_SEQ                  14      /* Received an Authentication frame with
5805 +                                                          authentication transaction sequence number
5806 +                                                          out of expected sequence */
5807 +#define DOT11_STATUS_AUTH_CHALLENGE_FAIL       15      /* Authentication rejected because of challenge failure */
5808 +#define DOT11_STATUS_AUTH_TIMEOUT              16      /* Authentication rejected due to timeout waiting
5809 +                                                          for next frame in sequence */
5810 +#define DOT11_STATUS_ASSOC_BUSY_FAIL           17      /* Association denied because AP is unable to
5811 +                                                          handle additional associated stations */
5812 +#define DOT11_STATUS_ASSOC_RATE_MISMATCH       18      /* Association denied due to requesting station
5813 +                                                          not supporting all of the data rates in the
5814 +                                                          BSSBasicRateSet parameter */
5815 +#define DOT11_STATUS_ASSOC_SHORT_REQUIRED      19      /* Association denied due to requesting station
5816 +                                                          not supporting the Short Preamble option */
5817 +#define DOT11_STATUS_ASSOC_PBCC_REQUIRED       20      /* Association denied due to requesting station
5818 +                                                          not supporting the PBCC Modulation option */
5819 +#define DOT11_STATUS_ASSOC_AGILITY_REQUIRED    21      /* Association denied due to requesting station
5820 +                                                          not supporting the Channel Agility option */
5821 +#define DOT11_STATUS_ASSOC_SPECTRUM_REQUIRED   22      /* Association denied because Spectrum Management
5822 +                                                          capability is required. */
5823 +#define DOT11_STATUS_ASSOC_BAD_POWER_CAP       23      /* Association denied because the info in the
5824 +                                                          Power Cap element is unacceptable. */
5825 +#define DOT11_STATUS_ASSOC_BAD_SUP_CHANNELS    24      /* Association denied because the info in the
5826 +                                                          Supported Channel element is unacceptable */
5827 +#define DOT11_STATUS_ASSOC_SHORTSLOT_REQUIRED  25      /* Association denied due to requesting station
5828 +                                                          not supporting the Short Slot Time option */
5829 +#define DOT11_STATUS_ASSOC_ERPBCC_REQUIRED     26      /* Association denied due to requesting station
5830 +                                                          not supporting the ER-PBCC Modulation option */
5831 +#define DOT11_STATUS_ASSOC_DSSOFDM_REQUIRED    27      /* Association denied due to requesting station
5832 +                                                          not supporting the DSS-OFDM option */
5833 +
5834 +/* Info Elts, length of INFORMATION portion of Info Elts */
5835 +#define DOT11_MNG_DS_PARAM_LEN                 1
5836 +#define DOT11_MNG_IBSS_PARAM_LEN               2
5837 +
5838 +/* TIM Info element has 3 bytes fixed info in INFORMATION field,
5839 + * followed by 1 to 251 bytes of Partial Virtual Bitmap */
5840 +#define DOT11_MNG_TIM_FIXED_LEN                        3
5841 +#define DOT11_MNG_TIM_DTIM_COUNT               0
5842 +#define DOT11_MNG_TIM_DTIM_PERIOD              1
5843 +#define DOT11_MNG_TIM_BITMAP_CTL               2
5844 +#define DOT11_MNG_TIM_PVB                      3
5845 +
5846 +/* TLV defines */
5847 +#define TLV_TAG_OFF            0
5848 +#define TLV_LEN_OFF            1
5849 +#define TLV_HDR_LEN            2
5850 +#define TLV_BODY_OFF           2
5851 +
5852 +/* Management Frame Information Element IDs */
5853 +#define DOT11_MNG_SSID_ID                      0
5854 +#define DOT11_MNG_RATES_ID                     1
5855 +#define DOT11_MNG_FH_PARMS_ID                  2
5856 +#define DOT11_MNG_DS_PARMS_ID                  3
5857 +#define DOT11_MNG_CF_PARMS_ID                  4
5858 +#define DOT11_MNG_TIM_ID                       5
5859 +#define DOT11_MNG_IBSS_PARMS_ID                        6
5860 +#define DOT11_MNG_COUNTRY_ID                   7
5861 +#define DOT11_MNG_HOPPING_PARMS_ID             8
5862 +#define DOT11_MNG_HOPPING_TABLE_ID             9
5863 +#define DOT11_MNG_REQUEST_ID                   10
5864 +#define DOT11_MNG_CHALLENGE_ID                 16
5865 +#define DOT11_MNG_PWR_CONSTRAINT_ID            32    /* 11H PowerConstraint    */
5866 +#define DOT11_MNG_PWR_CAP_ID                   33    /* 11H PowerCapability    */
5867 +#define DOT11_MNG_TPC_REQUEST_ID               34    /* 11H TPC Request        */
5868 +#define DOT11_MNG_TPC_REPORT_ID                        35    /* 11H TPC Report         */
5869 +#define DOT11_MNG_SUPP_CHANNELS_ID             36    /* 11H Supported Channels */
5870 +#define DOT11_MNG_CHANNEL_SWITCH_ID            37    /* 11H ChannelSwitch Announcement*/
5871 +#define DOT11_MNG_MEASURE_REQUEST_ID           38    /* 11H MeasurementRequest */
5872 +#define DOT11_MNG_MEASURE_REPORT_ID            39    /* 11H MeasurementReport  */
5873 +#define DOT11_MNG_QUIET_ID                     40    /* 11H Quiet              */
5874 +#define DOT11_MNG_IBSS_DFS_ID                  41    /* 11H IBSS_DFS           */
5875 +#define DOT11_MNG_ERP_ID                       42
5876 +#define DOT11_MNG_NONERP_ID                    47
5877 +#ifdef BCMWPA2
5878 +#define DOT11_MNG_RSN_ID                       48
5879 +#endif /* BCMWPA2 */
5880 +#define DOT11_MNG_EXT_RATES_ID                 50
5881 +#define DOT11_MNG_WPA_ID                       221
5882 +#define DOT11_MNG_PROPR_ID                     221
5883 +
5884 +/* ERP info element bit values */
5885 +#define DOT11_MNG_ERP_LEN                      1       /* ERP is currently 1 byte long */
5886 +#define DOT11_MNG_NONERP_PRESENT               0x01    /* NonERP (802.11b) STAs are present in the BSS */
5887 +#define DOT11_MNG_USE_PROTECTION               0x02    /* Use protection mechanisms for ERP-OFDM frames */
5888 +#define DOT11_MNG_BARKER_PREAMBLE              0x04    /* Short Preambles: 0 == allowed, 1 == not allowed */
5889 +
5890 +/* Capability Information Field */
5891 +#define DOT11_CAP_ESS                          0x0001
5892 +#define DOT11_CAP_IBSS                         0x0002
5893 +#define DOT11_CAP_POLLABLE                     0x0004
5894 +#define DOT11_CAP_POLL_RQ                      0x0008
5895 +#define DOT11_CAP_PRIVACY                      0x0010
5896 +#define DOT11_CAP_SHORT                                0x0020
5897 +#define DOT11_CAP_PBCC                         0x0040
5898 +#define DOT11_CAP_AGILITY                      0x0080
5899 +#define DOT11_CAP_SPECTRUM                     0x0100
5900 +#define DOT11_CAP_SHORTSLOT                    0x0400
5901 +#define DOT11_CAP_CCK_OFDM                     0x2000
5902 +
5903 +/* Action Frame Constants */
5904 +#define DOT11_ACTION_CAT_ERR_MASK      0x80
5905 +#define DOT11_ACTION_CAT_SPECT_MNG     0x00
5906 +#define DOT11_ACTION_NOTIFICATION      0x11    /* 17 */
5907 +
5908 +#define DOT11_ACTION_ID_M_REQ          0
5909 +#define DOT11_ACTION_ID_M_REP          1
5910 +#define DOT11_ACTION_ID_TPC_REQ                2
5911 +#define DOT11_ACTION_ID_TPC_REP                3
5912 +#define DOT11_ACTION_ID_CHANNEL_SWITCH 4
5913 +
5914 +/* MLME Enumerations */
5915 +#define DOT11_BSSTYPE_INFRASTRUCTURE           0
5916 +#define DOT11_BSSTYPE_INDEPENDENT              1
5917 +#define DOT11_BSSTYPE_ANY                      2
5918 +#define DOT11_SCANTYPE_ACTIVE                  0
5919 +#define DOT11_SCANTYPE_PASSIVE                 1
5920 +
5921 +/* 802.11 A PHY constants */
5922 +#define APHY_SLOT_TIME         9
5923 +#define APHY_SIFS_TIME         16
5924 +#define APHY_DIFS_TIME         (APHY_SIFS_TIME + (2 * APHY_SLOT_TIME))
5925 +#define APHY_PREAMBLE_TIME     16
5926 +#define APHY_SIGNAL_TIME       4
5927 +#define APHY_SYMBOL_TIME       4
5928 +#define APHY_SERVICE_NBITS     16
5929 +#define APHY_TAIL_NBITS                6
5930 +#define        APHY_CWMIN              15
5931 +
5932 +/* 802.11 B PHY constants */
5933 +#define BPHY_SLOT_TIME         20
5934 +#define BPHY_SIFS_TIME         10
5935 +#define BPHY_DIFS_TIME         50
5936 +#define BPHY_PLCP_TIME         192
5937 +#define BPHY_PLCP_SHORT_TIME   96
5938 +#define        BPHY_CWMIN              31
5939 +
5940 +/* 802.11 G constants */
5941 +#define DOT11_OFDM_SIGNAL_EXTENSION    6
5942 +
5943 +#define PHY_CWMAX              1023
5944 +
5945 +#define        DOT11_MAXNUMFRAGS       16      /* max # fragments per MSDU */
5946 +
5947 +/* dot11Counters Table - 802.11 spec., Annex D */
5948 +typedef struct d11cnt {
5949 +       uint32          txfrag;         /* dot11TransmittedFragmentCount */
5950 +       uint32          txmulti;        /* dot11MulticastTransmittedFrameCount */
5951 +       uint32          txfail;         /* dot11FailedCount */
5952 +       uint32          txretry;        /* dot11RetryCount */
5953 +       uint32          txretrie;       /* dot11MultipleRetryCount */
5954 +       uint32          rxdup;          /* dot11FrameduplicateCount */
5955 +       uint32          txrts;          /* dot11RTSSuccessCount */
5956 +       uint32          txnocts;        /* dot11RTSFailureCount */
5957 +       uint32          txnoack;        /* dot11ACKFailureCount */
5958 +       uint32          rxfrag;         /* dot11ReceivedFragmentCount */
5959 +       uint32          rxmulti;        /* dot11MulticastReceivedFrameCount */
5960 +       uint32          rxcrc;          /* dot11FCSErrorCount */
5961 +       uint32          txfrmsnt;       /* dot11TransmittedFrameCount */
5962 +       uint32          rxundec;        /* dot11WEPUndecryptableCount */
5963 +} d11cnt_t;
5964 +
5965 +/* BRCM OUI */
5966 +#define BRCM_OUI               "\x00\x10\x18"
5967 +
5968 +/* BRCM info element */
5969 +struct brcm_ie {
5970 +       uchar   id;             /* 221, DOT11_MNG_PROPR_ID */
5971 +       uchar   len;
5972 +       uchar   oui[3];
5973 +       uchar   ver;
5974 +       uchar   assoc;          /*  # of assoc STAs */
5975 +       uchar   flags;          /* misc flags */
5976 +} PACKED;
5977 +#define BRCM_IE_LEN            8
5978 +typedef        struct brcm_ie brcm_ie_t;
5979 +#define BRCM_IE_VER            2
5980 +#define BRCM_IE_LEGACY_AES_VER 1
5981 +
5982 +/* brcm_ie flags */
5983 +#define        BRF_ABCAP               0x1     /* afterburner capable */
5984 +#define        BRF_ABRQRD              0x2     /* afterburner requested */
5985 +#define        BRF_LZWDS               0x4     /* lazy wds enabled */
5986 +#define BRF_ABCOUNTER_MASK     0xf0  /* afterburner wds "state" counter */
5987 +#define BRF_ABCOUNTER_SHIFT    4
5988 +
5989 +#define AB_WDS_TIMEOUT_MAX     15              /* afterburner wds Max count indicating not locally capable */
5990 +#define AB_WDS_TIMEOUT_MIN     1               /* afterburner wds, use zero count as indicating "downrev" */
5991 +
5992 +
5993 +/* OUI for BRCM proprietary IE */
5994 +#define BRCM_PROP_OUI          "\x00\x90\x4C"
5995 +
5996 +/* Vendor IE structure */
5997 +struct vndr_ie {
5998 +       uchar id;
5999 +       uchar len;
6000 +       uchar oui [3];
6001 +       uchar data [1];         /* Variable size data */
6002 +}PACKED;
6003 +typedef struct vndr_ie vndr_ie_t;
6004 +
6005 +#define VNDR_IE_HDR_LEN                2       /* id + len field */
6006 +#define VNDR_IE_MIN_LEN                3       /* size of the oui field */
6007 +#define VNDR_IE_MAX_LEN                256
6008 +
6009 +/* WPA definitions */
6010 +#define WPA_VERSION            1
6011 +#define WPA_OUI                        "\x00\x50\xF2"
6012 +
6013 +#ifdef BCMWPA2
6014 +#define WPA2_VERSION           1
6015 +#define WPA2_VERSION_LEN       2
6016 +#define WPA2_OUI               "\x00\x0F\xAC"
6017 +#endif /* BCMWPA2 */
6018 +
6019 +#define WPA_OUI_LEN    3
6020 +
6021 +/* RSN authenticated key managment suite */
6022 +#define RSN_AKM_NONE           0       /* None (IBSS) */
6023 +#define RSN_AKM_UNSPECIFIED    1       /* Over 802.1x */
6024 +#define RSN_AKM_PSK            2       /* Pre-shared Key */
6025 +
6026 +
6027 +/* Key related defines */
6028 +#define DOT11_MAX_DEFAULT_KEYS 4       /* number of default keys */
6029 +#define DOT11_MAX_KEY_SIZE     32      /* max size of any key */
6030 +#define DOT11_MAX_IV_SIZE      16      /* max size of any IV */
6031 +#define DOT11_EXT_IV_FLAG      (1<<5)  /* flag to indicate IV is > 4 bytes */
6032 +
6033 +#define WEP1_KEY_SIZE          5       /* max size of any WEP key */
6034 +#define WEP1_KEY_HEX_SIZE      10      /* size of WEP key in hex. */
6035 +#define WEP128_KEY_SIZE                13      /* max size of any WEP key */
6036 +#define WEP128_KEY_HEX_SIZE    26      /* size of WEP key in hex. */
6037 +#define TKIP_MIC_SIZE          8       /* size of TKIP MIC */
6038 +#define TKIP_EOM_SIZE          7       /* max size of TKIP EOM */
6039 +#define TKIP_EOM_FLAG          0x5a    /* TKIP EOM flag byte */
6040 +#define TKIP_KEY_SIZE          32      /* size of any TKIP key */
6041 +#define TKIP_MIC_AUTH_TX       16      /* offset to Authenticator MIC TX key */
6042 +#define TKIP_MIC_AUTH_RX       24      /* offset to Authenticator MIC RX key */
6043 +#define TKIP_MIC_SUP_RX                16      /* offset to Supplicant MIC RX key */
6044 +#define TKIP_MIC_SUP_TX                24      /* offset to Supplicant MIC TX key */
6045 +#define AES_KEY_SIZE           16      /* size of AES key */
6046 +
6047 +#undef PACKED
6048 +#if !defined(__GNUC__)
6049 +#pragma pack()
6050 +#endif
6051 +
6052 +#endif /* _802_11_H_ */
6053 diff -Nur linux-2.4.32/arch/mips/bcm947xx/include/proto/bcmeth.h linux-2.4.32-brcm/arch/mips/bcm947xx/include/proto/bcmeth.h
6054 --- linux-2.4.32/arch/mips/bcm947xx/include/proto/bcmeth.h      1970-01-01 01:00:00.000000000 +0100
6055 +++ linux-2.4.32-brcm/arch/mips/bcm947xx/include/proto/bcmeth.h 2005-12-16 23:39:10.756825000 +0100
6056 @@ -0,0 +1,103 @@
6057 +/*
6058 + * Broadcom Ethernettype  protocol definitions
6059 + *
6060 + * Copyright 2005, Broadcom Corporation
6061 + * All Rights Reserved.
6062 + *
6063 + * THIS SOFTWARE IS OFFERED "AS IS", AND BROADCOM GRANTS NO WARRANTIES OF ANY
6064 + * KIND, EXPRESS OR IMPLIED, BY STATUTE, COMMUNICATION OR OTHERWISE. BROADCOM
6065 + * SPECIFICALLY DISCLAIMS ANY IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS
6066 + * FOR A SPECIFIC PURPOSE OR NONINFRINGEMENT CONCERNING THIS SOFTWARE.
6067 + *
6068 + */
6069 +
6070 +/*
6071 + * Broadcom Ethernet protocol defines
6072 + *
6073 + */
6074 +
6075 +#ifndef _BCMETH_H_
6076 +#define _BCMETH_H_
6077 +
6078 +/* enable structure packing */
6079 +#if defined(__GNUC__)
6080 +#define        PACKED  __attribute__((packed))
6081 +#else
6082 +#pragma pack(1)
6083 +#define        PACKED
6084 +#endif
6085 +
6086 +/* ETHER_TYPE_BRCM is defined in ethernet.h */
6087 +
6088 +/*
6089 + * Following the 2byte BRCM ether_type is a 16bit BRCM subtype field
6090 + * in one of two formats: (only subtypes 32768-65535 are in use now)
6091 + *
6092 + * subtypes 0-32767:
6093 + *     8 bit subtype (0-127)
6094 + *     8 bit length in bytes (0-255)
6095 + *
6096 + * subtypes 32768-65535:
6097 + *     16 bit big-endian subtype
6098 + *     16 bit big-endian length in bytes (0-65535)
6099 + *
6100 + * length is the number of additional bytes beyond the 4 or 6 byte header
6101 + *
6102 + * Reserved values:
6103 + * 0 reserved
6104 + * 5-15 reserved for iLine protocol assignments
6105 + * 17-126 reserved, assignable
6106 + * 127 reserved
6107 + * 32768 reserved
6108 + * 32769-65534 reserved, assignable
6109 + * 65535 reserved
6110 + */
6111 +
6112 +/*
6113 + * While adding the subtypes and their specific processing code make sure
6114 + * bcmeth_bcm_hdr_t is the first data structure in the user specific data structure definition
6115 + */
6116 +
6117 +#define        BCMILCP_SUBTYPE_RATE            1
6118 +#define        BCMILCP_SUBTYPE_LINK            2
6119 +#define        BCMILCP_SUBTYPE_CSA             3
6120 +#define        BCMILCP_SUBTYPE_LARQ            4
6121 +#define BCMILCP_SUBTYPE_VENDOR         5
6122 +#define        BCMILCP_SUBTYPE_FLH             17
6123 +
6124 +#define BCMILCP_SUBTYPE_VENDOR_LONG    32769
6125 +#define BCMILCP_SUBTYPE_CERT           32770
6126 +#define BCMILCP_SUBTYPE_SES            32771
6127 +
6128 +
6129 +#define BCMILCP_BCM_SUBTYPE_RESERVED   0
6130 +#define BCMILCP_BCM_SUBTYPE_EVENT              1
6131 +#define BCMILCP_BCM_SUBTYPE_SES                        2
6132 +/*
6133 +The EAPOL type is not used anymore. Instead EAPOL messages are now embedded
6134 +within BCMILCP_BCM_SUBTYPE_EVENT type messages
6135 +*/
6136 +/*#define BCMILCP_BCM_SUBTYPE_EAPOL            3*/
6137 +
6138 +#define BCMILCP_BCM_SUBTYPEHDR_MINLENGTH       8
6139 +#define BCMILCP_BCM_SUBTYPEHDR_VERSION         0
6140 +
6141 +/* These fields are stored in network order */
6142 +typedef  struct bcmeth_hdr
6143 +{
6144 +       uint16  subtype; /* Vendor specific..32769*/
6145 +       uint16  length;
6146 +       uint8   version; /* Version is 0*/
6147 +       uint8   oui[3]; /* Broadcom OUI*/
6148 +       /* user specific Data */
6149 +       uint16  usr_subtype;
6150 +} PACKED bcmeth_hdr_t;
6151 +
6152 +
6153 +
6154 +#undef PACKED
6155 +#if !defined(__GNUC__)
6156 +#pragma pack()
6157 +#endif
6158 +
6159 +#endif
6160 diff -Nur linux-2.4.32/arch/mips/bcm947xx/include/proto/bcmip.h linux-2.4.32-brcm/arch/mips/bcm947xx/include/proto/bcmip.h
6161 --- linux-2.4.32/arch/mips/bcm947xx/include/proto/bcmip.h       1970-01-01 01:00:00.000000000 +0100
6162 +++ linux-2.4.32-brcm/arch/mips/bcm947xx/include/proto/bcmip.h  2005-12-16 23:39:10.756825000 +0100
6163 @@ -0,0 +1,42 @@
6164 +/*
6165 + * Copyright 2005, Broadcom Corporation
6166 + * All Rights Reserved.
6167 + *
6168 + * This is UNPUBLISHED PROPRIETARY SOURCE CODE of Broadcom Corporation;
6169 + * the contents of this file may not be disclosed to third parties, copied
6170 + * or duplicated in any form, in whole or in part, without the prior
6171 + * written permission of Broadcom Corporation.
6172 + *
6173 + * Fundamental constants relating to IP Protocol
6174 + *
6175 + * $Id$
6176 + */
6177 +
6178 +#ifndef _bcmip_h_
6179 +#define _bcmip_h_
6180 +
6181 +/* IP header */
6182 +#define IPV4_VERIHL_OFFSET     0       /* version and ihl byte offset */
6183 +#define IPV4_TOS_OFFSET                1       /* TOS offset */
6184 +#define IPV4_PROT_OFFSET       9       /* protocol type offset */
6185 +#define IPV4_CHKSUM_OFFSET     10      /* IP header checksum offset */
6186 +#define IPV4_SRC_IP_OFFSET     12      /* src IP addr offset */
6187 +#define IPV4_DEST_IP_OFFSET    16      /* dest IP addr offset */
6188 +
6189 +#define IPV4_VER_MASK  0xf0
6190 +#define IPV4_IHL_MASK  0x0f
6191 +
6192 +#define IPV4_PROT_UDP  17      /* UDP protocol type */
6193 +
6194 +#define IPV4_ADDR_LEN  4       /* IP v4 address length */
6195 +
6196 +#define IPV4_VER_NUM   0x40    /* IP v4 version number */
6197 +
6198 +/* NULL IP address check */
6199 +#define IPV4_ISNULLADDR(a)     ((((uint8 *)(a))[0] + ((uint8 *)(a))[1] + \
6200 +                               ((uint8 *)(a))[2] + ((uint8 *)(a))[3]) == 0)
6201 +
6202 +#define IPV4_ADDR_STR_LEN      16
6203 +
6204 +#endif /* #ifndef _bcmip_h_ */
6205 +
6206 diff -Nur linux-2.4.32/arch/mips/bcm947xx/include/proto/ethernet.h linux-2.4.32-brcm/arch/mips/bcm947xx/include/proto/ethernet.h
6207 --- linux-2.4.32/arch/mips/bcm947xx/include/proto/ethernet.h    1970-01-01 01:00:00.000000000 +0100
6208 +++ linux-2.4.32-brcm/arch/mips/bcm947xx/include/proto/ethernet.h       2005-12-16 23:39:10.756825000 +0100
6209 @@ -0,0 +1,169 @@
6210 +/*******************************************************************************
6211 + * $Id$
6212 + * Copyright 2005, Broadcom Corporation
6213 + * All Rights Reserved.
6214 + *
6215 + * THIS SOFTWARE IS OFFERED "AS IS", AND BROADCOM GRANTS NO WARRANTIES OF ANY
6216 + * KIND, EXPRESS OR IMPLIED, BY STATUTE, COMMUNICATION OR OTHERWISE. BROADCOM
6217 + * SPECIFICALLY DISCLAIMS ANY IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS
6218 + * FOR A SPECIFIC PURPOSE OR NONINFRINGEMENT CONCERNING THIS SOFTWARE.
6219 + * From FreeBSD 2.2.7: Fundamental constants relating to ethernet.
6220 + ******************************************************************************/
6221 +
6222 +#ifndef _NET_ETHERNET_H_           /* use native BSD ethernet.h when available */
6223 +#define _NET_ETHERNET_H_
6224 +
6225 +#ifndef _TYPEDEFS_H_
6226 +#include "typedefs.h"
6227 +#endif
6228 +
6229 +/* enable structure packing */
6230 +#if defined(__GNUC__)
6231 +#define        PACKED  __attribute__((packed))
6232 +#else
6233 +#pragma pack(1)
6234 +#define        PACKED
6235 +#endif
6236 +
6237 +/*
6238 + * The number of bytes in an ethernet (MAC) address.
6239 + */
6240 +#define        ETHER_ADDR_LEN          6
6241 +
6242 +/*
6243 + * The number of bytes in the type field.
6244 + */
6245 +#define        ETHER_TYPE_LEN          2
6246 +
6247 +/*
6248 + * The number of bytes in the trailing CRC field.
6249 + */
6250 +#define        ETHER_CRC_LEN           4
6251 +
6252 +/*
6253 + * The length of the combined header.
6254 + */
6255 +#define        ETHER_HDR_LEN           (ETHER_ADDR_LEN*2+ETHER_TYPE_LEN)
6256 +
6257 +/*
6258 + * The minimum packet length.
6259 + */
6260 +#define        ETHER_MIN_LEN           64
6261 +
6262 +/*
6263 + * The minimum packet user data length.
6264 + */
6265 +#define        ETHER_MIN_DATA          46
6266 +
6267 +/*
6268 + * The maximum packet length.
6269 + */
6270 +#define        ETHER_MAX_LEN           1518
6271 +
6272 +/*
6273 + * The maximum packet user data length.
6274 + */
6275 +#define        ETHER_MAX_DATA          1500
6276 +
6277 +/* ether types */
6278 +#define        ETHER_TYPE_IP           0x0800          /* IP */
6279 +#define ETHER_TYPE_ARP         0x0806          /* ARP */
6280 +#define ETHER_TYPE_8021Q       0x8100          /* 802.1Q */
6281 +#define        ETHER_TYPE_BRCM         0x886c          /* Broadcom Corp. */
6282 +#define        ETHER_TYPE_802_1X       0x888e          /* 802.1x */
6283 +#define        ETHER_TYPE_802_1X_PREAUTH       0x88c7  /* 802.1x preauthentication*/
6284 +
6285 +/* Broadcom subtype follows ethertype;  First 2 bytes are reserved; Next 2 are subtype; */
6286 +#define        ETHER_BRCM_SUBTYPE_LEN  4               /* Broadcom 4 byte subtype */
6287 +#define        ETHER_BRCM_CRAM         0x1             /* Broadcom subtype cram protocol */
6288 +
6289 +/* ether header */
6290 +#define ETHER_DEST_OFFSET      0               /* dest address offset */
6291 +#define ETHER_SRC_OFFSET       6               /* src address offset */
6292 +#define ETHER_TYPE_OFFSET      12              /* ether type offset */
6293 +
6294 +/*
6295 + * A macro to validate a length with
6296 + */
6297 +#define        ETHER_IS_VALID_LEN(foo) \
6298 +       ((foo) >= ETHER_MIN_LEN && (foo) <= ETHER_MAX_LEN)
6299 +
6300 +
6301 +#ifndef __INCif_etherh     /* Quick and ugly hack for VxWorks */
6302 +/*
6303 + * Structure of a 10Mb/s Ethernet header.
6304 + */
6305 +struct ether_header {
6306 +       uint8   ether_dhost[ETHER_ADDR_LEN];
6307 +       uint8   ether_shost[ETHER_ADDR_LEN];
6308 +       uint16  ether_type;
6309 +} PACKED;
6310 +
6311 +/*
6312 + * Structure of a 48-bit Ethernet address.
6313 + */
6314 +struct ether_addr {
6315 +       uint8 octet[ETHER_ADDR_LEN];
6316 +} PACKED;
6317 +#endif
6318 +
6319 +/*
6320 + * Takes a pointer, sets locally admininistered
6321 + * address bit in the 48-bit Ethernet address.
6322 + */
6323 +#define ETHER_SET_LOCALADDR(ea) ( ((uint8 *)(ea))[0] = \
6324 +                               (((uint8 *)(ea))[0] | 2) )
6325 +
6326 +/*
6327 + * Takes a pointer, returns true if a 48-bit multicast address
6328 + * (including broadcast, since it is all ones)
6329 + */
6330 +#define ETHER_ISMULTI(ea) (((uint8 *)(ea))[0] & 1)
6331 +
6332 +
6333 +/* compare two ethernet addresses - assumes the pointers can be referenced as shorts */
6334 +#define        ether_cmp(a, b) ( \
6335 +       !(((short*)a)[0] == ((short*)b)[0]) | \
6336 +       !(((short*)a)[1] == ((short*)b)[1]) | \
6337 +       !(((short*)a)[2] == ((short*)b)[2]))
6338 +
6339 +/* copy an ethernet address - assumes the pointers can be referenced as shorts */
6340 +#define        ether_copy(s, d) { \
6341 +       ((short*)d)[0] = ((short*)s)[0]; \
6342 +       ((short*)d)[1] = ((short*)s)[1]; \
6343 +       ((short*)d)[2] = ((short*)s)[2]; }
6344 +
6345 +/*
6346 + * Takes a pointer, returns true if a 48-bit broadcast (all ones)
6347 + */
6348 +#define ETHER_ISBCAST(ea) ((((uint8 *)(ea))[0] &               \
6349 +                           ((uint8 *)(ea))[1] &                \
6350 +                           ((uint8 *)(ea))[2] &                \
6351 +                           ((uint8 *)(ea))[3] &                \
6352 +                           ((uint8 *)(ea))[4] &                \
6353 +                           ((uint8 *)(ea))[5]) == 0xff)
6354 +
6355 +static const struct ether_addr ether_bcast = {{255, 255, 255, 255, 255, 255}};
6356 +
6357 +/*
6358 + * Takes a pointer, returns true if a 48-bit null address (all zeros)
6359 + */
6360 +#define ETHER_ISNULLADDR(ea) ((((uint8 *)(ea))[0] |            \
6361 +                           ((uint8 *)(ea))[1] |                \
6362 +                           ((uint8 *)(ea))[2] |                \
6363 +                           ((uint8 *)(ea))[3] |                \
6364 +                           ((uint8 *)(ea))[4] |                \
6365 +                           ((uint8 *)(ea))[5]) == 0)
6366 +
6367 +/* Differentiated Services Codepoint - upper 6 bits of tos in iphdr */
6368 +#define        DSCP_MASK               0xFC            /* upper 6 bits */
6369 +#define        DSCP_SHIFT              2
6370 +#define        DSCP_WME_PRI_MASK       0xE0            /* upper 3 bits */
6371 +#define        DSCP_WME_PRI_SHIFT      5
6372 +
6373 +#undef PACKED
6374 +#if !defined(__GNUC__)
6375 +#pragma pack()
6376 +#endif
6377 +
6378 +#endif /* _NET_ETHERNET_H_ */
6379 diff -Nur linux-2.4.32/arch/mips/bcm947xx/include/proto/vlan.h linux-2.4.32-brcm/arch/mips/bcm947xx/include/proto/vlan.h
6380 --- linux-2.4.32/arch/mips/bcm947xx/include/proto/vlan.h        1970-01-01 01:00:00.000000000 +0100
6381 +++ linux-2.4.32-brcm/arch/mips/bcm947xx/include/proto/vlan.h   2005-12-16 23:39:10.756825000 +0100
6382 @@ -0,0 +1,50 @@
6383 +/*
6384 + * 802.1Q VLAN protocol definitions
6385 + *
6386 + * Copyright 2005, Broadcom Corporation
6387 + * All Rights Reserved.
6388 + *
6389 + * THIS SOFTWARE IS OFFERED "AS IS", AND BROADCOM GRANTS NO WARRANTIES OF ANY
6390 + * KIND, EXPRESS OR IMPLIED, BY STATUTE, COMMUNICATION OR OTHERWISE. BROADCOM
6391 + * SPECIFICALLY DISCLAIMS ANY IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS
6392 + * FOR A SPECIFIC PURPOSE OR NONINFRINGEMENT CONCERNING THIS SOFTWARE.
6393 + *
6394 + * $Id$
6395 + */
6396 +
6397 +#ifndef _vlan_h_
6398 +#define _vlan_h_
6399 +
6400 +/* enable structure packing */
6401 +#if defined(__GNUC__)
6402 +#define        PACKED  __attribute__((packed))
6403 +#else
6404 +#pragma pack(1)
6405 +#define        PACKED
6406 +#endif
6407 +
6408 +#define VLAN_VID_MASK          0xfff   /* low 12 bits are vlan id */
6409 +#define        VLAN_CFI_SHIFT          12      /* canonical format indicator bit */
6410 +#define VLAN_PRI_SHIFT         13      /* user priority */
6411 +
6412 +#define VLAN_PRI_MASK          7       /* 3 bits of priority */
6413 +
6414 +#define        VLAN_TAG_LEN            4
6415 +#define        VLAN_TAG_OFFSET         (2 * ETHER_ADDR_LEN)
6416 +
6417 +struct ethervlan_header {
6418 +       uint8   ether_dhost[ETHER_ADDR_LEN];
6419 +       uint8   ether_shost[ETHER_ADDR_LEN];
6420 +       uint16  vlan_type;              /* 0x8100 */
6421 +       uint16  vlan_tag;               /* priority, cfi and vid */
6422 +       uint16  ether_type;
6423 +};
6424 +
6425 +#define        ETHERVLAN_HDR_LEN       (ETHER_HDR_LEN + VLAN_TAG_LEN)
6426 +
6427 +#undef PACKED
6428 +#if !defined(__GNUC__)
6429 +#pragma pack()
6430 +#endif
6431 +
6432 +#endif /* _vlan_h_ */
6433 diff -Nur linux-2.4.32/arch/mips/bcm947xx/include/proto/wpa.h linux-2.4.32-brcm/arch/mips/bcm947xx/include/proto/wpa.h
6434 --- linux-2.4.32/arch/mips/bcm947xx/include/proto/wpa.h 1970-01-01 01:00:00.000000000 +0100
6435 +++ linux-2.4.32-brcm/arch/mips/bcm947xx/include/proto/wpa.h    2005-12-16 23:39:10.756825000 +0100
6436 @@ -0,0 +1,140 @@
6437 +/*
6438 + * Fundamental types and constants relating to WPA
6439 + *
6440 + * Copyright 2005, Broadcom Corporation
6441 + * All Rights Reserved.
6442 + *
6443 + * THIS SOFTWARE IS OFFERED "AS IS", AND BROADCOM GRANTS NO WARRANTIES OF ANY
6444 + * KIND, EXPRESS OR IMPLIED, BY STATUTE, COMMUNICATION OR OTHERWISE. BROADCOM
6445 + * SPECIFICALLY DISCLAIMS ANY IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS
6446 + * FOR A SPECIFIC PURPOSE OR NONINFRINGEMENT CONCERNING THIS SOFTWARE.
6447 + *
6448 + * $Id$
6449 + */
6450 +
6451 +#ifndef _proto_wpa_h_
6452 +#define _proto_wpa_h_
6453 +
6454 +#include <typedefs.h>
6455 +#include <proto/ethernet.h>
6456 +
6457 +/* enable structure packing */
6458 +#if defined(__GNUC__)
6459 +#define        PACKED  __attribute__((packed))
6460 +#else
6461 +#pragma pack(1)
6462 +#define        PACKED
6463 +#endif
6464 +
6465 +/* Reason Codes */
6466 +
6467 +/* 10 and 11 are from TGh. */
6468 +#define DOT11_RC_BAD_PC                                10      /* Unacceptable power capability element */
6469 +#define DOT11_RC_BAD_CHANNELS                  11      /* Unacceptable supported channels element */
6470 +/* 12 is unused */
6471 +/* 13 through 23 taken from P802.11i/D3.0, November 2002 */
6472 +#define DOT11_RC_INVALID_WPA_IE                        13      /* Invalid info. element */
6473 +#define DOT11_RC_MIC_FAILURE                   14      /* Michael failure */
6474 +#define DOT11_RC_4WH_TIMEOUT                   15      /* 4-way handshake timeout */
6475 +#define DOT11_RC_GTK_UPDATE_TIMEOUT            16      /* Group key update timeout */
6476 +#define DOT11_RC_WPA_IE_MISMATCH               17      /* WPA IE in 4-way handshake differs from (re-)assoc. request/probe response */
6477 +#define DOT11_RC_INVALID_MC_CIPHER             18      /* Invalid multicast cipher */
6478 +#define DOT11_RC_INVALID_UC_CIPHER             19      /* Invalid unicast cipher */
6479 +#define DOT11_RC_INVALID_AKMP                  20      /* Invalid authenticated key management protocol */
6480 +#define DOT11_RC_BAD_WPA_VERSION               21      /* Unsupported WPA version */
6481 +#define DOT11_RC_INVALID_WPA_CAP               22      /* Invalid WPA IE capabilities */
6482 +#define DOT11_RC_8021X_AUTH_FAIL               23      /* 802.1X authentication failure */
6483 +
6484 +#define WPA2_PMKID_LEN 16
6485 +
6486 +/* WPA IE fixed portion */
6487 +typedef struct
6488 +{
6489 +       uint8 tag;      /* TAG */
6490 +       uint8 length;   /* TAG length */
6491 +       uint8 oui[3];   /* IE OUI */
6492 +       uint8 oui_type; /* OUI type */
6493 +       struct {
6494 +               uint8 low;
6495 +               uint8 high;
6496 +       } PACKED version;       /* IE version */
6497 +} PACKED wpa_ie_fixed_t;
6498 +#define WPA_IE_OUITYPE_LEN     4
6499 +#define WPA_IE_FIXED_LEN       8
6500 +#define WPA_IE_TAG_FIXED_LEN   6
6501 +
6502 +typedef struct {
6503 +       uint8 tag;      /* TAG */
6504 +       uint8 length;   /* TAG length */
6505 +       struct {
6506 +               uint8 low;
6507 +               uint8 high;
6508 +       } PACKED version;       /* IE version */
6509 +} PACKED wpa_rsn_ie_fixed_t;
6510 +#define WPA_RSN_IE_FIXED_LEN   4
6511 +#define WPA_RSN_IE_TAG_FIXED_LEN       2
6512 +typedef uint8 wpa_pmkid_t[WPA2_PMKID_LEN];
6513 +
6514 +/* WPA suite/multicast suite */
6515 +typedef struct
6516 +{
6517 +       uint8 oui[3];
6518 +       uint8 type;
6519 +} PACKED wpa_suite_t, wpa_suite_mcast_t;
6520 +#define WPA_SUITE_LEN  4
6521 +
6522 +/* WPA unicast suite list/key management suite list */
6523 +typedef struct
6524 +{
6525 +       struct {
6526 +               uint8 low;
6527 +               uint8 high;
6528 +       } PACKED count;
6529 +       wpa_suite_t list[1];
6530 +} PACKED wpa_suite_ucast_t, wpa_suite_auth_key_mgmt_t;
6531 +#define WPA_IE_SUITE_COUNT_LEN 2
6532 +typedef struct
6533 +{
6534 +       struct {
6535 +               uint8 low;
6536 +               uint8 high;
6537 +       } PACKED count;
6538 +       wpa_pmkid_t list[1];
6539 +} PACKED wpa_pmkid_list_t;
6540 +
6541 +/* WPA cipher suites */
6542 +#define WPA_CIPHER_NONE                0       /* None */
6543 +#define WPA_CIPHER_WEP_40      1       /* WEP (40-bit) */
6544 +#define WPA_CIPHER_TKIP                2       /* TKIP: default for WPA */
6545 +#define WPA_CIPHER_AES_OCB     3       /* AES (OCB) */
6546 +#define WPA_CIPHER_AES_CCM     4       /* AES (CCM) */
6547 +#define WPA_CIPHER_WEP_104     5       /* WEP (104-bit) */
6548 +
6549 +#define IS_WPA_CIPHER(cipher)  ((cipher) == WPA_CIPHER_NONE || \
6550 +                                (cipher) == WPA_CIPHER_WEP_40 || \
6551 +                                (cipher) == WPA_CIPHER_WEP_104 || \
6552 +                                (cipher) == WPA_CIPHER_TKIP || \
6553 +                                (cipher) == WPA_CIPHER_AES_OCB || \
6554 +                                (cipher) == WPA_CIPHER_AES_CCM)
6555 +
6556 +/* WPA TKIP countermeasures parameters */
6557 +#define WPA_TKIP_CM_DETECT     60      /* multiple MIC failure window (seconds) */
6558 +#define WPA_TKIP_CM_BLOCK      60      /* countermeasures active window (seconds) */
6559 +
6560 +/* WPA capabilities defined in 802.11i */
6561 +#define WPA_CAP_4_REPLAY_CNTRS         2
6562 +#define WPA_CAP_16_REPLAY_CNTRS                3
6563 +#define WPA_CAP_REPLAY_CNTR_SHIFT      2
6564 +#define WPA_CAP_REPLAY_CNTR_MASK       0x000c
6565 +
6566 +/* WPA Specific defines */
6567 +#define WPA_CAP_LEN    2
6568 +
6569 +#define        WPA_CAP_WPA2_PREAUTH            1
6570 +
6571 +#undef PACKED
6572 +#if !defined(__GNUC__)
6573 +#pragma pack()
6574 +#endif
6575 +
6576 +#endif /* _proto_wpa_h_ */
6577 diff -Nur linux-2.4.32/arch/mips/bcm947xx/include/rts/crc.h linux-2.4.32-brcm/arch/mips/bcm947xx/include/rts/crc.h
6578 --- linux-2.4.32/arch/mips/bcm947xx/include/rts/crc.h   1970-01-01 01:00:00.000000000 +0100
6579 +++ linux-2.4.32-brcm/arch/mips/bcm947xx/include/rts/crc.h      2005-12-16 23:39:10.928835750 +0100
6580 @@ -0,0 +1,69 @@
6581 +/*******************************************************************************
6582 + * $Id$
6583 + * Copyright 2005, Broadcom Corporation
6584 + * All Rights Reserved.
6585 + *
6586 + * THIS SOFTWARE IS OFFERED "AS IS", AND BROADCOM GRANTS NO WARRANTIES OF ANY
6587 + * KIND, EXPRESS OR IMPLIED, BY STATUTE, COMMUNICATION OR OTHERWISE. BROADCOM
6588 + * SPECIFICALLY DISCLAIMS ANY IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS
6589 + * FOR A SPECIFIC PURPOSE OR NONINFRINGEMENT CONCERNING THIS SOFTWARE.
6590 + * crc.h - a function to compute crc for iLine10 headers
6591 + ******************************************************************************/
6592 +
6593 +#ifndef _RTS_CRC_H_
6594 +#define _RTS_CRC_H_ 1
6595 +
6596 +#include "typedefs.h"
6597 +
6598 +#ifdef __cplusplus
6599 +extern "C" {
6600 +#endif
6601 +
6602 +
6603 +#define CRC8_INIT_VALUE  0xff       /* Initial CRC8 checksum value */
6604 +#define CRC8_GOOD_VALUE  0x9f       /* Good final CRC8 checksum value */
6605 +#define HCS_GOOD_VALUE   0x39       /* Good final header checksum value */
6606 +
6607 +#define CRC16_INIT_VALUE 0xffff     /* Initial CRC16 checksum value */
6608 +#define CRC16_GOOD_VALUE 0xf0b8     /* Good final CRC16 checksum value */
6609 +
6610 +#define CRC32_INIT_VALUE 0xffffffff /* Initial CRC32 checksum value */
6611 +#define CRC32_GOOD_VALUE 0xdebb20e3 /* Good final CRC32 checksum value */
6612 +
6613 +void   hcs(uint8 *, uint);
6614 +uint8  crc8(uint8 *, uint, uint8);
6615 +uint16 crc16(uint8 *, uint, uint16);
6616 +uint32 crc32(uint8 *, uint, uint32);
6617 +
6618 +/* macros for common usage */
6619 +
6620 +#define APPEND_CRC8(pbytes, nbytes)                           \
6621 +do {                                                          \
6622 +    uint8 tmp = crc8(pbytes, nbytes, CRC8_INIT_VALUE) ^ 0xff; \
6623 +    (pbytes)[(nbytes)] = tmp;                                 \
6624 +    (nbytes) += 1;                                            \
6625 +} while (0)
6626 +
6627 +#define APPEND_CRC16(pbytes, nbytes)                               \
6628 +do {                                                               \
6629 +    uint16 tmp = crc16(pbytes, nbytes, CRC16_INIT_VALUE) ^ 0xffff; \
6630 +    (pbytes)[(nbytes) + 0] = (tmp >> 0) & 0xff;                    \
6631 +    (pbytes)[(nbytes) + 1] = (tmp >> 8) & 0xff;                    \
6632 +    (nbytes) += 2;                                                 \
6633 +} while (0)
6634 +
6635 +#define APPEND_CRC32(pbytes, nbytes)                                   \
6636 +do {                                                                   \
6637 +    uint32 tmp = crc32(pbytes, nbytes, CRC32_INIT_VALUE) ^ 0xffffffff; \
6638 +    (pbytes)[(nbytes) + 0] = (tmp >>  0) & 0xff;                       \
6639 +    (pbytes)[(nbytes) + 1] = (tmp >>  8) & 0xff;                       \
6640 +    (pbytes)[(nbytes) + 2] = (tmp >> 16) & 0xff;                       \
6641 +    (pbytes)[(nbytes) + 3] = (tmp >> 24) & 0xff;                       \
6642 +    (nbytes) += 4;                                                     \
6643 +} while (0)
6644 +
6645 +#ifdef __cplusplus
6646 +}
6647 +#endif
6648 +
6649 +#endif /* _RTS_CRC_H_ */
6650 diff -Nur linux-2.4.32/arch/mips/bcm947xx/include/sbchipc.h linux-2.4.32-brcm/arch/mips/bcm947xx/include/sbchipc.h
6651 --- linux-2.4.32/arch/mips/bcm947xx/include/sbchipc.h   1970-01-01 01:00:00.000000000 +0100
6652 +++ linux-2.4.32-brcm/arch/mips/bcm947xx/include/sbchipc.h      2005-12-16 23:39:10.932836000 +0100
6653 @@ -0,0 +1,440 @@
6654 +/*
6655 + * SiliconBackplane Chipcommon core hardware definitions.
6656 + *
6657 + * The chipcommon core provides chip identification, SB control,
6658 + * jtag, 0/1/2 uarts, clock frequency control, a watchdog interrupt timer,
6659 + * gpio interface, extbus, and support for serial and parallel flashes.
6660 + *
6661 + * $Id$
6662 + * Copyright 2005, Broadcom Corporation
6663 + * All Rights Reserved.
6664 + *
6665 + * THIS SOFTWARE IS OFFERED "AS IS", AND BROADCOM GRANTS NO WARRANTIES OF ANY
6666 + * KIND, EXPRESS OR IMPLIED, BY STATUTE, COMMUNICATION OR OTHERWISE. BROADCOM
6667 + * SPECIFICALLY DISCLAIMS ANY IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS
6668 + * FOR A SPECIFIC PURPOSE OR NONINFRINGEMENT CONCERNING THIS SOFTWARE.
6669 + *
6670 + */
6671 +
6672 +#ifndef        _SBCHIPC_H
6673 +#define        _SBCHIPC_H
6674 +
6675 +
6676 +#ifndef _LANGUAGE_ASSEMBLY
6677 +
6678 +/* cpp contortions to concatenate w/arg prescan */
6679 +#ifndef PAD
6680 +#define        _PADLINE(line)  pad ## line
6681 +#define        _XSTR(line)     _PADLINE(line)
6682 +#define        PAD             _XSTR(__LINE__)
6683 +#endif /* PAD */
6684 +
6685 +typedef volatile struct {
6686 +       uint32  chipid;                 /* 0x0 */
6687 +       uint32  capabilities;
6688 +       uint32  corecontrol;            /* corerev >= 1 */
6689 +       uint32  bist;
6690 +
6691 +       /* OTP */
6692 +       uint32  otpstatus;              /* 0x10, corerev >= 10 */
6693 +       uint32  otpcontrol;
6694 +       uint32  otpprog;
6695 +       uint32  PAD;
6696 +
6697 +       /* Interrupt control */
6698 +       uint32  intstatus;              /* 0x20 */
6699 +       uint32  intmask;
6700 +       uint32  chipcontrol;            /* 0x28, rev >= 11 */
6701 +       uint32  chipstatus;             /* 0x2c, rev >= 11 */
6702 +
6703 +       /* Jtag Master */
6704 +       uint32  jtagcmd;                /* 0x30, rev >= 10 */
6705 +       uint32  jtagir;
6706 +       uint32  jtagdr;
6707 +       uint32  jtagctrl;
6708 +
6709 +       /* serial flash interface registers */
6710 +       uint32  flashcontrol;           /* 0x40 */
6711 +       uint32  flashaddress;
6712 +       uint32  flashdata;
6713 +       uint32  PAD[1];
6714 +
6715 +       /* Silicon backplane configuration broadcast control */
6716 +       uint32  broadcastaddress;       /* 0x50 */
6717 +       uint32  broadcastdata;
6718 +       uint32  PAD[2];
6719 +
6720 +       /* gpio - cleared only by power-on-reset */
6721 +       uint32  gpioin;                 /* 0x60 */
6722 +       uint32  gpioout;
6723 +       uint32  gpioouten;
6724 +       uint32  gpiocontrol;
6725 +       uint32  gpiointpolarity;
6726 +       uint32  gpiointmask;
6727 +       uint32  PAD[2];
6728 +
6729 +       /* Watchdog timer */
6730 +       uint32  watchdog;               /* 0x80 */
6731 +       uint32  PAD[1];
6732 +
6733 +       /*GPIO based LED powersave registers corerev >= 16*/
6734 +       uint32  gpiotimerval;           /*0x88 */
6735 +       uint32  gpiotimeroutmask;
6736 +
6737 +       /* clock control */
6738 +       uint32  clockcontrol_n;         /* 0x90 */
6739 +       uint32  clockcontrol_sb;        /* aka m0 */
6740 +       uint32  clockcontrol_pci;       /* aka m1 */
6741 +       uint32  clockcontrol_m2;        /* mii/uart/mipsref */
6742 +       uint32  clockcontrol_mips;      /* aka m3 */
6743 +       uint32  clkdiv;                 /* corerev >= 3 */
6744 +       uint32  PAD[2];
6745 +
6746 +       /* pll delay registers (corerev >= 4) */
6747 +       uint32  pll_on_delay;           /* 0xb0 */
6748 +       uint32  fref_sel_delay;
6749 +       uint32  slow_clk_ctl;           /* 5 < corerev < 10 */
6750 +       uint32  PAD[1];
6751 +
6752 +       /* Instaclock registers (corerev >= 10) */
6753 +       uint32  system_clk_ctl;         /* 0xc0 */
6754 +       uint32  clkstatestretch;
6755 +       uint32  PAD[14];
6756 +
6757 +       /* ExtBus control registers (corerev >= 3) */
6758 +       uint32  pcmcia_config;          /* 0x100 */
6759 +       uint32  pcmcia_memwait;
6760 +       uint32  pcmcia_attrwait;
6761 +       uint32  pcmcia_iowait;
6762 +       uint32  ide_config;
6763 +       uint32  ide_memwait;
6764 +       uint32  ide_attrwait;
6765 +       uint32  ide_iowait;
6766 +       uint32  prog_config;
6767 +       uint32  prog_waitcount;
6768 +       uint32  flash_config;
6769 +       uint32  flash_waitcount;
6770 +       uint32  PAD[116];
6771 +
6772 +       /* uarts */
6773 +       uint8   uart0data;              /* 0x300 */
6774 +       uint8   uart0imr;
6775 +       uint8   uart0fcr;
6776 +       uint8   uart0lcr;
6777 +       uint8   uart0mcr;
6778 +       uint8   uart0lsr;
6779 +       uint8   uart0msr;
6780 +       uint8   uart0scratch;
6781 +       uint8   PAD[248];               /* corerev >= 1 */
6782 +
6783 +       uint8   uart1data;              /* 0x400 */
6784 +       uint8   uart1imr;
6785 +       uint8   uart1fcr;
6786 +       uint8   uart1lcr;
6787 +       uint8   uart1mcr;
6788 +       uint8   uart1lsr;
6789 +       uint8   uart1msr;
6790 +       uint8   uart1scratch;
6791 +} chipcregs_t;
6792 +
6793 +#endif /* _LANGUAGE_ASSEMBLY */
6794 +
6795 +#define        CC_CHIPID               0
6796 +#define        CC_CAPABILITIES         4
6797 +#define        CC_JTAGCMD              0x30
6798 +#define        CC_JTAGIR               0x34
6799 +#define        CC_JTAGDR               0x38
6800 +#define        CC_JTAGCTRL             0x3c
6801 +#define        CC_WATCHDOG             0x80
6802 +#define        CC_CLKC_N               0x90
6803 +#define        CC_CLKC_M0              0x94
6804 +#define        CC_CLKC_M1              0x98
6805 +#define        CC_CLKC_M2              0x9c
6806 +#define        CC_CLKC_M3              0xa0
6807 +#define        CC_CLKDIV               0xa4
6808 +#define        CC_SYS_CLK_CTL          0xc0
6809 +#define        CC_OTP                  0x800
6810 +
6811 +/* chipid */
6812 +#define        CID_ID_MASK             0x0000ffff              /* Chip Id mask */
6813 +#define        CID_REV_MASK            0x000f0000              /* Chip Revision mask */
6814 +#define        CID_REV_SHIFT           16                      /* Chip Revision shift */
6815 +#define        CID_PKG_MASK            0x00f00000              /* Package Option mask */
6816 +#define        CID_PKG_SHIFT           20                      /* Package Option shift */
6817 +#define        CID_CC_MASK             0x0f000000              /* CoreCount (corerev >= 4) */
6818 +#define CID_CC_SHIFT           24
6819 +
6820 +/* capabilities */
6821 +#define        CAP_UARTS_MASK          0x00000003              /* Number of uarts */
6822 +#define CAP_MIPSEB             0x00000004              /* MIPS is in big-endian mode */
6823 +#define CAP_UCLKSEL            0x00000018              /* UARTs clock select */
6824 +#define CAP_UINTCLK            0x00000008              /* UARTs are driven by internal divided clock */
6825 +#define CAP_UARTGPIO           0x00000020              /* UARTs own Gpio's 15:12 */
6826 +#define CAP_EXTBUS             0x00000040              /* External bus present */
6827 +#define        CAP_FLASH_MASK          0x00000700              /* Type of flash */
6828 +#define        CAP_PLL_MASK            0x00038000              /* Type of PLL */
6829 +#define CAP_PWR_CTL            0x00040000              /* Power control */
6830 +#define CAP_OTPSIZE            0x00380000              /* OTP Size (0 = none) */
6831 +#define CAP_OTPSIZE_SHIFT      19                      /* OTP Size shift */
6832 +#define CAP_OTPSIZE_BASE       5                       /* OTP Size base */
6833 +#define CAP_JTAGP              0x00400000              /* JTAG Master Present */
6834 +#define CAP_ROM                        0x00800000              /* Internal boot rom active */
6835 +
6836 +/* PLL type */
6837 +#define PLL_NONE               0x00000000
6838 +#define PLL_TYPE1              0x00010000              /* 48Mhz base, 3 dividers */
6839 +#define PLL_TYPE2              0x00020000              /* 48Mhz, 4 dividers */
6840 +#define PLL_TYPE3              0x00030000              /* 25Mhz, 2 dividers */
6841 +#define PLL_TYPE4              0x00008000              /* 48Mhz, 4 dividers */
6842 +#define PLL_TYPE5              0x00018000              /* 25Mhz, 4 dividers */
6843 +#define PLL_TYPE6              0x00028000              /* 100/200 or 120/240 only */
6844 +#define PLL_TYPE7              0x00038000              /* 25Mhz, 4 dividers */
6845 +
6846 +/* corecontrol */
6847 +#define CC_UARTCLKO            0x00000001              /* Drive UART with internal clock */
6848 +#define        CC_SE                   0x00000002              /* sync clk out enable (corerev >= 3) */
6849 +
6850 +/* Fields in the otpstatus register */
6851 +#define        OTPS_PROGFAIL           0x80000000
6852 +#define        OTPS_PROTECT            0x00000007
6853 +#define        OTPS_HW_PROTECT         0x00000001
6854 +#define        OTPS_SW_PROTECT         0x00000002
6855 +#define        OTPS_CID_PROTECT        0x00000004
6856 +
6857 +/* Fields in the otpcontrol register */
6858 +#define        OTPC_RECWAIT            0xff000000
6859 +#define        OTPC_PROGWAIT           0x00ffff00
6860 +#define        OTPC_PRW_SHIFT          8
6861 +#define        OTPC_MAXFAIL            0x00000038
6862 +#define        OTPC_VSEL               0x00000006
6863 +#define        OTPC_SELVL              0x00000001
6864 +
6865 +/* Fields in otpprog */
6866 +#define        OTPP_COL_MASK           0x000000ff
6867 +#define        OTPP_ROW_MASK           0x0000ff00
6868 +#define        OTPP_ROW_SHIFT          8
6869 +#define        OTPP_READERR            0x10000000
6870 +#define        OTPP_VALUE              0x20000000
6871 +#define        OTPP_VALUE_SHIFT                29
6872 +#define        OTPP_READ               0x40000000
6873 +#define        OTPP_START              0x80000000
6874 +#define        OTPP_BUSY               0x80000000
6875 +
6876 +/* jtagcmd */
6877 +#define JCMD_START             0x80000000
6878 +#define JCMD_BUSY              0x80000000
6879 +#define JCMD_PAUSE             0x40000000
6880 +#define JCMD0_ACC_MASK         0x0000f000
6881 +#define JCMD0_ACC_IRDR         0x00000000
6882 +#define JCMD0_ACC_DR           0x00001000
6883 +#define JCMD0_ACC_IR           0x00002000
6884 +#define JCMD0_ACC_RESET                0x00003000
6885 +#define JCMD0_ACC_IRPDR                0x00004000
6886 +#define JCMD0_ACC_PDR          0x00005000
6887 +#define JCMD0_IRW_MASK         0x00000f00
6888 +#define JCMD_ACC_MASK          0x000f0000              /* Changes for corerev 11 */
6889 +#define JCMD_ACC_IRDR          0x00000000
6890 +#define JCMD_ACC_DR            0x00010000
6891 +#define JCMD_ACC_IR            0x00020000
6892 +#define JCMD_ACC_RESET         0x00030000
6893 +#define JCMD_ACC_IRPDR         0x00040000
6894 +#define JCMD_ACC_PDR           0x00050000
6895 +#define JCMD_IRW_MASK          0x00001f00
6896 +#define JCMD_IRW_SHIFT         8
6897 +#define JCMD_DRW_MASK          0x0000003f
6898 +
6899 +/* jtagctrl */
6900 +#define JCTRL_FORCE_CLK                4                       /* Force clock */
6901 +#define JCTRL_EXT_EN           2                       /* Enable external targets */
6902 +#define JCTRL_EN               1                       /* Enable Jtag master */
6903 +
6904 +/* Fields in clkdiv */
6905 +#define        CLKD_SFLASH             0x0f000000
6906 +#define        CLKD_SFLASH_SHIFT       24
6907 +#define        CLKD_OTP                0x000f0000
6908 +#define        CLKD_OTP_SHIFT          16
6909 +#define        CLKD_JTAG               0x00000f00
6910 +#define        CLKD_JTAG_SHIFT         8
6911 +#define        CLKD_UART               0x000000ff
6912 +
6913 +/* intstatus/intmask */
6914 +#define        CI_GPIO                 0x00000001              /* gpio intr */
6915 +#define        CI_EI                   0x00000002              /* ro: ext intr pin (corerev >= 3) */
6916 +#define        CI_WDRESET              0x80000000              /* watchdog reset occurred */
6917 +
6918 +/* slow_clk_ctl */
6919 +#define SCC_SS_MASK            0x00000007              /* slow clock source mask */
6920 +#define        SCC_SS_LPO              0x00000000              /* source of slow clock is LPO */
6921 +#define        SCC_SS_XTAL             0x00000001              /* source of slow clock is crystal */
6922 +#define        SCC_SS_PCI              0x00000002              /* source of slow clock is PCI */
6923 +#define SCC_LF                 0x00000200              /* LPOFreqSel, 1: 160Khz, 0: 32KHz */
6924 +#define SCC_LP                 0x00000400              /* LPOPowerDown, 1: LPO is disabled, 0: LPO is enabled */
6925 +#define SCC_FS                 0x00000800              /* ForceSlowClk, 1: sb/cores running on slow clock, 0: power logic control */
6926 +#define SCC_IP                 0x00001000              /* IgnorePllOffReq, 1/0: power logic ignores/honors PLL clock disable requests from core */
6927 +#define SCC_XC                 0x00002000              /* XtalControlEn, 1/0: power logic does/doesn't disable crystal when appropriate */
6928 +#define SCC_XP                 0x00004000              /* XtalPU (RO), 1/0: crystal running/disabled */
6929 +#define SCC_CD_MASK            0xffff0000              /* ClockDivider (SlowClk = 1/(4+divisor)) */
6930 +#define SCC_CD_SHIFT           16
6931 +
6932 +/* system_clk_ctl */
6933 +#define        SYCC_IE                 0x00000001              /* ILPen: Enable Idle Low Power */
6934 +#define        SYCC_AE                 0x00000002              /* ALPen: Enable Active Low Power */
6935 +#define        SYCC_FP                 0x00000004              /* ForcePLLOn */
6936 +#define        SYCC_AR                 0x00000008              /* Force ALP (or HT if ALPen is not set */
6937 +#define        SYCC_HR                 0x00000010              /* Force HT */
6938 +#define SYCC_CD_MASK           0xffff0000              /* ClkDiv  (ILP = 1/(4+divisor)) */
6939 +#define SYCC_CD_SHIFT          16
6940 +
6941 +/* gpiotimerval*/
6942 +#define GPIO_ONTIME_SHIFT      16
6943 +
6944 +/* clockcontrol_n */
6945 +#define        CN_N1_MASK              0x3f                    /* n1 control */
6946 +#define        CN_N2_MASK              0x3f00                  /* n2 control */
6947 +#define        CN_N2_SHIFT             8
6948 +#define        CN_PLLC_MASK            0xf0000                 /* pll control */
6949 +#define        CN_PLLC_SHIFT           16
6950 +
6951 +/* clockcontrol_sb/pci/uart */
6952 +#define        CC_M1_MASK              0x3f                    /* m1 control */
6953 +#define        CC_M2_MASK              0x3f00                  /* m2 control */
6954 +#define        CC_M2_SHIFT             8
6955 +#define        CC_M3_MASK              0x3f0000                /* m3 control */
6956 +#define        CC_M3_SHIFT             16
6957 +#define        CC_MC_MASK              0x1f000000              /* mux control */
6958 +#define        CC_MC_SHIFT             24
6959 +
6960 +/* N3M Clock control magic field values */
6961 +#define        CC_F6_2                 0x02                    /* A factor of 2 in */
6962 +#define        CC_F6_3                 0x03                    /* 6-bit fields like */
6963 +#define        CC_F6_4                 0x05                    /* N1, M1 or M3 */
6964 +#define        CC_F6_5                 0x09
6965 +#define        CC_F6_6                 0x11
6966 +#define        CC_F6_7                 0x21
6967 +
6968 +#define        CC_F5_BIAS              5                       /* 5-bit fields get this added */
6969 +
6970 +#define        CC_MC_BYPASS            0x08
6971 +#define        CC_MC_M1                0x04
6972 +#define        CC_MC_M1M2              0x02
6973 +#define        CC_MC_M1M2M3            0x01
6974 +#define        CC_MC_M1M3              0x11
6975 +
6976 +/* Type 2 Clock control magic field values */
6977 +#define        CC_T2_BIAS              2                       /* n1, n2, m1 & m3 bias */
6978 +#define        CC_T2M2_BIAS            3                       /* m2 bias */
6979 +
6980 +#define        CC_T2MC_M1BYP           1
6981 +#define        CC_T2MC_M2BYP           2
6982 +#define        CC_T2MC_M3BYP           4
6983 +
6984 +/* Type 6 Clock control magic field values */
6985 +#define        CC_T6_MMASK             1                       /* bits of interest in m */
6986 +#define        CC_T6_M0                120000000               /* sb clock for m = 0 */
6987 +#define        CC_T6_M1                100000000               /* sb clock for m = 1 */
6988 +#define        SB2MIPS_T6(sb)          (2 * (sb))
6989 +
6990 +/* Common clock base */
6991 +#define        CC_CLOCK_BASE1          24000000                /* Half the clock freq */
6992 +#define CC_CLOCK_BASE2         12500000                /* Alternate crystal on some PLL's */
6993 +
6994 +/* Clock control values for 200Mhz in 5350 */
6995 +#define        CLKC_5350_N             0x0311
6996 +#define        CLKC_5350_M             0x04020009
6997 +
6998 +/* Flash types in the chipcommon capabilities register */
6999 +#define FLASH_NONE             0x000           /* No flash */
7000 +#define SFLASH_ST              0x100           /* ST serial flash */
7001 +#define SFLASH_AT              0x200           /* Atmel serial flash */
7002 +#define        PFLASH                  0x700           /* Parallel flash */
7003 +
7004 +/* Bits in the config registers */
7005 +#define        CC_CFG_EN               0x0001          /* Enable */
7006 +#define        CC_CFG_EM_MASK          0x000e          /* Extif Mode */
7007 +#define        CC_CFG_EM_ASYNC         0x0002          /*   Async/Parallel flash */
7008 +#define        CC_CFG_EM_SYNC          0x0004          /*   Synchronous */
7009 +#define        CC_CFG_EM_PCMCIA        0x0008          /*   PCMCIA */
7010 +#define        CC_CFG_EM_IDE           0x000a          /*   IDE */
7011 +#define        CC_CFG_DS               0x0010          /* Data size, 0=8bit, 1=16bit */
7012 +#define        CC_CFG_CD_MASK          0x0060          /* Sync: Clock divisor */
7013 +#define        CC_CFG_CE               0x0080          /* Sync: Clock enable */
7014 +#define        CC_CFG_SB               0x0100          /* Sync: Size/Bytestrobe */
7015 +
7016 +/* Start/busy bit in flashcontrol */
7017 +#define SFLASH_START           0x80000000
7018 +#define SFLASH_BUSY            SFLASH_START
7019 +
7020 +/* flashcontrol opcodes for ST flashes */
7021 +#define SFLASH_ST_WREN         0x0006          /* Write Enable */
7022 +#define SFLASH_ST_WRDIS                0x0004          /* Write Disable */
7023 +#define SFLASH_ST_RDSR         0x0105          /* Read Status Register */
7024 +#define SFLASH_ST_WRSR         0x0101          /* Write Status Register */
7025 +#define SFLASH_ST_READ         0x0303          /* Read Data Bytes */
7026 +#define SFLASH_ST_PP           0x0302          /* Page Program */
7027 +#define SFLASH_ST_SE           0x02d8          /* Sector Erase */
7028 +#define SFLASH_ST_BE           0x00c7          /* Bulk Erase */
7029 +#define SFLASH_ST_DP           0x00b9          /* Deep Power-down */
7030 +#define SFLASH_ST_RES          0x03ab          /* Read Electronic Signature */
7031 +
7032 +/* Status register bits for ST flashes */
7033 +#define SFLASH_ST_WIP          0x01            /* Write In Progress */
7034 +#define SFLASH_ST_WEL          0x02            /* Write Enable Latch */
7035 +#define SFLASH_ST_BP_MASK      0x1c            /* Block Protect */
7036 +#define SFLASH_ST_BP_SHIFT     2
7037 +#define SFLASH_ST_SRWD         0x80            /* Status Register Write Disable */
7038 +
7039 +/* flashcontrol opcodes for Atmel flashes */
7040 +#define SFLASH_AT_READ                         0x07e8
7041 +#define SFLASH_AT_PAGE_READ                    0x07d2
7042 +#define SFLASH_AT_BUF1_READ
7043 +#define SFLASH_AT_BUF2_READ
7044 +#define SFLASH_AT_STATUS                       0x01d7
7045 +#define SFLASH_AT_BUF1_WRITE                   0x0384
7046 +#define SFLASH_AT_BUF2_WRITE                   0x0387
7047 +#define SFLASH_AT_BUF1_ERASE_PROGRAM           0x0283
7048 +#define SFLASH_AT_BUF2_ERASE_PROGRAM           0x0286
7049 +#define SFLASH_AT_BUF1_PROGRAM                 0x0288
7050 +#define SFLASH_AT_BUF2_PROGRAM                 0x0289
7051 +#define SFLASH_AT_PAGE_ERASE                   0x0281
7052 +#define SFLASH_AT_BLOCK_ERASE                  0x0250
7053 +#define SFLASH_AT_BUF1_WRITE_ERASE_PROGRAM     0x0382
7054 +#define SFLASH_AT_BUF2_WRITE_ERASE_PROGRAM     0x0385
7055 +#define SFLASH_AT_BUF1_LOAD                    0x0253
7056 +#define SFLASH_AT_BUF2_LOAD                    0x0255
7057 +#define SFLASH_AT_BUF1_COMPARE                 0x0260
7058 +#define SFLASH_AT_BUF2_COMPARE                 0x0261
7059 +#define SFLASH_AT_BUF1_REPROGRAM               0x0258
7060 +#define SFLASH_AT_BUF2_REPROGRAM               0x0259
7061 +
7062 +/* Status register bits for Atmel flashes */
7063 +#define SFLASH_AT_READY                                0x80
7064 +#define SFLASH_AT_MISMATCH                     0x40
7065 +#define SFLASH_AT_ID_MASK                      0x38
7066 +#define SFLASH_AT_ID_SHIFT                     3
7067 +
7068 +/* OTP regions */
7069 +#define        OTP_HW_REGION   OTPS_HW_PROTECT
7070 +#define        OTP_SW_REGION   OTPS_SW_PROTECT
7071 +#define        OTP_CID_REGION  OTPS_CID_PROTECT
7072 +
7073 +/* OTP regions (Byte offsets from otp size) */
7074 +#define        OTP_SWLIM_OFF   (-8)
7075 +#define        OTP_CIDBASE_OFF 0
7076 +#define        OTP_CIDLIM_OFF  8
7077 +
7078 +/* Predefined OTP words (Word offset from otp size) */
7079 +#define        OTP_BOUNDARY_OFF (-4)
7080 +#define        OTP_HWSIGN_OFF  (-3)
7081 +#define        OTP_SWSIGN_OFF  (-2)
7082 +#define        OTP_CIDSIGN_OFF (-1)
7083 +
7084 +#define        OTP_CID_OFF     0
7085 +#define        OTP_PKG_OFF     1
7086 +#define        OTP_FID_OFF     2
7087 +#define        OTP_RSV_OFF     3
7088 +#define        OTP_LIM_OFF     4
7089 +
7090 +#define        OTP_SIGNATURE   0x578a
7091 +#define        OTP_MAGIC       0x4e56
7092 +
7093 +#endif /* _SBCHIPC_H */
7094 diff -Nur linux-2.4.32/arch/mips/bcm947xx/include/sbconfig.h linux-2.4.32-brcm/arch/mips/bcm947xx/include/sbconfig.h
7095 --- linux-2.4.32/arch/mips/bcm947xx/include/sbconfig.h  1970-01-01 01:00:00.000000000 +0100
7096 +++ linux-2.4.32-brcm/arch/mips/bcm947xx/include/sbconfig.h     2005-12-16 23:39:10.932836000 +0100
7097 @@ -0,0 +1,342 @@
7098 +/*
7099 + * Broadcom SiliconBackplane hardware register definitions.
7100 + *
7101 + * Copyright 2005, Broadcom Corporation
7102 + * All Rights Reserved.
7103 + *
7104 + * THIS SOFTWARE IS OFFERED "AS IS", AND BROADCOM GRANTS NO WARRANTIES OF ANY
7105 + * KIND, EXPRESS OR IMPLIED, BY STATUTE, COMMUNICATION OR OTHERWISE. BROADCOM
7106 + * SPECIFICALLY DISCLAIMS ANY IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS
7107 + * FOR A SPECIFIC PURPOSE OR NONINFRINGEMENT CONCERNING THIS SOFTWARE.
7108 + * $Id$
7109 + */
7110 +
7111 +#ifndef        _SBCONFIG_H
7112 +#define        _SBCONFIG_H
7113 +
7114 +/* cpp contortions to concatenate w/arg prescan */
7115 +#ifndef PAD
7116 +#define        _PADLINE(line)  pad ## line
7117 +#define        _XSTR(line)     _PADLINE(line)
7118 +#define        PAD             _XSTR(__LINE__)
7119 +#endif
7120 +
7121 +/*
7122 + * SiliconBackplane Address Map.
7123 + * All regions may not exist on all chips.
7124 + */
7125 +#define SB_SDRAM_BASE          0x00000000      /* Physical SDRAM */
7126 +#define SB_PCI_MEM             0x08000000      /* Host Mode sb2pcitranslation0 (64 MB) */
7127 +#define SB_PCI_CFG             0x0c000000      /* Host Mode sb2pcitranslation1 (64 MB) */
7128 +#define        SB_SDRAM_SWAPPED        0x10000000      /* Byteswapped Physical SDRAM */
7129 +#define SB_ENUM_BASE           0x18000000      /* Enumeration space base */
7130 +#define        SB_ENUM_LIM             0x18010000      /* Enumeration space limit */
7131 +
7132 +#define        SB_FLASH2               0x1c000000      /* Flash Region 2 (region 1 shadowed here) */
7133 +#define        SB_FLASH2_SZ            0x02000000      /* Size of Flash Region 2 */
7134 +
7135 +#define        SB_EXTIF_BASE           0x1f000000      /* External Interface region base address */
7136 +#define        SB_FLASH1               0x1fc00000      /* Flash Region 1 */
7137 +#define        SB_FLASH1_SZ            0x00400000      /* Size of Flash Region 1 */
7138 +
7139 +#define SB_PCI_DMA             0x40000000      /* Client Mode sb2pcitranslation2 (1 GB) */
7140 +#define SB_PCI_DMA_SZ          0x40000000      /* Client Mode sb2pcitranslation2 size in bytes */
7141 +#define SB_PCIE_DMA_L32                0x00000000      /* PCIE Client Mode sb2pcitranslation2 (2 ZettaBytes), low 32 bits */
7142 +#define SB_PCIE_DMA_H32                0x80000000      /* PCIE Client Mode sb2pcitranslation2 (2 ZettaBytes), high 32 bits */
7143 +#define        SB_EUART                (SB_EXTIF_BASE + 0x00800000)
7144 +#define        SB_LED                  (SB_EXTIF_BASE + 0x00900000)
7145 +
7146 +
7147 +/* enumeration space related defs */
7148 +#define SB_CORE_SIZE           0x1000          /* each core gets 4Kbytes for registers */
7149 +#define        SB_MAXCORES             ((SB_ENUM_LIM - SB_ENUM_BASE)/SB_CORE_SIZE)
7150 +#define        SBCONFIGOFF             0xf00           /* core sbconfig regs are top 256bytes of regs */
7151 +#define        SBCONFIGSIZE            256             /* sizeof (sbconfig_t) */
7152 +
7153 +/* mips address */
7154 +#define        SB_EJTAG                0xff200000      /* MIPS EJTAG space (2M) */
7155 +
7156 +/*
7157 + * Sonics Configuration Space Registers.
7158 + */
7159 +#define SBIPSFLAG              0x08
7160 +#define SBTPSFLAG              0x18
7161 +#define        SBTMERRLOGA             0x48            /* sonics >= 2.3 */
7162 +#define        SBTMERRLOG              0x50            /* sonics >= 2.3 */
7163 +#define SBADMATCH3             0x60
7164 +#define SBADMATCH2             0x68
7165 +#define SBADMATCH1             0x70
7166 +#define SBIMSTATE              0x90
7167 +#define SBINTVEC               0x94
7168 +#define SBTMSTATELOW           0x98
7169 +#define SBTMSTATEHIGH          0x9c
7170 +#define SBBWA0                 0xa0
7171 +#define SBIMCONFIGLOW          0xa8
7172 +#define SBIMCONFIGHIGH         0xac
7173 +#define SBADMATCH0             0xb0
7174 +#define SBTMCONFIGLOW          0xb8
7175 +#define SBTMCONFIGHIGH         0xbc
7176 +#define SBBCONFIG              0xc0
7177 +#define SBBSTATE               0xc8
7178 +#define SBACTCNFG              0xd8
7179 +#define        SBFLAGST                0xe8
7180 +#define SBIDLOW                        0xf8
7181 +#define SBIDHIGH               0xfc
7182 +
7183 +#ifndef _LANGUAGE_ASSEMBLY
7184 +
7185 +typedef volatile struct _sbconfig {
7186 +       uint32  PAD[2];
7187 +       uint32  sbipsflag;              /* initiator port ocp slave flag */
7188 +       uint32  PAD[3];
7189 +       uint32  sbtpsflag;              /* target port ocp slave flag */
7190 +       uint32  PAD[11];
7191 +       uint32  sbtmerrloga;            /* (sonics >= 2.3) */
7192 +       uint32  PAD;
7193 +       uint32  sbtmerrlog;             /* (sonics >= 2.3) */
7194 +       uint32  PAD[3];
7195 +       uint32  sbadmatch3;             /* address match3 */
7196 +       uint32  PAD;
7197 +       uint32  sbadmatch2;             /* address match2 */
7198 +       uint32  PAD;
7199 +       uint32  sbadmatch1;             /* address match1 */
7200 +       uint32  PAD[7];
7201 +       uint32  sbimstate;              /* initiator agent state */
7202 +       uint32  sbintvec;               /* interrupt mask */
7203 +       uint32  sbtmstatelow;           /* target state */
7204 +       uint32  sbtmstatehigh;          /* target state */
7205 +       uint32  sbbwa0;                 /* bandwidth allocation table0 */
7206 +       uint32  PAD;
7207 +       uint32  sbimconfiglow;          /* initiator configuration */
7208 +       uint32  sbimconfighigh;         /* initiator configuration */
7209 +       uint32  sbadmatch0;             /* address match0 */
7210 +       uint32  PAD;
7211 +       uint32  sbtmconfiglow;          /* target configuration */
7212 +       uint32  sbtmconfighigh;         /* target configuration */
7213 +       uint32  sbbconfig;              /* broadcast configuration */
7214 +       uint32  PAD;
7215 +       uint32  sbbstate;               /* broadcast state */
7216 +       uint32  PAD[3];
7217 +       uint32  sbactcnfg;              /* activate configuration */
7218 +       uint32  PAD[3];
7219 +       uint32  sbflagst;               /* current sbflags */
7220 +       uint32  PAD[3];
7221 +       uint32  sbidlow;                /* identification */
7222 +       uint32  sbidhigh;               /* identification */
7223 +} sbconfig_t;
7224 +
7225 +#endif /* _LANGUAGE_ASSEMBLY */
7226 +
7227 +/* sbipsflag */
7228 +#define        SBIPS_INT1_MASK         0x3f            /* which sbflags get routed to mips interrupt 1 */
7229 +#define        SBIPS_INT1_SHIFT        0
7230 +#define        SBIPS_INT2_MASK         0x3f00          /* which sbflags get routed to mips interrupt 2 */
7231 +#define        SBIPS_INT2_SHIFT        8
7232 +#define        SBIPS_INT3_MASK         0x3f0000        /* which sbflags get routed to mips interrupt 3 */
7233 +#define        SBIPS_INT3_SHIFT        16
7234 +#define        SBIPS_INT4_MASK         0x3f000000      /* which sbflags get routed to mips interrupt 4 */
7235 +#define        SBIPS_INT4_SHIFT        24
7236 +
7237 +/* sbtpsflag */
7238 +#define        SBTPS_NUM0_MASK         0x3f            /* interrupt sbFlag # generated by this core */
7239 +#define        SBTPS_F0EN0             0x40            /* interrupt is always sent on the backplane */
7240 +
7241 +/* sbtmerrlog */
7242 +#define        SBTMEL_CM               0x00000007      /* command */
7243 +#define        SBTMEL_CI               0x0000ff00      /* connection id */
7244 +#define        SBTMEL_EC               0x0f000000      /* error code */
7245 +#define        SBTMEL_ME               0x80000000      /* multiple error */
7246 +
7247 +/* sbimstate */
7248 +#define        SBIM_PC                 0xf             /* pipecount */
7249 +#define        SBIM_AP_MASK            0x30            /* arbitration policy */
7250 +#define        SBIM_AP_BOTH            0x00            /* use both timeslaces and token */
7251 +#define        SBIM_AP_TS              0x10            /* use timesliaces only */
7252 +#define        SBIM_AP_TK              0x20            /* use token only */
7253 +#define        SBIM_AP_RSV             0x30            /* reserved */
7254 +#define        SBIM_IBE                0x20000         /* inbanderror */
7255 +#define        SBIM_TO                 0x40000         /* timeout */
7256 +#define        SBIM_BY                 0x01800000      /* busy (sonics >= 2.3) */
7257 +#define        SBIM_RJ                 0x02000000      /* reject (sonics >= 2.3) */
7258 +
7259 +/* sbtmstatelow */
7260 +#define        SBTML_RESET             0x1             /* reset */
7261 +#define        SBTML_REJ_MASK          0x6             /* reject */
7262 +#define        SBTML_REJ_SHIFT         1
7263 +#define        SBTML_CLK               0x10000         /* clock enable */
7264 +#define        SBTML_FGC               0x20000         /* force gated clocks on */
7265 +#define        SBTML_FL_MASK           0x3ffc0000      /* core-specific flags */
7266 +#define        SBTML_PE                0x40000000      /* pme enable */
7267 +#define        SBTML_BE                0x80000000      /* bist enable */
7268 +
7269 +/* sbtmstatehigh */
7270 +#define        SBTMH_SERR              0x1             /* serror */
7271 +#define        SBTMH_INT               0x2             /* interrupt */
7272 +#define        SBTMH_BUSY              0x4             /* busy */
7273 +#define        SBTMH_TO                0x00000020      /* timeout (sonics >= 2.3) */
7274 +#define        SBTMH_FL_MASK           0x1fff0000      /* core-specific flags */
7275 +#define SBTMH_DMA64            0x10000000      /* supports DMA with 64-bit addresses */
7276 +#define        SBTMH_GCR               0x20000000      /* gated clock request */
7277 +#define        SBTMH_BISTF             0x40000000      /* bist failed */
7278 +#define        SBTMH_BISTD             0x80000000      /* bist done */
7279 +
7280 +
7281 +/* sbbwa0 */
7282 +#define        SBBWA_TAB0_MASK         0xffff          /* lookup table 0 */
7283 +#define        SBBWA_TAB1_MASK         0xffff          /* lookup table 1 */
7284 +#define        SBBWA_TAB1_SHIFT        16
7285 +
7286 +/* sbimconfiglow */
7287 +#define        SBIMCL_STO_MASK         0x7             /* service timeout */
7288 +#define        SBIMCL_RTO_MASK         0x70            /* request timeout */
7289 +#define        SBIMCL_RTO_SHIFT        4
7290 +#define        SBIMCL_CID_MASK         0xff0000        /* connection id */
7291 +#define        SBIMCL_CID_SHIFT        16
7292 +
7293 +/* sbimconfighigh */
7294 +#define        SBIMCH_IEM_MASK         0xc             /* inband error mode */
7295 +#define        SBIMCH_TEM_MASK         0x30            /* timeout error mode */
7296 +#define        SBIMCH_TEM_SHIFT        4
7297 +#define        SBIMCH_BEM_MASK         0xc0            /* bus error mode */
7298 +#define        SBIMCH_BEM_SHIFT        6
7299 +
7300 +/* sbadmatch0 */
7301 +#define        SBAM_TYPE_MASK          0x3             /* address type */
7302 +#define        SBAM_AD64               0x4             /* reserved */
7303 +#define        SBAM_ADINT0_MASK        0xf8            /* type0 size */
7304 +#define        SBAM_ADINT0_SHIFT       3
7305 +#define        SBAM_ADINT1_MASK        0x1f8           /* type1 size */
7306 +#define        SBAM_ADINT1_SHIFT       3
7307 +#define        SBAM_ADINT2_MASK        0x1f8           /* type2 size */
7308 +#define        SBAM_ADINT2_SHIFT       3
7309 +#define        SBAM_ADEN               0x400           /* enable */
7310 +#define        SBAM_ADNEG              0x800           /* negative decode */
7311 +#define        SBAM_BASE0_MASK         0xffffff00      /* type0 base address */
7312 +#define        SBAM_BASE0_SHIFT        8
7313 +#define        SBAM_BASE1_MASK         0xfffff000      /* type1 base address for the core */
7314 +#define        SBAM_BASE1_SHIFT        12
7315 +#define        SBAM_BASE2_MASK         0xffff0000      /* type2 base address for the core */
7316 +#define        SBAM_BASE2_SHIFT        16
7317 +
7318 +/* sbtmconfiglow */
7319 +#define        SBTMCL_CD_MASK          0xff            /* clock divide */
7320 +#define        SBTMCL_CO_MASK          0xf800          /* clock offset */
7321 +#define        SBTMCL_CO_SHIFT         11
7322 +#define        SBTMCL_IF_MASK          0xfc0000        /* interrupt flags */
7323 +#define        SBTMCL_IF_SHIFT         18
7324 +#define        SBTMCL_IM_MASK          0x3000000       /* interrupt mode */
7325 +#define        SBTMCL_IM_SHIFT         24
7326 +
7327 +/* sbtmconfighigh */
7328 +#define        SBTMCH_BM_MASK          0x3             /* busy mode */
7329 +#define        SBTMCH_RM_MASK          0x3             /* retry mode */
7330 +#define        SBTMCH_RM_SHIFT         2
7331 +#define        SBTMCH_SM_MASK          0x30            /* stop mode */
7332 +#define        SBTMCH_SM_SHIFT         4
7333 +#define        SBTMCH_EM_MASK          0x300           /* sb error mode */
7334 +#define        SBTMCH_EM_SHIFT         8
7335 +#define        SBTMCH_IM_MASK          0xc00           /* int mode */
7336 +#define        SBTMCH_IM_SHIFT         10
7337 +
7338 +/* sbbconfig */
7339 +#define        SBBC_LAT_MASK           0x3             /* sb latency */
7340 +#define        SBBC_MAX0_MASK          0xf0000         /* maxccntr0 */
7341 +#define        SBBC_MAX0_SHIFT         16
7342 +#define        SBBC_MAX1_MASK          0xf00000        /* maxccntr1 */
7343 +#define        SBBC_MAX1_SHIFT         20
7344 +
7345 +/* sbbstate */
7346 +#define        SBBS_SRD                0x1             /* st reg disable */
7347 +#define        SBBS_HRD                0x2             /* hold reg disable */
7348 +
7349 +/* sbidlow */
7350 +#define        SBIDL_CS_MASK           0x3             /* config space */
7351 +#define        SBIDL_AR_MASK           0x38            /* # address ranges supported */
7352 +#define        SBIDL_AR_SHIFT          3
7353 +#define        SBIDL_SYNCH             0x40            /* sync */
7354 +#define        SBIDL_INIT              0x80            /* initiator */
7355 +#define        SBIDL_MINLAT_MASK       0xf00           /* minimum backplane latency */
7356 +#define        SBIDL_MINLAT_SHIFT      8
7357 +#define        SBIDL_MAXLAT            0xf000          /* maximum backplane latency */
7358 +#define        SBIDL_MAXLAT_SHIFT      12
7359 +#define        SBIDL_FIRST             0x10000         /* this initiator is first */
7360 +#define        SBIDL_CW_MASK           0xc0000         /* cycle counter width */
7361 +#define        SBIDL_CW_SHIFT          18
7362 +#define        SBIDL_TP_MASK           0xf00000        /* target ports */
7363 +#define        SBIDL_TP_SHIFT          20
7364 +#define        SBIDL_IP_MASK           0xf000000       /* initiator ports */
7365 +#define        SBIDL_IP_SHIFT          24
7366 +#define        SBIDL_RV_MASK           0xf0000000      /* sonics backplane revision code */
7367 +#define        SBIDL_RV_SHIFT          28
7368 +#define        SBIDL_RV_2_2            0x00000000      /* version 2.2 or earlier */
7369 +#define        SBIDL_RV_2_3            0x10000000      /* version 2.3 */
7370 +
7371 +/* sbidhigh */
7372 +#define        SBIDH_RC_MASK           0x000f          /* revision code */
7373 +#define        SBIDH_RCE_MASK          0x7000          /* revision code extension field */
7374 +#define        SBIDH_RCE_SHIFT         8
7375 +#define        SBCOREREV(sbidh) \
7376 +       ((((sbidh) & SBIDH_RCE_MASK) >> SBIDH_RCE_SHIFT) | ((sbidh) & SBIDH_RC_MASK))
7377 +#define        SBIDH_CC_MASK           0x8ff0          /* core code */
7378 +#define        SBIDH_CC_SHIFT          4
7379 +#define        SBIDH_VC_MASK           0xffff0000      /* vendor code */
7380 +#define        SBIDH_VC_SHIFT          16
7381 +
7382 +#define        SB_COMMIT               0xfd8           /* update buffered registers value */
7383 +
7384 +/* vendor codes */
7385 +#define        SB_VEND_BCM             0x4243          /* Broadcom's SB vendor code */
7386 +
7387 +/* core codes */
7388 +#define        SB_CC                   0x800           /* chipcommon core */
7389 +#define        SB_ILINE20              0x801           /* iline20 core */
7390 +#define        SB_SDRAM                0x803           /* sdram core */
7391 +#define        SB_PCI                  0x804           /* pci core */
7392 +#define        SB_MIPS                 0x805           /* mips core */
7393 +#define        SB_ENET                 0x806           /* enet mac core */
7394 +#define        SB_CODEC                0x807           /* v90 codec core */
7395 +#define        SB_USB                  0x808           /* usb 1.1 host/device core */
7396 +#define        SB_ADSL                 0x809           /* ADSL core */
7397 +#define        SB_ILINE100             0x80a           /* iline100 core */
7398 +#define        SB_IPSEC                0x80b           /* ipsec core */
7399 +#define        SB_PCMCIA               0x80d           /* pcmcia core */
7400 +#define        SB_SOCRAM               0x80e           /* internal memory core */
7401 +#define        SB_MEMC                 0x80f           /* memc sdram core */
7402 +#define        SB_EXTIF                0x811           /* external interface core */
7403 +#define        SB_D11                  0x812           /* 802.11 MAC core */
7404 +#define        SB_MIPS33               0x816           /* mips3302 core */
7405 +#define        SB_USB11H               0x817           /* usb 1.1 host core */
7406 +#define        SB_USB11D               0x818           /* usb 1.1 device core */
7407 +#define        SB_USB20H               0x819           /* usb 2.0 host core */
7408 +#define        SB_USB20D               0x81a           /* usb 2.0 device core */
7409 +#define        SB_SDIOH                0x81b           /* sdio host core */
7410 +#define        SB_ROBO                 0x81c           /* roboswitch core */
7411 +#define        SB_ATA100               0x81d           /* parallel ATA core */
7412 +#define        SB_SATAXOR              0x81e           /* serial ATA & XOR DMA core */
7413 +#define        SB_GIGETH               0x81f           /* gigabit ethernet core */
7414 +#define        SB_PCIE                 0x820           /* pci express core */
7415 +#define        SB_SRAMC                0x822           /* SRAM controller core */
7416 +#define        SB_MINIMAC              0x823           /* MINI MAC/phy core */
7417 +
7418 +#define        SB_CC_IDX               0               /* chipc, when present, is always core 0 */
7419 +
7420 +/* Not really related to Silicon Backplane, but a couple of software
7421 + * conventions for the use the flash space:
7422 + */
7423 +
7424 +/* Minumum amount of flash we support */
7425 +#define FLASH_MIN              0x00020000      /* Minimum flash size */
7426 +
7427 +/* A boot/binary may have an embedded block that describes its size  */
7428 +#define        BISZ_OFFSET             0x3e0           /* At this offset into the binary */
7429 +#define        BISZ_MAGIC              0x4249535a      /* Marked with this value: 'BISZ' */
7430 +#define        BISZ_MAGIC_IDX          0               /* Word 0: magic */
7431 +#define        BISZ_TXTST_IDX          1               /*      1: text start */
7432 +#define        BISZ_TXTEND_IDX         2               /*      2: text start */
7433 +#define        BISZ_DATAST_IDX         3               /*      3: text start */
7434 +#define        BISZ_DATAEND_IDX        4               /*      4: text start */
7435 +#define        BISZ_BSSST_IDX          5               /*      5: text start */
7436 +#define        BISZ_BSSEND_IDX         6               /*      6: text start */
7437 +#define BISZ_SIZE              7               /* descriptor size in 32-bit intergers */
7438 +
7439 +#endif /* _SBCONFIG_H */
7440 diff -Nur linux-2.4.32/arch/mips/bcm947xx/include/sbextif.h linux-2.4.32-brcm/arch/mips/bcm947xx/include/sbextif.h
7441 --- linux-2.4.32/arch/mips/bcm947xx/include/sbextif.h   1970-01-01 01:00:00.000000000 +0100
7442 +++ linux-2.4.32-brcm/arch/mips/bcm947xx/include/sbextif.h      2005-12-16 23:39:10.932836000 +0100
7443 @@ -0,0 +1,242 @@
7444 +/*
7445 + * Hardware-specific External Interface I/O core definitions
7446 + * for the BCM47xx family of SiliconBackplane-based chips.
7447 + *
7448 + * The External Interface core supports a total of three external chip selects
7449 + * supporting external interfaces. One of the external chip selects is
7450 + * used for Flash, one is used for PCMCIA, and the other may be
7451 + * programmed to support either a synchronous interface or an
7452 + * asynchronous interface. The asynchronous interface can be used to
7453 + * support external devices such as UARTs and the BCM2019 Bluetooth
7454 + * baseband processor.
7455 + * The external interface core also contains 2 on-chip 16550 UARTs, clock
7456 + * frequency control, a watchdog interrupt timer, and a GPIO interface.
7457 + *
7458 + * Copyright 2005, Broadcom Corporation
7459 + * All Rights Reserved.
7460 + *
7461 + * THIS SOFTWARE IS OFFERED "AS IS", AND BROADCOM GRANTS NO WARRANTIES OF ANY
7462 + * KIND, EXPRESS OR IMPLIED, BY STATUTE, COMMUNICATION OR OTHERWISE. BROADCOM
7463 + * SPECIFICALLY DISCLAIMS ANY IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS
7464 + * FOR A SPECIFIC PURPOSE OR NONINFRINGEMENT CONCERNING THIS SOFTWARE.
7465 + * $Id$
7466 + */
7467 +
7468 +#ifndef        _SBEXTIF_H
7469 +#define        _SBEXTIF_H
7470 +
7471 +/* external interface address space */
7472 +#define        EXTIF_PCMCIA_MEMBASE(x) (x)
7473 +#define        EXTIF_PCMCIA_IOBASE(x)  ((x) + 0x100000)
7474 +#define        EXTIF_PCMCIA_CFGBASE(x) ((x) + 0x200000)
7475 +#define        EXTIF_CFGIF_BASE(x)     ((x) + 0x800000)
7476 +#define        EXTIF_FLASH_BASE(x)     ((x) + 0xc00000)
7477 +
7478 +/* cpp contortions to concatenate w/arg prescan */
7479 +#ifndef PAD
7480 +#define        _PADLINE(line)  pad ## line
7481 +#define        _XSTR(line)     _PADLINE(line)
7482 +#define        PAD             _XSTR(__LINE__)
7483 +#endif /* PAD */
7484 +
7485 +/*
7486 + * The multiple instances of output and output enable registers
7487 + * are present to allow driver software for multiple cores to control
7488 + * gpio outputs without needing to share a single register pair.
7489 + */
7490 +struct gpiouser {
7491 +       uint32  out;
7492 +       uint32  outen;
7493 +};
7494 +#define        NGPIOUSER       5
7495 +
7496 +typedef volatile struct {
7497 +       uint32  corecontrol;
7498 +       uint32  extstatus;
7499 +       uint32  PAD[2];
7500 +
7501 +       /* pcmcia control registers */
7502 +       uint32  pcmcia_config;
7503 +       uint32  pcmcia_memwait;
7504 +       uint32  pcmcia_attrwait;
7505 +       uint32  pcmcia_iowait;
7506 +
7507 +       /* programmable interface control registers */
7508 +       uint32  prog_config;
7509 +       uint32  prog_waitcount;
7510 +
7511 +       /* flash control registers */
7512 +       uint32  flash_config;
7513 +       uint32  flash_waitcount;
7514 +       uint32  PAD[4];
7515 +
7516 +       uint32  watchdog;
7517 +
7518 +       /* clock control */
7519 +       uint32  clockcontrol_n;
7520 +       uint32  clockcontrol_sb;
7521 +       uint32  clockcontrol_pci;
7522 +       uint32  clockcontrol_mii;
7523 +       uint32  PAD[3];
7524 +
7525 +       /* gpio */
7526 +       uint32  gpioin;
7527 +       struct gpiouser gpio[NGPIOUSER];
7528 +       uint32  PAD;
7529 +       uint32  ejtagouten;
7530 +       uint32  gpiointpolarity;
7531 +       uint32  gpiointmask;
7532 +       uint32  PAD[153];
7533 +
7534 +       uint8   uartdata;
7535 +       uint8   PAD[3];
7536 +       uint8   uartimer;
7537 +       uint8   PAD[3];
7538 +       uint8   uartfcr;
7539 +       uint8   PAD[3];
7540 +       uint8   uartlcr;
7541 +       uint8   PAD[3];
7542 +       uint8   uartmcr;
7543 +       uint8   PAD[3];
7544 +       uint8   uartlsr;
7545 +       uint8   PAD[3];
7546 +       uint8   uartmsr;
7547 +       uint8   PAD[3];
7548 +       uint8   uartscratch;
7549 +       uint8   PAD[3];
7550 +} extifregs_t;
7551 +
7552 +/* corecontrol */
7553 +#define        CC_UE           (1 << 0)                /* uart enable */
7554 +
7555 +/* extstatus */
7556 +#define        ES_EM           (1 << 0)                /* endian mode (ro) */
7557 +#define        ES_EI           (1 << 1)                /* external interrupt pin (ro) */
7558 +#define        ES_GI           (1 << 2)                /* gpio interrupt pin (ro) */
7559 +
7560 +/* gpio bit mask */
7561 +#define GPIO_BIT0      (1 << 0)
7562 +#define GPIO_BIT1      (1 << 1)
7563 +#define GPIO_BIT2      (1 << 2)
7564 +#define GPIO_BIT3      (1 << 3)
7565 +#define GPIO_BIT4      (1 << 4)
7566 +#define GPIO_BIT5      (1 << 5)
7567 +#define GPIO_BIT6      (1 << 6)
7568 +#define GPIO_BIT7      (1 << 7)
7569 +
7570 +
7571 +/* pcmcia/prog/flash_config */
7572 +#define        CF_EN           (1 << 0)                /* enable */
7573 +#define        CF_EM_MASK      0xe                     /* mode */
7574 +#define        CF_EM_SHIFT     1
7575 +#define        CF_EM_FLASH     0x0                     /* flash/asynchronous mode */
7576 +#define        CF_EM_SYNC      0x2                     /* synchronous mode */
7577 +#define        CF_EM_PCMCIA    0x4                     /* pcmcia mode */
7578 +#define        CF_DS           (1 << 4)                /* destsize:  0=8bit, 1=16bit */
7579 +#define        CF_BS           (1 << 5)                /* byteswap */
7580 +#define        CF_CD_MASK      0xc0                    /* clock divider */
7581 +#define        CF_CD_SHIFT     6
7582 +#define        CF_CD_DIV2      0x0                     /* backplane/2 */
7583 +#define        CF_CD_DIV3      0x40                    /* backplane/3 */
7584 +#define        CF_CD_DIV4      0x80                    /* backplane/4 */
7585 +#define        CF_CE           (1 << 8)                /* clock enable */
7586 +#define        CF_SB           (1 << 9)                /* size/bytestrobe (synch only) */
7587 +
7588 +/* pcmcia_memwait */
7589 +#define        PM_W0_MASK      0x3f                    /* waitcount0 */
7590 +#define        PM_W1_MASK      0x1f00                  /* waitcount1 */
7591 +#define        PM_W1_SHIFT     8
7592 +#define        PM_W2_MASK      0x1f0000                /* waitcount2 */
7593 +#define        PM_W2_SHIFT     16
7594 +#define        PM_W3_MASK      0x1f000000              /* waitcount3 */
7595 +#define        PM_W3_SHIFT     24
7596 +
7597 +/* pcmcia_attrwait */
7598 +#define        PA_W0_MASK      0x3f                    /* waitcount0 */
7599 +#define        PA_W1_MASK      0x1f00                  /* waitcount1 */
7600 +#define        PA_W1_SHIFT     8
7601 +#define        PA_W2_MASK      0x1f0000                /* waitcount2 */
7602 +#define        PA_W2_SHIFT     16
7603 +#define        PA_W3_MASK      0x1f000000              /* waitcount3 */
7604 +#define        PA_W3_SHIFT     24
7605 +
7606 +/* pcmcia_iowait */
7607 +#define        PI_W0_MASK      0x3f                    /* waitcount0 */
7608 +#define        PI_W1_MASK      0x1f00                  /* waitcount1 */
7609 +#define        PI_W1_SHIFT     8
7610 +#define        PI_W2_MASK      0x1f0000                /* waitcount2 */
7611 +#define        PI_W2_SHIFT     16
7612 +#define        PI_W3_MASK      0x1f000000              /* waitcount3 */
7613 +#define        PI_W3_SHIFT     24
7614 +
7615 +/* prog_waitcount */
7616 +#define        PW_W0_MASK      0x0000001f                      /* waitcount0 */
7617 +#define        PW_W1_MASK      0x00001f00                      /* waitcount1 */
7618 +#define        PW_W1_SHIFT     8
7619 +#define        PW_W2_MASK      0x001f0000              /* waitcount2 */
7620 +#define        PW_W2_SHIFT     16
7621 +#define        PW_W3_MASK      0x1f000000              /* waitcount3 */
7622 +#define        PW_W3_SHIFT     24
7623 +
7624 +#define PW_W0       0x0000000c
7625 +#define PW_W1       0x00000a00
7626 +#define PW_W2       0x00020000
7627 +#define PW_W3       0x01000000
7628 +
7629 +/* flash_waitcount */
7630 +#define        FW_W0_MASK      0x1f                    /* waitcount0 */
7631 +#define        FW_W1_MASK      0x1f00                  /* waitcount1 */
7632 +#define        FW_W1_SHIFT     8
7633 +#define        FW_W2_MASK      0x1f0000                /* waitcount2 */
7634 +#define        FW_W2_SHIFT     16
7635 +#define        FW_W3_MASK      0x1f000000              /* waitcount3 */
7636 +#define        FW_W3_SHIFT     24
7637 +
7638 +/* watchdog */
7639 +#define WATCHDOG_CLOCK 48000000                /* Hz */
7640 +
7641 +/* clockcontrol_n */
7642 +#define        CN_N1_MASK      0x3f                    /* n1 control */
7643 +#define        CN_N2_MASK      0x3f00                  /* n2 control */
7644 +#define        CN_N2_SHIFT     8
7645 +
7646 +/* clockcontrol_sb/pci/mii */
7647 +#define        CC_M1_MASK      0x3f                    /* m1 control */
7648 +#define        CC_M2_MASK      0x3f00                  /* m2 control */
7649 +#define        CC_M2_SHIFT     8
7650 +#define        CC_M3_MASK      0x3f0000                /* m3 control */
7651 +#define        CC_M3_SHIFT     16
7652 +#define        CC_MC_MASK      0x1f000000              /* mux control */
7653 +#define        CC_MC_SHIFT     24
7654 +
7655 +/* Clock control default values */
7656 +#define CC_DEF_N       0x0009                  /* Default values for bcm4710 */
7657 +#define CC_DEF_100     0x04020011
7658 +#define CC_DEF_33      0x11030011
7659 +#define CC_DEF_25      0x11050011
7660 +
7661 +/* Clock control values for 125Mhz */
7662 +#define        CC_125_N        0x0802
7663 +#define        CC_125_M        0x04020009
7664 +#define        CC_125_M25      0x11090009
7665 +#define        CC_125_M33      0x11090005
7666 +
7667 +/* Clock control magic field values */
7668 +#define        CC_F6_2         0x02                    /* A factor of 2 in */
7669 +#define        CC_F6_3         0x03                    /*  6-bit fields like */
7670 +#define        CC_F6_4         0x05                    /*  N1, M1 or M3 */
7671 +#define        CC_F6_5         0x09
7672 +#define        CC_F6_6         0x11
7673 +#define        CC_F6_7         0x21
7674 +
7675 +#define        CC_F5_BIAS      5                       /* 5-bit fields get this added */
7676 +
7677 +#define        CC_MC_BYPASS    0x08
7678 +#define        CC_MC_M1        0x04
7679 +#define        CC_MC_M1M2      0x02
7680 +#define        CC_MC_M1M2M3    0x01
7681 +#define        CC_MC_M1M3      0x11
7682 +
7683 +#define        CC_CLOCK_BASE   24000000        /* Half the clock freq. in the 4710 */
7684 +
7685 +#endif /* _SBEXTIF_H */
7686 diff -Nur linux-2.4.32/arch/mips/bcm947xx/include/sbhnddma.h linux-2.4.32-brcm/arch/mips/bcm947xx/include/sbhnddma.h
7687 --- linux-2.4.32/arch/mips/bcm947xx/include/sbhnddma.h  1970-01-01 01:00:00.000000000 +0100
7688 +++ linux-2.4.32-brcm/arch/mips/bcm947xx/include/sbhnddma.h     2005-12-16 23:39:10.932836000 +0100
7689 @@ -0,0 +1,312 @@
7690 +/*
7691 + * Generic Broadcom Home Networking Division (HND) DMA engine HW interface
7692 + * This supports the following chips: BCM42xx, 44xx, 47xx .
7693 + *
7694 + * Copyright 2005, Broadcom Corporation
7695 + * All Rights Reserved.
7696 + *
7697 + * THIS SOFTWARE IS OFFERED "AS IS", AND BROADCOM GRANTS NO WARRANTIES OF ANY
7698 + * KIND, EXPRESS OR IMPLIED, BY STATUTE, COMMUNICATION OR OTHERWISE. BROADCOM
7699 + * SPECIFICALLY DISCLAIMS ANY IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS
7700 + * FOR A SPECIFIC PURPOSE OR NONINFRINGEMENT CONCERNING THIS SOFTWARE.
7701 + * $Id$
7702 + */
7703 +
7704 +#ifndef        _sbhnddma_h_
7705 +#define        _sbhnddma_h_
7706 +
7707 +
7708 +/* 2byte-wide pio register set per channel(xmt or rcv) */
7709 +typedef volatile struct {
7710 +       uint16  fifocontrol;
7711 +       uint16  fifodata;
7712 +       uint16  fifofree;       /* only valid in xmt channel, not in rcv channel */
7713 +       uint16  PAD;
7714 +} pio2regs_t;
7715 +
7716 +/* a pair of pio channels(tx and rx) */
7717 +typedef volatile struct {
7718 +       pio2regs_t      tx;
7719 +       pio2regs_t      rx;
7720 +} pio2regp_t;
7721 +
7722 +/* 4byte-wide pio register set per channel(xmt or rcv) */
7723 +typedef volatile struct {
7724 +       uint32  fifocontrol;
7725 +       uint32  fifodata;
7726 +} pio4regs_t;
7727 +
7728 +/* a pair of pio channels(tx and rx) */
7729 +typedef volatile struct {
7730 +       pio4regs_t      tx;
7731 +       pio4regs_t      rx;
7732 +} pio4regp_t;
7733 +
7734 +
7735 +
7736 +/* DMA structure:
7737 + *  support two DMA engines: 32 bits address or 64 bit addressing
7738 + *  basic DMA register set is per channel(transmit or receive)
7739 + *  a pair of channels is defined for convenience
7740 + */
7741 +
7742 +
7743 +/*** 32 bits addressing ***/
7744 +
7745 +/* dma registers per channel(xmt or rcv) */
7746 +typedef volatile struct {
7747 +       uint32  control;                /* enable, et al */
7748 +       uint32  addr;                   /* descriptor ring base address (4K aligned) */
7749 +       uint32  ptr;                    /* last descriptor posted to chip */
7750 +       uint32  status;                 /* current active descriptor, et al */
7751 +} dma32regs_t;
7752 +
7753 +typedef volatile struct {
7754 +       dma32regs_t     xmt;            /* dma tx channel */
7755 +       dma32regs_t     rcv;            /* dma rx channel */
7756 +} dma32regp_t;
7757 +
7758 +typedef volatile struct {      /* diag access */
7759 +       uint32  fifoaddr;               /* diag address */
7760 +       uint32  fifodatalow;            /* low 32bits of data */
7761 +       uint32  fifodatahigh;           /* high 32bits of data */
7762 +       uint32  pad;                    /* reserved */
7763 +} dma32diag_t;
7764 +
7765 +/*
7766 + * DMA Descriptor
7767 + * Descriptors are only read by the hardware, never written back.
7768 + */
7769 +typedef volatile struct {
7770 +       uint32  ctrl;           /* misc control bits & bufcount */
7771 +       uint32  addr;           /* data buffer address */
7772 +} dma32dd_t;
7773 +
7774 +/*
7775 + * Each descriptor ring must be 4096byte aligned, and fit within a single 4096byte page.
7776 + */
7777 +#define        D32MAXRINGSZ    4096
7778 +#define        D32RINGALIGN    4096
7779 +#define        D32MAXDD        (D32MAXRINGSZ / sizeof (dma32dd_t))
7780 +
7781 +/* transmit channel control */
7782 +#define        XC_XE           ((uint32)1 << 0)        /* transmit enable */
7783 +#define        XC_SE           ((uint32)1 << 1)        /* transmit suspend request */
7784 +#define        XC_LE           ((uint32)1 << 2)        /* loopback enable */
7785 +#define        XC_FL           ((uint32)1 << 4)        /* flush request */
7786 +#define        XC_AE           ((uint32)3 << 16)       /* address extension bits */
7787 +#define        XC_AE_SHIFT     16
7788 +
7789 +/* transmit descriptor table pointer */
7790 +#define        XP_LD_MASK      0xfff                   /* last valid descriptor */
7791 +
7792 +/* transmit channel status */
7793 +#define        XS_CD_MASK      0x0fff                  /* current descriptor pointer */
7794 +#define        XS_XS_MASK      0xf000                  /* transmit state */
7795 +#define        XS_XS_SHIFT     12
7796 +#define        XS_XS_DISABLED  0x0000                  /* disabled */
7797 +#define        XS_XS_ACTIVE    0x1000                  /* active */
7798 +#define        XS_XS_IDLE      0x2000                  /* idle wait */
7799 +#define        XS_XS_STOPPED   0x3000                  /* stopped */
7800 +#define        XS_XS_SUSP      0x4000                  /* suspend pending */
7801 +#define        XS_XE_MASK      0xf0000                 /* transmit errors */
7802 +#define        XS_XE_SHIFT     16
7803 +#define        XS_XE_NOERR     0x00000                 /* no error */
7804 +#define        XS_XE_DPE       0x10000                 /* descriptor protocol error */
7805 +#define        XS_XE_DFU       0x20000                 /* data fifo underrun */
7806 +#define        XS_XE_BEBR      0x30000                 /* bus error on buffer read */
7807 +#define        XS_XE_BEDA      0x40000                 /* bus error on descriptor access */
7808 +#define        XS_AD_MASK      0xfff00000              /* active descriptor */
7809 +#define        XS_AD_SHIFT     20
7810 +
7811 +/* receive channel control */
7812 +#define        RC_RE           ((uint32)1 << 0)        /* receive enable */
7813 +#define        RC_RO_MASK      0xfe                    /* receive frame offset */
7814 +#define        RC_RO_SHIFT     1
7815 +#define        RC_FM           ((uint32)1 << 8)        /* direct fifo receive (pio) mode */
7816 +#define        RC_AE           ((uint32)3 << 16)       /* address extension bits */
7817 +#define        RC_AE_SHIFT     16
7818 +
7819 +/* receive descriptor table pointer */
7820 +#define        RP_LD_MASK      0xfff                   /* last valid descriptor */
7821 +
7822 +/* receive channel status */
7823 +#define        RS_CD_MASK      0x0fff                  /* current descriptor pointer */
7824 +#define        RS_RS_MASK      0xf000                  /* receive state */
7825 +#define        RS_RS_SHIFT     12
7826 +#define        RS_RS_DISABLED  0x0000                  /* disabled */
7827 +#define        RS_RS_ACTIVE    0x1000                  /* active */
7828 +#define        RS_RS_IDLE      0x2000                  /* idle wait */
7829 +#define        RS_RS_STOPPED   0x3000                  /* reserved */
7830 +#define        RS_RE_MASK      0xf0000                 /* receive errors */
7831 +#define        RS_RE_SHIFT     16
7832 +#define        RS_RE_NOERR     0x00000                 /* no error */
7833 +#define        RS_RE_DPE       0x10000                 /* descriptor protocol error */
7834 +#define        RS_RE_DFO       0x20000                 /* data fifo overflow */
7835 +#define        RS_RE_BEBW      0x30000                 /* bus error on buffer write */
7836 +#define        RS_RE_BEDA      0x40000                 /* bus error on descriptor access */
7837 +#define        RS_AD_MASK      0xfff00000              /* active descriptor */
7838 +#define        RS_AD_SHIFT     20
7839 +
7840 +/* fifoaddr */
7841 +#define        FA_OFF_MASK     0xffff                  /* offset */
7842 +#define        FA_SEL_MASK     0xf0000                 /* select */
7843 +#define        FA_SEL_SHIFT    16
7844 +#define        FA_SEL_XDD      0x00000                 /* transmit dma data */
7845 +#define        FA_SEL_XDP      0x10000                 /* transmit dma pointers */
7846 +#define        FA_SEL_RDD      0x40000                 /* receive dma data */
7847 +#define        FA_SEL_RDP      0x50000                 /* receive dma pointers */
7848 +#define        FA_SEL_XFD      0x80000                 /* transmit fifo data */
7849 +#define        FA_SEL_XFP      0x90000                 /* transmit fifo pointers */
7850 +#define        FA_SEL_RFD      0xc0000                 /* receive fifo data */
7851 +#define        FA_SEL_RFP      0xd0000                 /* receive fifo pointers */
7852 +#define        FA_SEL_RSD      0xe0000                 /* receive frame status data */
7853 +#define        FA_SEL_RSP      0xf0000                 /* receive frame status pointers */
7854 +
7855 +/* descriptor control flags */
7856 +#define        CTRL_BC_MASK    0x1fff                  /* buffer byte count */
7857 +#define        CTRL_AE         ((uint32)3 << 16)       /* address extension bits */
7858 +#define        CTRL_AE_SHIFT   16
7859 +#define        CTRL_EOT        ((uint32)1 << 28)       /* end of descriptor table */
7860 +#define        CTRL_IOC        ((uint32)1 << 29)       /* interrupt on completion */
7861 +#define        CTRL_EOF        ((uint32)1 << 30)       /* end of frame */
7862 +#define        CTRL_SOF        ((uint32)1 << 31)       /* start of frame */
7863 +
7864 +/* control flags in the range [27:20] are core-specific and not defined here */
7865 +#define        CTRL_CORE_MASK  0x0ff00000
7866 +
7867 +/*** 64 bits addressing ***/
7868 +
7869 +/* dma registers per channel(xmt or rcv) */
7870 +typedef volatile struct {
7871 +       uint32  control;                /* enable, et al */
7872 +       uint32  ptr;                    /* last descriptor posted to chip */
7873 +       uint32  addrlow;                /* descriptor ring base address low 32-bits (8K aligned) */
7874 +       uint32  addrhigh;               /* descriptor ring base address bits 63:32 (8K aligned) */
7875 +       uint32  status0;                /* current descriptor, xmt state */
7876 +       uint32  status1;                /* active descriptor, xmt error */
7877 +} dma64regs_t;
7878 +
7879 +typedef volatile struct {
7880 +       dma64regs_t     tx;             /* dma64 tx channel */
7881 +       dma64regs_t     rx;             /* dma64 rx channel */
7882 +} dma64regp_t;
7883 +
7884 +typedef volatile struct {              /* diag access */
7885 +       uint32  fifoaddr;               /* diag address */
7886 +       uint32  fifodatalow;            /* low 32bits of data */
7887 +       uint32  fifodatahigh;           /* high 32bits of data */
7888 +       uint32  pad;                    /* reserved */
7889 +} dma64diag_t;
7890 +
7891 +/*
7892 + * DMA Descriptor
7893 + * Descriptors are only read by the hardware, never written back.
7894 + */
7895 +typedef volatile struct {
7896 +       uint32  ctrl1;          /* misc control bits & bufcount */
7897 +       uint32  ctrl2;          /* buffer count and address extension */
7898 +       uint32  addrlow;        /* memory address of the first byte of the date buffer, bits 31:0 */
7899 +       uint32  addrhigh;       /* memory address of the first byte of the date buffer, bits 63:32 */
7900 +} dma64dd_t;
7901 +
7902 +/*
7903 + * Each descriptor ring must be 8kB aligned, and fit within a contiguous 8kB physical addresss.
7904 + */
7905 +#define        D64MAXRINGSZ    8192
7906 +#define        D64RINGALIGN    8192
7907 +#define        D64MAXDD        (D64MAXRINGSZ / sizeof (dma64dd_t))
7908 +
7909 +/* transmit channel control */
7910 +#define        D64_XC_XE               0x00000001      /* transmit enable */
7911 +#define        D64_XC_SE               0x00000002      /* transmit suspend request */
7912 +#define        D64_XC_LE               0x00000004      /* loopback enable */
7913 +#define        D64_XC_FL               0x00000010      /* flush request */
7914 +#define        D64_XC_AE               0x00110000      /* address extension bits */
7915 +#define        D64_XC_AE_SHIFT         16
7916 +
7917 +/* transmit descriptor table pointer */
7918 +#define        D64_XP_LD_MASK          0x00000fff      /* last valid descriptor */
7919 +
7920 +/* transmit channel status */
7921 +#define        D64_XS0_CD_MASK         0x00001fff      /* current descriptor pointer */
7922 +#define        D64_XS0_XS_MASK         0xf0000000      /* transmit state */
7923 +#define        D64_XS0_XS_SHIFT                28
7924 +#define        D64_XS0_XS_DISABLED     0x00000000      /* disabled */
7925 +#define        D64_XS0_XS_ACTIVE       0x10000000      /* active */
7926 +#define        D64_XS0_XS_IDLE         0x20000000      /* idle wait */
7927 +#define        D64_XS0_XS_STOPPED      0x30000000      /* stopped */
7928 +#define        D64_XS0_XS_SUSP         0x40000000      /* suspend pending */
7929 +
7930 +#define        D64_XS1_AD_MASK         0x0001ffff      /* active descriptor */
7931 +#define        D64_XS1_XE_MASK         0xf0000000      /* transmit errors */
7932 +#define        D64_XS1_XE_SHIFT                28
7933 +#define        D64_XS1_XE_NOERR        0x00000000      /* no error */
7934 +#define        D64_XS1_XE_DPE          0x10000000      /* descriptor protocol error */
7935 +#define        D64_XS1_XE_DFU          0x20000000      /* data fifo underrun */
7936 +#define        D64_XS1_XE_DTE          0x30000000      /* data transfer error */
7937 +#define        D64_XS1_XE_DESRE        0x40000000      /* descriptor read error */
7938 +#define        D64_XS1_XE_COREE        0x50000000      /* core error */
7939 +
7940 +/* receive channel control */
7941 +#define        D64_RC_RE               0x00000001      /* receive enable */
7942 +#define        D64_RC_RO_MASK          0x000000fe      /* receive frame offset */
7943 +#define        D64_RC_RO_SHIFT         1
7944 +#define        D64_RC_FM               0x00000100      /* direct fifo receive (pio) mode */
7945 +#define        D64_RC_AE               0x00110000      /* address extension bits */
7946 +#define        D64_RC_AE_SHIFT         16
7947 +
7948 +/* receive descriptor table pointer */
7949 +#define        D64_RP_LD_MASK          0x00000fff      /* last valid descriptor */
7950 +
7951 +/* receive channel status */
7952 +#define        D64_RS0_CD_MASK         0x00001fff      /* current descriptor pointer */
7953 +#define        D64_RS0_RS_MASK         0xf0000000      /* receive state */
7954 +#define        D64_RS0_RS_SHIFT                28
7955 +#define        D64_RS0_RS_DISABLED     0x00000000      /* disabled */
7956 +#define        D64_RS0_RS_ACTIVE       0x10000000      /* active */
7957 +#define        D64_RS0_RS_IDLE         0x20000000      /* idle wait */
7958 +#define        D64_RS0_RS_STOPPED      0x30000000      /* stopped */
7959 +#define        D64_RS0_RS_SUSP         0x40000000      /* suspend pending */
7960 +
7961 +#define        D64_RS1_AD_MASK         0x0001ffff      /* active descriptor */
7962 +#define        D64_RS1_RE_MASK         0xf0000000      /* receive errors */
7963 +#define        D64_RS1_RE_SHIFT                28
7964 +#define        D64_RS1_RE_NOERR        0x00000000      /* no error */
7965 +#define        D64_RS1_RE_DPO          0x10000000      /* descriptor protocol error */
7966 +#define        D64_RS1_RE_DFU          0x20000000      /* data fifo overflow */
7967 +#define        D64_RS1_RE_DTE          0x30000000      /* data transfer error */
7968 +#define        D64_RS1_RE_DESRE        0x40000000      /* descriptor read error */
7969 +#define        D64_RS1_RE_COREE        0x50000000      /* core error */
7970 +
7971 +/* fifoaddr */
7972 +#define        D64_FA_OFF_MASK         0xffff          /* offset */
7973 +#define        D64_FA_SEL_MASK         0xf0000         /* select */
7974 +#define        D64_FA_SEL_SHIFT        16
7975 +#define        D64_FA_SEL_XDD          0x00000         /* transmit dma data */
7976 +#define        D64_FA_SEL_XDP          0x10000         /* transmit dma pointers */
7977 +#define        D64_FA_SEL_RDD          0x40000         /* receive dma data */
7978 +#define        D64_FA_SEL_RDP          0x50000         /* receive dma pointers */
7979 +#define        D64_FA_SEL_XFD          0x80000         /* transmit fifo data */
7980 +#define        D64_FA_SEL_XFP          0x90000         /* transmit fifo pointers */
7981 +#define        D64_FA_SEL_RFD          0xc0000         /* receive fifo data */
7982 +#define        D64_FA_SEL_RFP          0xd0000         /* receive fifo pointers */
7983 +#define        D64_FA_SEL_RSD          0xe0000         /* receive frame status data */
7984 +#define        D64_FA_SEL_RSP          0xf0000         /* receive frame status pointers */
7985 +
7986 +/* descriptor control flags 1 */
7987 +#define        D64_CTRL1_EOT           ((uint32)1 << 28)       /* end of descriptor table */
7988 +#define        D64_CTRL1_IOC           ((uint32)1 << 29)       /* interrupt on completion */
7989 +#define        D64_CTRL1_EOF           ((uint32)1 << 30)       /* end of frame */
7990 +#define        D64_CTRL1_SOF           ((uint32)1 << 31)       /* start of frame */
7991 +
7992 +/* descriptor control flags 2 */
7993 +#define        D64_CTRL2_BC_MASK       0x00007fff      /* buffer byte count mask */
7994 +#define        D64_CTRL2_AE            0x00110000      /* address extension bits */
7995 +#define        D64_CTRL2_AE_SHIFT      16
7996 +
7997 +/* control flags in the range [27:20] are core-specific and not defined here */
7998 +#define        D64_CTRL_CORE_MASK      0x0ff00000
7999 +
8000 +
8001 +#endif /* _sbhnddma_h_ */
8002 diff -Nur linux-2.4.32/arch/mips/bcm947xx/include/sbmemc.h linux-2.4.32-brcm/arch/mips/bcm947xx/include/sbmemc.h
8003 --- linux-2.4.32/arch/mips/bcm947xx/include/sbmemc.h    1970-01-01 01:00:00.000000000 +0100
8004 +++ linux-2.4.32-brcm/arch/mips/bcm947xx/include/sbmemc.h       2005-12-16 23:39:10.932836000 +0100
8005 @@ -0,0 +1,148 @@
8006 +/*
8007 + * BCM47XX Sonics SiliconBackplane DDR/SDRAM controller core hardware definitions.
8008 + *
8009 + * Copyright 2005, Broadcom Corporation
8010 + * All Rights Reserved.
8011 + *
8012 + * THIS SOFTWARE IS OFFERED "AS IS", AND BROADCOM GRANTS NO WARRANTIES OF ANY
8013 + * KIND, EXPRESS OR IMPLIED, BY STATUTE, COMMUNICATION OR OTHERWISE. BROADCOM
8014 + * SPECIFICALLY DISCLAIMS ANY IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS
8015 + * FOR A SPECIFIC PURPOSE OR NONINFRINGEMENT CONCERNING THIS SOFTWARE.
8016 + *
8017 + * $Id$
8018 + */
8019 +
8020 +#ifndef        _SBMEMC_H
8021 +#define        _SBMEMC_H
8022 +
8023 +#ifdef _LANGUAGE_ASSEMBLY
8024 +
8025 +#define        MEMC_CONTROL            0x00
8026 +#define        MEMC_CONFIG             0x04
8027 +#define        MEMC_REFRESH            0x08
8028 +#define        MEMC_BISTSTAT           0x0c
8029 +#define        MEMC_MODEBUF            0x10
8030 +#define        MEMC_BKCLS              0x14
8031 +#define        MEMC_PRIORINV           0x18
8032 +#define        MEMC_DRAMTIM            0x1c
8033 +#define        MEMC_INTSTAT            0x20
8034 +#define        MEMC_INTMASK            0x24
8035 +#define        MEMC_INTINFO            0x28
8036 +#define        MEMC_NCDLCTL            0x30
8037 +#define        MEMC_RDNCDLCOR          0x34
8038 +#define        MEMC_WRNCDLCOR          0x38
8039 +#define        MEMC_MISCDLYCTL         0x3c
8040 +#define        MEMC_DQSGATENCDL        0x40
8041 +#define        MEMC_SPARE              0x44
8042 +#define        MEMC_TPADDR             0x48
8043 +#define        MEMC_TPDATA             0x4c
8044 +#define        MEMC_BARRIER            0x50
8045 +#define        MEMC_CORE               0x54
8046 +
8047 +
8048 +#else
8049 +
8050 +/* Sonics side: MEMC core registers */
8051 +typedef volatile struct sbmemcregs {
8052 +       uint32  control;
8053 +       uint32  config;
8054 +       uint32  refresh;
8055 +       uint32  biststat;
8056 +       uint32  modebuf;
8057 +       uint32  bkcls;
8058 +       uint32  priorinv;
8059 +       uint32  dramtim;
8060 +       uint32  intstat;
8061 +       uint32  intmask;
8062 +       uint32  intinfo;
8063 +       uint32  reserved1;
8064 +       uint32  ncdlctl;
8065 +       uint32  rdncdlcor;
8066 +       uint32  wrncdlcor;
8067 +       uint32  miscdlyctl;
8068 +       uint32  dqsgatencdl;
8069 +       uint32  spare;
8070 +       uint32  tpaddr;
8071 +       uint32  tpdata;
8072 +       uint32  barrier;
8073 +       uint32  core;
8074 +} sbmemcregs_t;
8075 +
8076 +#endif
8077 +
8078 +/* MEMC Core Init values (OCP ID 0x80f) */
8079 +
8080 +/* For sdr: */
8081 +#define MEMC_SD_CONFIG_INIT    0x00048000
8082 +#define MEMC_SD_DRAMTIM2_INIT  0x000754d8
8083 +#define MEMC_SD_DRAMTIM3_INIT  0x000754da
8084 +#define MEMC_SD_RDNCDLCOR_INIT 0x00000000
8085 +#define MEMC_SD_WRNCDLCOR_INIT 0x49351200
8086 +#define MEMC_SD1_WRNCDLCOR_INIT        0x14500200      /* For corerev 1 (4712) */
8087 +#define MEMC_SD_MISCDLYCTL_INIT        0x00061c1b
8088 +#define MEMC_SD1_MISCDLYCTL_INIT 0x00021416    /* For corerev 1 (4712) */
8089 +#define MEMC_SD_CONTROL_INIT0  0x00000002
8090 +#define MEMC_SD_CONTROL_INIT1  0x00000008
8091 +#define MEMC_SD_CONTROL_INIT2  0x00000004
8092 +#define MEMC_SD_CONTROL_INIT3  0x00000010
8093 +#define MEMC_SD_CONTROL_INIT4  0x00000001
8094 +#define MEMC_SD_MODEBUF_INIT   0x00000000
8095 +#define MEMC_SD_REFRESH_INIT   0x0000840f
8096 +
8097 +
8098 +/* This is for SDRM8X8X4 */
8099 +#define        MEMC_SDR_INIT           0x0008
8100 +#define        MEMC_SDR_MODE           0x32
8101 +#define        MEMC_SDR_NCDL           0x00020032
8102 +#define        MEMC_SDR1_NCDL          0x0002020f      /* For corerev 1 (4712) */
8103 +
8104 +/* For ddr: */
8105 +#define MEMC_CONFIG_INIT       0x00048000
8106 +#define MEMC_DRAMTIM2_INIT     0x000754d8
8107 +#define MEMC_DRAMTIM25_INIT    0x000754d9
8108 +#define MEMC_RDNCDLCOR_INIT    0x00000000
8109 +#define MEMC_RDNCDLCOR_SIMINIT 0xf6f6f6f6      /* For hdl sim */
8110 +#define MEMC_WRNCDLCOR_INIT    0x49351200
8111 +#define MEMC_1_WRNCDLCOR_INIT  0x14500200
8112 +#define MEMC_DQSGATENCDL_INIT  0x00030000
8113 +#define MEMC_MISCDLYCTL_INIT   0x21061c1b
8114 +#define MEMC_1_MISCDLYCTL_INIT 0x21021400
8115 +#define MEMC_NCDLCTL_INIT      0x00002001
8116 +#define MEMC_CONTROL_INIT0     0x00000002
8117 +#define MEMC_CONTROL_INIT1     0x00000008
8118 +#define MEMC_MODEBUF_INIT0     0x00004000
8119 +#define MEMC_CONTROL_INIT2     0x00000010
8120 +#define MEMC_MODEBUF_INIT1     0x00000100
8121 +#define MEMC_CONTROL_INIT3     0x00000010
8122 +#define MEMC_CONTROL_INIT4     0x00000008
8123 +#define MEMC_REFRESH_INIT      0x0000840f
8124 +#define MEMC_CONTROL_INIT5     0x00000004
8125 +#define MEMC_MODEBUF_INIT2     0x00000000
8126 +#define MEMC_CONTROL_INIT6     0x00000010
8127 +#define MEMC_CONTROL_INIT7     0x00000001
8128 +
8129 +
8130 +/* This is for DDRM16X16X2 */
8131 +#define        MEMC_DDR_INIT           0x0009
8132 +#define        MEMC_DDR_MODE           0x62
8133 +#define        MEMC_DDR_NCDL           0x0005050a
8134 +#define        MEMC_DDR1_NCDL          0x00000a0a      /* For corerev 1 (4712) */
8135 +
8136 +/* mask for sdr/ddr calibration registers */
8137 +#define MEMC_RDNCDLCOR_RD_MASK 0x000000ff
8138 +#define MEMC_WRNCDLCOR_WR_MASK 0x000000ff
8139 +#define MEMC_DQSGATENCDL_G_MASK        0x000000ff
8140 +
8141 +/* masks for miscdlyctl registers */
8142 +#define MEMC_MISC_SM_MASK      0x30000000
8143 +#define MEMC_MISC_SM_SHIFT     28
8144 +#define MEMC_MISC_SD_MASK      0x0f000000
8145 +#define MEMC_MISC_SD_SHIFT     24
8146 +
8147 +/* hw threshhold for calculating wr/rd for sdr memc */
8148 +#define MEMC_CD_THRESHOLD      128
8149 +
8150 +/* Low bit of init register says if memc is ddr or sdr */
8151 +#define MEMC_CONFIG_DDR                0x00000001
8152 +
8153 +#endif /* _SBMEMC_H */
8154 diff -Nur linux-2.4.32/arch/mips/bcm947xx/include/sbmips.h linux-2.4.32-brcm/arch/mips/bcm947xx/include/sbmips.h
8155 --- linux-2.4.32/arch/mips/bcm947xx/include/sbmips.h    1970-01-01 01:00:00.000000000 +0100
8156 +++ linux-2.4.32-brcm/arch/mips/bcm947xx/include/sbmips.h       2005-12-16 23:39:10.936836250 +0100
8157 @@ -0,0 +1,62 @@
8158 +/*
8159 + * Broadcom SiliconBackplane MIPS definitions
8160 + *
8161 + * SB MIPS cores are custom MIPS32 processors with SiliconBackplane
8162 + * OCP interfaces. The CP0 processor ID is 0x00024000, where bits
8163 + * 23:16 mean Broadcom and bits 15:8 mean a MIPS core with an OCP
8164 + * interface. The core revision is stored in the SB ID register in SB
8165 + * configuration space.
8166 + *
8167 + * Copyright 2005, Broadcom Corporation
8168 + * All Rights Reserved.
8169 + *
8170 + * THIS SOFTWARE IS OFFERED "AS IS", AND BROADCOM GRANTS NO WARRANTIES OF ANY
8171 + * KIND, EXPRESS OR IMPLIED, BY STATUTE, COMMUNICATION OR OTHERWISE. BROADCOM
8172 + * SPECIFICALLY DISCLAIMS ANY IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS
8173 + * FOR A SPECIFIC PURPOSE OR NONINFRINGEMENT CONCERNING THIS SOFTWARE.
8174 + *
8175 + * $Id$
8176 + */
8177 +
8178 +#ifndef        _SBMIPS_H
8179 +#define        _SBMIPS_H
8180 +
8181 +#include <mipsinc.h>
8182 +
8183 +#ifndef _LANGUAGE_ASSEMBLY
8184 +
8185 +/* cpp contortions to concatenate w/arg prescan */
8186 +#ifndef PAD
8187 +#define        _PADLINE(line)  pad ## line
8188 +#define        _XSTR(line)     _PADLINE(line)
8189 +#define        PAD             _XSTR(__LINE__)
8190 +#endif /* PAD */
8191 +
8192 +typedef volatile struct {
8193 +       uint32  corecontrol;
8194 +       uint32  PAD[2];
8195 +       uint32  biststatus;
8196 +       uint32  PAD[4];
8197 +       uint32  intstatus;
8198 +       uint32  intmask;
8199 +       uint32  timer;
8200 +} mipsregs_t;
8201 +
8202 +extern uint32 sb_flag(sb_t *sbh);
8203 +extern uint sb_irq(sb_t *sbh);
8204 +
8205 +extern void BCMINIT(sb_serial_init)(sb_t *sbh, void (*add)(void *regs, uint irq, uint baud_base, uint reg_shift));
8206 +
8207 +extern void *sb_jtagm_init(sb_t *sbh, uint clkd, bool exttap);
8208 +extern void sb_jtagm_disable(void *h);
8209 +extern uint32 jtag_rwreg(void *h, uint32 ir, uint32 dr);
8210 +extern void BCMINIT(sb_mips_init)(sb_t *sbh);
8211 +extern uint32 BCMINIT(sb_mips_clock)(sb_t *sbh);
8212 +extern bool BCMINIT(sb_mips_setclock)(sb_t *sbh, uint32 mipsclock, uint32 sbclock, uint32 pciclock);
8213 +extern void BCMINIT(enable_pfc)(uint32 mode);
8214 +extern uint32 BCMINIT(sb_memc_get_ncdl)(sb_t *sbh);
8215 +
8216 +
8217 +#endif /* _LANGUAGE_ASSEMBLY */
8218 +
8219 +#endif /* _SBMIPS_H */
8220 diff -Nur linux-2.4.32/arch/mips/bcm947xx/include/sbpcie.h linux-2.4.32-brcm/arch/mips/bcm947xx/include/sbpcie.h
8221 --- linux-2.4.32/arch/mips/bcm947xx/include/sbpcie.h    1970-01-01 01:00:00.000000000 +0100
8222 +++ linux-2.4.32-brcm/arch/mips/bcm947xx/include/sbpcie.h       2005-12-16 23:39:10.936836250 +0100
8223 @@ -0,0 +1,199 @@
8224 +/*
8225 + * BCM43XX SiliconBackplane PCIE core hardware definitions.
8226 + *
8227 + * $Id:
8228 + * Copyright 2005, Broadcom Corporation
8229 + * All Rights Reserved.
8230 + *
8231 + * THIS SOFTWARE IS OFFERED "AS IS", AND BROADCOM GRANTS NO WARRANTIES OF ANY
8232 + * KIND, EXPRESS OR IMPLIED, BY STATUTE, COMMUNICATION OR OTHERWISE. BROADCOM
8233 + * SPECIFICALLY DISCLAIMS ANY IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS
8234 + * FOR A SPECIFIC PURPOSE OR NONINFRINGEMENT CONCERNING THIS SOFTWARE.
8235 + */
8236 +
8237 +#ifndef        _SBPCIE_H
8238 +#define        _SBPCIE_H
8239 +
8240 +/* cpp contortions to concatenate w/arg prescan */
8241 +#ifndef PAD
8242 +#define        _PADLINE(line)  pad ## line
8243 +#define        _XSTR(line)     _PADLINE(line)
8244 +#define        PAD             _XSTR(__LINE__)
8245 +#endif
8246 +
8247 +/* PCIE Enumeration space offsets*/
8248 +#define  PCIE_CORE_CONFIG_OFFSET       0x0
8249 +#define  PCIE_FUNC0_CONFIG_OFFSET      0x400
8250 +#define  PCIE_FUNC1_CONFIG_OFFSET      0x500
8251 +#define  PCIE_FUNC2_CONFIG_OFFSET      0x600
8252 +#define  PCIE_FUNC3_CONFIG_OFFSET      0x700
8253 +#define  PCIE_SPROM_SHADOW_OFFSET      0x800
8254 +#define  PCIE_SBCONFIG_OFFSET          0xE00
8255 +
8256 +/* PCIE Bar0 Address Mapping. Each function maps 16KB config space */
8257 +#define PCIE_BAR0_WINMAPCORE_OFFSET    0x0
8258 +#define PCIE_BAR0_EXTSPROM_OFFSET      0x1000
8259 +#define PCIE_BAR0_PCIECORE_OFFSET      0x2000
8260 +#define PCIE_BAR0_CCCOREREG_OFFSET     0x3000
8261 +
8262 +/* SB side: PCIE core and host control registers */
8263 +typedef struct sbpcieregs {
8264 +
8265 +       uint32 PAD[3];
8266 +       uint32 biststatus;       /* bist Status: 0x00C*/
8267 +       uint32 PAD[6];
8268 +       uint32 sbtopcimailbox;   /* sb to pcie mailbox: 0x028*/
8269 +       uint32 PAD[54];
8270 +       uint32 sbtopcie0;       /* sb to pcie translation 0: 0x100 */
8271 +       uint32 sbtopcie1;       /* sb to pcie translation 1: 0x104 */
8272 +       uint32 sbtopcie2;       /* sb to pcie translation 2: 0x108 */
8273 +       uint32 PAD[4];
8274 +
8275 +       /* pcie core supports in direct access to config space */
8276 +       uint32 configaddr;      /* pcie config space access: Address field: 0x120*/
8277 +       uint32 configdata;      /* pcie config space access: Data field: 0x124*/
8278 +
8279 +       /* mdio access to serdes */
8280 +       uint32 mdiocontrol;     /* controls the mdio access: 0x128 */
8281 +       uint32 mdiodata;        /* Data to the mdio access: 0x12c */
8282 +
8283 +       /* pcie protocol phy/dllp/tlp register access mechanism*/
8284 +       uint32 pcieaddr;        /* address of the internal registeru: 0x130 */
8285 +       uint32 pciedata;        /* Data to/from the internal regsiter: 0x134 */
8286 +
8287 +       uint32 PAD[434];
8288 +       uint16 sprom[36];       /* SPROM shadow Area */
8289 +} sbpcieregs_t;
8290 +
8291 +/* SB to PCIE translation masks */
8292 +#define SBTOPCIE0_MASK 0xfc000000
8293 +#define SBTOPCIE1_MASK 0xfc000000
8294 +#define SBTOPCIE2_MASK 0xc0000000
8295 +
8296 +/* Access type bits (0:1)*/
8297 +#define SBTOPCIE_MEM   0
8298 +#define SBTOPCIE_IO    1
8299 +#define SBTOPCIE_CFG0  2
8300 +#define SBTOPCIE_CFG1  3
8301 +
8302 +/*Prefetch enable bit 2*/
8303 +#define SBTOPCIE_PF            4
8304 +
8305 +/*Write Burst enable for memory write bit 3*/
8306 +#define SBTOPCIE_WR_BURST      8
8307 +
8308 +/* config access */
8309 +#define CONFIGADDR_FUNC_MASK   0x7000
8310 +#define CONFIGADDR_FUNC_SHF    12
8311 +#define CONFIGADDR_REG_MASK    0x0FFF
8312 +#define CONFIGADDR_REG_SHF     0
8313 +
8314 +/* PCIE protocol regs Indirect Address */
8315 +#define PCIEADDR_PROT_MASK     0x300
8316 +#define PCIEADDR_PROT_SHF      8
8317 +#define PCIEADDR_PL_TLP                0
8318 +#define PCIEADDR_PL_DLLP       1
8319 +#define PCIEADDR_PL_PLP                2
8320 +
8321 +/* PCIE protocol PHY diagnostic registers */
8322 +#define        PCIE_PLP_MODEREG                0x200 /* Mode*/
8323 +#define        PCIE_PLP_STATUSREG              0x204 /* Status*/
8324 +#define PCIE_PLP_LTSSMCTRLREG          0x208 /* LTSSM control  */
8325 +#define PCIE_PLP_LTLINKNUMREG          0x20c /* Link Training Link number*/
8326 +#define PCIE_PLP_LTLANENUMREG          0x210 /* Link Training Lane number*/
8327 +#define PCIE_PLP_LTNFTSREG             0x214 /* Link Training N_FTS */
8328 +#define PCIE_PLP_ATTNREG               0x218 /* Attention */
8329 +#define PCIE_PLP_ATTNMASKREG           0x21C /* Attention Mask */
8330 +#define PCIE_PLP_RXERRCTR              0x220 /* Rx Error */
8331 +#define PCIE_PLP_RXFRMERRCTR           0x224 /* Rx Framing Error*/
8332 +#define PCIE_PLP_RXERRTHRESHREG                0x228 /* Rx Error threshold */
8333 +#define PCIE_PLP_TESTCTRLREG           0x22C /* Test Control reg*/
8334 +#define PCIE_PLP_SERDESCTRLOVRDREG     0x230 /* SERDES Control Override */
8335 +#define PCIE_PLP_TIMINGOVRDREG         0x234 /* Timing param override */
8336 +#define PCIE_PLP_RXTXSMDIAGREG         0x238 /* RXTX State Machine Diag*/
8337 +#define PCIE_PLP_LTSSMDIAGREG          0x23C /* LTSSM State Machine Diag*/
8338 +
8339 +/* PCIE protocol DLLP diagnostic registers */
8340 +#define PCIE_DLLP_LCREG                        0x100 /* Link Control*/
8341 +#define PCIE_DLLP_LSREG                        0x104 /* Link Status */
8342 +#define PCIE_DLLP_LAREG                        0x108 /* Link Attention*/
8343 +#define PCIE_DLLP_LAMASKREG            0x10C /* Link Attention Mask */
8344 +#define PCIE_DLLP_NEXTTXSEQNUMREG      0x110 /* Next Tx Seq Num*/
8345 +#define PCIE_DLLP_ACKEDTXSEQNUMREG     0x114 /* Acked Tx Seq Num*/
8346 +#define PCIE_DLLP_PURGEDTXSEQNUMREG    0x118 /* Purged Tx Seq Num*/
8347 +#define PCIE_DLLP_RXSEQNUMREG          0x11C /* Rx Sequence Number */
8348 +#define PCIE_DLLP_LRREG                        0x120 /* Link Replay*/
8349 +#define PCIE_DLLP_LACKTOREG            0x124 /* Link Ack Timeout*/
8350 +#define PCIE_DLLP_PMTHRESHREG          0x128 /* Power Management Threshold*/
8351 +#define PCIE_DLLP_RTRYWPREG            0x12C /* Retry buffer write ptr*/
8352 +#define PCIE_DLLP_RTRYRPREG            0x130 /* Retry buffer Read ptr*/
8353 +#define PCIE_DLLP_RTRYPPREG            0x134 /* Retry buffer Purged ptr*/
8354 +#define PCIE_DLLP_RTRRWREG             0x138 /* Retry buffer Read/Write*/
8355 +#define PCIE_DLLP_ECTHRESHREG          0x13C /* Error Count Threshold */
8356 +#define PCIE_DLLP_TLPERRCTRREG         0x140 /* TLP Error Counter */
8357 +#define PCIE_DLLP_ERRCTRREG            0x144 /* Error Counter*/
8358 +#define PCIE_DLLP_NAKRXCTRREG          0x148 /* NAK Received Counter*/
8359 +#define PCIE_DLLP_TESTREG              0x14C /* Test */
8360 +#define PCIE_DLLP_PKTBIST              0x150 /* Packet BIST*/
8361 +
8362 +/* PCIE protocol TLP diagnostic registers */
8363 +#define PCIE_TLP_CONFIGREG             0x000 /* Configuration */
8364 +#define PCIE_TLP_WORKAROUNDSREG                0x004 /* TLP Workarounds */
8365 +#define PCIE_TLP_WRDMAUPPER            0x010 /* Write DMA Upper Address*/
8366 +#define PCIE_TLP_WRDMALOWER            0x014 /* Write DMA Lower Address*/
8367 +#define PCIE_TLP_WRDMAREQ_LBEREG       0x018 /* Write DMA Len/ByteEn Req*/
8368 +#define PCIE_TLP_RDDMAUPPER            0x01C /* Read DMA Upper Address*/
8369 +#define PCIE_TLP_RDDMALOWER            0x020 /* Read DMA Lower Address*/
8370 +#define PCIE_TLP_RDDMALENREG           0x024 /* Read DMA Len Req*/
8371 +#define PCIE_TLP_MSIDMAUPPER           0x028 /* MSI DMA Upper Address*/
8372 +#define PCIE_TLP_MSIDMALOWER           0x02C /* MSI DMA Lower Address*/
8373 +#define PCIE_TLP_MSIDMALENREG          0x030 /* MSI DMA Len Req*/
8374 +#define PCIE_TLP_SLVREQLENREG          0x034 /* Slave Request Len*/
8375 +#define PCIE_TLP_FCINPUTSREQ           0x038 /* Flow Control Inputs*/
8376 +#define PCIE_TLP_TXSMGRSREQ            0x03C /* Tx StateMachine and Gated Req*/
8377 +#define PCIE_TLP_ADRACKCNTARBLEN       0x040 /* Address Ack XferCnt and ARB Len*/
8378 +#define PCIE_TLP_DMACPLHDR0            0x044 /* DMA Completion Hdr 0*/
8379 +#define PCIE_TLP_DMACPLHDR1            0x048 /* DMA Completion Hdr 1*/
8380 +#define PCIE_TLP_DMACPLHDR2            0x04C /* DMA Completion Hdr 2*/
8381 +#define PCIE_TLP_DMACPLMISC0           0x050 /* DMA Completion Misc0 */
8382 +#define PCIE_TLP_DMACPLMISC1           0x054 /* DMA Completion Misc1 */
8383 +#define PCIE_TLP_DMACPLMISC2           0x058 /* DMA Completion Misc2 */
8384 +#define PCIE_TLP_SPTCTRLLEN            0x05C /* Split Controller Req len*/
8385 +#define PCIE_TLP_SPTCTRLMSIC0          0x060 /* Split Controller Misc 0*/
8386 +#define PCIE_TLP_SPTCTRLMSIC1          0x064 /* Split Controller Misc 1*/
8387 +#define PCIE_TLP_BUSDEVFUNC            0x068 /* Bus/Device/Func*/
8388 +#define PCIE_TLP_RESETCTR              0x06C /* Reset Counter*/
8389 +#define PCIE_TLP_RTRYBUF               0x070 /* Retry Buffer value*/
8390 +#define PCIE_TLP_TGTDEBUG1             0x074 /* Target Debug Reg1*/
8391 +#define PCIE_TLP_TGTDEBUG2             0x078 /* Target Debug Reg2*/
8392 +#define PCIE_TLP_TGTDEBUG3             0x07C /* Target Debug Reg3*/
8393 +#define PCIE_TLP_TGTDEBUG4             0x080 /* Target Debug Reg4*/
8394 +
8395 +/* MDIO control */
8396 +#define MDIOCTL_DIVISOR_MASK           0x7f    /* clock to be used on MDIO */
8397 +#define MDIOCTL_DIVISOR_VAL            0x2
8398 +#define MDIOCTL_PREAM_EN               0x80    /* Enable preamble sequnce */
8399 +#define MDIOCTL_ACCESS_DONE            0x100   /* Tranaction complete */
8400 +
8401 +/* MDIO Data */
8402 +#define MDIODATA_MASK                  0x0000ffff      /* data 2 bytes */
8403 +#define MDIODATA_TA                    0x00020000      /* Turnaround */
8404 +#define MDIODATA_REGADDR_SHF           18              /* Regaddr shift */
8405 +#define MDIODATA_REGADDR_MASK          0x003c0000      /* Regaddr Mask */
8406 +#define MDIODATA_DEVADDR_SHF           22              /* Physmedia devaddr shift */
8407 +#define MDIODATA_DEVADDR_MASK          0x0fc00000      /* Physmedia devaddr Mask */
8408 +#define MDIODATA_WRITE                 0x10000000      /* write Transaction */
8409 +#define MDIODATA_READ                  0x20000000      /* Read Transaction */
8410 +#define MDIODATA_START                 0x40000000      /* start of Transaction */
8411 +
8412 +/* MDIO devices (SERDES modules) */
8413 +#define MDIODATA_DEV_PLL                       0x1d    /* SERDES PLL Dev */
8414 +#define MDIODATA_DEV_TX                        0x1e    /* SERDES TX Dev */
8415 +#define MDIODATA_DEV_RX                        0x1f    /* SERDES RX Dev */
8416 +
8417 +/* SERDES registers */
8418 +#define SERDES_RX_TIMER1               2       /* Rx Timer1 */
8419 +#define SERDES_RX_CDR                  6       /* CDR */
8420 +#define SERDES_RX_CDRBW                        7       /* CDR BW */
8421 +
8422 +#endif /* _SBPCIE_H */
8423 diff -Nur linux-2.4.32/arch/mips/bcm947xx/include/sbpci.h linux-2.4.32-brcm/arch/mips/bcm947xx/include/sbpci.h
8424 --- linux-2.4.32/arch/mips/bcm947xx/include/sbpci.h     1970-01-01 01:00:00.000000000 +0100
8425 +++ linux-2.4.32-brcm/arch/mips/bcm947xx/include/sbpci.h        2005-12-16 23:39:10.936836250 +0100
8426 @@ -0,0 +1,122 @@
8427 +/*
8428 + * BCM47XX Sonics SiliconBackplane PCI core hardware definitions.
8429 + *
8430 + * $Id$
8431 + * Copyright 2005, Broadcom Corporation
8432 + * All Rights Reserved.
8433 + *
8434 + * THIS SOFTWARE IS OFFERED "AS IS", AND BROADCOM GRANTS NO WARRANTIES OF ANY
8435 + * KIND, EXPRESS OR IMPLIED, BY STATUTE, COMMUNICATION OR OTHERWISE. BROADCOM
8436 + * SPECIFICALLY DISCLAIMS ANY IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS
8437 + * FOR A SPECIFIC PURPOSE OR NONINFRINGEMENT CONCERNING THIS SOFTWARE.
8438 + */
8439 +
8440 +#ifndef        _SBPCI_H
8441 +#define        _SBPCI_H
8442 +
8443 +/* cpp contortions to concatenate w/arg prescan */
8444 +#ifndef PAD
8445 +#define        _PADLINE(line)  pad ## line
8446 +#define        _XSTR(line)     _PADLINE(line)
8447 +#define        PAD             _XSTR(__LINE__)
8448 +#endif
8449 +
8450 +/* Sonics side: PCI core and host control registers */
8451 +typedef struct sbpciregs {
8452 +       uint32 control;         /* PCI control */
8453 +       uint32 PAD[3];
8454 +       uint32 arbcontrol;      /* PCI arbiter control */
8455 +       uint32 PAD[3];
8456 +       uint32 intstatus;       /* Interrupt status */
8457 +       uint32 intmask;         /* Interrupt mask */
8458 +       uint32 sbtopcimailbox;  /* Sonics to PCI mailbox */
8459 +       uint32 PAD[9];
8460 +       uint32 bcastaddr;       /* Sonics broadcast address */
8461 +       uint32 bcastdata;       /* Sonics broadcast data */
8462 +       uint32 PAD[2];
8463 +       uint32 gpioin;          /* ro: gpio input (>=rev2) */
8464 +       uint32 gpioout;         /* rw: gpio output (>=rev2) */
8465 +       uint32 gpioouten;       /* rw: gpio output enable (>= rev2) */
8466 +       uint32 gpiocontrol;     /* rw: gpio control (>= rev2) */
8467 +       uint32 PAD[36];
8468 +       uint32 sbtopci0;        /* Sonics to PCI translation 0 */
8469 +       uint32 sbtopci1;        /* Sonics to PCI translation 1 */
8470 +       uint32 sbtopci2;        /* Sonics to PCI translation 2 */
8471 +       uint32 PAD[445];
8472 +       uint16 sprom[36];       /* SPROM shadow Area */
8473 +       uint32 PAD[46];
8474 +} sbpciregs_t;
8475 +
8476 +/* PCI control */
8477 +#define PCI_RST_OE     0x01    /* When set, drives PCI_RESET out to pin */
8478 +#define PCI_RST                0x02    /* Value driven out to pin */
8479 +#define PCI_CLK_OE     0x04    /* When set, drives clock as gated by PCI_CLK out to pin */
8480 +#define PCI_CLK                0x08    /* Gate for clock driven out to pin */
8481 +
8482 +/* PCI arbiter control */
8483 +#define PCI_INT_ARB    0x01    /* When set, use an internal arbiter */
8484 +#define PCI_EXT_ARB    0x02    /* When set, use an external arbiter */
8485 +#define PCI_PARKID_MASK        0x06    /* Selects which agent is parked on an idle bus */
8486 +#define PCI_PARKID_SHIFT   1
8487 +#define PCI_PARKID_LAST           0    /* Last requestor */
8488 +#define PCI_PARKID_4710           1    /* 4710 */
8489 +#define PCI_PARKID_EXTREQ0 2   /* External requestor 0 */
8490 +#define PCI_PARKID_EXTREQ1 3   /* External requestor 1 */
8491 +
8492 +/* Interrupt status/mask */
8493 +#define PCI_INTA       0x01    /* PCI INTA# is asserted */
8494 +#define PCI_INTB       0x02    /* PCI INTB# is asserted */
8495 +#define PCI_SERR       0x04    /* PCI SERR# has been asserted (write one to clear) */
8496 +#define PCI_PERR       0x08    /* PCI PERR# has been asserted (write one to clear) */
8497 +#define PCI_PME                0x10    /* PCI PME# is asserted */
8498 +
8499 +/* (General) PCI/SB mailbox interrupts, two bits per pci function */
8500 +#define        MAILBOX_F0_0    0x100   /* function 0, int 0 */
8501 +#define        MAILBOX_F0_1    0x200   /* function 0, int 1 */
8502 +#define        MAILBOX_F1_0    0x400   /* function 1, int 0 */
8503 +#define        MAILBOX_F1_1    0x800   /* function 1, int 1 */
8504 +#define        MAILBOX_F2_0    0x1000  /* function 2, int 0 */
8505 +#define        MAILBOX_F2_1    0x2000  /* function 2, int 1 */
8506 +#define        MAILBOX_F3_0    0x4000  /* function 3, int 0 */
8507 +#define        MAILBOX_F3_1    0x8000  /* function 3, int 1 */
8508 +
8509 +/* Sonics broadcast address */
8510 +#define BCAST_ADDR_MASK        0xff    /* Broadcast register address */
8511 +
8512 +/* Sonics to PCI translation types */
8513 +#define SBTOPCI0_MASK  0xfc000000
8514 +#define SBTOPCI1_MASK  0xfc000000
8515 +#define SBTOPCI2_MASK  0xc0000000
8516 +#define SBTOPCI_MEM    0
8517 +#define SBTOPCI_IO     1
8518 +#define SBTOPCI_CFG0   2
8519 +#define SBTOPCI_CFG1   3
8520 +#define        SBTOPCI_PREF    0x4             /* prefetch enable */
8521 +#define        SBTOPCI_BURST   0x8             /* burst enable */
8522 +#define        SBTOPCI_RC_MASK         0x30    /* read command (>= rev11) */
8523 +#define        SBTOPCI_RC_READ         0x00    /* memory read */
8524 +#define        SBTOPCI_RC_READLINE     0x10    /* memory read line */
8525 +#define        SBTOPCI_RC_READMULTI    0x20    /* memory read multiple */
8526 +
8527 +/* PCI core index in SROM shadow area */
8528 +#define SRSH_PI_OFFSET 0       /* first word */
8529 +#define SRSH_PI_MASK   0xf000  /* bit 15:12 */
8530 +#define SRSH_PI_SHIFT  12      /* bit 15:12 */
8531 +
8532 +/* PCI side: Reserved PCI configuration registers (see pcicfg.h) */
8533 +#define cap_list       rsvd_a[0]
8534 +#define bar0_window    dev_dep[0x80 - 0x40]
8535 +#define bar1_window    dev_dep[0x84 - 0x40]
8536 +#define sprom_control  dev_dep[0x88 - 0x40]
8537 +
8538 +#ifndef _LANGUAGE_ASSEMBLY
8539 +
8540 +extern int sbpci_read_config(sb_t *sbh, uint bus, uint dev, uint func, uint off, void *buf, int len);
8541 +extern int sbpci_write_config(sb_t *sbh, uint bus, uint dev, uint func, uint off, void *buf, int len);
8542 +extern void sbpci_ban(uint16 core);
8543 +extern int sbpci_init(sb_t *sbh);
8544 +extern void sbpci_check(sb_t *sbh);
8545 +
8546 +#endif /* !_LANGUAGE_ASSEMBLY */
8547 +
8548 +#endif /* _SBPCI_H */
8549 diff -Nur linux-2.4.32/arch/mips/bcm947xx/include/sbpcmcia.h linux-2.4.32-brcm/arch/mips/bcm947xx/include/sbpcmcia.h
8550 --- linux-2.4.32/arch/mips/bcm947xx/include/sbpcmcia.h  1970-01-01 01:00:00.000000000 +0100
8551 +++ linux-2.4.32-brcm/arch/mips/bcm947xx/include/sbpcmcia.h     2005-12-16 23:39:10.936836250 +0100
8552 @@ -0,0 +1,146 @@
8553 +/*
8554 + * BCM43XX Sonics SiliconBackplane PCMCIA core hardware definitions.
8555 + *
8556 + * $Id$
8557 + * Copyright 2005, Broadcom Corporation
8558 + * All Rights Reserved.
8559 + *
8560 + * THIS SOFTWARE IS OFFERED "AS IS", AND BROADCOM GRANTS NO WARRANTIES OF ANY
8561 + * KIND, EXPRESS OR IMPLIED, BY STATUTE, COMMUNICATION OR OTHERWISE. BROADCOM
8562 + * SPECIFICALLY DISCLAIMS ANY IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS
8563 + * FOR A SPECIFIC PURPOSE OR NONINFRINGEMENT CONCERNING THIS SOFTWARE.
8564 + */
8565 +
8566 +#ifndef        _SBPCMCIA_H
8567 +#define        _SBPCMCIA_H
8568 +
8569 +
8570 +/* All the addresses that are offsets in attribute space are divided
8571 + * by two to account for the fact that odd bytes are invalid in
8572 + * attribute space and our read/write routines make the space appear
8573 + * as if they didn't exist. Still we want to show the original numbers
8574 + * as documented in the hnd_pcmcia core manual.
8575 + */
8576 +
8577 +/* PCMCIA Function Configuration Registers */
8578 +#define        PCMCIA_FCR              (0x700 / 2)
8579 +
8580 +#define        FCR0_OFF                0
8581 +#define        FCR1_OFF                (0x40 / 2)
8582 +#define        FCR2_OFF                (0x80 / 2)
8583 +#define        FCR3_OFF                (0xc0 / 2)
8584 +
8585 +#define        PCMCIA_FCR0             (0x700 / 2)
8586 +#define        PCMCIA_FCR1             (0x740 / 2)
8587 +#define        PCMCIA_FCR2             (0x780 / 2)
8588 +#define        PCMCIA_FCR3             (0x7c0 / 2)
8589 +
8590 +/* Standard PCMCIA FCR registers */
8591 +
8592 +#define        PCMCIA_COR              0
8593 +
8594 +#define        COR_RST                 0x80
8595 +#define        COR_LEV                 0x40
8596 +#define        COR_IRQEN               0x04
8597 +#define        COR_BLREN               0x01
8598 +#define        COR_FUNEN               0x01
8599 +
8600 +
8601 +#define        PCICIA_FCSR             (2 / 2)
8602 +#define        PCICIA_PRR              (4 / 2)
8603 +#define        PCICIA_SCR              (6 / 2)
8604 +#define        PCICIA_ESR              (8 / 2)
8605 +
8606 +
8607 +#define PCM_MEMOFF             0x0000
8608 +#define F0_MEMOFF              0x1000
8609 +#define F1_MEMOFF              0x2000
8610 +#define F2_MEMOFF              0x3000
8611 +#define F3_MEMOFF              0x4000
8612 +
8613 +/* Memory base in the function fcr's */
8614 +#define MEM_ADDR0              (0x728 / 2)
8615 +#define MEM_ADDR1              (0x72a / 2)
8616 +#define MEM_ADDR2              (0x72c / 2)
8617 +
8618 +/* PCMCIA base plus Srom access in fcr0: */
8619 +#define PCMCIA_ADDR0           (0x072e / 2)
8620 +#define PCMCIA_ADDR1           (0x0730 / 2)
8621 +#define PCMCIA_ADDR2           (0x0732 / 2)
8622 +
8623 +#define MEM_SEG                        (0x0734 / 2)
8624 +#define SROM_CS                        (0x0736 / 2)
8625 +#define SROM_DATAL             (0x0738 / 2)
8626 +#define SROM_DATAH             (0x073a / 2)
8627 +#define SROM_ADDRL             (0x073c / 2)
8628 +#define SROM_ADDRH             (0x073e / 2)
8629 +
8630 +/*  Values for srom_cs: */
8631 +#define SROM_IDLE              0
8632 +#define SROM_WRITE             1
8633 +#define SROM_READ              2
8634 +#define SROM_WEN               4
8635 +#define SROM_WDS               7
8636 +#define SROM_DONE              8
8637 +
8638 +/* CIS stuff */
8639 +
8640 +/* The CIS stops where the FCRs start */
8641 +#define        CIS_SIZE                PCMCIA_FCR
8642 +
8643 +/* Standard tuples we know about */
8644 +
8645 +#define        CISTPL_MANFID           0x20            /* Manufacturer and device id */
8646 +#define        CISTPL_FUNCE            0x22            /* Function extensions */
8647 +#define        CISTPL_CFTABLE          0x1b            /* Config table entry */
8648 +
8649 +/* Function extensions for LANs */
8650 +
8651 +#define        LAN_TECH                1               /* Technology type */
8652 +#define        LAN_SPEED               2               /* Raw bit rate */
8653 +#define        LAN_MEDIA               3               /* Transmission media */
8654 +#define        LAN_NID                 4               /* Node identification (aka MAC addr) */
8655 +#define        LAN_CONN                5               /* Connector standard */
8656 +
8657 +
8658 +/* CFTable */
8659 +#define CFTABLE_REGWIN_2K      0x08            /* 2k reg windows size */
8660 +#define CFTABLE_REGWIN_4K      0x10            /* 4k reg windows size */
8661 +#define CFTABLE_REGWIN_8K      0x20            /* 8k reg windows size */
8662 +
8663 +/* Vendor unique tuples are 0x80-0x8f. Within Broadcom we'll
8664 + * take one for HNBU, and use "extensions" (a la FUNCE) within it.
8665 + */
8666 +
8667 +#define        CISTPL_BRCM_HNBU        0x80
8668 +
8669 +/* Subtypes of BRCM_HNBU: */
8670 +
8671 +#define HNBU_SROMREV           0x00            /* A byte with sromrev, 1 if not present */
8672 +#define HNBU_CHIPID            0x01            /* Six bytes with PCI vendor &
8673 +                                                * device id and chiprev
8674 +                                                */
8675 +#define HNBU_BOARDREV          0x02            /* Two bytes board revision */
8676 +#define HNBU_PAPARMS           0x03            /* PA parameters: 1 (old), 8 (sreomrev == 1)
8677 +                                                * or 9 (sromrev > 1) bytes */
8678 +#define HNBU_OEM               0x04            /* Eight bytes OEM data (sromrev == 1) */
8679 +#define HNBU_CC                        0x05            /* Default country code (sromrev == 1) */
8680 +#define        HNBU_AA                 0x06            /* Antennas available */
8681 +#define        HNBU_AG                 0x07            /* Antenna gain */
8682 +#define HNBU_BOARDFLAGS                0x08            /* board flags (2 or 4 bytes) */
8683 +#define HNBU_LEDS              0x09            /* LED set */
8684 +#define HNBU_CCODE             0x0a            /* Country code (2 bytes ascii + 1 byte cctl)
8685 +                                                * in rev 2
8686 +                                                */
8687 +#define HNBU_CCKPO             0x0b            /* 2 byte cck power offsets in rev 3 */
8688 +#define HNBU_OFDMPO            0x0c            /* 4 byte 11g ofdm power offsets in rev 3 */
8689 +
8690 +
8691 +/* sbtmstatelow */
8692 +#define SBTML_INT_ACK          0x40000         /* ack the sb interrupt */
8693 +#define SBTML_INT_EN           0x20000         /* enable sb interrupt */
8694 +
8695 +/* sbtmstatehigh */
8696 +#define SBTMH_INT_STATUS       0x40000         /* sb interrupt status */
8697 +
8698 +#endif /* _SBPCMCIA_H */
8699 diff -Nur linux-2.4.32/arch/mips/bcm947xx/include/sbsdram.h linux-2.4.32-brcm/arch/mips/bcm947xx/include/sbsdram.h
8700 --- linux-2.4.32/arch/mips/bcm947xx/include/sbsdram.h   1970-01-01 01:00:00.000000000 +0100
8701 +++ linux-2.4.32-brcm/arch/mips/bcm947xx/include/sbsdram.h      2005-12-16 23:39:10.936836250 +0100
8702 @@ -0,0 +1,75 @@
8703 +/*
8704 + * BCM47XX Sonics SiliconBackplane SDRAM controller core hardware definitions.
8705 + *
8706 + * Copyright 2005, Broadcom Corporation
8707 + * All Rights Reserved.
8708 + *
8709 + * THIS SOFTWARE IS OFFERED "AS IS", AND BROADCOM GRANTS NO WARRANTIES OF ANY
8710 + * KIND, EXPRESS OR IMPLIED, BY STATUTE, COMMUNICATION OR OTHERWISE. BROADCOM
8711 + * SPECIFICALLY DISCLAIMS ANY IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS
8712 + * FOR A SPECIFIC PURPOSE OR NONINFRINGEMENT CONCERNING THIS SOFTWARE.
8713 + * $Id$
8714 + */
8715 +
8716 +#ifndef        _SBSDRAM_H
8717 +#define        _SBSDRAM_H
8718 +
8719 +#ifndef _LANGUAGE_ASSEMBLY
8720 +
8721 +/* Sonics side: SDRAM core registers */
8722 +typedef volatile struct sbsdramregs {
8723 +       uint32  initcontrol;    /* Generates external SDRAM initialization sequence */
8724 +       uint32  config;         /* Initializes external SDRAM mode register */
8725 +       uint32  refresh;        /* Controls external SDRAM refresh rate */
8726 +       uint32  pad1;
8727 +       uint32  pad2;
8728 +} sbsdramregs_t;
8729 +
8730 +#endif
8731 +
8732 +/* SDRAM initialization control (initcontrol) register bits */
8733 +#define SDRAM_CBR      0x0001  /* Writing 1 generates refresh cycle and toggles bit */
8734 +#define SDRAM_PRE      0x0002  /* Writing 1 generates precharge cycle and toggles bit */
8735 +#define SDRAM_MRS      0x0004  /* Writing 1 generates mode register select cycle and toggles bit */
8736 +#define SDRAM_EN       0x0008  /* When set, enables access to SDRAM */
8737 +#define SDRAM_16Mb     0x0000  /* Use 16 Megabit SDRAM */
8738 +#define SDRAM_64Mb     0x0010  /* Use 64 Megabit SDRAM */
8739 +#define SDRAM_128Mb    0x0020  /* Use 128 Megabit SDRAM */
8740 +#define SDRAM_RSVMb    0x0030  /* Use special SDRAM */
8741 +#define SDRAM_RST      0x0080  /* Writing 1 causes soft reset of controller */
8742 +#define SDRAM_SELFREF  0x0100  /* Writing 1 enables self refresh mode */
8743 +#define SDRAM_PWRDOWN  0x0200  /* Writing 1 causes controller to power down */
8744 +#define SDRAM_32BIT    0x0400  /* When set, indicates 32 bit SDRAM interface */
8745 +#define SDRAM_9BITCOL  0x0800  /* When set, indicates 9 bit column */
8746 +
8747 +/* SDRAM configuration (config) register bits */
8748 +#define SDRAM_BURSTFULL        0x0000  /* Use full page bursts */
8749 +#define SDRAM_BURST8   0x0001  /* Use burst of 8 */
8750 +#define SDRAM_BURST4   0x0002  /* Use burst of 4 */
8751 +#define SDRAM_BURST2   0x0003  /* Use burst of 2 */
8752 +#define SDRAM_CAS3     0x0000  /* Use CAS latency of 3 */
8753 +#define SDRAM_CAS2     0x0004  /* Use CAS latency of 2 */
8754 +
8755 +/* SDRAM refresh control (refresh) register bits */
8756 +#define SDRAM_REF(p)   (((p)&0xff) | SDRAM_REF_EN)     /* Refresh period */
8757 +#define SDRAM_REF_EN   0x8000          /* Writing 1 enables periodic refresh */
8758 +
8759 +/* SDRAM Core default Init values (OCP ID 0x803) */
8760 +#define SDRAM_INIT     MEM4MX16X2
8761 +#define SDRAM_CONFIG    SDRAM_BURSTFULL
8762 +#define SDRAM_REFRESH   SDRAM_REF(0x40)
8763 +
8764 +#define MEM1MX16       0x009   /* 2 MB */
8765 +#define MEM1MX16X2     0x409   /* 4 MB */
8766 +#define MEM2MX8X2      0x809   /* 4 MB */
8767 +#define MEM2MX8X4      0xc09   /* 8 MB */
8768 +#define MEM2MX32       0x439   /* 8 MB */
8769 +#define MEM4MX16       0x019   /* 8 MB */
8770 +#define MEM4MX16X2     0x419   /* 16 MB */
8771 +#define MEM8MX8X2      0x819   /* 16 MB */
8772 +#define MEM8MX16       0x829   /* 16 MB */
8773 +#define MEM4MX32       0x429   /* 16 MB */
8774 +#define MEM8MX8X4      0xc19   /* 32 MB */
8775 +#define MEM8MX16X2     0xc29   /* 32 MB */
8776 +
8777 +#endif /* _SBSDRAM_H */
8778 diff -Nur linux-2.4.32/arch/mips/bcm947xx/include/sbsocram.h linux-2.4.32-brcm/arch/mips/bcm947xx/include/sbsocram.h
8779 --- linux-2.4.32/arch/mips/bcm947xx/include/sbsocram.h  1970-01-01 01:00:00.000000000 +0100
8780 +++ linux-2.4.32-brcm/arch/mips/bcm947xx/include/sbsocram.h     2005-12-16 23:39:10.936836250 +0100
8781 @@ -0,0 +1,37 @@
8782 +/*
8783 + * BCM47XX Sonics SiliconBackplane embedded ram core
8784 + *
8785 + * Copyright 2005, Broadcom Corporation
8786 + * All Rights Reserved.
8787 + *
8788 + * THIS SOFTWARE IS OFFERED "AS IS", AND BROADCOM GRANTS NO WARRANTIES OF ANY
8789 + * KIND, EXPRESS OR IMPLIED, BY STATUTE, COMMUNICATION OR OTHERWISE. BROADCOM
8790 + * SPECIFICALLY DISCLAIMS ANY IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS
8791 + * FOR A SPECIFIC PURPOSE OR NONINFRINGEMENT CONCERNING THIS SOFTWARE.
8792 + *
8793 + * $Id$
8794 + */
8795 +
8796 +#ifndef        _SBSOCRAM_H
8797 +#define        _SBSOCRAM_H
8798 +
8799 +#define        SOCRAM_MEMSIZE          0x00
8800 +#define        SOCRAM_BISTSTAT         0x0c
8801 +
8802 +
8803 +#ifndef _LANGUAGE_ASSEMBLY
8804 +
8805 +/* Memcsocram core registers */
8806 +typedef volatile struct sbsocramregs {
8807 +       uint32  memsize;
8808 +       uint32  biststat;
8809 +} sbsocramregs_t;
8810 +
8811 +#endif
8812 +
8813 +/* Them memory size is 2 to the power of the following
8814 + * base added to the contents of the memsize register.
8815 + */
8816 +#define SOCRAM_MEMSIZE_BASESHIFT 16
8817 +
8818 +#endif /* _SBSOCRAM_H */
8819 diff -Nur linux-2.4.32/arch/mips/bcm947xx/include/sbutils.h linux-2.4.32-brcm/arch/mips/bcm947xx/include/sbutils.h
8820 --- linux-2.4.32/arch/mips/bcm947xx/include/sbutils.h   1970-01-01 01:00:00.000000000 +0100
8821 +++ linux-2.4.32-brcm/arch/mips/bcm947xx/include/sbutils.h      2005-12-16 23:39:10.936836250 +0100
8822 @@ -0,0 +1,140 @@
8823 +/*
8824 + * Misc utility routines for accessing chip-specific features
8825 + * of Broadcom HNBU SiliconBackplane-based chips.
8826 + *
8827 + * Copyright 2005, Broadcom Corporation
8828 + * All Rights Reserved.
8829 + *
8830 + * THIS SOFTWARE IS OFFERED "AS IS", AND BROADCOM GRANTS NO WARRANTIES OF ANY
8831 + * KIND, EXPRESS OR IMPLIED, BY STATUTE, COMMUNICATION OR OTHERWISE. BROADCOM
8832 + * SPECIFICALLY DISCLAIMS ANY IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS
8833 + * FOR A SPECIFIC PURPOSE OR NONINFRINGEMENT CONCERNING THIS SOFTWARE.
8834 + *
8835 + * $Id$
8836 + */
8837 +
8838 +#ifndef        _sbutils_h_
8839 +#define        _sbutils_h_
8840 +
8841 +/*
8842 + * Datastructure to export all chip specific common variables
8843 + * public (read-only) portion of sbutils handle returned by
8844 + * sb_attach()/sb_kattach()
8845 +*/
8846 +
8847 +struct sb_pub {
8848 +
8849 +       uint    bustype;                /* SB_BUS, PCI_BUS  */
8850 +       uint    buscoretype;            /* SB_PCI, SB_PCMCIA, SB_PCIE*/
8851 +       uint    buscorerev;             /* buscore rev */
8852 +       uint    buscoreidx;             /* buscore index */
8853 +       int     ccrev;                  /* chip common core rev */
8854 +       uint    boardtype;              /* board type */
8855 +       uint    boardvendor;            /* board vendor */
8856 +       uint    chip;                   /* chip number */
8857 +       uint    chiprev;                /* chip revision */
8858 +       uint    chippkg;                /* chip package option */
8859 +       uint    sonicsrev;              /* sonics backplane rev */
8860 +};
8861 +
8862 +typedef const struct sb_pub  sb_t;
8863 +
8864 +/*
8865 + * Many of the routines below take an 'sbh' handle as their first arg.
8866 + * Allocate this by calling sb_attach().  Free it by calling sb_detach().
8867 + * At any one time, the sbh is logically focused on one particular sb core
8868 + * (the "current core").
8869 + * Use sb_setcore() or sb_setcoreidx() to change the association to another core.
8870 + */
8871 +
8872 +/* exported externs */
8873 +extern sb_t * BCMINIT(sb_attach)(uint pcidev, osl_t *osh, void *regs, uint bustype, void *sdh, char **vars, int *varsz);
8874 +extern sb_t * BCMINIT(sb_kattach)(void);
8875 +extern void sb_detach(sb_t *sbh);
8876 +extern uint BCMINIT(sb_chip)(sb_t *sbh);
8877 +extern uint BCMINIT(sb_chiprev)(sb_t *sbh);
8878 +extern uint BCMINIT(sb_chipcrev)(sb_t *sbh);
8879 +extern uint BCMINIT(sb_chippkg)(sb_t *sbh);
8880 +extern uint BCMINIT(sb_pcirev)(sb_t *sbh);
8881 +extern bool BCMINIT(sb_war16165)(sb_t *sbh);
8882 +extern uint BCMINIT(sb_pcmciarev)(sb_t *sbh);
8883 +extern uint BCMINIT(sb_boardvendor)(sb_t *sbh);
8884 +extern uint BCMINIT(sb_boardtype)(sb_t *sbh);
8885 +extern uint sb_bus(sb_t *sbh);
8886 +extern uint sb_buscoretype(sb_t *sbh);
8887 +extern uint sb_buscorerev(sb_t *sbh);
8888 +extern uint sb_corelist(sb_t *sbh, uint coreid[]);
8889 +extern uint sb_coreid(sb_t *sbh);
8890 +extern uint sb_coreidx(sb_t *sbh);
8891 +extern uint sb_coreunit(sb_t *sbh);
8892 +extern uint sb_corevendor(sb_t *sbh);
8893 +extern uint sb_corerev(sb_t *sbh);
8894 +extern void *sb_osh(sb_t *sbh);
8895 +extern void *sb_coreregs(sb_t *sbh);
8896 +extern uint32 sb_coreflags(sb_t *sbh, uint32 mask, uint32 val);
8897 +extern uint32 sb_coreflagshi(sb_t *sbh, uint32 mask, uint32 val);
8898 +extern bool sb_iscoreup(sb_t *sbh);
8899 +extern void *sb_setcoreidx(sb_t *sbh, uint coreidx);
8900 +extern void *sb_setcore(sb_t *sbh, uint coreid, uint coreunit);
8901 +extern int sb_corebist(sb_t *sbh, uint coreid, uint coreunit);
8902 +extern void sb_commit(sb_t *sbh);
8903 +extern uint32 sb_base(uint32 admatch);
8904 +extern uint32 sb_size(uint32 admatch);
8905 +extern void sb_core_reset(sb_t *sbh, uint32 bits);
8906 +extern void sb_core_tofixup(sb_t *sbh);
8907 +extern void sb_core_disable(sb_t *sbh, uint32 bits);
8908 +extern uint32 sb_clock_rate(uint32 pll_type, uint32 n, uint32 m);
8909 +extern uint32 sb_clock(sb_t *sbh);
8910 +extern void sb_pci_setup(sb_t *sbh, uint coremask);
8911 +extern void sb_pcmcia_init(sb_t *sbh);
8912 +extern void sb_watchdog(sb_t *sbh, uint ticks);
8913 +extern void *sb_gpiosetcore(sb_t *sbh);
8914 +extern uint32 sb_gpiocontrol(sb_t *sbh, uint32 mask, uint32 val, uint8 priority);
8915 +extern uint32 sb_gpioouten(sb_t *sbh, uint32 mask, uint32 val, uint8 priority);
8916 +extern uint32 sb_gpioout(sb_t *sbh, uint32 mask, uint32 val, uint8 priority);
8917 +extern uint32 sb_gpioin(sb_t *sbh);
8918 +extern uint32 sb_gpiointpolarity(sb_t *sbh, uint32 mask, uint32 val, uint8 priority);
8919 +extern uint32 sb_gpiointmask(sb_t *sbh, uint32 mask, uint32 val, uint8 priority);
8920 +extern uint32 sb_gpioled(sb_t *sbh, uint32 mask, uint32 val);
8921 +extern uint32 sb_gpioreserve(sb_t *sbh, uint32 gpio_num, uint8 priority);
8922 +extern uint32 sb_gpiorelease(sb_t *sbh, uint32 gpio_num, uint8 priority);
8923 +
8924 +extern void sb_clkctl_init(sb_t *sbh);
8925 +extern uint16 sb_clkctl_fast_pwrup_delay(sb_t *sbh);
8926 +extern bool sb_clkctl_clk(sb_t *sbh, uint mode);
8927 +extern int sb_clkctl_xtal(sb_t *sbh, uint what, bool on);
8928 +extern void sb_register_intr_callback(sb_t *sbh, void *intrsoff_fn,
8929 +       void *intrsrestore_fn, void *intrsenabled_fn, void *intr_arg);
8930 +extern uint32 sb_set_initiator_to(sb_t *sbh, uint32 to);
8931 +extern void sb_corepciid(sb_t *sbh, uint16 *pcivendor, uint16 *pcidevice,
8932 +       uint8 *pciclass, uint8 *pcisubclass, uint8 *pciprogif);
8933 +extern uint sb_pcie_readreg(void *sbh, void* arg1, uint offset);
8934 +extern uint sb_pcie_writereg(sb_t *sbh, void *arg1,  uint offset, uint val);
8935 +extern uint32 sb_gpiotimerval(sb_t *sbh, uint32 mask, uint32 val);
8936 +
8937 +
8938 +
8939 +/*
8940 +* Build device path. Path size must be >= SB_DEVPATH_BUFSZ.
8941 +* The returned path is NULL terminated and has trailing '/'.
8942 +* Return 0 on success, nonzero otherwise.
8943 +*/
8944 +extern int sb_devpath(sb_t *sbh, char *path, int size);
8945 +
8946 +/* clkctl xtal what flags */
8947 +#define        XTAL            0x1                     /* primary crystal oscillator (2050) */
8948 +#define        PLL             0x2                     /* main chip pll */
8949 +
8950 +/* clkctl clk mode */
8951 +#define        CLK_FAST        0                       /* force fast (pll) clock */
8952 +#define        CLK_DYNAMIC     2                       /* enable dynamic clock control */
8953 +
8954 +
8955 +/* GPIO usage priorities */
8956 +#define GPIO_DRV_PRIORITY      0
8957 +#define GPIO_APP_PRIORITY      1
8958 +
8959 +/* device path */
8960 +#define SB_DEVPATH_BUFSZ       16      /* min buffer size in bytes */
8961 +
8962 +#endif /* _sbutils_h_ */
8963 diff -Nur linux-2.4.32/arch/mips/bcm947xx/include/sflash.h linux-2.4.32-brcm/arch/mips/bcm947xx/include/sflash.h
8964 --- linux-2.4.32/arch/mips/bcm947xx/include/sflash.h    1970-01-01 01:00:00.000000000 +0100
8965 +++ linux-2.4.32-brcm/arch/mips/bcm947xx/include/sflash.h       2005-12-16 23:39:10.936836250 +0100
8966 @@ -0,0 +1,36 @@
8967 +/*
8968 + * Broadcom SiliconBackplane chipcommon serial flash interface
8969 + *
8970 + * Copyright 2005, Broadcom Corporation
8971 + * All Rights Reserved.
8972 + *
8973 + * THIS SOFTWARE IS OFFERED "AS IS", AND BROADCOM GRANTS NO WARRANTIES OF ANY
8974 + * KIND, EXPRESS OR IMPLIED, BY STATUTE, COMMUNICATION OR OTHERWISE. BROADCOM
8975 + * SPECIFICALLY DISCLAIMS ANY IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS
8976 + * FOR A SPECIFIC PURPOSE OR NONINFRINGEMENT CONCERNING THIS SOFTWARE.
8977 + *
8978 + * $Id$
8979 + */
8980 +
8981 +#ifndef _sflash_h_
8982 +#define _sflash_h_
8983 +
8984 +#include <typedefs.h>
8985 +#include <sbchipc.h>
8986 +
8987 +struct sflash {
8988 +       uint blocksize;         /* Block size */
8989 +       uint numblocks;         /* Number of blocks */
8990 +       uint32 type;            /* Type */
8991 +       uint size;              /* Total size in bytes */
8992 +};
8993 +
8994 +/* Utility functions */
8995 +extern int sflash_poll(chipcregs_t *cc, uint offset);
8996 +extern int sflash_read(chipcregs_t *cc, uint offset, uint len, uchar *buf);
8997 +extern int sflash_write(chipcregs_t *cc, uint offset, uint len, const uchar *buf);
8998 +extern int sflash_erase(chipcregs_t *cc, uint offset);
8999 +extern int sflash_commit(chipcregs_t *cc, uint offset, uint len, const uchar *buf);
9000 +extern struct sflash * sflash_init(chipcregs_t *cc);
9001 +
9002 +#endif /* _sflash_h_ */
9003 diff -Nur linux-2.4.32/arch/mips/bcm947xx/include/trxhdr.h linux-2.4.32-brcm/arch/mips/bcm947xx/include/trxhdr.h
9004 --- linux-2.4.32/arch/mips/bcm947xx/include/trxhdr.h    1970-01-01 01:00:00.000000000 +0100
9005 +++ linux-2.4.32-brcm/arch/mips/bcm947xx/include/trxhdr.h       2005-12-16 23:39:10.940836500 +0100
9006 @@ -0,0 +1,33 @@
9007 +/*
9008 + * TRX image file header format.
9009 + *
9010 + * Copyright 2005, Broadcom Corporation
9011 + * All Rights Reserved.
9012 + *
9013 + * THIS SOFTWARE IS OFFERED "AS IS", AND BROADCOM GRANTS NO WARRANTIES OF ANY
9014 + * KIND, EXPRESS OR IMPLIED, BY STATUTE, COMMUNICATION OR OTHERWISE. BROADCOM
9015 + * SPECIFICALLY DISCLAIMS ANY IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS
9016 + * FOR A SPECIFIC PURPOSE OR NONINFRINGEMENT CONCERNING THIS SOFTWARE.
9017 + *
9018 + * $Id$
9019 + */
9020 +
9021 +#include <typedefs.h>
9022 +
9023 +#define TRX_MAGIC      0x30524448      /* "HDR0" */
9024 +#define TRX_VERSION    1
9025 +#define TRX_MAX_LEN    0x3A0000
9026 +#define TRX_NO_HEADER  1               /* Do not write TRX header */
9027 +#define TRX_GZ_FILES   0x2     /* Contains up to TRX_MAX_OFFSET individual gzip files */
9028 +#define TRX_MAX_OFFSET 3
9029 +
9030 +struct trx_header {
9031 +       uint32 magic;           /* "HDR0" */
9032 +       uint32 len;             /* Length of file including header */
9033 +       uint32 crc32;           /* 32-bit CRC from flag_version to end of file */
9034 +       uint32 flag_version;    /* 0:15 flags, 16:31 version */
9035 +       uint32 offsets[TRX_MAX_OFFSET]; /* Offsets of partitions from start of header */
9036 +};
9037 +
9038 +/* Compatibility */
9039 +typedef struct trx_header TRXHDR, *PTRXHDR;
9040 diff -Nur linux-2.4.32/arch/mips/bcm947xx/include/typedefs.h linux-2.4.32-brcm/arch/mips/bcm947xx/include/typedefs.h
9041 --- linux-2.4.32/arch/mips/bcm947xx/include/typedefs.h  1970-01-01 01:00:00.000000000 +0100
9042 +++ linux-2.4.32-brcm/arch/mips/bcm947xx/include/typedefs.h     2005-12-16 23:39:10.940836500 +0100
9043 @@ -0,0 +1,326 @@
9044 +/*
9045 + * Copyright 2005, Broadcom Corporation
9046 + * All Rights Reserved.
9047 + *
9048 + * THIS SOFTWARE IS OFFERED "AS IS", AND BROADCOM GRANTS NO WARRANTIES OF ANY
9049 + * KIND, EXPRESS OR IMPLIED, BY STATUTE, COMMUNICATION OR OTHERWISE. BROADCOM
9050 + * SPECIFICALLY DISCLAIMS ANY IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS
9051 + * FOR A SPECIFIC PURPOSE OR NONINFRINGEMENT CONCERNING THIS SOFTWARE.
9052 + * $Id$
9053 + */
9054 +
9055 +#ifndef _TYPEDEFS_H_
9056 +#define _TYPEDEFS_H_
9057 +
9058 +
9059 +/* Define 'SITE_TYPEDEFS' in the compile to include a site specific
9060 + * typedef file "site_typedefs.h".
9061 + *
9062 + * If 'SITE_TYPEDEFS' is not defined, then the "Inferred Typedefs"
9063 + * section of this file makes inferences about the compile environment
9064 + * based on defined symbols and possibly compiler pragmas.
9065 + *
9066 + * Following these two sections is the "Default Typedefs"
9067 + * section. This section is only prcessed if 'USE_TYPEDEF_DEFAULTS' is
9068 + * defined. This section has a default set of typedefs and a few
9069 + * proprocessor symbols (TRUE, FALSE, NULL, ...).
9070 + */
9071 +
9072 +#ifdef SITE_TYPEDEFS
9073 +
9074 +/*******************************************************************************
9075 + * Site Specific Typedefs
9076 + *******************************************************************************/
9077 +
9078 +#include "site_typedefs.h"
9079 +
9080 +#else
9081 +
9082 +/*******************************************************************************
9083 + * Inferred Typedefs
9084 + *******************************************************************************/
9085 +
9086 +/* Infer the compile environment based on preprocessor symbols and pramas.
9087 + * Override type definitions as needed, and include configuration dependent
9088 + * header files to define types.
9089 + */
9090 +
9091 +#ifdef __cplusplus
9092 +
9093 +#define TYPEDEF_BOOL
9094 +#ifndef FALSE
9095 +#define FALSE  false
9096 +#endif
9097 +#ifndef TRUE
9098 +#define TRUE   true
9099 +#endif
9100 +
9101 +#else  /* ! __cplusplus */
9102 +
9103 +#if defined(_WIN32)
9104 +
9105 +#define TYPEDEF_BOOL
9106 +typedef        unsigned char   bool;                   /* consistent w/BOOL */
9107 +
9108 +#endif /* _WIN32 */
9109 +
9110 +#endif /* ! __cplusplus */
9111 +
9112 +/* use the Windows ULONG_PTR type when compiling for 64 bit */
9113 +#if defined(_WIN64)
9114 +#include <basetsd.h>
9115 +#define TYPEDEF_UINTPTR
9116 +typedef ULONG_PTR      uintptr;
9117 +#endif
9118 +
9119 +#ifdef _HNDRTE_
9120 +typedef long unsigned int size_t;
9121 +#endif
9122 +
9123 +#ifdef _MSC_VER            /* Microsoft C */
9124 +#define TYPEDEF_INT64
9125 +#define TYPEDEF_UINT64
9126 +typedef signed __int64 int64;
9127 +typedef unsigned __int64 uint64;
9128 +#endif
9129 +
9130 +#if defined(MACOSX) && defined(KERNEL)
9131 +#define TYPEDEF_BOOL
9132 +#endif
9133 +
9134 +
9135 +#if defined(linux)
9136 +#define TYPEDEF_UINT
9137 +#define TYPEDEF_USHORT
9138 +#define TYPEDEF_ULONG
9139 +#endif
9140 +
9141 +#if !defined(linux) && !defined(_WIN32) && !defined(PMON) && !defined(_CFE_) && !defined(_HNDRTE_) && !defined(_MINOSL_)
9142 +#define TYPEDEF_UINT
9143 +#define TYPEDEF_USHORT
9144 +#endif
9145 +
9146 +
9147 +/* Do not support the (u)int64 types with strict ansi for GNU C */
9148 +#if defined(__GNUC__) && defined(__STRICT_ANSI__)
9149 +#define TYPEDEF_INT64
9150 +#define TYPEDEF_UINT64
9151 +#endif
9152 +
9153 +/* ICL accepts unsigned 64 bit type only, and complains in ANSI mode
9154 + * for singned or unsigned */
9155 +#if defined(__ICL)
9156 +
9157 +#define TYPEDEF_INT64
9158 +
9159 +#if defined(__STDC__)
9160 +#define TYPEDEF_UINT64
9161 +#endif
9162 +
9163 +#endif /* __ICL */
9164 +
9165 +
9166 +#if !defined(_WIN32) && !defined(PMON) && !defined(_CFE_) && !defined(_HNDRTE_) && !defined(_MINOSL_)
9167 +
9168 +/* pick up ushort & uint from standard types.h */
9169 +#if defined(linux) && defined(__KERNEL__)
9170 +
9171 +#include <linux/types.h>       /* sys/types.h and linux/types.h are oil and water */
9172 +
9173 +#else
9174 +
9175 +#include <sys/types.h>
9176 +
9177 +#endif
9178 +
9179 +#endif /* !_WIN32 && !PMON && !_CFE_ && !_HNDRTE_  && !_MINOSL_ */
9180 +
9181 +#if defined(MACOSX) && defined(KERNEL)
9182 +#include <IOKit/IOTypes.h>
9183 +#endif
9184 +
9185 +
9186 +/* use the default typedefs in the next section of this file */
9187 +#define USE_TYPEDEF_DEFAULTS
9188 +
9189 +#endif /* SITE_TYPEDEFS */
9190 +
9191 +
9192 +/*******************************************************************************
9193 + * Default Typedefs
9194 + *******************************************************************************/
9195 +
9196 +#ifdef USE_TYPEDEF_DEFAULTS
9197 +#undef USE_TYPEDEF_DEFAULTS
9198 +
9199 +#ifndef TYPEDEF_BOOL
9200 +typedef        /*@abstract@*/ unsigned char    bool;
9201 +#endif
9202 +
9203 +/*----------------------- define uchar, ushort, uint, ulong ------------------*/
9204 +
9205 +#ifndef TYPEDEF_UCHAR
9206 +typedef unsigned char  uchar;
9207 +#endif
9208 +
9209 +#ifndef TYPEDEF_USHORT
9210 +typedef unsigned short ushort;
9211 +#endif
9212 +
9213 +#ifndef TYPEDEF_UINT
9214 +typedef unsigned int   uint;
9215 +#endif
9216 +
9217 +#ifndef TYPEDEF_ULONG
9218 +typedef unsigned long  ulong;
9219 +#endif
9220 +
9221 +/*----------------------- define [u]int8/16/32/64, uintptr --------------------*/
9222 +
9223 +#ifndef TYPEDEF_UINT8
9224 +typedef unsigned char  uint8;
9225 +#endif
9226 +
9227 +#ifndef TYPEDEF_UINT16
9228 +typedef unsigned short uint16;
9229 +#endif
9230 +
9231 +#ifndef TYPEDEF_UINT32
9232 +typedef unsigned int   uint32;
9233 +#endif
9234 +
9235 +#ifndef TYPEDEF_UINT64
9236 +typedef unsigned long long uint64;
9237 +#endif
9238 +
9239 +#ifndef TYPEDEF_UINTPTR
9240 +typedef unsigned int   uintptr;
9241 +#endif
9242 +
9243 +#ifndef TYPEDEF_INT8
9244 +typedef signed char    int8;
9245 +#endif
9246 +
9247 +#ifndef TYPEDEF_INT16
9248 +typedef signed short   int16;
9249 +#endif
9250 +
9251 +#ifndef TYPEDEF_INT32
9252 +typedef signed int     int32;
9253 +#endif
9254 +
9255 +#ifndef TYPEDEF_INT64
9256 +typedef signed long long int64;
9257 +#endif
9258 +
9259 +/*----------------------- define float32/64, float_t -----------------------*/
9260 +
9261 +#ifndef TYPEDEF_FLOAT32
9262 +typedef float          float32;
9263 +#endif
9264 +
9265 +#ifndef TYPEDEF_FLOAT64
9266 +typedef double         float64;
9267 +#endif
9268 +
9269 +/*
9270 + * abstracted floating point type allows for compile time selection of
9271 + * single or double precision arithmetic.  Compiling with -DFLOAT32
9272 + * selects single precision; the default is double precision.
9273 + */
9274 +
9275 +#ifndef TYPEDEF_FLOAT_T
9276 +
9277 +#if defined(FLOAT32)
9278 +typedef float32 float_t;
9279 +#else /* default to double precision floating point */
9280 +typedef float64 float_t;
9281 +#endif
9282 +
9283 +#endif /* TYPEDEF_FLOAT_T */
9284 +
9285 +/*----------------------- define macro values -----------------------------*/
9286 +
9287 +#ifndef FALSE
9288 +#define FALSE  0
9289 +#endif
9290 +
9291 +#ifndef TRUE
9292 +#define TRUE   1
9293 +#endif
9294 +
9295 +#ifndef NULL
9296 +#define        NULL    0
9297 +#endif
9298 +
9299 +#ifndef OFF
9300 +#define        OFF     0
9301 +#endif
9302 +
9303 +#ifndef ON
9304 +#define        ON      1
9305 +#endif
9306 +
9307 +#define        AUTO    (-1)
9308 +
9309 +/* Reclaiming text and data :
9310 +   The following macros specify special linker sections that can be reclaimed
9311 +   after a system is considered 'up'.
9312 + */
9313 +#if defined(__GNUC__) && defined(BCMRECLAIM)
9314 +extern bool    bcmreclaimed;
9315 +#define BCMINITDATA(_data)     __attribute__ ((__section__ (".dataini." #_data))) _data##_ini
9316 +#define BCMINITFN(_fn)         __attribute__ ((__section__ (".textini." #_fn))) _fn##_ini
9317 +#define BCMINIT(_id)           _id##_ini
9318 +#else
9319 +#define BCMINITDATA(_data)     _data
9320 +#define BCMINITFN(_fn)         _fn
9321 +#define BCMINIT(_id)           _id
9322 +#define bcmreclaimed           0
9323 +#endif
9324 +
9325 +/*----------------------- define PTRSZ, INLINE ----------------------------*/
9326 +
9327 +#ifndef PTRSZ
9328 +#define        PTRSZ   sizeof (char*)
9329 +#endif
9330 +
9331 +#ifndef INLINE
9332 +
9333 +#ifdef _MSC_VER
9334 +
9335 +#define INLINE __inline
9336 +
9337 +#elif __GNUC__
9338 +
9339 +#define INLINE __inline__
9340 +
9341 +#else
9342 +
9343 +#define INLINE
9344 +
9345 +#endif /* _MSC_VER */
9346 +
9347 +#endif /* INLINE */
9348 +
9349 +#undef TYPEDEF_BOOL
9350 +#undef TYPEDEF_UCHAR
9351 +#undef TYPEDEF_USHORT
9352 +#undef TYPEDEF_UINT
9353 +#undef TYPEDEF_ULONG
9354 +#undef TYPEDEF_UINT8
9355 +#undef TYPEDEF_UINT16
9356 +#undef TYPEDEF_UINT32
9357 +#undef TYPEDEF_UINT64
9358 +#undef TYPEDEF_UINTPTR
9359 +#undef TYPEDEF_INT8
9360 +#undef TYPEDEF_INT16
9361 +#undef TYPEDEF_INT32
9362 +#undef TYPEDEF_INT64
9363 +#undef TYPEDEF_FLOAT32
9364 +#undef TYPEDEF_FLOAT64
9365 +#undef TYPEDEF_FLOAT_T
9366 +
9367 +#endif /* USE_TYPEDEF_DEFAULTS */
9368 +
9369 +#endif /* _TYPEDEFS_H_ */
9370 diff -Nur linux-2.4.32/arch/mips/bcm947xx/include/wlioctl.h linux-2.4.32-brcm/arch/mips/bcm947xx/include/wlioctl.h
9371 --- linux-2.4.32/arch/mips/bcm947xx/include/wlioctl.h   1970-01-01 01:00:00.000000000 +0100
9372 +++ linux-2.4.32-brcm/arch/mips/bcm947xx/include/wlioctl.h      2005-12-16 23:39:10.940836500 +0100
9373 @@ -0,0 +1,1030 @@
9374 +/*
9375 + * Custom OID/ioctl definitions for
9376 + * Broadcom 802.11abg Networking Device Driver
9377 + *
9378 + * Definitions subject to change without notice.
9379 + *
9380 + * Copyright 2005, Broadcom Corporation
9381 + * All Rights Reserved.
9382 + *
9383 + * THIS SOFTWARE IS OFFERED "AS IS", AND BROADCOM GRANTS NO WARRANTIES OF ANY
9384 + * KIND, EXPRESS OR IMPLIED, BY STATUTE, COMMUNICATION OR OTHERWISE. BROADCOM
9385 + * SPECIFICALLY DISCLAIMS ANY IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS
9386 + * FOR A SPECIFIC PURPOSE OR NONINFRINGEMENT CONCERNING THIS SOFTWARE.
9387 + *
9388 + * $Id$
9389 + */
9390 +
9391 +#ifndef _wlioctl_h_
9392 +#define        _wlioctl_h_
9393 +
9394 +#include <typedefs.h>
9395 +#include <proto/ethernet.h>
9396 +#include <proto/bcmeth.h>
9397 +#include <proto/bcmevent.h>
9398 +#include <proto/802.11.h>
9399 +
9400 +/* require default structure packing */
9401 +#if !defined(__GNUC__)
9402 +#pragma pack(push,8)
9403 +#endif
9404 +
9405 +#define WL_NUMRATES            255     /* max # of rates in a rateset */
9406 +
9407 +typedef struct wl_rateset {
9408 +       uint32  count;                  /* # rates in this set */
9409 +       uint8   rates[WL_NUMRATES];     /* rates in 500kbps units w/hi bit set if basic */
9410 +} wl_rateset_t;
9411 +
9412 +#define WL_CHANSPEC_CHAN_MASK  0x0fff
9413 +#define WL_CHANSPEC_BAND_MASK  0xf000
9414 +#define WL_CHANSPEC_BAND_SHIFT 12
9415 +#define WL_CHANSPEC_BAND_A     0x1000
9416 +#define WL_CHANSPEC_BAND_B     0x2000
9417 +
9418 +/*
9419 + * Per-bss information structure.
9420 + */
9421 +
9422 +#define        WL_BSS_INFO_VERSION             107     /* current version of wl_bss_info struct */
9423 +
9424 +typedef struct wl_bss_info {
9425 +       uint32          version;        /* version field */
9426 +       uint32          length;         /* byte length of data in this record, starting at version and including IEs */
9427 +       struct ether_addr BSSID;
9428 +       uint16          beacon_period;  /* units are Kusec */
9429 +       uint16          capability;     /* Capability information */
9430 +       uint8           SSID_len;
9431 +       uint8           SSID[32];
9432 +       struct {
9433 +               uint    count;          /* # rates in this set */
9434 +               uint8   rates[16];      /* rates in 500kbps units w/hi bit set if basic */
9435 +       } rateset;                      /* supported rates */
9436 +       uint8           channel;        /* Channel no. */
9437 +       uint16          atim_window;    /* units are Kusec */
9438 +       uint8           dtim_period;    /* DTIM period */
9439 +       int16           RSSI;           /* receive signal strength (in dBm) */
9440 +       int8            phy_noise;      /* noise (in dBm) */
9441 +       uint32          ie_length;      /* byte length of Information Elements */
9442 +       /* variable length Information Elements */
9443 +} wl_bss_info_t;
9444 +
9445 +typedef struct wlc_ssid {
9446 +       uint32          SSID_len;
9447 +       uchar           SSID[32];
9448 +} wlc_ssid_t;
9449 +
9450 +typedef struct wl_scan_params {
9451 +       wlc_ssid_t ssid;        /* default is {0, ""} */
9452 +       struct ether_addr bssid;/* default is bcast */
9453 +       int8 bss_type;          /* default is any, DOT11_BSSTYPE_ANY/INFRASTRUCTURE/INDEPENDENT */
9454 +       int8 scan_type;         /* -1 use default, DOT11_SCANTYPE_ACTIVE/PASSIVE */
9455 +       int32 nprobes;          /* -1 use default, number of probes per channel */
9456 +       int32 active_time;      /* -1 use default, dwell time per channel for active scanning */
9457 +       int32 passive_time;     /* -1 use default, dwell time per channel for passive scanning */
9458 +       int32 home_time;        /* -1 use default, dwell time for the home channel between channel scans */
9459 +       int32 channel_num;      /* 0 use default (all available channels), count of channels in channel_list */
9460 +       uint16 channel_list[1]; /* list of chanspecs */
9461 +} wl_scan_params_t;
9462 +/* size of wl_scan_params not including variable length array */
9463 +#define WL_SCAN_PARAMS_FIXED_SIZE 64
9464 +
9465 +typedef struct wl_scan_results {
9466 +       uint32 buflen;
9467 +       uint32 version;
9468 +       uint32 count;
9469 +       wl_bss_info_t bss_info[1];
9470 +} wl_scan_results_t;
9471 +/* size of wl_scan_results not including variable length array */
9472 +#define WL_SCAN_RESULTS_FIXED_SIZE 12
9473 +
9474 +/* uint32 list */
9475 +typedef struct wl_uint32_list {
9476 +       /* in - # of elements, out - # of entries */
9477 +       uint32 count;
9478 +       /* variable length uint32 list */
9479 +       uint32 element[1];
9480 +} wl_uint32_list_t;
9481 +
9482 +#define WLC_CNTRY_BUF_SZ       4               /* Country string is 3 bytes + NULL */
9483 +
9484 +typedef struct wl_channels_in_country {
9485 +       uint32 buflen;
9486 +       uint32 band;
9487 +       char country_abbrev[WLC_CNTRY_BUF_SZ];
9488 +       uint32 count;
9489 +       uint32 channel[1];
9490 +} wl_channels_in_country_t;
9491 +
9492 +typedef struct wl_country_list {
9493 +       uint32 buflen;
9494 +       uint32 band_set;
9495 +       uint32 band;
9496 +       uint32 count;
9497 +       char country_abbrev[1];
9498 +} wl_country_list_t;
9499 +
9500 +#define WL_RM_TYPE_BASIC       1
9501 +#define WL_RM_TYPE_CCA         2
9502 +#define WL_RM_TYPE_RPI         3
9503 +
9504 +#define WL_RM_FLAG_PARALLEL    (1<<0)
9505 +
9506 +#define WL_RM_FLAG_LATE                (1<<1)
9507 +#define WL_RM_FLAG_INCAPABLE   (1<<2)
9508 +#define WL_RM_FLAG_REFUSED     (1<<3)
9509 +
9510 +typedef struct wl_rm_req_elt {
9511 +       int8    type;
9512 +       int8    flags;
9513 +       uint16  chanspec;
9514 +       uint32  token;          /* token for this measurement */
9515 +       uint32  tsf_h;          /* TSF high 32-bits of Measurement start time */
9516 +       uint32  tsf_l;          /* TSF low 32-bits */
9517 +       uint32  dur;            /* TUs */
9518 +} wl_rm_req_elt_t;
9519 +
9520 +typedef struct wl_rm_req {
9521 +       uint32  token;          /* overall measurement set token */
9522 +       uint32  count;          /* number of measurement reqests */
9523 +       wl_rm_req_elt_t req[1]; /* variable length block of requests */
9524 +} wl_rm_req_t;
9525 +#define WL_RM_REQ_FIXED_LEN    8
9526 +
9527 +typedef struct wl_rm_rep_elt {
9528 +       int8    type;
9529 +       int8    flags;
9530 +       uint16  chanspec;
9531 +       uint32  token;          /* token for this measurement */
9532 +       uint32  tsf_h;          /* TSF high 32-bits of Measurement start time */
9533 +       uint32  tsf_l;          /* TSF low 32-bits */
9534 +       uint32  dur;            /* TUs */
9535 +       uint32  len;            /* byte length of data block */
9536 +       uint8   data[1];        /* variable length data block */
9537 +} wl_rm_rep_elt_t;
9538 +#define WL_RM_REP_ELT_FIXED_LEN        24      /* length excluding data block */
9539 +
9540 +#define WL_RPI_REP_BIN_NUM 8
9541 +typedef struct wl_rm_rpi_rep {
9542 +       uint8   rpi[WL_RPI_REP_BIN_NUM];
9543 +       int8    rpi_max[WL_RPI_REP_BIN_NUM];
9544 +} wl_rm_rpi_rep_t;
9545 +
9546 +typedef struct wl_rm_rep {
9547 +       uint32  token;          /* overall measurement set token */
9548 +       uint32  len;            /* length of measurement report block */
9549 +       wl_rm_rep_elt_t rep[1]; /* variable length block of reports */
9550 +} wl_rm_rep_t;
9551 +#define WL_RM_REP_FIXED_LEN    8
9552 +
9553 +
9554 +#if defined(BCMSUP_PSK)
9555 +typedef enum sup_auth_status {
9556 +       WLC_SUP_DISCONNECTED = 0,
9557 +       WLC_SUP_CONNECTING,
9558 +       WLC_SUP_IDREQUIRED,
9559 +       WLC_SUP_AUTHENTICATING,
9560 +       WLC_SUP_AUTHENTICATED,
9561 +       WLC_SUP_KEYXCHANGE,
9562 +       WLC_SUP_KEYED,
9563 +       WLC_SUP_TIMEOUT
9564 +} sup_auth_status_t;
9565 +#endif /* BCMCCX | BCMSUP_PSK */
9566 +
9567 +/* Enumerate crypto algorithms */
9568 +#define        CRYPTO_ALGO_OFF                 0
9569 +#define        CRYPTO_ALGO_WEP1                1
9570 +#define        CRYPTO_ALGO_TKIP                2
9571 +#define        CRYPTO_ALGO_WEP128              3
9572 +#define CRYPTO_ALGO_AES_CCM            4
9573 +#define CRYPTO_ALGO_AES_OCB_MSDU       5
9574 +#define CRYPTO_ALGO_AES_OCB_MPDU       6
9575 +#define CRYPTO_ALGO_NALG               7
9576 +
9577 +#define WSEC_GEN_MIC_ERROR     0x0001
9578 +#define WSEC_GEN_REPLAY                0x0002
9579 +
9580 +#define WL_SOFT_KEY    (1 << 0)        /* Indicates this key is using soft encrypt */
9581 +#define WL_PRIMARY_KEY (1 << 1)        /* Indicates this key is the primary (ie tx) key */
9582 +#define WL_KF_RES_4    (1 << 4)        /* Reserved for backward compat */
9583 +#define WL_KF_RES_5    (1 << 5)        /* Reserved for backward compat */
9584 +
9585 +typedef struct wl_wsec_key {
9586 +       uint32          index;          /* key index */
9587 +       uint32          len;            /* key length */
9588 +       uint8           data[DOT11_MAX_KEY_SIZE];       /* key data */
9589 +       uint32          pad_1[18];
9590 +       uint32          algo;           /* CRYPTO_ALGO_AES_CCM, CRYPTO_ALGO_WEP128, etc */
9591 +       uint32          flags;          /* misc flags */
9592 +       uint32          pad_2[2];
9593 +       int             pad_3;
9594 +       int             iv_initialized; /* has IV been initialized already? */
9595 +       int             pad_4;
9596 +       /* Rx IV */
9597 +       struct {
9598 +               uint32  hi;             /* upper 32 bits of IV */
9599 +               uint16  lo;             /* lower 16 bits of IV */
9600 +       } rxiv;
9601 +       uint32          pad_5[2];
9602 +       struct ether_addr ea;           /* per station */
9603 +} wl_wsec_key_t;
9604 +
9605 +
9606 +#define WSEC_MIN_PSK_LEN       8
9607 +#define WSEC_MAX_PSK_LEN       64
9608 +
9609 +/* Flag for key material needing passhash'ing */
9610 +#define WSEC_PASSPHRASE                (1<<0)
9611 +
9612 +/* recepticle for WLC_SET_WSEC_PMK parameter */
9613 +typedef struct {
9614 +       ushort  key_len;                /* octets in key material */
9615 +       ushort  flags;                  /* key handling qualification */
9616 +       uint8   key[WSEC_MAX_PSK_LEN];  /* PMK material */
9617 +} wsec_pmk_t;
9618 +
9619 +/* wireless security bitvec */
9620 +#define WEP_ENABLED            0x0001
9621 +#define TKIP_ENABLED           0x0002
9622 +#define AES_ENABLED            0x0004
9623 +#define WSEC_SWFLAG            0x0008
9624 +#define SES_OW_ENABLED         0x0040  /* to go into transition mode without setting wep */
9625 +
9626 +/* WPA authentication mode bitvec */
9627 +#define WPA_AUTH_DISABLED      0x0000  /* Legacy (i.e., non-WPA) */
9628 +#define WPA_AUTH_NONE          0x0001  /* none (IBSS) */
9629 +#define WPA_AUTH_UNSPECIFIED   0x0002  /* over 802.1x */
9630 +#define WPA_AUTH_PSK           0x0004  /* Pre-shared key */
9631 +/*#define WPA_AUTH_8021X 0x0020*/      /* 802.1x, reserved */
9632 +
9633 +#define WPA2_AUTH_UNSPECIFIED  0x0040  /* over 802.1x */
9634 +#define WPA2_AUTH_PSK          0x0080  /* Pre-shared key */
9635 +
9636 +
9637 +
9638 +/* pmkid */
9639 +#define        MAXPMKID                16
9640 +
9641 +typedef struct _pmkid
9642 +{
9643 +       struct ether_addr       BSSID;
9644 +       uint8                   PMKID[WPA2_PMKID_LEN];
9645 +} pmkid_t;
9646 +
9647 +typedef struct _pmkid_list
9648 +{
9649 +       uint32  npmkid;
9650 +       pmkid_t pmkid[1];
9651 +} pmkid_list_t;
9652 +
9653 +typedef struct _pmkid_cand {
9654 +       struct ether_addr       BSSID;
9655 +       uint8                   preauth;
9656 +} pmkid_cand_t;
9657 +
9658 +typedef struct _pmkid_cand_list {
9659 +       uint32  npmkid_cand;
9660 +       pmkid_cand_t    pmkid_cand[1];
9661 +} pmkid_cand_list_t;
9662 +
9663 +
9664 +typedef struct wl_led_info {
9665 +       uint32          index;          /* led index */
9666 +       uint32          behavior;
9667 +       bool            activehi;
9668 +} wl_led_info_t;
9669 +
9670 +typedef struct wlc_assoc_info {
9671 +       uint32          req_len;
9672 +       uint32          resp_len;
9673 +       uint32          flags;
9674 +       struct dot11_assoc_req req;
9675 +       struct ether_addr reassoc_bssid; /* used in reassoc's */
9676 +       struct dot11_assoc_resp resp;
9677 +} wl_assoc_info_t;
9678 +/* flags */
9679 +#define WLC_ASSOC_REQ_IS_REASSOC 0x01 /* assoc req was actually a reassoc */
9680 +/* srom read/write struct passed through ioctl */
9681 +typedef struct {
9682 +       uint    byteoff;                /* byte offset */
9683 +       uint    nbytes;         /* number of bytes */
9684 +       uint16 buf[1];
9685 +} srom_rw_t;
9686 +
9687 +/* R_REG and W_REG struct passed through ioctl */
9688 +typedef struct {
9689 +       uint32  byteoff;        /* byte offset of the field in d11regs_t */
9690 +       uint32  val;            /* read/write value of the field */
9691 +       uint32  size;           /* sizeof the field */
9692 +       uint    band;           /* band (optional) */
9693 +} rw_reg_t;
9694 +
9695 +/* Structure used by GET/SET_ATTEN ioctls */
9696 +typedef struct {
9697 +       uint16  auto_ctrl;      /* 1: Automatic control, 0: overriden */
9698 +       uint16  bb;             /* Baseband attenuation */
9699 +       uint16  radio;          /* Radio attenuation */
9700 +       uint16  txctl1;         /* Radio TX_CTL1 value */
9701 +} atten_t;
9702 +
9703 +/* Used to get specific STA parameters */
9704 +typedef struct {
9705 +       uint32  val;
9706 +       struct ether_addr ea;
9707 +} scb_val_t;
9708 +
9709 +
9710 +/* Event data type */
9711 +typedef struct wlc_event {
9712 +       wl_event_msg_t event; /* encapsulated event */
9713 +       struct ether_addr *addr; /* used to keep a trace of the potential present of
9714 +                                                       an address in wlc_event_msg_t */
9715 +       void *data;                     /* used to hang additional data on an event */
9716 +       struct wlc_event *next; /* enables ordered list of pending events */
9717 +} wlc_event_t;
9718 +
9719 +#define BCM_MAC_STATUS_INDICATION           (0x40010200L)
9720 +
9721 +typedef struct {
9722 +       uint16          ver;            /* version of this struct */
9723 +       uint16          len;            /* length in bytes of this structure */
9724 +       uint16          cap;            /* sta's advertized capabilities */
9725 +       uint32          flags;          /* flags defined below */
9726 +       uint32          idle;           /* time since data pkt rx'd from sta */
9727 +       struct ether_addr       ea;     /* Station address */
9728 +       wl_rateset_t    rateset;        /* rateset in use */
9729 +       uint32          in;             /* seconds elapsed since associated */
9730 +       uint32          listen_interval_inms; /* Min Listen interval in ms for this STA*/
9731 +} sta_info_t;
9732 +
9733 +#define WL_STA_VER     2
9734 +
9735 +/* flags fields */
9736 +#define WL_STA_BRCM    0x01
9737 +#define WL_STA_WME     0x02
9738 +#define WL_STA_ABCAP   0x04
9739 +#define WL_STA_AUTHE   0x08
9740 +#define WL_STA_ASSOC   0x10
9741 +#define WL_STA_AUTHO   0x20
9742 +#define WL_STA_WDS     0x40
9743 +#define WL_WDS_LINKUP  0x80
9744 +
9745 +
9746 +/*
9747 + * Country locale determines which channels are available to us.
9748 + */
9749 +typedef enum _wlc_locale {
9750 +       WLC_WW = 0,     /* Worldwide */
9751 +       WLC_THA,        /* Thailand */
9752 +       WLC_ISR,        /* Israel */
9753 +       WLC_JDN,        /* Jordan */
9754 +       WLC_PRC,        /* China */
9755 +       WLC_JPN,        /* Japan */
9756 +       WLC_FCC,        /* USA */
9757 +       WLC_EUR,        /* Europe */
9758 +       WLC_USL,        /* US Low Band only */
9759 +       WLC_JPH,        /* Japan High Band only */
9760 +       WLC_ALL,        /* All the channels in this band */
9761 +       WLC_11D,        /* Represents locale recieved by 11d beacons */
9762 +       WLC_LAST_LOCALE,
9763 +       WLC_UNDEFINED_LOCALE = 0xf
9764 +} wlc_locale_t;
9765 +
9766 +/* channel encoding */
9767 +typedef struct channel_info {
9768 +       int hw_channel;
9769 +       int target_channel;
9770 +       int scan_channel;
9771 +} channel_info_t;
9772 +
9773 +/* For ioctls that take a list of MAC addresses */
9774 +struct maclist {
9775 +       uint count;                     /* number of MAC addresses */
9776 +       struct ether_addr ea[1];        /* variable length array of MAC addresses */
9777 +};
9778 +
9779 +/* get pkt count struct passed through ioctl */
9780 +typedef struct get_pktcnt {
9781 +       uint rx_good_pkt;
9782 +       uint rx_bad_pkt;
9783 +       uint tx_good_pkt;
9784 +       uint tx_bad_pkt;
9785 +} get_pktcnt_t;
9786 +
9787 +/* Linux network driver ioctl encoding */
9788 +typedef struct wl_ioctl {
9789 +       uint cmd;       /* common ioctl definition */
9790 +       void *buf;      /* pointer to user buffer */
9791 +       uint len;       /* length of user buffer */
9792 +       bool set;       /* get or set request (optional) */
9793 +       uint used;      /* bytes read or written (optional) */
9794 +       uint needed;    /* bytes needed (optional) */
9795 +} wl_ioctl_t;
9796 +
9797 +/*
9798 + * Structure for passing hardware and software
9799 + * revision info up from the driver.
9800 + */
9801 +typedef struct wlc_rev_info {
9802 +       uint            vendorid;       /* PCI vendor id */
9803 +       uint            deviceid;       /* device id of chip */
9804 +       uint            radiorev;       /* radio revision */
9805 +       uint            chiprev;        /* chip revision */
9806 +       uint            corerev;        /* core revision */
9807 +       uint            boardid;        /* board identifier (usu. PCI sub-device id) */
9808 +       uint            boardvendor;    /* board vendor (usu. PCI sub-vendor id) */
9809 +       uint            boardrev;       /* board revision */
9810 +       uint            driverrev;      /* driver version */
9811 +       uint            ucoderev;       /* microcode version */
9812 +       uint            bus;            /* bus type */
9813 +       uint            chipnum;        /* chip number */
9814 +} wlc_rev_info_t;
9815 +
9816 +#define WL_BRAND_MAX 10
9817 +typedef struct wl_instance_info {
9818 +       uint instance;
9819 +       char brand[WL_BRAND_MAX];
9820 +} wl_instance_info_t;
9821 +
9822 +/* check this magic number */
9823 +#define WLC_IOCTL_MAGIC                0x14e46c77
9824 +
9825 +/* bump this number if you change the ioctl interface */
9826 +#define WLC_IOCTL_VERSION      1
9827 +
9828 +#define        WLC_IOCTL_MAXLEN        8192            /* max length ioctl buffer required */
9829 +#define        WLC_IOCTL_SMLEN         256             /* "small" length ioctl buffer required */
9830 +
9831 +/* common ioctl definitions */
9832 +#define WLC_GET_MAGIC                          0
9833 +#define WLC_GET_VERSION                                1
9834 +#define WLC_UP                                         2
9835 +#define WLC_DOWN                                       3
9836 +#define WLC_DUMP                                       6
9837 +#define WLC_GET_MSGLEVEL                       7
9838 +#define WLC_SET_MSGLEVEL                       8
9839 +#define WLC_GET_PROMISC                                9
9840 +#define WLC_SET_PROMISC                                10
9841 +#define WLC_GET_RATE                           12
9842 +/* #define WLC_SET_RATE                                13 */ /* no longer supported */
9843 +#define WLC_GET_INSTANCE                       14
9844 +/* #define WLC_GET_FRAG                                15 */ /* no longer supported */
9845 +/* #define WLC_SET_FRAG                                16 */ /* no longer supported */
9846 +/* #define WLC_GET_RTS                         17 */ /* no longer supported */
9847 +/* #define WLC_SET_RTS                         18 */ /* no longer supported */
9848 +#define WLC_GET_INFRA                          19
9849 +#define WLC_SET_INFRA                          20
9850 +#define WLC_GET_AUTH                           21
9851 +#define WLC_SET_AUTH                           22
9852 +#define WLC_GET_BSSID                          23
9853 +#define WLC_SET_BSSID                          24
9854 +#define WLC_GET_SSID                           25
9855 +#define WLC_SET_SSID                           26
9856 +#define WLC_RESTART                            27
9857 +#define WLC_GET_CHANNEL                                29
9858 +#define WLC_SET_CHANNEL                                30
9859 +#define WLC_GET_SRL                            31
9860 +#define WLC_SET_SRL                            32
9861 +#define WLC_GET_LRL                            33
9862 +#define WLC_SET_LRL                            34
9863 +#define WLC_GET_PLCPHDR                                35
9864 +#define WLC_SET_PLCPHDR                                36
9865 +#define WLC_GET_RADIO                          37
9866 +#define WLC_SET_RADIO                          38
9867 +#define WLC_GET_PHYTYPE                                39
9868 +/* #define WLC_GET_WEP                         42 */ /* no longer supported */
9869 +/* #define WLC_SET_WEP                         43 */ /* no longer supported */
9870 +#define WLC_GET_KEY                                    44
9871 +#define WLC_SET_KEY                                    45
9872 +#define WLC_GET_REGULATORY                     46
9873 +#define WLC_SET_REGULATORY                     47
9874 +#define WLC_SCAN                                       50
9875 +#define WLC_SCAN_RESULTS                       51
9876 +#define WLC_DISASSOC                           52
9877 +#define WLC_REASSOC                                    53
9878 +#define WLC_GET_ROAM_TRIGGER           54
9879 +#define WLC_SET_ROAM_TRIGGER                   55
9880 +#define WLC_GET_TXANT                          61
9881 +#define WLC_SET_TXANT                          62
9882 +#define WLC_GET_ANTDIV                         63
9883 +#define WLC_SET_ANTDIV                         64
9884 +/* #define WLC_GET_TXPWR                       65 */ /* no longer supported */
9885 +/* #define WLC_SET_TXPWR                       66 */ /* no longer supported */
9886 +#define WLC_GET_CLOSED                         67
9887 +#define WLC_SET_CLOSED                         68
9888 +#define WLC_GET_MACLIST                                69
9889 +#define WLC_SET_MACLIST                                70
9890 +#define WLC_GET_RATESET                                71
9891 +#define WLC_SET_RATESET                                72
9892 +#define WLC_GET_LOCALE                         73
9893 +#define WLC_LONGTRAIN                          74
9894 +#define WLC_GET_BCNPRD                         75
9895 +#define WLC_SET_BCNPRD                         76
9896 +#define WLC_GET_DTIMPRD                                77
9897 +#define WLC_SET_DTIMPRD                                78
9898 +#define WLC_GET_SROM                           79
9899 +#define WLC_SET_SROM                           80
9900 +#define WLC_GET_WEP_RESTRICT                   81
9901 +#define WLC_SET_WEP_RESTRICT                   82
9902 +#define WLC_GET_COUNTRY                                83
9903 +#define WLC_SET_COUNTRY                                84
9904 +#define WLC_GET_REVINFO                                98
9905 +#define WLC_GET_MACMODE                                105
9906 +#define WLC_SET_MACMODE                                106
9907 +#define WLC_GET_GMODE                          109
9908 +#define WLC_SET_GMODE                          110
9909 +#define WLC_GET_CURR_RATESET                   114     /* current rateset */
9910 +#define WLC_GET_SCANSUPPRESS                   115
9911 +#define WLC_SET_SCANSUPPRESS                   116
9912 +#define WLC_GET_AP                             117
9913 +#define WLC_SET_AP                             118
9914 +#define WLC_GET_EAP_RESTRICT                   119
9915 +#define WLC_SET_EAP_RESTRICT                   120
9916 +#define WLC_GET_WDSLIST                                123
9917 +#define WLC_SET_WDSLIST                                124
9918 +#define WLC_GET_RSSI                           127
9919 +#define WLC_GET_WSEC                           133
9920 +#define WLC_SET_WSEC                           134
9921 +#define WLC_GET_BSS_INFO                       136
9922 +#define WLC_GET_LAZYWDS                                138
9923 +#define WLC_SET_LAZYWDS                                139
9924 +#define WLC_GET_BANDLIST                       140
9925 +#define WLC_GET_BAND                           141
9926 +#define WLC_SET_BAND                           142
9927 +#define WLC_GET_SHORTSLOT                      144
9928 +#define WLC_GET_SHORTSLOT_OVERRIDE             145
9929 +#define WLC_SET_SHORTSLOT_OVERRIDE             146
9930 +#define WLC_GET_SHORTSLOT_RESTRICT             147
9931 +#define WLC_SET_SHORTSLOT_RESTRICT             148
9932 +#define WLC_GET_GMODE_PROTECTION               149
9933 +#define WLC_GET_GMODE_PROTECTION_OVERRIDE      150
9934 +#define WLC_SET_GMODE_PROTECTION_OVERRIDE      151
9935 +#define WLC_UPGRADE                                            152
9936 +/* #define WLC_GET_MRATE                               153 */ /* no longer supported */
9937 +/* #define WLC_SET_MRATE                               154 */ /* no longer supported */
9938 +#define WLC_GET_ASSOCLIST                              159
9939 +#define WLC_GET_CLK                                            160
9940 +#define WLC_SET_CLK                                            161
9941 +#define WLC_GET_UP                                             162
9942 +#define WLC_OUT                                                        163
9943 +#define WLC_GET_WPA_AUTH                               164
9944 +#define WLC_SET_WPA_AUTH                       165
9945 +#define WLC_GET_GMODE_PROTECTION_CONTROL       178
9946 +#define WLC_SET_GMODE_PROTECTION_CONTROL       179
9947 +#define WLC_GET_PHYLIST                                180
9948 +#define WLC_GET_KEY_SEQ                                183
9949 +#define WLC_GET_GMODE_PROTECTION_CTS           198
9950 +#define WLC_SET_GMODE_PROTECTION_CTS           199
9951 +#define WLC_GET_PIOMODE                                203
9952 +#define WLC_SET_PIOMODE                                204
9953 +#define WLC_SET_LED                            209
9954 +#define WLC_GET_LED                            210
9955 +#define WLC_GET_CHANNEL_SEL                    215
9956 +#define WLC_START_CHANNEL_SEL                  216
9957 +#define WLC_GET_VALID_CHANNELS                 217
9958 +#define WLC_GET_FAKEFRAG                       218
9959 +#define WLC_SET_FAKEFRAG                       219
9960 +#define WLC_GET_WET                            230
9961 +#define WLC_SET_WET                            231
9962 +#define WLC_GET_KEY_PRIMARY                    235
9963 +#define WLC_SET_KEY_PRIMARY                    236
9964 +#define WLC_GET_RADAR                          242
9965 +#define WLC_SET_RADAR                          243
9966 +#define WLC_SET_SPECT_MANAGMENT                        244
9967 +#define WLC_GET_SPECT_MANAGMENT                        245
9968 +#define WLC_WDS_GET_REMOTE_HWADDR              246     /* currently handled in wl_linux.c/wl_vx.c */
9969 +#define WLC_SET_CS_SCAN_TIMER                  248
9970 +#define WLC_GET_CS_SCAN_TIMER                  249
9971 +#define WLC_SEND_PWR_CONSTRAINT                        254
9972 +#define WLC_CURRENT_PWR                                256
9973 +#define WLC_GET_CHANNELS_IN_COUNTRY            260
9974 +#define WLC_GET_COUNTRY_LIST                   261
9975 +#define WLC_GET_VAR                            262     /* get value of named variable */
9976 +#define WLC_SET_VAR                            263     /* set named variable to value */
9977 +#define WLC_NVRAM_GET                          264
9978 +#define WLC_NVRAM_SET                          265
9979 +#define WLC_SET_WSEC_PMK                       268
9980 +#define WLC_GET_AUTH_MODE                      269
9981 +#define WLC_SET_AUTH_MODE                      270
9982 +#define WLC_NDCONFIG_ITEM                      273     /* currently handled in wl_oid.c */
9983 +#define WLC_NVOTPW                                     274
9984 +/* #define WLC_OTPW                                    275 */ /* no longer supported */
9985 +#define WLC_SET_LOCALE                         278
9986 +#define WLC_LAST                               279     /* do not change - use get_var/set_var */
9987 +
9988 +/*
9989 + * Minor kludge alert:
9990 + * Duplicate a few definitions that irelay requires from epiioctl.h here
9991 + * so caller doesn't have to include this file and epiioctl.h .
9992 + * If this grows any more, it would be time to move these irelay-specific
9993 + * definitions out of the epiioctl.h and into a separate driver common file.
9994 + */
9995 +#ifndef EPICTRL_COOKIE
9996 +#define EPICTRL_COOKIE         0xABADCEDE
9997 +#endif
9998 +
9999 +/* vx wlc ioctl's offset */
10000 +#define CMN_IOCTL_OFF 0x180
10001 +
10002 +/*
10003 + * custom OID support
10004 + *
10005 + * 0xFF - implementation specific OID
10006 + * 0xE4 - first byte of Broadcom PCI vendor ID
10007 + * 0x14 - second byte of Broadcom PCI vendor ID
10008 + * 0xXX - the custom OID number
10009 + */
10010 +
10011 +/* begin 0x1f values beyond the start of the ET driver range. */
10012 +#define WL_OID_BASE            0xFFE41420
10013 +
10014 +/* NDIS overrides */
10015 +#define OID_WL_GETINSTANCE     (WL_OID_BASE + WLC_GET_INSTANCE)
10016 +#define OID_WL_NDCONFIG_ITEM (WL_OID_BASE + WLC_NDCONFIG_ITEM)
10017 +
10018 +#define WL_DECRYPT_STATUS_SUCCESS      1
10019 +#define WL_DECRYPT_STATUS_FAILURE      2
10020 +#define WL_DECRYPT_STATUS_UNKNOWN      3
10021 +
10022 +/* allows user-mode app to poll the status of USB image upgrade */
10023 +#define WLC_UPGRADE_SUCCESS                    0
10024 +#define WLC_UPGRADE_PENDING                    1
10025 +
10026 +#ifdef CONFIG_USBRNDIS_RETAIL
10027 +/* struct passed in for WLC_NDCONFIG_ITEM */
10028 +typedef struct {
10029 +       char *name;
10030 +       void *param;
10031 +} ndconfig_item_t;
10032 +#endif
10033 +
10034 +/* Bit masks for radio disabled status - returned by WL_GET_RADIO */
10035 +#define WL_RADIO_SW_DISABLE            (1<<0)
10036 +#define WL_RADIO_HW_DISABLE            (1<<1)
10037 +#define WL_RADIO_MPC_DISABLE           (1<<2)
10038 +#define WL_RADIO_COUNTRY_DISABLE       (1<<3)  /* some countries don't support any 802.11 channel */
10039 +
10040 +/* Override bit for WLC_SET_TXPWR.  if set, ignore other level limits */
10041 +#define WL_TXPWR_OVERRIDE      (1<<31)
10042 +
10043 +/* "diag" iovar argument and error code */
10044 +#define WL_DIAG_INTERRUPT                      1       /* d11 loopback interrupt test */
10045 +#define WL_DIAG_MEMORY                         3       /* d11 memory test */
10046 +#define WL_DIAG_LED                            4       /* LED test */
10047 +#define WL_DIAG_REG                            5       /* d11/phy register test */
10048 +#define WL_DIAG_SROM                           6       /* srom read/crc test */
10049 +#define WL_DIAG_DMA                            7       /* DMA test */
10050 +
10051 +#define WL_DIAGERR_SUCCESS                     0
10052 +#define WL_DIAGERR_FAIL_TO_RUN                 1       /* unable to run requested diag */
10053 +#define WL_DIAGERR_NOT_SUPPORTED               2       /* diag requested is not supported */
10054 +#define WL_DIAGERR_INTERRUPT_FAIL              3       /* loopback interrupt test failed */
10055 +#define WL_DIAGERR_LOOPBACK_FAIL               4       /* loopback data test failed */
10056 +#define WL_DIAGERR_SROM_FAIL                   5       /* srom read failed */
10057 +#define WL_DIAGERR_SROM_BADCRC                 6       /* srom crc failed */
10058 +#define WL_DIAGERR_REG_FAIL                    7       /* d11/phy register test failed */
10059 +#define WL_DIAGERR_MEMORY_FAIL                 8       /* d11 memory test failed */
10060 +#define WL_DIAGERR_NOMEM                       9       /* diag test failed due to no memory */
10061 +#define WL_DIAGERR_DMA_FAIL                    10      /* DMA test failed */
10062 +
10063 +/* Bus types */
10064 +#define WL_SB_BUS      0       /* Silicon Backplane */
10065 +#define WL_PCI_BUS     1       /* PCI target */
10066 +#define WL_PCMCIA_BUS  2       /* PCMCIA target */
10067 +
10068 +/* band types */
10069 +#define        WLC_BAND_AUTO           0       /* auto-select */
10070 +#define        WLC_BAND_A              1       /* "a" band (5 Ghz) */
10071 +#define        WLC_BAND_B              2       /* "b" band (2.4 Ghz) */
10072 +#define        WLC_BAND_ALL            3       /* all bands */
10073 +
10074 +/* phy types (returned by WLC_GET_PHYTPE) */
10075 +#define        WLC_PHY_TYPE_A          0
10076 +#define        WLC_PHY_TYPE_B          1
10077 +#define        WLC_PHY_TYPE_G          2
10078 +#define        WLC_PHY_TYPE_NULL       0xf
10079 +
10080 +/* MAC list modes */
10081 +#define WLC_MACMODE_DISABLED   0       /* MAC list disabled */
10082 +#define WLC_MACMODE_DENY       1       /* Deny specified (i.e. allow unspecified) */
10083 +#define WLC_MACMODE_ALLOW      2       /* Allow specified (i.e. deny unspecified) */
10084 +
10085 +/*
10086 + *
10087 + */
10088 +#define GMODE_LEGACY_B         0
10089 +#define GMODE_AUTO             1
10090 +#define GMODE_ONLY             2
10091 +#define GMODE_B_DEFERRED       3
10092 +#define GMODE_PERFORMANCE      4
10093 +#define GMODE_LRS              5
10094 +#define GMODE_MAX              6
10095 +
10096 +/* values for PLCPHdr_override */
10097 +#define WLC_PLCP_AUTO  -1
10098 +#define WLC_PLCP_SHORT 0
10099 +#define WLC_PLCP_LONG  1
10100 +
10101 +/* values for g_protection_override */
10102 +#define WLC_G_PROTECTION_AUTO  -1
10103 +#define WLC_G_PROTECTION_OFF   0
10104 +#define WLC_G_PROTECTION_ON    1
10105 +
10106 +/* values for g_protection_control */
10107 +#define WLC_G_PROTECTION_CTL_OFF       0
10108 +#define WLC_G_PROTECTION_CTL_LOCAL     1
10109 +#define WLC_G_PROTECTION_CTL_OVERLAP   2
10110 +
10111 +/* Values for PM */
10112 +#define PM_OFF 0
10113 +#define PM_MAX 1
10114 +#define PM_FAST 2
10115 +
10116 +
10117 +
10118 +typedef struct {
10119 +       int npulses;    /* required number of pulses at n * t_int */
10120 +       int ncontig;    /* required number of pulses at t_int */
10121 +       int min_pw;     /* minimum pulse width (20 MHz clocks) */
10122 +       int max_pw;     /* maximum pulse width (20 MHz clocks) */
10123 +       uint16 thresh0; /* Radar detection, thresh 0 */
10124 +       uint16 thresh1; /* Radar detection, thresh 1 */
10125 +} wl_radar_args_t;
10126 +
10127 +/* radar iovar SET defines */
10128 +#define WL_RADRA_DETECTOR_OFF          0       /* radar dector off */
10129 +#define WL_RADAR_DETECTOR_ON           1       /* radar detector on */
10130 +#define WL_RADAR_SIMULATED             2       /* force radar detector to declare detection once */
10131 +
10132 +/* dfs_status iovar-related defines */
10133 +
10134 +/* cac - channel availability check,
10135 + * ism - in-service monitoring
10136 + * csa - channel switching anouncement
10137 + */
10138 +
10139 +/* cac state values */
10140 +#define WL_DFS_CACSTATE_IDLE           0       /* state for operating in non-radar channel */
10141 +#define        WL_DFS_CACSTATE_PREISM_CAC      1       /* CAC in progress */
10142 +#define WL_DFS_CACSTATE_ISM            2       /* ISM in progress */
10143 +#define WL_DFS_CACSTATE_CSA            3       /* csa */
10144 +#define WL_DFS_CACSTATE_POSTISM_CAC    4       /* ISM CAC */
10145 +#define WL_DFS_CACSTATE_PREISM_OOC     5       /* PREISM OOC */
10146 +#define WL_DFS_CACSTATE_POSTISM_OOC    6       /* POSTISM OOC */
10147 +#define WL_DFS_CACSTATES               7       /* this many states exist */
10148 +
10149 +/* data structure used in 'dfs_status' wl interface, which is used to query dfs status */
10150 +typedef struct {
10151 +       uint state;             /* noted by WL_DFS_CACSTATE_XX. */
10152 +       uint duration;          /* time spent in ms in state. */
10153 +       /* as dfs enters ISM state, it removes the operational channel from quiet channel list
10154 +        * and notes the channel in channel_cleared. set to 0 if no channel is cleared
10155 +        */
10156 +       uint channel_cleared;
10157 +} wl_dfs_status_t;
10158 +
10159 +#define NUM_PWRCTRL_RATES 12
10160 +
10161 +
10162 +/* 802.11h enforcement levels */
10163 +#define SPECT_MNGMT_OFF                0               /* 11h disabled */
10164 +#define SPECT_MNGMT_LOOSE      1               /* allow scan lists to contain non-11h AP */
10165 +#define SPECT_MNGMT_STRICT     2               /* prune out non-11h APs from scan list */
10166 +#define SPECT_MNGMT_11D                3               /* switch to 802.11D mode */
10167 +
10168 +#define WL_CHAN_VALID_HW       (1 << 0)        /* valid with current HW */
10169 +#define WL_CHAN_VALID_SW       (1 << 1)        /* valid with current country setting */
10170 +#define WL_CHAN_BAND_A         (1 << 2)        /* A-band channel */
10171 +#define WL_CHAN_RADAR          (1 << 3)        /* radar sensitive  channel */
10172 +#define WL_CHAN_INACTIVE       (1 << 4)        /* temporarily out of service due to radar */
10173 +#define WL_CHAN_RADAR_PASSIVE  (1 << 5)        /* radar channel is in passive mode */
10174 +
10175 +#define WL_MPC_VAL             0x00400000
10176 +#define WL_APSTA_VAL           0x00800000
10177 +#define WL_DFS_VAL             0x01000000
10178 +
10179 +/* max # of leds supported by GPIO (gpio pin# == led index#) */
10180 +#define        WL_LED_NUMGPIO          16      /* gpio 0-15 */
10181 +
10182 +/* led per-pin behaviors */
10183 +#define        WL_LED_OFF              0               /* always off */
10184 +#define        WL_LED_ON               1               /* always on */
10185 +#define        WL_LED_ACTIVITY         2               /* activity */
10186 +#define        WL_LED_RADIO            3               /* radio enabled */
10187 +#define        WL_LED_ARADIO           4               /* 5  Ghz radio enabled */
10188 +#define        WL_LED_BRADIO           5               /* 2.4Ghz radio enabled */
10189 +#define        WL_LED_BGMODE           6               /* on if gmode, off if bmode */
10190 +#define        WL_LED_WI1              7
10191 +#define        WL_LED_WI2              8
10192 +#define        WL_LED_WI3              9
10193 +#define        WL_LED_ASSOC            10              /* associated state indicator */
10194 +#define        WL_LED_INACTIVE         11              /* null behavior (clears default behavior) */
10195 +#define        WL_LED_NUMBEHAVIOR      12
10196 +
10197 +/* led behavior numeric value format */
10198 +#define        WL_LED_BEH_MASK         0x7f            /* behavior mask */
10199 +#define        WL_LED_AL_MASK          0x80            /* activelow (polarity) bit */
10200 +
10201 +
10202 +/* WDS link local endpoint WPA role */
10203 +#define WL_WDS_WPA_ROLE_AUTH   0       /* authenticator */
10204 +#define WL_WDS_WPA_ROLE_SUP    1       /* supplicant */
10205 +#define WL_WDS_WPA_ROLE_AUTO   255     /* auto, based on mac addr value */
10206 +
10207 +/* number of bytes needed to define a 128-bit mask for MAC event reporting */
10208 +#define WL_EVENTING_MASK_LEN   16
10209 +
10210 +/* Structures and constants used for "vndr_ie" IOVar interface */
10211 +#define VNDR_IE_CMD_LEN                4       /* length of the set command string: "add", "del" (+ NULL) */
10212 +
10213 +/* 802.11 Mgmt Packet flags */
10214 +#define VNDR_IE_BEACON_FLAG    0x1
10215 +#define VNDR_IE_PRBRSP_FLAG    0x2
10216 +#define VNDR_IE_ASSOCRSP_FLAG  0x4
10217 +#define VNDR_IE_AUTHRSP_FLAG   0x8
10218 +
10219 +typedef struct {
10220 +       uint32 pktflag;                 /* bitmask indicating which packet(s) contain this IE */
10221 +       vndr_ie_t vndr_ie_data;         /* vendor IE data */
10222 +} vndr_ie_info_t;
10223 +
10224 +typedef struct {
10225 +       int iecount;                    /* number of entries in the vndr_ie_list[] array */
10226 +       vndr_ie_info_t vndr_ie_list[1]; /* variable size list of vndr_ie_info_t structs */
10227 +} vndr_ie_buf_t;
10228 +
10229 +typedef struct {
10230 +       char cmd[VNDR_IE_CMD_LEN];      /* vndr_ie IOVar set command : "add", "del" + NULL */
10231 +       vndr_ie_buf_t vndr_ie_buffer;   /* buffer containing Vendor IE list information */
10232 +} vndr_ie_setbuf_t;
10233 +
10234 +/* join target preference types */
10235 +#define WL_JOIN_PREF_RSSI      1       /* by RSSI, mandatory */
10236 +#define WL_JOIN_PREF_WPA       2       /* by akm and ciphers, optional, RSN and WPA as values */
10237 +#define WL_JOIN_PREF_BAND      3       /* by 802.11 band, optional, WLC_BAND_XXXX as values */
10238 +
10239 +/* band preference */
10240 +#define WLJP_BAND_ASSOC_PREF   255     /* use assoc preference settings */
10241 +                                       /* others use WLC_BAND_XXXX as values */
10242 +
10243 +/* any multicast cipher suite */
10244 +#define WL_WPA_ACP_MCS_ANY     "\x00\x00\x00\x00"
10245 +
10246 +#if !defined(__GNUC__)
10247 +#pragma pack(pop)
10248 +#endif
10249 +
10250 +#define        NFIFO                           6       /* # tx/rx fifopairs */
10251 +
10252 +#define        WL_CNT_T_VERSION                1       /* current version of wl_cnt_t struct */
10253 +
10254 +typedef struct {
10255 +       uint16  version;        /* see definition of WL_CNT_T_VERSION */
10256 +       uint16  length;         /* length of entire structure */
10257 +
10258 +       /* transmit stat counters */
10259 +       uint32  txframe;        /* tx data frames */
10260 +       uint32  txbyte;         /* tx data bytes */
10261 +       uint32  txretrans;      /* tx mac retransmits */
10262 +       uint32  txerror;        /* tx data errors */
10263 +       uint32  txctl;          /* tx management frames */
10264 +       uint32  txprshort;      /* tx short preamble frames */
10265 +       uint32  txserr;         /* tx status errors */
10266 +       uint32  txnobuf;        /* tx out of buffers errors */
10267 +       uint32  txnoassoc;      /* tx discard because we're not associated */
10268 +       uint32  txrunt;         /* tx runt frames */
10269 +       uint32  txchit;         /* tx header cache hit (fastpath) */
10270 +       uint32  txcmiss;        /* tx header cache miss (slowpath) */
10271 +
10272 +       /* transmit chip error counters */
10273 +       uint32  txuflo;         /* tx fifo underflows */
10274 +       uint32  txphyerr;       /* tx phy errors (indicated in tx status) */
10275 +       uint32  txphycrs;
10276 +
10277 +       /* receive stat counters */
10278 +       uint32  rxframe;        /* rx data frames */
10279 +       uint32  rxbyte;         /* rx data bytes */
10280 +       uint32  rxerror;        /* rx data errors */
10281 +       uint32  rxctl;          /* rx management frames */
10282 +       uint32  rxnobuf;        /* rx out of buffers errors */
10283 +       uint32  rxnondata;      /* rx non data frames in the data channel errors */
10284 +       uint32  rxbadds;        /* rx bad DS errors */
10285 +       uint32  rxbadcm;        /* rx bad control or management frames */
10286 +       uint32  rxfragerr;      /* rx fragmentation errors */
10287 +       uint32  rxrunt;         /* rx runt frames */
10288 +       uint32  rxgiant;        /* rx giant frames */
10289 +       uint32  rxnoscb;        /* rx no scb error */
10290 +       uint32  rxbadproto;     /* rx invalid frames */
10291 +       uint32  rxbadsrcmac;    /* rx frames with Invalid Src Mac*/
10292 +       uint32  rxbadda;        /* rx frames tossed for invalid da */
10293 +       uint32  rxfilter;       /* rx frames filtered out */
10294 +
10295 +       /* receive chip error counters */
10296 +       uint32  rxoflo;         /* rx fifo overflow errors */
10297 +       uint32  rxuflo[NFIFO];  /* rx dma descriptor underflow errors */
10298 +
10299 +       uint32  d11cnt_txrts_off;       /* d11cnt txrts value when reset d11cnt */
10300 +       uint32  d11cnt_rxcrc_off;       /* d11cnt rxcrc value when reset d11cnt */
10301 +       uint32  d11cnt_txnocts_off;     /* d11cnt txnocts value when reset d11cnt */
10302 +
10303 +       /* misc counters */
10304 +       uint32  dmade;          /* tx/rx dma descriptor errors */
10305 +       uint32  dmada;          /* tx/rx dma data errors */
10306 +       uint32  dmape;          /* tx/rx dma descriptor protocol errors */
10307 +       uint32  reset;          /* reset count */
10308 +       uint32  tbtt;           /* cnts the TBTT int's */
10309 +       uint32  txdmawar;
10310 +
10311 +       /* MAC counters: 32-bit version of d11.h's macstat_t */
10312 +       uint32  txallfrm;       /* total number of frames sent, incl. Data, ACK, RTS, CTS,
10313 +                                  Control Management (includes retransmissions) */
10314 +       uint32  txrtsfrm;       /* number of RTS sent out by the MAC */
10315 +       uint32  txctsfrm;       /* number of CTS sent out by the MAC */
10316 +       uint32  txackfrm;       /* number of ACK frames sent out */
10317 +       uint32  txdnlfrm;       /* Not used */
10318 +       uint32  txbcnfrm;       /* beacons transmitted */
10319 +       uint32  txfunfl[8];     /* per-fifo tx underflows */
10320 +       uint32  txtplunfl;      /* Template underflows (mac was too slow to transmit ACK/CTS or BCN) */
10321 +       uint32  txphyerror;     /* Transmit phy error, type of error is reported in tx-status for
10322 +                                  driver enqueued frames*/
10323 +       uint32  rxfrmtoolong;   /* Received frame longer than legal limit (2346 bytes) */
10324 +       uint32  rxfrmtooshrt;   /* Received frame did not contain enough bytes for its frame type */
10325 +       uint32  rxinvmachdr;    /* Either the protocol version != 0 or frame type not
10326 +                                  data/control/management*/
10327 +       uint32  rxbadfcs;       /* number of frames for which the CRC check failed in the MAC */
10328 +       uint32  rxbadplcp;      /* parity check of the PLCP header failed */
10329 +       uint32  rxcrsglitch;    /* PHY was able to correlate the preamble but not the header */
10330 +       uint32  rxstrt;         /* Number of received frames with a good PLCP (i.e. passing parity check) */
10331 +       uint32  rxdfrmucastmbss; /* Number of received DATA frames with good FCS and matching RA */
10332 +       uint32  rxmfrmucastmbss; /* number of received mgmt frames with good FCS and matching RA */
10333 +       uint32  rxcfrmucast;    /* number of received CNTRL frames with good FCS and matching RA */
10334 +       uint32  rxrtsucast;     /* number of unicast RTS addressed to the MAC (good FCS) */
10335 +       uint32  rxctsucast;     /* number of unicast CTS addressed to the MAC (good FCS)*/
10336 +       uint32  rxackucast;     /* number of ucast ACKS received (good FCS)*/
10337 +       uint32  rxdfrmocast;    /* number of received DATA frames with good FCS and not matching RA */
10338 +       uint32  rxmfrmocast;    /* number of received MGMT frames with good FCS and not matching RA */
10339 +       uint32  rxcfrmocast;    /* number of received CNTRL frame with good FCS and not matching RA */
10340 +       uint32  rxrtsocast;     /* number of received RTS not addressed to the MAC */
10341 +       uint32  rxctsocast;     /* number of received CTS not addressed to the MAC */
10342 +       uint32  rxdfrmmcast;    /* number of RX Data multicast frames received by the MAC */
10343 +       uint32  rxmfrmmcast;    /* number of RX Management multicast frames received by the MAC */
10344 +       uint32  rxcfrmmcast;    /* number of RX Control multicast frames received by the MAC (unlikely
10345 +                                  to see these) */
10346 +       uint32  rxbeaconmbss;   /* beacons received from member of BSS */
10347 +       uint32  rxdfrmucastobss; /* number of unicast frames addressed to the MAC from other BSS (WDS FRAME) */
10348 +       uint32  rxbeaconobss;   /* beacons received from other BSS */
10349 +       uint32  rxrsptmout;     /* Number of response timeouts for transmitted frames expecting a
10350 +                                  response */
10351 +       uint32  bcntxcancl;     /* transmit beacons cancelled due to receipt of beacon (IBSS) */
10352 +       uint32  rxf0ovfl;       /* Number of receive fifo 0 overflows */
10353 +       uint32  rxf1ovfl;       /* Number of receive fifo 1 overflows (obsolete) */
10354 +       uint32  rxf2ovfl;       /* Number of receive fifo 2 overflows (obsolete) */
10355 +       uint32  txsfovfl;       /* Number of transmit status fifo overflows (obsolete) */
10356 +       uint32  pmqovfl;        /* Number of PMQ overflows */
10357 +       uint32  rxcgprqfrm;     /* Number of received Probe requests that made it into the PRQ fifo */
10358 +       uint32  rxcgprsqovfl;   /* Rx Probe Request Que overflow in the AP */
10359 +       uint32  txcgprsfail;    /* Tx Probe Response Fail. AP sent probe response but did not get ACK */
10360 +       uint32  txcgprssuc;     /* Tx Probe Rresponse Success (ACK was received) */
10361 +       uint32  prs_timeout;    /* Number of probe requests that were dropped from the PRQ fifo because
10362 +                                  a probe response could not be sent out within the time limit defined
10363 +                                  in M_PRS_MAXTIME */
10364 +       uint32  rxnack;         /* Number of NACKS received (Afterburner) */
10365 +       uint32  frmscons;       /* Number of frames completed without transmission because of an
10366 +                                  Afterburner re-queue */
10367 +       uint32  txnack;         /* Number of NACKs transmtitted  (Afterburner) */
10368 +       uint32  txglitch_nack;  /* obsolete */
10369 +       uint32  txburst;        /* obsolete */
10370 +       uint32  rxburst;        /* obsolete */
10371 +
10372 +       /* 802.11 MIB counters, pp. 614 of 802.11 reaff doc. */
10373 +       uint32  txfrag;         /* dot11TransmittedFragmentCount */
10374 +       uint32  txmulti;        /* dot11MulticastTransmittedFrameCount */
10375 +       uint32  txfail;         /* dot11FailedCount */
10376 +       uint32  txretry;        /* dot11RetryCount */
10377 +       uint32  txretrie;       /* dot11MultipleRetryCount */
10378 +       uint32  rxdup;          /* dot11FrameduplicateCount */
10379 +       uint32  txrts;          /* dot11RTSSuccessCount */
10380 +       uint32  txnocts;        /* dot11RTSFailureCount */
10381 +       uint32  txnoack;        /* dot11ACKFailureCount */
10382 +       uint32  rxfrag;         /* dot11ReceivedFragmentCount */
10383 +       uint32  rxmulti;        /* dot11MulticastReceivedFrameCount */
10384 +       uint32  rxcrc;          /* dot11FCSErrorCount */
10385 +       uint32  txfrmsnt;       /* dot11TransmittedFrameCount (bogus MIB?) */
10386 +       uint32  rxundec;        /* dot11WEPUndecryptableCount */
10387 +
10388 +       /* WPA2 counters (see rxundec for DecryptFailureCount) */
10389 +       uint32  tkipmicfaill;   /* TKIPLocalMICFailures */
10390 +       uint32  tkipcntrmsr;    /* TKIPCounterMeasuresInvoked */
10391 +       uint32  tkipreplay;     /* TKIPReplays */
10392 +       uint32  ccmpfmterr;     /* CCMPFormatErrors */
10393 +       uint32  ccmpreplay;     /* CCMPReplays */
10394 +       uint32  ccmpundec;      /* CCMPDecryptErrors */
10395 +       uint32  fourwayfail;    /* FourWayHandshakeFailures */
10396 +       uint32  wepundec;       /* dot11WEPUndecryptableCount */
10397 +       uint32  wepicverr;      /* dot11WEPICVErrorCount */
10398 +       uint32  decsuccess;     /* DecryptSuccessCount */
10399 +       uint32  tkipicverr;     /* TKIPICVErrorCount */
10400 +       uint32  wepexcluded;    /* dot11WEPExcludedCount */
10401 +} wl_cnt_t;
10402 +
10403 +#endif /* _wlioctl_h_ */
10404 diff -Nur linux-2.4.32/arch/mips/bcm947xx/Makefile linux-2.4.32-brcm/arch/mips/bcm947xx/Makefile
10405 --- linux-2.4.32/arch/mips/bcm947xx/Makefile    1970-01-01 01:00:00.000000000 +0100
10406 +++ linux-2.4.32-brcm/arch/mips/bcm947xx/Makefile       2005-12-19 01:56:51.733868750 +0100
10407 @@ -0,0 +1,15 @@
10408 +#
10409 +# Makefile for the BCM947xx specific kernel interface routines
10410 +# under Linux.
10411 +#
10412 +
10413 +EXTRA_CFLAGS+=-I$(TOPDIR)/arch/mips/bcm947xx/include -DBCMDRIVER
10414 +
10415 +O_TARGET        := bcm947xx.o
10416 +
10417 +export-objs     := nvram_linux.o setup.o
10418 +obj-y          := prom.o setup.o time.o sbmips.o gpio.o
10419 +obj-y          += nvram.o nvram_linux.o sflash.o cfe_env.o
10420 +obj-$(CONFIG_PCI) += sbpci.o pcibios.o
10421 +
10422 +include $(TOPDIR)/Rules.make
10423 diff -Nur linux-2.4.32/arch/mips/bcm947xx/nvram.c linux-2.4.32-brcm/arch/mips/bcm947xx/nvram.c
10424 --- linux-2.4.32/arch/mips/bcm947xx/nvram.c     1970-01-01 01:00:00.000000000 +0100
10425 +++ linux-2.4.32-brcm/arch/mips/bcm947xx/nvram.c        2005-12-19 01:05:00.079582750 +0100
10426 @@ -0,0 +1,320 @@
10427 +/*
10428 + * NVRAM variable manipulation (common)
10429 + *
10430 + * Copyright 2004, Broadcom Corporation
10431 + * All Rights Reserved.
10432 + *
10433 + * THIS SOFTWARE IS OFFERED "AS IS", AND BROADCOM GRANTS NO WARRANTIES OF ANY
10434 + * KIND, EXPRESS OR IMPLIED, BY STATUTE, COMMUNICATION OR OTHERWISE. BROADCOM
10435 + * SPECIFICALLY DISCLAIMS ANY IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS
10436 + * FOR A SPECIFIC PURPOSE OR NONINFRINGEMENT CONCERNING THIS SOFTWARE.
10437 + *
10438 + */
10439 +
10440 +#include <typedefs.h>
10441 +#include <osl.h>
10442 +#include <bcmendian.h>
10443 +#include <bcmnvram.h>
10444 +#include <bcmutils.h>
10445 +#include <sbsdram.h>
10446 +
10447 +extern struct nvram_tuple * BCMINIT(_nvram_realloc)(struct nvram_tuple *t, const char *name, const char *value);
10448 +extern void BCMINIT(_nvram_free)(struct nvram_tuple *t);
10449 +extern int BCMINIT(_nvram_read)(void *buf);
10450 +
10451 +char * BCMINIT(_nvram_get)(const char *name);
10452 +int BCMINIT(_nvram_set)(const char *name, const char *value);
10453 +int BCMINIT(_nvram_unset)(const char *name);
10454 +int BCMINIT(_nvram_getall)(char *buf, int count);
10455 +int BCMINIT(_nvram_commit)(struct nvram_header *header);
10456 +int BCMINIT(_nvram_init)(void);
10457 +void BCMINIT(_nvram_exit)(void);
10458 +
10459 +static struct nvram_tuple * BCMINITDATA(nvram_hash)[257];
10460 +static struct nvram_tuple * nvram_dead;
10461 +
10462 +/* Free all tuples. Should be locked. */
10463 +static void
10464 +BCMINITFN(nvram_free)(void)
10465 +{
10466 +       uint i;
10467 +       struct nvram_tuple *t, *next;
10468 +
10469 +       /* Free hash table */
10470 +       for (i = 0; i < ARRAYSIZE(BCMINIT(nvram_hash)); i++) {
10471 +               for (t = BCMINIT(nvram_hash)[i]; t; t = next) {
10472 +                       next = t->next;
10473 +                       BCMINIT(_nvram_free)(t);
10474 +               }
10475 +               BCMINIT(nvram_hash)[i] = NULL;
10476 +       }
10477 +
10478 +       /* Free dead table */
10479 +       for (t = nvram_dead; t; t = next) {
10480 +               next = t->next;
10481 +               BCMINIT(_nvram_free)(t);
10482 +       }
10483 +       nvram_dead = NULL;
10484 +
10485 +       /* Indicate to per-port code that all tuples have been freed */
10486 +       BCMINIT(_nvram_free)(NULL);
10487 +}
10488 +
10489 +/* String hash */
10490 +static INLINE uint
10491 +hash(const char *s)
10492 +{
10493 +       uint hash = 0;
10494 +
10495 +       while (*s)
10496 +               hash = 31 * hash + *s++;
10497 +
10498 +       return hash;
10499 +}
10500 +
10501 +/* (Re)initialize the hash table. Should be locked. */
10502 +static int
10503 +BCMINITFN(nvram_rehash)(struct nvram_header *header)
10504 +{
10505 +       char buf[] = "0xXXXXXXXX", *name, *value, *end, *eq;
10506 +
10507 +       /* (Re)initialize hash table */
10508 +       BCMINIT(nvram_free)();
10509 +
10510 +       /* Parse and set "name=value\0 ... \0\0" */
10511 +       name = (char *) &header[1];
10512 +       end = (char *) header + NVRAM_SPACE - 2;
10513 +       end[0] = end[1] = '\0';
10514 +       for (; *name; name = value + strlen(value) + 1) {
10515 +               if (!(eq = strchr(name, '=')))
10516 +                       break;
10517 +               *eq = '\0';
10518 +               value = eq + 1;
10519 +               BCMINIT(_nvram_set)(name, value);
10520 +               *eq = '=';
10521 +       }
10522 +
10523 +       /* Set special SDRAM parameters */
10524 +       if (!BCMINIT(_nvram_get)("sdram_init")) {
10525 +               sprintf(buf, "0x%04X", (uint16)(header->crc_ver_init >> 16));
10526 +               BCMINIT(_nvram_set)("sdram_init", buf);
10527 +       }
10528 +       if (!BCMINIT(_nvram_get)("sdram_config")) {
10529 +               sprintf(buf, "0x%04X", (uint16)(header->config_refresh & 0xffff));
10530 +               BCMINIT(_nvram_set)("sdram_config", buf);
10531 +       }
10532 +       if (!BCMINIT(_nvram_get)("sdram_refresh")) {
10533 +               sprintf(buf, "0x%04X", (uint16)((header->config_refresh >> 16) & 0xffff));
10534 +               BCMINIT(_nvram_set)("sdram_refresh", buf);
10535 +       }
10536 +       if (!BCMINIT(_nvram_get)("sdram_ncdl")) {
10537 +               sprintf(buf, "0x%08X", header->config_ncdl);
10538 +               BCMINIT(_nvram_set)("sdram_ncdl", buf);
10539 +       }
10540 +
10541 +       return 0;
10542 +}
10543 +
10544 +/* Get the value of an NVRAM variable. Should be locked. */
10545 +char *
10546 +BCMINITFN(_nvram_get)(const char *name)
10547 +{
10548 +       uint i;
10549 +       struct nvram_tuple *t;
10550 +       char *value;
10551 +
10552 +       if (!name)
10553 +               return NULL;
10554 +
10555 +       /* Hash the name */
10556 +       i = hash(name) % ARRAYSIZE(BCMINIT(nvram_hash));
10557 +
10558 +       /* Find the associated tuple in the hash table */
10559 +       for (t = BCMINIT(nvram_hash)[i]; t && strcmp(t->name, name); t = t->next);
10560 +
10561 +       value = t ? t->value : NULL;
10562 +
10563 +       return value;
10564 +}
10565 +
10566 +/* Get the value of an NVRAM variable. Should be locked. */
10567 +int
10568 +BCMINITFN(_nvram_set)(const char *name, const char *value)
10569 +{
10570 +       uint i;
10571 +       struct nvram_tuple *t, *u, **prev;
10572 +
10573 +       /* Hash the name */
10574 +       i = hash(name) % ARRAYSIZE(BCMINIT(nvram_hash));
10575 +
10576 +       /* Find the associated tuple in the hash table */
10577 +       for (prev = &BCMINIT(nvram_hash)[i], t = *prev; t && strcmp(t->name, name); prev = &t->next, t = *prev);
10578 +
10579 +       /* (Re)allocate tuple */
10580 +       if (!(u = BCMINIT(_nvram_realloc)(t, name, value)))
10581 +               return -12; /* -ENOMEM */
10582 +
10583 +       /* Value reallocated */
10584 +       if (t && t == u)
10585 +               return 0;
10586 +
10587 +       /* Move old tuple to the dead table */
10588 +       if (t) {
10589 +               *prev = t->next;
10590 +               t->next = nvram_dead;
10591 +               nvram_dead = t;
10592 +       }
10593 +
10594 +       /* Add new tuple to the hash table */
10595 +       u->next = BCMINIT(nvram_hash)[i];
10596 +       BCMINIT(nvram_hash)[i] = u;
10597 +
10598 +       return 0;
10599 +}
10600 +
10601 +/* Unset the value of an NVRAM variable. Should be locked. */
10602 +int
10603 +BCMINITFN(_nvram_unset)(const char *name)
10604 +{
10605 +       uint i;
10606 +       struct nvram_tuple *t, **prev;
10607 +
10608 +       if (!name)
10609 +               return 0;
10610 +
10611 +       /* Hash the name */
10612 +       i = hash(name) % ARRAYSIZE(BCMINIT(nvram_hash));
10613 +
10614 +       /* Find the associated tuple in the hash table */
10615 +       for (prev = &BCMINIT(nvram_hash)[i], t = *prev; t && strcmp(t->name, name); prev = &t->next, t = *prev);
10616 +
10617 +       /* Move it to the dead table */
10618 +       if (t) {
10619 +               *prev = t->next;
10620 +               t->next = nvram_dead;
10621 +               nvram_dead = t;
10622 +       }
10623 +
10624 +       return 0;
10625 +}
10626 +
10627 +/* Get all NVRAM variables. Should be locked. */
10628 +int
10629 +BCMINITFN(_nvram_getall)(char *buf, int count)
10630 +{
10631 +       uint i;
10632 +       struct nvram_tuple *t;
10633 +       int len = 0;
10634 +
10635 +       bzero(buf, count);
10636 +
10637 +       /* Write name=value\0 ... \0\0 */
10638 +       for (i = 0; i < ARRAYSIZE(BCMINIT(nvram_hash)); i++) {
10639 +               for (t = BCMINIT(nvram_hash)[i]; t; t = t->next) {
10640 +                       if ((count - len) > (strlen(t->name) + 1 + strlen(t->value) + 1))
10641 +                               len += sprintf(buf + len, "%s=%s", t->name, t->value) + 1;
10642 +                       else
10643 +                               break;
10644 +               }
10645 +       }
10646 +
10647 +       return 0;
10648 +}
10649 +
10650 +/* Regenerate NVRAM. Should be locked. */
10651 +int
10652 +BCMINITFN(_nvram_commit)(struct nvram_header *header)
10653 +{
10654 +       char *init, *config, *refresh, *ncdl;
10655 +       char *ptr, *end;
10656 +       int i;
10657 +       struct nvram_tuple *t;
10658 +       struct nvram_header tmp;
10659 +       uint8 crc;
10660 +
10661 +       /* Regenerate header */
10662 +       header->magic = NVRAM_MAGIC;
10663 +       header->crc_ver_init = (NVRAM_VERSION << 8);
10664 +       if (!(init = BCMINIT(_nvram_get)("sdram_init")) ||
10665 +           !(config = BCMINIT(_nvram_get)("sdram_config")) ||
10666 +           !(refresh = BCMINIT(_nvram_get)("sdram_refresh")) ||
10667 +           !(ncdl = BCMINIT(_nvram_get)("sdram_ncdl"))) {
10668 +               header->crc_ver_init |= SDRAM_INIT << 16;
10669 +               header->config_refresh = SDRAM_CONFIG;
10670 +               header->config_refresh |= SDRAM_REFRESH << 16;
10671 +               header->config_ncdl = 0;
10672 +       } else {
10673 +               header->crc_ver_init |= (bcm_strtoul(init, NULL, 0) & 0xffff) << 16;
10674 +               header->config_refresh = bcm_strtoul(config, NULL, 0) & 0xffff;
10675 +               header->config_refresh |= (bcm_strtoul(refresh, NULL, 0) & 0xffff) << 16;
10676 +               header->config_ncdl = bcm_strtoul(ncdl, NULL, 0);
10677 +       }
10678 +
10679 +       /* Clear data area */
10680 +       ptr = (char *) header + sizeof(struct nvram_header);
10681 +       bzero(ptr, NVRAM_SPACE - sizeof(struct nvram_header));
10682 +
10683 +       /* Leave space for a double NUL at the end */
10684 +       end = (char *) header + NVRAM_SPACE - 2;
10685 +
10686 +       /* Write out all tuples */
10687 +       for (i = 0; i < ARRAYSIZE(BCMINIT(nvram_hash)); i++) {
10688 +               for (t = BCMINIT(nvram_hash)[i]; t; t = t->next) {
10689 +                       if ((ptr + strlen(t->name) + 1 + strlen(t->value) + 1) > end)
10690 +                               break;
10691 +                       ptr += sprintf(ptr, "%s=%s", t->name, t->value) + 1;
10692 +               }
10693 +       }
10694 +
10695 +       /* End with a double NUL */
10696 +       ptr += 2;
10697 +
10698 +       /* Set new length */
10699 +       header->len = ROUNDUP(ptr - (char *) header, 4);
10700 +
10701 +       /* Little-endian CRC8 over the last 11 bytes of the header */
10702 +       tmp.crc_ver_init = htol32(header->crc_ver_init);
10703 +       tmp.config_refresh = htol32(header->config_refresh);
10704 +       tmp.config_ncdl = htol32(header->config_ncdl);
10705 +       crc = hndcrc8((char *) &tmp + 9, sizeof(struct nvram_header) - 9, CRC8_INIT_VALUE);
10706 +
10707 +       /* Continue CRC8 over data bytes */
10708 +       crc = hndcrc8((char *) &header[1], header->len - sizeof(struct nvram_header), crc);
10709 +
10710 +       /* Set new CRC8 */
10711 +       header->crc_ver_init |= crc;
10712 +
10713 +       /* Reinitialize hash table */
10714 +       return BCMINIT(nvram_rehash)(header);
10715 +}
10716 +
10717 +/* Initialize hash table. Should be locked. */
10718 +int
10719 +BCMINITFN(_nvram_init)(void)
10720 +{
10721 +       struct nvram_header *header;
10722 +       int ret;
10723 +       void *osh;
10724 +
10725 +       /* get kernel osl handler */
10726 +       osh = osl_attach(NULL);
10727 +
10728 +       if (!(header = (struct nvram_header *) MALLOC(osh, NVRAM_SPACE))) {
10729 +               printf("nvram_init: out of memory, malloced %d bytes\n", MALLOCED(osh));
10730 +               return -12; /* -ENOMEM */
10731 +       }
10732 +
10733 +       if ((ret = BCMINIT(_nvram_read)(header)) == 0 &&
10734 +           header->magic == NVRAM_MAGIC)
10735 +               BCMINIT(nvram_rehash)(header);
10736 +
10737 +       MFREE(osh, header, NVRAM_SPACE);
10738 +       return ret;
10739 +}
10740 +
10741 +/* Free hash table. Should be locked. */
10742 +void
10743 +BCMINITFN(_nvram_exit)(void)
10744 +{
10745 +       BCMINIT(nvram_free)();
10746 +}
10747 diff -Nur linux-2.4.32/arch/mips/bcm947xx/nvram_linux.c linux-2.4.32-brcm/arch/mips/bcm947xx/nvram_linux.c
10748 --- linux-2.4.32/arch/mips/bcm947xx/nvram_linux.c       1970-01-01 01:00:00.000000000 +0100
10749 +++ linux-2.4.32-brcm/arch/mips/bcm947xx/nvram_linux.c  2005-12-19 01:09:59.782313000 +0100
10750 @@ -0,0 +1,653 @@
10751 +/*
10752 + * NVRAM variable manipulation (Linux kernel half)
10753 + *
10754 + * Copyright 2005, Broadcom Corporation
10755 + * All Rights Reserved.
10756 + *
10757 + * THIS SOFTWARE IS OFFERED "AS IS", AND BROADCOM GRANTS NO WARRANTIES OF ANY
10758 + * KIND, EXPRESS OR IMPLIED, BY STATUTE, COMMUNICATION OR OTHERWISE. BROADCOM
10759 + * SPECIFICALLY DISCLAIMS ANY IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS
10760 + * FOR A SPECIFIC PURPOSE OR NONINFRINGEMENT CONCERNING THIS SOFTWARE.
10761 + *
10762 + */
10763 +
10764 +#include <linux/config.h>
10765 +#include <linux/init.h>
10766 +#include <linux/module.h>
10767 +#include <linux/kernel.h>
10768 +#include <linux/string.h>
10769 +#include <linux/interrupt.h>
10770 +#include <linux/spinlock.h>
10771 +#include <linux/slab.h>
10772 +#include <linux/bootmem.h>
10773 +#include <linux/wrapper.h>
10774 +#include <linux/fs.h>
10775 +#include <linux/miscdevice.h>
10776 +#include <linux/mtd/mtd.h>
10777 +#include <asm/addrspace.h>
10778 +#include <asm/io.h>
10779 +#include <asm/uaccess.h>
10780 +
10781 +#include <typedefs.h>
10782 +#include <bcmendian.h>
10783 +#include <bcmnvram.h>
10784 +#include <bcmutils.h>
10785 +#include <sbconfig.h>
10786 +#include <sbchipc.h>
10787 +#include <sbutils.h>
10788 +#include <sbmips.h>
10789 +#include <sflash.h>
10790 +
10791 +/* In BSS to minimize text size and page aligned so it can be mmap()-ed */
10792 +static char nvram_buf[NVRAM_SPACE] __attribute__((aligned(PAGE_SIZE)));
10793 +
10794 +#ifdef MODULE
10795 +
10796 +#define early_nvram_get(name) nvram_get(name)
10797 +
10798 +#else /* !MODULE */
10799 +
10800 +/* Global SB handle */
10801 +extern void *bcm947xx_sbh;
10802 +extern spinlock_t bcm947xx_sbh_lock;
10803 +
10804 +static int cfe_env;
10805 +extern char *cfe_env_get(char *nv_buf, const char *name);
10806 +
10807 +/* Convenience */
10808 +#define sbh bcm947xx_sbh
10809 +#define sbh_lock bcm947xx_sbh_lock
10810 +#define KB * 1024
10811 +#define MB * 1024 * 1024
10812 +
10813 +/* Probe for NVRAM header */
10814 +static void __init
10815 +early_nvram_init(void)
10816 +{
10817 +       struct nvram_header *header;
10818 +       chipcregs_t *cc;
10819 +       struct sflash *info = NULL;
10820 +       int i;
10821 +       uint32 base, off, lim;
10822 +       u32 *src, *dst;
10823 +
10824 +       if ((cc = sb_setcore(sbh, SB_CC, 0)) != NULL) {
10825 +               base = KSEG1ADDR(SB_FLASH2);
10826 +               switch (readl(&cc->capabilities) & CAP_FLASH_MASK) {
10827 +               case PFLASH:
10828 +                       lim = SB_FLASH2_SZ;
10829 +                       break;
10830 +
10831 +               case SFLASH_ST:
10832 +               case SFLASH_AT:
10833 +                       if ((info = sflash_init(cc)) == NULL)
10834 +                               return;
10835 +                       lim = info->size;
10836 +                       break;
10837 +
10838 +               case FLASH_NONE:
10839 +               default:
10840 +                       return;
10841 +               }
10842 +       } else {
10843 +               /* extif assumed, Stop at 4 MB */
10844 +               base = KSEG1ADDR(SB_FLASH1);
10845 +               lim = SB_FLASH1_SZ;
10846 +       }
10847 +
10848 +       /* XXX: hack for supporting the CFE environment stuff on WGT634U */
10849 +       src = (u32 *) KSEG1ADDR(base + 8 * 1024 * 1024 - 0x2000);
10850 +       dst = (u32 *) nvram_buf;
10851 +       if ((lim == 0x02000000) && ((*src & 0xff00ff) == 0x000001)) {
10852 +               printk("early_nvram_init: WGT634U NVRAM found.\n");
10853 +
10854 +               for (i = 0; i < 0x1ff0; i++) {
10855 +                       if (*src == 0xFFFFFFFF)
10856 +                               break;
10857 +                       *dst++ = *src++;
10858 +               }
10859 +               cfe_env = 1;
10860 +               return;
10861 +       }
10862 +
10863 +       off = FLASH_MIN;
10864 +       while (off <= lim) {
10865 +               /* Windowed flash access */
10866 +               header = (struct nvram_header *) KSEG1ADDR(base + off - NVRAM_SPACE);
10867 +               if (header->magic == NVRAM_MAGIC)
10868 +                       goto found;
10869 +               off <<= 1;
10870 +       }
10871 +
10872 +       /* Try embedded NVRAM at 4 KB and 1 KB as last resorts */
10873 +       header = (struct nvram_header *) KSEG1ADDR(base + 4 KB);
10874 +       if (header->magic == NVRAM_MAGIC)
10875 +               goto found;
10876 +
10877 +       header = (struct nvram_header *) KSEG1ADDR(base + 1 KB);
10878 +       if (header->magic == NVRAM_MAGIC)
10879 +               goto found;
10880 +
10881 +       printk("early_nvram_init: NVRAM not found\n");
10882 +       return;
10883 +
10884 +found:
10885 +       src = (u32 *) header;
10886 +       dst = (u32 *) nvram_buf;
10887 +       for (i = 0; i < sizeof(struct nvram_header); i += 4)
10888 +               *dst++ = *src++;
10889 +       for (; i < header->len && i < NVRAM_SPACE; i += 4)
10890 +               *dst++ = ltoh32(*src++);
10891 +}
10892 +
10893 +/* Early (before mm or mtd) read-only access to NVRAM */
10894 +static char * __init
10895 +early_nvram_get(const char *name)
10896 +{
10897 +       char *var, *value, *end, *eq;
10898 +
10899 +       if (!name)
10900 +               return NULL;
10901 +
10902 +       /* Too early? */
10903 +       if (sbh == NULL)
10904 +               return NULL;
10905 +
10906 +       if (!nvram_buf[0])
10907 +               early_nvram_init();
10908 +
10909 +       if (cfe_env)
10910 +               return cfe_env_get(nvram_buf, name);
10911 +
10912 +       /* Look for name=value and return value */
10913 +       var = &nvram_buf[sizeof(struct nvram_header)];
10914 +       end = nvram_buf + sizeof(nvram_buf) - 2;
10915 +       end[0] = end[1] = '\0';
10916 +       for (; *var; var = value + strlen(value) + 1) {
10917 +               if (!(eq = strchr(var, '=')))
10918 +                       break;
10919 +               value = eq + 1;
10920 +               if ((eq - var) == strlen(name) && strncmp(var, name, (eq - var)) == 0)
10921 +                       return value;
10922 +       }
10923 +
10924 +       return NULL;
10925 +}
10926 +
10927 +#endif /* !MODULE */
10928 +
10929 +extern char * _nvram_get(const char *name);
10930 +extern int _nvram_set(const char *name, const char *value);
10931 +extern int _nvram_unset(const char *name);
10932 +extern int _nvram_getall(char *buf, int count);
10933 +extern int _nvram_commit(struct nvram_header *header);
10934 +extern int _nvram_init(void);
10935 +extern void _nvram_exit(void);
10936 +
10937 +/* Globals */
10938 +static spinlock_t nvram_lock = SPIN_LOCK_UNLOCKED;
10939 +static struct semaphore nvram_sem;
10940 +static unsigned long nvram_offset = 0;
10941 +static int nvram_major = -1;
10942 +static devfs_handle_t nvram_handle = NULL;
10943 +static struct mtd_info *nvram_mtd = NULL;
10944 +
10945 +int
10946 +_nvram_read(char *buf)
10947 +{
10948 +       struct nvram_header *header = (struct nvram_header *) buf;
10949 +       size_t len;
10950 +
10951 +       if (!nvram_mtd ||
10952 +           MTD_READ(nvram_mtd, nvram_mtd->size - NVRAM_SPACE, NVRAM_SPACE, &len, buf) ||
10953 +           len != NVRAM_SPACE ||
10954 +           header->magic != NVRAM_MAGIC) {
10955 +               /* Maybe we can recover some data from early initialization */
10956 +               memcpy(buf, nvram_buf, NVRAM_SPACE);
10957 +       }
10958 +
10959 +       return 0;
10960 +}
10961 +
10962 +struct nvram_tuple *
10963 +_nvram_realloc(struct nvram_tuple *t, const char *name, const char *value)
10964 +{
10965 +       if ((nvram_offset + strlen(value) + 1) > NVRAM_SPACE)
10966 +               return NULL;
10967 +
10968 +       if (!t) {
10969 +               if (!(t = kmalloc(sizeof(struct nvram_tuple) + strlen(name) + 1, GFP_ATOMIC)))
10970 +                       return NULL;
10971 +
10972 +               /* Copy name */
10973 +               t->name = (char *) &t[1];
10974 +               strcpy(t->name, name);
10975 +
10976 +               t->value = NULL;
10977 +       }
10978 +
10979 +       /* Copy value */
10980 +       if (!t->value || strcmp(t->value, value)) {
10981 +               t->value = &nvram_buf[nvram_offset];
10982 +               strcpy(t->value, value);
10983 +               nvram_offset += strlen(value) + 1;
10984 +       }
10985 +
10986 +       return t;
10987 +}
10988 +
10989 +void
10990 +_nvram_free(struct nvram_tuple *t)
10991 +{
10992 +       if (!t)
10993 +               nvram_offset = 0;
10994 +       else
10995 +               kfree(t);
10996 +}
10997 +
10998 +int
10999 +nvram_set(const char *name, const char *value)
11000 +{
11001 +       unsigned long flags;
11002 +       int ret;
11003 +       struct nvram_header *header;
11004 +
11005 +       spin_lock_irqsave(&nvram_lock, flags);
11006 +       if ((ret = _nvram_set(name, value))) {
11007 +               /* Consolidate space and try again */
11008 +               if ((header = kmalloc(NVRAM_SPACE, GFP_ATOMIC))) {
11009 +                       if (_nvram_commit(header) == 0)
11010 +                               ret = _nvram_set(name, value);
11011 +                       kfree(header);
11012 +               }
11013 +       }
11014 +       spin_unlock_irqrestore(&nvram_lock, flags);
11015 +
11016 +       return ret;
11017 +}
11018 +
11019 +char *
11020 +real_nvram_get(const char *name)
11021 +{
11022 +       unsigned long flags;
11023 +       char *value;
11024 +
11025 +       spin_lock_irqsave(&nvram_lock, flags);
11026 +       value = _nvram_get(name);
11027 +       spin_unlock_irqrestore(&nvram_lock, flags);
11028 +
11029 +       return value;
11030 +}
11031 +
11032 +char *
11033 +nvram_get(const char *name)
11034 +{
11035 +       if (nvram_major >= 0)
11036 +               return real_nvram_get(name);
11037 +       else
11038 +               return early_nvram_get(name);
11039 +}
11040 +
11041 +int
11042 +nvram_unset(const char *name)
11043 +{
11044 +       unsigned long flags;
11045 +       int ret;
11046 +
11047 +       spin_lock_irqsave(&nvram_lock, flags);
11048 +       ret = _nvram_unset(name);
11049 +       spin_unlock_irqrestore(&nvram_lock, flags);
11050 +
11051 +       return ret;
11052 +}
11053 +
11054 +static void
11055 +erase_callback(struct erase_info *done)
11056 +{
11057 +       wait_queue_head_t *wait_q = (wait_queue_head_t *) done->priv;
11058 +       wake_up(wait_q);
11059 +}
11060 +
11061 +int
11062 +nvram_commit(void)
11063 +{
11064 +       char *buf;
11065 +       size_t erasesize, len;
11066 +       unsigned int i;
11067 +       int ret;
11068 +       struct nvram_header *header;
11069 +       unsigned long flags;
11070 +       u_int32_t offset;
11071 +       DECLARE_WAITQUEUE(wait, current);
11072 +       wait_queue_head_t wait_q;
11073 +       struct erase_info erase;
11074 +
11075 +       if (!nvram_mtd) {
11076 +               printk("nvram_commit: NVRAM not found\n");
11077 +               return -ENODEV;
11078 +       }
11079 +
11080 +       if (in_interrupt()) {
11081 +               printk("nvram_commit: not committing in interrupt\n");
11082 +               return -EINVAL;
11083 +       }
11084 +
11085 +       /* Backup sector blocks to be erased */
11086 +       erasesize = ROUNDUP(NVRAM_SPACE, nvram_mtd->erasesize);
11087 +       if (!(buf = kmalloc(erasesize, GFP_KERNEL))) {
11088 +               printk("nvram_commit: out of memory\n");
11089 +               return -ENOMEM;
11090 +       }
11091 +
11092 +       down(&nvram_sem);
11093 +
11094 +       if ((i = erasesize - NVRAM_SPACE) > 0) {
11095 +               offset = nvram_mtd->size - erasesize;
11096 +               len = 0;
11097 +               ret = MTD_READ(nvram_mtd, offset, i, &len, buf);
11098 +               if (ret || len != i) {
11099 +                       printk("nvram_commit: read error ret = %d, len = %d/%d\n", ret, len, i);
11100 +                       ret = -EIO;
11101 +                       goto done;
11102 +               }
11103 +               header = (struct nvram_header *)(buf + i);
11104 +       } else {
11105 +               offset = nvram_mtd->size - NVRAM_SPACE;
11106 +               header = (struct nvram_header *)buf;
11107 +       }
11108 +
11109 +       /* Regenerate NVRAM */
11110 +       spin_lock_irqsave(&nvram_lock, flags);
11111 +       ret = _nvram_commit(header);
11112 +       spin_unlock_irqrestore(&nvram_lock, flags);
11113 +       if (ret)
11114 +               goto done;
11115 +
11116 +       /* Erase sector blocks */
11117 +       init_waitqueue_head(&wait_q);
11118 +       for (; offset < nvram_mtd->size - NVRAM_SPACE + header->len; offset += nvram_mtd->erasesize) {
11119 +               erase.mtd = nvram_mtd;
11120 +               erase.addr = offset;
11121 +               erase.len = nvram_mtd->erasesize;
11122 +               erase.callback = erase_callback;
11123 +               erase.priv = (u_long) &wait_q;
11124 +
11125 +               set_current_state(TASK_INTERRUPTIBLE);
11126 +               add_wait_queue(&wait_q, &wait);
11127 +
11128 +               /* Unlock sector blocks */
11129 +               if (nvram_mtd->unlock)
11130 +                       nvram_mtd->unlock(nvram_mtd, offset, nvram_mtd->erasesize);
11131 +
11132 +               if ((ret = MTD_ERASE(nvram_mtd, &erase))) {
11133 +                       set_current_state(TASK_RUNNING);
11134 +                       remove_wait_queue(&wait_q, &wait);
11135 +                       printk("nvram_commit: erase error\n");
11136 +                       goto done;
11137 +               }
11138 +
11139 +               /* Wait for erase to finish */
11140 +               schedule();
11141 +               remove_wait_queue(&wait_q, &wait);
11142 +       }
11143 +
11144 +       /* Write partition up to end of data area */
11145 +       offset = nvram_mtd->size - erasesize;
11146 +       i = erasesize - NVRAM_SPACE + header->len;
11147 +       ret = MTD_WRITE(nvram_mtd, offset, i, &len, buf);
11148 +       if (ret || len != i) {
11149 +               printk("nvram_commit: write error\n");
11150 +               ret = -EIO;
11151 +               goto done;
11152 +       }
11153 +
11154 +       offset = nvram_mtd->size - erasesize;
11155 +       ret = MTD_READ(nvram_mtd, offset, 4, &len, buf);
11156 +
11157 + done:
11158 +       up(&nvram_sem);
11159 +       kfree(buf);
11160 +       return ret;
11161 +}
11162 +
11163 +int
11164 +nvram_getall(char *buf, int count)
11165 +{
11166 +       unsigned long flags;
11167 +       int ret;
11168 +
11169 +       spin_lock_irqsave(&nvram_lock, flags);
11170 +       ret = _nvram_getall(buf, count);
11171 +       spin_unlock_irqrestore(&nvram_lock, flags);
11172 +
11173 +       return ret;
11174 +}
11175 +
11176 +EXPORT_SYMBOL(nvram_get);
11177 +EXPORT_SYMBOL(nvram_getall);
11178 +EXPORT_SYMBOL(nvram_set);
11179 +EXPORT_SYMBOL(nvram_unset);
11180 +EXPORT_SYMBOL(nvram_commit);
11181 +
11182 +/* User mode interface below */
11183 +
11184 +static ssize_t
11185 +dev_nvram_read(struct file *file, char *buf, size_t count, loff_t *ppos)
11186 +{
11187 +       char tmp[100], *name = tmp, *value;
11188 +       ssize_t ret;
11189 +       unsigned long off;
11190 +
11191 +       if (count > sizeof(tmp)) {
11192 +               if (!(name = kmalloc(count, GFP_KERNEL)))
11193 +                       return -ENOMEM;
11194 +       }
11195 +
11196 +       if (copy_from_user(name, buf, count)) {
11197 +               ret = -EFAULT;
11198 +               goto done;
11199 +       }
11200 +
11201 +       if (*name == '\0') {
11202 +               /* Get all variables */
11203 +               ret = nvram_getall(name, count);
11204 +               if (ret == 0) {
11205 +                       if (copy_to_user(buf, name, count)) {
11206 +                               ret = -EFAULT;
11207 +                               goto done;
11208 +                       }
11209 +                       ret = count;
11210 +               }
11211 +       } else {
11212 +               if (!(value = nvram_get(name))) {
11213 +                       ret = 0;
11214 +                       goto done;
11215 +               }
11216 +
11217 +               /* Provide the offset into mmap() space */
11218 +               off = (unsigned long) value - (unsigned long) nvram_buf;
11219 +
11220 +               if (put_user(off, (unsigned long *) buf)) {
11221 +                       ret = -EFAULT;
11222 +                       goto done;
11223 +               }
11224 +
11225 +               ret = sizeof(unsigned long);
11226 +       }
11227 +
11228 +       flush_cache_all();
11229 +
11230 +done:
11231 +       if (name != tmp)
11232 +               kfree(name);
11233 +
11234 +       return ret;
11235 +}
11236 +
11237 +static ssize_t
11238 +dev_nvram_write(struct file *file, const char *buf, size_t count, loff_t *ppos)
11239 +{
11240 +       char tmp[100], *name = tmp, *value;
11241 +       ssize_t ret;
11242 +
11243 +       if (count > sizeof(tmp)) {
11244 +               if (!(name = kmalloc(count, GFP_KERNEL)))
11245 +                       return -ENOMEM;
11246 +       }
11247 +
11248 +       if (copy_from_user(name, buf, count)) {
11249 +               ret = -EFAULT;
11250 +               goto done;
11251 +       }
11252 +
11253 +       value = name;
11254 +       name = strsep(&value, "=");
11255 +       if (value)
11256 +               ret = nvram_set(name, value) ? : count;
11257 +       else
11258 +               ret = nvram_unset(name) ? : count;
11259 +
11260 + done:
11261 +       if (name != tmp)
11262 +               kfree(name);
11263 +
11264 +       return ret;
11265 +}
11266 +
11267 +static int
11268 +dev_nvram_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg)
11269 +{
11270 +       if (cmd != NVRAM_MAGIC)
11271 +               return -EINVAL;
11272 +       return nvram_commit();
11273 +}
11274 +
11275 +static int
11276 +dev_nvram_mmap(struct file *file, struct vm_area_struct *vma)
11277 +{
11278 +       unsigned long offset = virt_to_phys(nvram_buf);
11279 +
11280 +       if (remap_page_range(vma->vm_start, offset, vma->vm_end-vma->vm_start,
11281 +                            vma->vm_page_prot))
11282 +               return -EAGAIN;
11283 +
11284 +       return 0;
11285 +}
11286 +
11287 +static int
11288 +dev_nvram_open(struct inode *inode, struct file * file)
11289 +{
11290 +       MOD_INC_USE_COUNT;
11291 +       return 0;
11292 +}
11293 +
11294 +static int
11295 +dev_nvram_release(struct inode *inode, struct file * file)
11296 +{
11297 +       MOD_DEC_USE_COUNT;
11298 +       return 0;
11299 +}
11300 +
11301 +static struct file_operations dev_nvram_fops = {
11302 +       owner:          THIS_MODULE,
11303 +       open:           dev_nvram_open,
11304 +       release:        dev_nvram_release,
11305 +       read:           dev_nvram_read,
11306 +       write:          dev_nvram_write,
11307 +       ioctl:          dev_nvram_ioctl,
11308 +       mmap:           dev_nvram_mmap,
11309 +};
11310 +
11311 +static void
11312 +dev_nvram_exit(void)
11313 +{
11314 +       int order = 0;
11315 +       struct page *page, *end;
11316 +
11317 +       if (nvram_handle)
11318 +               devfs_unregister(nvram_handle);
11319 +
11320 +       if (nvram_major >= 0)
11321 +               devfs_unregister_chrdev(nvram_major, "nvram");
11322 +
11323 +       if (nvram_mtd)
11324 +               put_mtd_device(nvram_mtd);
11325 +
11326 +       while ((PAGE_SIZE << order) < NVRAM_SPACE)
11327 +               order++;
11328 +       end = virt_to_page(nvram_buf + (PAGE_SIZE << order) - 1);
11329 +       for (page = virt_to_page(nvram_buf); page <= end; page++)
11330 +               mem_map_unreserve(page);
11331 +
11332 +       _nvram_exit();
11333 +}
11334 +
11335 +static int __init
11336 +dev_nvram_init(void)
11337 +{
11338 +       int order = 0, ret = 0;
11339 +       struct page *page, *end;
11340 +       unsigned int i;
11341 +
11342 +       /* Allocate and reserve memory to mmap() */
11343 +       while ((PAGE_SIZE << order) < NVRAM_SPACE)
11344 +               order++;
11345 +       end = virt_to_page(nvram_buf + (PAGE_SIZE << order) - 1);
11346 +       for (page = virt_to_page(nvram_buf); page <= end; page++)
11347 +               mem_map_reserve(page);
11348 +
11349 +#ifdef CONFIG_MTD
11350 +       /* Find associated MTD device */
11351 +       for (i = 0; i < MAX_MTD_DEVICES; i++) {
11352 +               nvram_mtd = get_mtd_device(NULL, i);
11353 +               if (nvram_mtd) {
11354 +                       if (!strcmp(nvram_mtd->name, "nvram") &&
11355 +                           nvram_mtd->size >= NVRAM_SPACE)
11356 +                               break;
11357 +                       put_mtd_device(nvram_mtd);
11358 +               }
11359 +       }
11360 +       if (i >= MAX_MTD_DEVICES)
11361 +               nvram_mtd = NULL;
11362 +#endif
11363 +
11364 +       /* Initialize hash table lock */
11365 +       spin_lock_init(&nvram_lock);
11366 +
11367 +       /* Initialize commit semaphore */
11368 +       init_MUTEX(&nvram_sem);
11369 +
11370 +       /* Register char device */
11371 +       if ((nvram_major = devfs_register_chrdev(0, "nvram", &dev_nvram_fops)) < 0) {
11372 +               ret = nvram_major;
11373 +               goto err;
11374 +       }
11375 +
11376 +       /* Initialize hash table */
11377 +       _nvram_init();
11378 +
11379 +       /* Create /dev/nvram handle */
11380 +       nvram_handle = devfs_register(NULL, "nvram", DEVFS_FL_NONE, nvram_major, 0,
11381 +                                     S_IFCHR | S_IRUSR | S_IWUSR | S_IRGRP, &dev_nvram_fops, NULL);
11382 +
11383 +       /* Set the SDRAM NCDL value into NVRAM if not already done */
11384 +       if (getintvar(NULL, "sdram_ncdl") == 0) {
11385 +               unsigned int ncdl;
11386 +               char buf[] = "0x00000000";
11387 +
11388 +               if ((ncdl = sb_memc_get_ncdl(sbh))) {
11389 +                       sprintf(buf, "0x%08x", ncdl);
11390 +                       nvram_set("sdram_ncdl", buf);
11391 +                       nvram_commit();
11392 +               }
11393 +       }
11394 +
11395 +       return 0;
11396 +
11397 + err:
11398 +       dev_nvram_exit();
11399 +       return ret;
11400 +}
11401 +
11402 +module_init(dev_nvram_init);
11403 +module_exit(dev_nvram_exit);
11404 diff -Nur linux-2.4.32/arch/mips/bcm947xx/pcibios.c linux-2.4.32-brcm/arch/mips/bcm947xx/pcibios.c
11405 --- linux-2.4.32/arch/mips/bcm947xx/pcibios.c   1970-01-01 01:00:00.000000000 +0100
11406 +++ linux-2.4.32-brcm/arch/mips/bcm947xx/pcibios.c      2005-12-16 23:39:10.944836750 +0100
11407 @@ -0,0 +1,355 @@
11408 +/*
11409 + * Low-Level PCI and SB support for BCM47xx (Linux support code)
11410 + *
11411 + * Copyright 2005, Broadcom Corporation
11412 + * All Rights Reserved.
11413 + *
11414 + * THIS SOFTWARE IS OFFERED "AS IS", AND BROADCOM GRANTS NO WARRANTIES OF ANY
11415 + * KIND, EXPRESS OR IMPLIED, BY STATUTE, COMMUNICATION OR OTHERWISE. BROADCOM
11416 + * SPECIFICALLY DISCLAIMS ANY IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS
11417 + * FOR A SPECIFIC PURPOSE OR NONINFRINGEMENT CONCERNING THIS SOFTWARE.
11418 + *
11419 + * $Id$
11420 + */
11421 +
11422 +#include <linux/config.h>
11423 +#include <linux/types.h>
11424 +#include <linux/kernel.h>
11425 +#include <linux/sched.h>
11426 +#include <linux/pci.h>
11427 +#include <linux/init.h>
11428 +#include <linux/delay.h>
11429 +#include <asm/io.h>
11430 +#include <asm/irq.h>
11431 +#include <asm/paccess.h>
11432 +
11433 +#include <typedefs.h>
11434 +#include <bcmutils.h>
11435 +#include <sbconfig.h>
11436 +#include <sbutils.h>
11437 +#include <sbpci.h>
11438 +#include <pcicfg.h>
11439 +#include <bcmdevs.h>
11440 +#include <bcmnvram.h>
11441 +
11442 +/* Global SB handle */
11443 +extern sb_t *bcm947xx_sbh;
11444 +extern spinlock_t bcm947xx_sbh_lock;
11445 +
11446 +/* Convenience */
11447 +#define sbh bcm947xx_sbh
11448 +#define sbh_lock bcm947xx_sbh_lock
11449 +
11450 +static int
11451 +sbpci_read_config_byte(struct pci_dev *dev, int where, u8 *value)
11452 +{
11453 +       unsigned long flags;
11454 +       int ret;
11455 +
11456 +       spin_lock_irqsave(&sbh_lock, flags);
11457 +       ret = sbpci_read_config(sbh, dev->bus->number, PCI_SLOT(dev->devfn), PCI_FUNC(dev->devfn), where, value, sizeof(*value));
11458 +       spin_unlock_irqrestore(&sbh_lock, flags);
11459 +       return ret ? PCIBIOS_DEVICE_NOT_FOUND : PCIBIOS_SUCCESSFUL;
11460 +}
11461 +
11462 +static int
11463 +sbpci_read_config_word(struct pci_dev *dev, int where, u16 *value)
11464 +{
11465 +       unsigned long flags;
11466 +       int ret;
11467 +
11468 +       spin_lock_irqsave(&sbh_lock, flags);
11469 +       ret = sbpci_read_config(sbh, dev->bus->number, PCI_SLOT(dev->devfn), PCI_FUNC(dev->devfn), where, value, sizeof(*value));
11470 +       spin_unlock_irqrestore(&sbh_lock, flags);
11471 +       return ret ? PCIBIOS_DEVICE_NOT_FOUND : PCIBIOS_SUCCESSFUL;
11472 +}
11473 +
11474 +static int
11475 +sbpci_read_config_dword(struct pci_dev *dev, int where, u32 *value)
11476 +{
11477 +       unsigned long flags;
11478 +       int ret;
11479 +
11480 +       spin_lock_irqsave(&sbh_lock, flags);
11481 +       ret = sbpci_read_config(sbh, dev->bus->number, PCI_SLOT(dev->devfn), PCI_FUNC(dev->devfn), where, value, sizeof(*value));
11482 +       spin_unlock_irqrestore(&sbh_lock, flags);
11483 +       return ret ? PCIBIOS_DEVICE_NOT_FOUND : PCIBIOS_SUCCESSFUL;
11484 +}
11485 +
11486 +static int
11487 +sbpci_write_config_byte(struct pci_dev *dev, int where, u8 value)
11488 +{
11489 +       unsigned long flags;
11490 +       int ret;
11491 +
11492 +       spin_lock_irqsave(&sbh_lock, flags);
11493 +       ret = sbpci_write_config(sbh, dev->bus->number, PCI_SLOT(dev->devfn), PCI_FUNC(dev->devfn), where, &value, sizeof(value));
11494 +       spin_unlock_irqrestore(&sbh_lock, flags);
11495 +       return ret ? PCIBIOS_DEVICE_NOT_FOUND : PCIBIOS_SUCCESSFUL;
11496 +}
11497 +
11498 +static int
11499 +sbpci_write_config_word(struct pci_dev *dev, int where, u16 value)
11500 +{
11501 +       unsigned long flags;
11502 +       int ret;
11503 +
11504 +       spin_lock_irqsave(&sbh_lock, flags);
11505 +       ret = sbpci_write_config(sbh, dev->bus->number, PCI_SLOT(dev->devfn), PCI_FUNC(dev->devfn), where, &value, sizeof(value));
11506 +       spin_unlock_irqrestore(&sbh_lock, flags);
11507 +       return ret ? PCIBIOS_DEVICE_NOT_FOUND : PCIBIOS_SUCCESSFUL;
11508 +}
11509 +
11510 +static int
11511 +sbpci_write_config_dword(struct pci_dev *dev, int where, u32 value)
11512 +{
11513 +       unsigned long flags;
11514 +       int ret;
11515 +
11516 +       spin_lock_irqsave(&sbh_lock, flags);
11517 +       ret = sbpci_write_config(sbh, dev->bus->number, PCI_SLOT(dev->devfn), PCI_FUNC(dev->devfn), where, &value, sizeof(value));
11518 +       spin_unlock_irqrestore(&sbh_lock, flags);
11519 +       return ret ? PCIBIOS_DEVICE_NOT_FOUND : PCIBIOS_SUCCESSFUL;
11520 +}
11521 +
11522 +static struct pci_ops pcibios_ops = {
11523 +       sbpci_read_config_byte,
11524 +       sbpci_read_config_word,
11525 +       sbpci_read_config_dword,
11526 +       sbpci_write_config_byte,
11527 +       sbpci_write_config_word,
11528 +       sbpci_write_config_dword
11529 +};
11530 +
11531 +
11532 +void __init
11533 +pcibios_init(void)
11534 +{
11535 +       ulong flags;
11536 +
11537 +       if (!(sbh = sb_kattach()))
11538 +               panic("sb_kattach failed");
11539 +       spin_lock_init(&sbh_lock);
11540 +
11541 +       spin_lock_irqsave(&sbh_lock, flags);
11542 +       sbpci_init(sbh);
11543 +       spin_unlock_irqrestore(&sbh_lock, flags);
11544 +
11545 +       set_io_port_base((unsigned long) ioremap_nocache(SB_PCI_MEM, 0x04000000));
11546 +
11547 +       mdelay(300); //By Joey for Atheros Card
11548 +
11549 +       /* Scan the SB bus */
11550 +       pci_scan_bus(0, &pcibios_ops, NULL);
11551 +
11552 +}
11553 +
11554 +char * __init
11555 +pcibios_setup(char *str)
11556 +{
11557 +       if (!strncmp(str, "ban=", 4)) {
11558 +               sbpci_ban(simple_strtoul(str + 4, NULL, 0));
11559 +               return NULL;
11560 +       }
11561 +
11562 +       return (str);
11563 +}
11564 +
11565 +static u32 pci_iobase = 0x100;
11566 +static u32 pci_membase = SB_PCI_DMA;
11567 +
11568 +void __init
11569 +pcibios_fixup_bus(struct pci_bus *b)
11570 +{
11571 +       struct list_head *ln;
11572 +       struct pci_dev *d;
11573 +       struct resource *res;
11574 +       int pos, size;
11575 +       u32 *base;
11576 +       u8 irq;
11577 +
11578 +               printk("PCI: Fixing up bus %d\n", b->number);
11579 +
11580 +       /* Fix up SB */
11581 +       if (b->number == 0) {
11582 +               for (ln=b->devices.next; ln != &b->devices; ln=ln->next) {
11583 +                       d = pci_dev_b(ln);
11584 +                       /* Fix up interrupt lines */
11585 +                       pci_read_config_byte(d, PCI_INTERRUPT_LINE, &irq);
11586 +                       d->irq = irq + 2;
11587 +                       pci_write_config_byte(d, PCI_INTERRUPT_LINE, d->irq);
11588 +               }
11589 +       }
11590 +
11591 +       /* Fix up external PCI */
11592 +       else {
11593 +               for (ln=b->devices.next; ln != &b->devices; ln=ln->next) {
11594 +                       d = pci_dev_b(ln);
11595 +                       /* Fix up resource bases */
11596 +                       for (pos = 0; pos < 6; pos++) {
11597 +                               res = &d->resource[pos];
11598 +                               base = (res->flags & IORESOURCE_IO) ? &pci_iobase : &pci_membase;
11599 +                               if (res->end) {
11600 +                                       size = res->end - res->start + 1;
11601 +                                       if (*base & (size - 1))
11602 +                                               *base = (*base + size) & ~(size - 1);
11603 +                                       res->start = *base;
11604 +                                       res->end = res->start + size - 1;
11605 +                                       *base += size;
11606 +                                       pci_write_config_dword(d, PCI_BASE_ADDRESS_0 + (pos << 2), res->start);
11607 +                               }
11608 +                               /* Fix up PCI bridge BAR0 only */
11609 +                               if (b->number == 1 && PCI_SLOT(d->devfn) == 0)
11610 +                                       break;
11611 +                       }
11612 +                       /* Fix up interrupt lines */
11613 +                       if (pci_find_device(VENDOR_BROADCOM, SB_PCI, NULL))
11614 +                               d->irq = (pci_find_device(VENDOR_BROADCOM, SB_PCI, NULL))->irq;
11615 +                       pci_write_config_byte(d, PCI_INTERRUPT_LINE, d->irq);
11616 +               }
11617 +       }
11618 +}
11619 +
11620 +unsigned int
11621 +pcibios_assign_all_busses(void)
11622 +{
11623 +       return 1;
11624 +}
11625 +
11626 +void
11627 +pcibios_align_resource(void *data, struct resource *res,
11628 +                      unsigned long size, unsigned long align)
11629 +{
11630 +}
11631 +
11632 +int
11633 +pcibios_enable_resources(struct pci_dev *dev)
11634 +{
11635 +       u16 cmd, old_cmd;
11636 +       int idx;
11637 +       struct resource *r;
11638 +
11639 +       /* External PCI only */
11640 +       if (dev->bus->number == 0)
11641 +               return 0;
11642 +
11643 +       pci_read_config_word(dev, PCI_COMMAND, &cmd);
11644 +       old_cmd = cmd;
11645 +       for(idx=0; idx<6; idx++) {
11646 +               r = &dev->resource[idx];
11647 +               if (r->flags & IORESOURCE_IO)
11648 +                       cmd |= PCI_COMMAND_IO;
11649 +               if (r->flags & IORESOURCE_MEM)
11650 +                       cmd |= PCI_COMMAND_MEMORY;
11651 +       }
11652 +       if (dev->resource[PCI_ROM_RESOURCE].start)
11653 +               cmd |= PCI_COMMAND_MEMORY;
11654 +       if (cmd != old_cmd) {
11655 +               printk("PCI: Enabling device %s (%04x -> %04x)\n", dev->slot_name, old_cmd, cmd);
11656 +               pci_write_config_word(dev, PCI_COMMAND, cmd);
11657 +       }
11658 +       return 0;
11659 +}
11660 +
11661 +int
11662 +pcibios_enable_device(struct pci_dev *dev, int mask)
11663 +{
11664 +       ulong flags;
11665 +       uint coreidx;
11666 +
11667 +       /* External PCI device enable */
11668 +       if (dev->bus->number != 0)
11669 +               return pcibios_enable_resources(dev);
11670 +
11671 +       /* These cores come out of reset enabled */
11672 +       if (dev->device == SB_MIPS ||
11673 +           dev->device == SB_MIPS33 ||
11674 +           dev->device == SB_EXTIF ||
11675 +           dev->device == SB_CC)
11676 +               return 0;
11677 +
11678 +       spin_lock_irqsave(&sbh_lock, flags);
11679 +       coreidx = sb_coreidx(sbh);
11680 +       if (!sb_setcoreidx(sbh, PCI_SLOT(dev->devfn)))
11681 +               return PCIBIOS_DEVICE_NOT_FOUND;
11682 +
11683 +       /*
11684 +        * The USB core requires a special bit to be set during core
11685 +        * reset to enable host (OHCI) mode. Resetting the SB core in
11686 +        * pcibios_enable_device() is a hack for compatibility with
11687 +        * vanilla usb-ohci so that it does not have to know about
11688 +        * SB. A driver that wants to use the USB core in device mode
11689 +        * should know about SB and should reset the bit back to 0
11690 +        * after calling pcibios_enable_device().
11691 +        */
11692 +       if (sb_coreid(sbh) == SB_USB) {
11693 +               sb_core_disable(sbh, sb_coreflags(sbh, 0, 0));
11694 +               sb_core_reset(sbh, 1 << 29);
11695 +       } else
11696 +               sb_core_reset(sbh, 0);
11697 +
11698 +       sb_setcoreidx(sbh, coreidx);
11699 +       spin_unlock_irqrestore(&sbh_lock, flags);
11700 +
11701 +       return 0;
11702 +}
11703 +
11704 +void
11705 +pcibios_update_resource(struct pci_dev *dev, struct resource *root,
11706 +                       struct resource *res, int resource)
11707 +{
11708 +       unsigned long where, size;
11709 +       u32 reg;
11710 +
11711 +       /* External PCI only */
11712 +       if (dev->bus->number == 0)
11713 +               return;
11714 +
11715 +       where = PCI_BASE_ADDRESS_0 + (resource * 4);
11716 +       size = res->end - res->start;
11717 +       pci_read_config_dword(dev, where, &reg);
11718 +       reg = (reg & size) | (((u32)(res->start - root->start)) & ~size);
11719 +       pci_write_config_dword(dev, where, reg);
11720 +}
11721 +
11722 +static void __init
11723 +quirk_sbpci_bridge(struct pci_dev *dev)
11724 +{
11725 +       if (dev->bus->number != 1 || PCI_SLOT(dev->devfn) != 0)
11726 +               return;
11727 +
11728 +       printk("PCI: Fixing up bridge\n");
11729 +
11730 +       /* Enable PCI bridge bus mastering and memory space */
11731 +       pci_set_master(dev);
11732 +       pcibios_enable_resources(dev);
11733 +
11734 +       /* Enable PCI bridge BAR1 prefetch and burst */
11735 +       pci_write_config_dword(dev, PCI_BAR1_CONTROL, 3);
11736 +}
11737 +
11738 +struct pci_fixup pcibios_fixups[] = {
11739 +       { PCI_FIXUP_HEADER, PCI_ANY_ID, PCI_ANY_ID, quirk_sbpci_bridge },
11740 +       { 0 }
11741 +};
11742 +
11743 +/*
11744 + *  If we set up a device for bus mastering, we need to check the latency
11745 + *  timer as certain crappy BIOSes forget to set it properly.
11746 + */
11747 +unsigned int pcibios_max_latency = 255;
11748 +
11749 +void pcibios_set_master(struct pci_dev *dev)
11750 +{
11751 +       u8 lat;
11752 +       pci_read_config_byte(dev, PCI_LATENCY_TIMER, &lat);
11753 +       if (lat < 16)
11754 +               lat = (64 <= pcibios_max_latency) ? 64 : pcibios_max_latency;
11755 +       else if (lat > pcibios_max_latency)
11756 +               lat = pcibios_max_latency;
11757 +       else
11758 +               return;
11759 +       printk(KERN_DEBUG "PCI: Setting latency timer of device %s to %d\n", dev->slot_name, lat);
11760 +       pci_write_config_byte(dev, PCI_LATENCY_TIMER, lat);
11761 +}
11762 +
11763 diff -Nur linux-2.4.32/arch/mips/bcm947xx/prom.c linux-2.4.32-brcm/arch/mips/bcm947xx/prom.c
11764 --- linux-2.4.32/arch/mips/bcm947xx/prom.c      1970-01-01 01:00:00.000000000 +0100
11765 +++ linux-2.4.32-brcm/arch/mips/bcm947xx/prom.c 2005-12-16 23:39:10.944836750 +0100
11766 @@ -0,0 +1,41 @@
11767 +/*
11768 + * Early initialization code for BCM94710 boards
11769 + *
11770 + * Copyright 2004, Broadcom Corporation
11771 + * All Rights Reserved.
11772 + *
11773 + * THIS SOFTWARE IS OFFERED "AS IS", AND BROADCOM GRANTS NO WARRANTIES OF ANY
11774 + * KIND, EXPRESS OR IMPLIED, BY STATUTE, COMMUNICATION OR OTHERWISE. BROADCOM
11775 + * SPECIFICALLY DISCLAIMS ANY IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS
11776 + * FOR A SPECIFIC PURPOSE OR NONINFRINGEMENT CONCERNING THIS SOFTWARE.
11777 + *
11778 + * $Id: prom.c,v 1.1 2005/03/16 13:49:59 wbx Exp $
11779 + */
11780 +
11781 +#include <linux/config.h>
11782 +#include <linux/init.h>
11783 +#include <linux/kernel.h>
11784 +#include <linux/types.h>
11785 +#include <asm/bootinfo.h>
11786 +
11787 +void __init
11788 +prom_init(int argc, const char **argv)
11789 +{
11790 +       unsigned long mem;
11791 +
11792 +        mips_machgroup = MACH_GROUP_BRCM;
11793 +        mips_machtype = MACH_BCM947XX;
11794 +
11795 +       /* Figure out memory size by finding aliases */
11796 +       for (mem = (1 << 20); mem < (128 << 20); mem += (1 << 20)) {
11797 +               if (*(unsigned long *)((unsigned long)(prom_init) + mem) ==
11798 +                   *(unsigned long *)(prom_init))
11799 +                       break;
11800 +       }
11801 +       add_memory_region(0, mem, BOOT_MEM_RAM);
11802 +}
11803 +
11804 +void __init
11805 +prom_free_prom_memory(void)
11806 +{
11807 +}
11808 diff -Nur linux-2.4.32/arch/mips/bcm947xx/sbmips.c linux-2.4.32-brcm/arch/mips/bcm947xx/sbmips.c
11809 --- linux-2.4.32/arch/mips/bcm947xx/sbmips.c    1970-01-01 01:00:00.000000000 +0100
11810 +++ linux-2.4.32-brcm/arch/mips/bcm947xx/sbmips.c       2005-12-16 23:39:10.944836750 +0100
11811 @@ -0,0 +1,1038 @@
11812 +/*
11813 + * BCM47XX Sonics SiliconBackplane MIPS core routines
11814 + *
11815 + * Copyright 2005, Broadcom Corporation
11816 + * All Rights Reserved.
11817 + *
11818 + * THIS SOFTWARE IS OFFERED "AS IS", AND BROADCOM GRANTS NO WARRANTIES OF ANY
11819 + * KIND, EXPRESS OR IMPLIED, BY STATUTE, COMMUNICATION OR OTHERWISE. BROADCOM
11820 + * SPECIFICALLY DISCLAIMS ANY IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS
11821 + * FOR A SPECIFIC PURPOSE OR NONINFRINGEMENT CONCERNING THIS SOFTWARE.
11822 + *
11823 + * $Id$
11824 + */
11825 +
11826 +#include <typedefs.h>
11827 +#include <osl.h>
11828 +#include <sbutils.h>
11829 +#include <bcmdevs.h>
11830 +#include <bcmnvram.h>
11831 +#include <bcmutils.h>
11832 +#include <hndmips.h>
11833 +#include <sbconfig.h>
11834 +#include <sbextif.h>
11835 +#include <sbchipc.h>
11836 +#include <sbmemc.h>
11837 +#include <mipsinc.h>
11838 +#include <sbutils.h>
11839 +
11840 +/*
11841 + * Returns TRUE if an external UART exists at the given base
11842 + * register.
11843 + */
11844 +static bool
11845 +BCMINITFN(serial_exists)(uint8 *regs)
11846 +{
11847 +       uint8 save_mcr, status1;
11848 +
11849 +       save_mcr = R_REG(&regs[UART_MCR]);
11850 +       W_REG(&regs[UART_MCR], UART_MCR_LOOP | 0x0a);
11851 +       status1 = R_REG(&regs[UART_MSR]) & 0xf0;
11852 +       W_REG(&regs[UART_MCR], save_mcr);
11853 +
11854 +       return (status1 == 0x90);
11855 +}
11856 +
11857 +/*
11858 + * Initializes UART access. The callback function will be called once
11859 + * per found UART.
11860 + */
11861 +void
11862 +BCMINITFN(sb_serial_init)(sb_t *sbh, void (*add)(void *regs, uint irq, uint baud_base, uint reg_shift))
11863 +{
11864 +       void *regs;
11865 +       ulong base;
11866 +       uint irq;
11867 +       int i, n;
11868 +
11869 +       if ((regs = sb_setcore(sbh, SB_EXTIF, 0))) {
11870 +               extifregs_t *eir = (extifregs_t *) regs;
11871 +               sbconfig_t *sb;
11872 +
11873 +               /* Determine external UART register base */
11874 +               sb = (sbconfig_t *)((ulong) eir + SBCONFIGOFF);
11875 +               base = EXTIF_CFGIF_BASE(sb_base(R_REG(&sb->sbadmatch1)));
11876 +
11877 +               /* Determine IRQ */
11878 +               irq = sb_irq(sbh);
11879 +
11880 +               /* Disable GPIO interrupt initially */
11881 +               W_REG(&eir->gpiointpolarity, 0);
11882 +               W_REG(&eir->gpiointmask, 0);
11883 +
11884 +               /* Search for external UARTs */
11885 +               n = 2;
11886 +               for (i = 0; i < 2; i++) {
11887 +                       regs = (void *) REG_MAP(base + (i * 8), 8);
11888 +                       if (BCMINIT(serial_exists)(regs)) {
11889 +                               /* Set GPIO 1 to be the external UART IRQ */
11890 +                               W_REG(&eir->gpiointmask, 2);
11891 +                               if (add)
11892 +                                       add(regs, irq, 13500000, 0);
11893 +                       }
11894 +               }
11895 +
11896 +               /* Add internal UART if enabled */
11897 +               if (R_REG(&eir->corecontrol) & CC_UE)
11898 +                       if (add)
11899 +                               add((void *) &eir->uartdata, irq, sb_clock(sbh), 2);
11900 +       } else if ((regs = sb_setcore(sbh, SB_CC, 0))) {
11901 +               chipcregs_t *cc = (chipcregs_t *) regs;
11902 +               uint32 rev, cap, pll, baud_base, div;
11903 +
11904 +               /* Determine core revision and capabilities */
11905 +               rev = sb_corerev(sbh);
11906 +               cap = R_REG(&cc->capabilities);
11907 +               pll = cap & CAP_PLL_MASK;
11908 +
11909 +               /* Determine IRQ */
11910 +               irq = sb_irq(sbh);
11911 +
11912 +               if (pll == PLL_TYPE1) {
11913 +                       /* PLL clock */
11914 +                       baud_base = sb_clock_rate(pll,
11915 +                                                 R_REG(&cc->clockcontrol_n),
11916 +                                                 R_REG(&cc->clockcontrol_m2));
11917 +                       div = 1;
11918 +               } else {
11919 +                       if (rev >= 11) {
11920 +                               /* Fixed ALP clock */
11921 +                               baud_base = 20000000;
11922 +                               div = 1;
11923 +                               /* Set the override bit so we don't divide it */
11924 +                               W_REG(&cc->corecontrol, CC_UARTCLKO);
11925 +                       } else if (rev >= 3) {
11926 +                               /* Internal backplane clock */
11927 +                               baud_base = sb_clock(sbh);
11928 +                               div = 2;        /* Minimum divisor */
11929 +                               W_REG(&cc->clkdiv,
11930 +                                     ((R_REG(&cc->clkdiv) & ~CLKD_UART) | div));
11931 +                       } else {
11932 +                               /* Fixed internal backplane clock */
11933 +                               baud_base = 88000000;
11934 +                               div = 48;
11935 +                       }
11936 +
11937 +                       /* Clock source depends on strapping if UartClkOverride is unset */
11938 +                       if ((rev > 0) &&
11939 +                           ((R_REG(&cc->corecontrol) & CC_UARTCLKO) == 0)) {
11940 +                               if ((cap & CAP_UCLKSEL) == CAP_UINTCLK) {
11941 +                                       /* Internal divided backplane clock */
11942 +                                       baud_base /= div;
11943 +                               } else {
11944 +                                       /* Assume external clock of 1.8432 MHz */
11945 +                                       baud_base = 1843200;
11946 +                               }
11947 +                       }
11948 +               }
11949 +
11950 +               /* Add internal UARTs */
11951 +               n = cap & CAP_UARTS_MASK;
11952 +               for (i = 0; i < n; i++) {
11953 +                       /* Register offset changed after revision 0 */
11954 +                       if (rev)
11955 +                               regs = (void *)((ulong) &cc->uart0data + (i * 256));
11956 +                       else
11957 +                               regs = (void *)((ulong) &cc->uart0data + (i * 8));
11958 +
11959 +                       if (add)
11960 +                               add(regs, irq, baud_base, 0);
11961 +               }
11962 +       }
11963 +}
11964 +
11965 +/*
11966 + * Initialize jtag master and return handle for
11967 + * jtag_rwreg. Returns NULL on failure.
11968 + */
11969 +void *
11970 +sb_jtagm_init(sb_t *sbh, uint clkd, bool exttap)
11971 +{
11972 +       void *regs;
11973 +
11974 +       if ((regs = sb_setcore(sbh, SB_CC, 0)) != NULL) {
11975 +               chipcregs_t *cc = (chipcregs_t *) regs;
11976 +               uint32 tmp;
11977 +
11978 +               /*
11979 +                * Determine jtagm availability from
11980 +                * core revision and capabilities.
11981 +                */
11982 +               tmp = sb_corerev(sbh);
11983 +               /*
11984 +                * Corerev 10 has jtagm, but the only chip
11985 +                * with it does not have a mips, and
11986 +                * the layout of the jtagcmd register is
11987 +                * different. We'll only accept >= 11.
11988 +                */
11989 +               if (tmp < 11)
11990 +                       return (NULL);
11991 +
11992 +               tmp = R_REG(&cc->capabilities);
11993 +               if ((tmp & CAP_JTAGP) == 0)
11994 +                       return (NULL);
11995 +
11996 +               /* Set clock divider if requested */
11997 +               if (clkd != 0) {
11998 +                       tmp = R_REG(&cc->clkdiv);
11999 +                       tmp = (tmp & ~CLKD_JTAG) |
12000 +                               ((clkd << CLKD_JTAG_SHIFT) & CLKD_JTAG);
12001 +                       W_REG(&cc->clkdiv, tmp);
12002 +               }
12003 +
12004 +               /* Enable jtagm */
12005 +               tmp = JCTRL_EN | (exttap ? JCTRL_EXT_EN : 0);
12006 +               W_REG(&cc->jtagctrl, tmp);
12007 +       }
12008 +
12009 +       return (regs);
12010 +}
12011 +
12012 +void
12013 +sb_jtagm_disable(void *h)
12014 +{
12015 +       chipcregs_t *cc = (chipcregs_t *)h;
12016 +
12017 +       W_REG(&cc->jtagctrl, R_REG(&cc->jtagctrl) & ~JCTRL_EN);
12018 +}
12019 +
12020 +/*
12021 + * Read/write a jtag register. Assumes a target with
12022 + * 8 bit IR and 32 bit DR.
12023 + */
12024 +#define        IRWIDTH         8
12025 +#define        DRWIDTH         32
12026 +uint32
12027 +jtag_rwreg(void *h, uint32 ir, uint32 dr)
12028 +{
12029 +       chipcregs_t *cc = (chipcregs_t *) h;
12030 +       uint32 tmp;
12031 +
12032 +       W_REG(&cc->jtagir, ir);
12033 +       W_REG(&cc->jtagdr, dr);
12034 +       tmp = JCMD_START | JCMD_ACC_IRDR |
12035 +               ((IRWIDTH - 1) << JCMD_IRW_SHIFT) |
12036 +               (DRWIDTH - 1);
12037 +       W_REG(&cc->jtagcmd, tmp);
12038 +       while (((tmp = R_REG(&cc->jtagcmd)) & JCMD_BUSY) == JCMD_BUSY) {
12039 +               /* OSL_DELAY(1); */
12040 +       }
12041 +
12042 +       tmp = R_REG(&cc->jtagdr);
12043 +       return (tmp);
12044 +}
12045 +
12046 +/* Returns the SB interrupt flag of the current core. */
12047 +uint32
12048 +sb_flag(sb_t *sbh)
12049 +{
12050 +       void *regs;
12051 +       sbconfig_t *sb;
12052 +
12053 +       regs = sb_coreregs(sbh);
12054 +       sb = (sbconfig_t *)((ulong) regs + SBCONFIGOFF);
12055 +
12056 +       return (R_REG(&sb->sbtpsflag) & SBTPS_NUM0_MASK);
12057 +}
12058 +
12059 +static const uint32 sbips_int_mask[] = {
12060 +       0,
12061 +       SBIPS_INT1_MASK,
12062 +       SBIPS_INT2_MASK,
12063 +       SBIPS_INT3_MASK,
12064 +       SBIPS_INT4_MASK
12065 +};
12066 +
12067 +static const uint32 sbips_int_shift[] = {
12068 +       0,
12069 +       0,
12070 +       SBIPS_INT2_SHIFT,
12071 +       SBIPS_INT3_SHIFT,
12072 +       SBIPS_INT4_SHIFT
12073 +};
12074 +
12075 +/*
12076 + * Returns the MIPS IRQ assignment of the current core. If unassigned,
12077 + * 0 is returned.
12078 + */
12079 +uint
12080 +sb_irq(sb_t *sbh)
12081 +{
12082 +       uint idx;
12083 +       void *regs;
12084 +       sbconfig_t *sb;
12085 +       uint32 flag, sbipsflag;
12086 +       uint irq = 0;
12087 +
12088 +       flag = sb_flag(sbh);
12089 +
12090 +       idx = sb_coreidx(sbh);
12091 +
12092 +       if ((regs = sb_setcore(sbh, SB_MIPS, 0)) ||
12093 +           (regs = sb_setcore(sbh, SB_MIPS33, 0))) {
12094 +               sb = (sbconfig_t *)((ulong) regs + SBCONFIGOFF);
12095 +
12096 +               /* sbipsflag specifies which core is routed to interrupts 1 to 4 */
12097 +               sbipsflag = R_REG(&sb->sbipsflag);
12098 +               for (irq = 1; irq <= 4; irq++) {
12099 +                       if (((sbipsflag & sbips_int_mask[irq]) >> sbips_int_shift[irq]) == flag)
12100 +                               break;
12101 +               }
12102 +               if (irq == 5)
12103 +                       irq = 0;
12104 +       }
12105 +
12106 +       sb_setcoreidx(sbh, idx);
12107 +
12108 +       return irq;
12109 +}
12110 +
12111 +/* Clears the specified MIPS IRQ. */
12112 +static void
12113 +BCMINITFN(sb_clearirq)(sb_t *sbh, uint irq)
12114 +{
12115 +       void *regs;
12116 +       sbconfig_t *sb;
12117 +
12118 +       if (!(regs = sb_setcore(sbh, SB_MIPS, 0)) &&
12119 +           !(regs = sb_setcore(sbh, SB_MIPS33, 0)))
12120 +               ASSERT(regs);
12121 +       sb = (sbconfig_t *)((ulong) regs + SBCONFIGOFF);
12122 +
12123 +       if (irq == 0)
12124 +               W_REG(&sb->sbintvec, 0);
12125 +       else
12126 +               OR_REG(&sb->sbipsflag, sbips_int_mask[irq]);
12127 +}
12128 +
12129 +/*
12130 + * Assigns the specified MIPS IRQ to the specified core. Shared MIPS
12131 + * IRQ 0 may be assigned more than once.
12132 + */
12133 +static void
12134 +BCMINITFN(sb_setirq)(sb_t *sbh, uint irq, uint coreid, uint coreunit)
12135 +{
12136 +       void *regs;
12137 +       sbconfig_t *sb;
12138 +       uint32 flag;
12139 +
12140 +       regs = sb_setcore(sbh, coreid, coreunit);
12141 +       ASSERT(regs);
12142 +       flag = sb_flag(sbh);
12143 +
12144 +       if (!(regs = sb_setcore(sbh, SB_MIPS, 0)) &&
12145 +           !(regs = sb_setcore(sbh, SB_MIPS33, 0)))
12146 +               ASSERT(regs);
12147 +       sb = (sbconfig_t *)((ulong) regs + SBCONFIGOFF);
12148 +
12149 +       if (irq == 0)
12150 +               OR_REG(&sb->sbintvec, 1 << flag);
12151 +       else {
12152 +               flag <<= sbips_int_shift[irq];
12153 +               ASSERT(!(flag & ~sbips_int_mask[irq]));
12154 +               flag |= R_REG(&sb->sbipsflag) & ~sbips_int_mask[irq];
12155 +               W_REG(&sb->sbipsflag, flag);
12156 +       }
12157 +}
12158 +
12159 +/*
12160 + * Initializes clocks and interrupts. SB and NVRAM access must be
12161 + * initialized prior to calling.
12162 + */
12163 +void
12164 +BCMINITFN(sb_mips_init)(sb_t *sbh)
12165 +{
12166 +       ulong hz, ns, tmp;
12167 +       extifregs_t *eir;
12168 +       chipcregs_t *cc;
12169 +       char *value;
12170 +       uint irq;
12171 +
12172 +       /* Figure out current SB clock speed */
12173 +       if ((hz = sb_clock(sbh)) == 0)
12174 +               hz = 100000000;
12175 +       ns = 1000000000 / hz;
12176 +
12177 +       /* Setup external interface timing */
12178 +       if ((eir = sb_setcore(sbh, SB_EXTIF, 0))) {
12179 +               /* Initialize extif so we can get to the LEDs and external UART */
12180 +               W_REG(&eir->prog_config, CF_EN);
12181 +
12182 +               /* Set timing for the flash */
12183 +               tmp = CEIL(10, ns) << FW_W3_SHIFT;      /* W3 = 10nS */
12184 +               tmp = tmp | (CEIL(40, ns) << FW_W1_SHIFT); /* W1 = 40nS */
12185 +               tmp = tmp | CEIL(120, ns);              /* W0 = 120nS */
12186 +               W_REG(&eir->prog_waitcount, tmp);       /* 0x01020a0c for a 100Mhz clock */
12187 +
12188 +               /* Set programmable interface timing for external uart */
12189 +               tmp = CEIL(10, ns) << FW_W3_SHIFT;      /* W3 = 10nS */
12190 +               tmp = tmp | (CEIL(20, ns) << FW_W2_SHIFT); /* W2 = 20nS */
12191 +               tmp = tmp | (CEIL(100, ns) << FW_W1_SHIFT); /* W1 = 100nS */
12192 +               tmp = tmp | CEIL(120, ns);              /* W0 = 120nS */
12193 +               W_REG(&eir->prog_waitcount, tmp);       /* 0x01020a0c for a 100Mhz clock */
12194 +       } else if ((cc = sb_setcore(sbh, SB_CC, 0))) {
12195 +               /* Set timing for the flash */
12196 +               tmp = CEIL(10, ns) << FW_W3_SHIFT;      /* W3 = 10nS */
12197 +               tmp |= CEIL(10, ns) << FW_W1_SHIFT;     /* W1 = 10nS */
12198 +               tmp |= CEIL(120, ns);                   /* W0 = 120nS */
12199 +
12200 +               // Added by Chen-I for 5365
12201 +               if (BCMINIT(sb_chip)(sbh) == BCM5365_DEVICE_ID)
12202 +               {
12203 +                       W_REG(&cc->flash_waitcount, tmp);
12204 +                       W_REG(&cc->pcmcia_memwait, tmp);
12205 +               }
12206 +               else
12207 +               {
12208 +                       if (sb_corerev(sbh) < 9)
12209 +                               W_REG(&cc->flash_waitcount, tmp);
12210 +
12211 +                       if ((sb_corerev(sbh) < 9) ||
12212 +                        ((BCMINIT(sb_chip)(sbh) == BCM5350_DEVICE_ID) && BCMINIT(sb_chiprev)(sbh) == 0)) {
12213 +                               W_REG(&cc->pcmcia_memwait, tmp);
12214 +                       }
12215 +               }
12216 +       }
12217 +
12218 +       /* Chip specific initialization */
12219 +       switch (BCMINIT(sb_chip)(sbh)) {
12220 +       case BCM4710_DEVICE_ID:
12221 +               /* Clear interrupt map */
12222 +               for (irq = 0; irq <= 4; irq++)
12223 +                       BCMINIT(sb_clearirq)(sbh, irq);
12224 +               BCMINIT(sb_setirq)(sbh, 0, SB_CODEC, 0);
12225 +               BCMINIT(sb_setirq)(sbh, 0, SB_EXTIF, 0);
12226 +               BCMINIT(sb_setirq)(sbh, 2, SB_ENET, 1);
12227 +               BCMINIT(sb_setirq)(sbh, 3, SB_ILINE20, 0);
12228 +               BCMINIT(sb_setirq)(sbh, 4, SB_PCI, 0);
12229 +               ASSERT(eir);
12230 +               value = BCMINIT(nvram_get)("et0phyaddr");
12231 +               if (value && !strcmp(value, "31")) {
12232 +                       /* Enable internal UART */
12233 +                       W_REG(&eir->corecontrol, CC_UE);
12234 +                       /* Give USB its own interrupt */
12235 +                       BCMINIT(sb_setirq)(sbh, 1, SB_USB, 0);
12236 +               } else {
12237 +                       /* Disable internal UART */
12238 +                       W_REG(&eir->corecontrol, 0);
12239 +                       /* Give Ethernet its own interrupt */
12240 +                       BCMINIT(sb_setirq)(sbh, 1, SB_ENET, 0);
12241 +                       BCMINIT(sb_setirq)(sbh, 0, SB_USB, 0);
12242 +               }
12243 +               break;
12244 +       case BCM5350_DEVICE_ID:
12245 +               /* Clear interrupt map */
12246 +               for (irq = 0; irq <= 4; irq++)
12247 +                       BCMINIT(sb_clearirq)(sbh, irq);
12248 +               BCMINIT(sb_setirq)(sbh, 0, SB_CC, 0);
12249 +               BCMINIT(sb_setirq)(sbh, 1, SB_D11, 0);
12250 +               BCMINIT(sb_setirq)(sbh, 2, SB_ENET, 0);
12251 +               BCMINIT(sb_setirq)(sbh, 3, SB_PCI, 0);
12252 +               BCMINIT(sb_setirq)(sbh, 4, SB_USB, 0);
12253 +               break;
12254 +       }
12255 +}
12256 +
12257 +uint32
12258 +BCMINITFN(sb_mips_clock)(sb_t *sbh)
12259 +{
12260 +       extifregs_t *eir;
12261 +       chipcregs_t *cc;
12262 +       uint32 n, m;
12263 +       uint idx;
12264 +       uint32 pll_type, rate = 0;
12265 +
12266 +       /* get index of the current core */
12267 +       idx = sb_coreidx(sbh);
12268 +       pll_type = PLL_TYPE1;
12269 +
12270 +       /* switch to extif or chipc core */
12271 +       if ((eir = (extifregs_t *) sb_setcore(sbh, SB_EXTIF, 0))) {
12272 +               n = R_REG(&eir->clockcontrol_n);
12273 +               m = R_REG(&eir->clockcontrol_sb);
12274 +       } else if ((cc = (chipcregs_t *) sb_setcore(sbh, SB_CC, 0))) {
12275 +               pll_type = R_REG(&cc->capabilities) & CAP_PLL_MASK;
12276 +               n = R_REG(&cc->clockcontrol_n);
12277 +               if ((pll_type == PLL_TYPE2) ||
12278 +                   (pll_type == PLL_TYPE4) ||
12279 +                   (pll_type == PLL_TYPE6) ||
12280 +                   (pll_type == PLL_TYPE7))
12281 +                       m = R_REG(&cc->clockcontrol_mips);
12282 +               else if (pll_type == PLL_TYPE5) {
12283 +                       rate = 200000000;
12284 +                       goto out;
12285 +               }
12286 +               else if (pll_type == PLL_TYPE3) {
12287 +                       if (BCMINIT(sb_chip)(sbh) == BCM5365_DEVICE_ID) { /* 5365 is also type3 */
12288 +                               rate = 200000000;
12289 +                               goto out;
12290 +                       } else
12291 +                               m = R_REG(&cc->clockcontrol_m2); /* 5350 uses m2 to control mips */
12292 +               } else
12293 +                       m = R_REG(&cc->clockcontrol_sb);
12294 +       } else
12295 +               goto out;
12296 +
12297 +       // Added by Chen-I for 5365
12298 +       if (BCMINIT(sb_chip)(sbh) == BCM5365_DEVICE_ID)
12299 +               rate = 100000000;
12300 +       else
12301 +               /* calculate rate */
12302 +               rate = sb_clock_rate(pll_type, n, m);
12303 +
12304 +       if (pll_type == PLL_TYPE6)
12305 +               rate = SB2MIPS_T6(rate);
12306 +
12307 +out:
12308 +       /* switch back to previous core */
12309 +       sb_setcoreidx(sbh, idx);
12310 +
12311 +       return rate;
12312 +}
12313 +
12314 +#define ALLINTS (IE_IRQ0 | IE_IRQ1 | IE_IRQ2 | IE_IRQ3 | IE_IRQ4)
12315 +
12316 +static void
12317 +BCMINITFN(handler)(void)
12318 +{
12319 +       /* Step 11 */
12320 +       __asm__ (
12321 +               ".set\tmips32\n\t"
12322 +               "ssnop\n\t"
12323 +               "ssnop\n\t"
12324 +       /* Disable interrupts */
12325 +       /*      MTC0(C0_STATUS, 0, MFC0(C0_STATUS, 0) & ~(ALLINTS | STO_IE)); */
12326 +               "mfc0 $15, $12\n\t"
12327 +       /* Just a Hack to not to use reg 'at' which was causing problems on 4704 A2 */
12328 +               "li $14, -31746\n\t"
12329 +               "and $15, $15, $14\n\t"
12330 +               "mtc0 $15, $12\n\t"
12331 +               "eret\n\t"
12332 +               "nop\n\t"
12333 +               "nop\n\t"
12334 +               ".set\tmips0"
12335 +       );
12336 +}
12337 +
12338 +/* The following MUST come right after handler() */
12339 +static void
12340 +BCMINITFN(afterhandler)(void)
12341 +{
12342 +}
12343 +
12344 +/*
12345 + * Set the MIPS, backplane and PCI clocks as closely as possible.
12346 + */
12347 +bool
12348 +BCMINITFN(sb_mips_setclock)(sb_t *sbh, uint32 mipsclock, uint32 sbclock, uint32 pciclock)
12349 +{
12350 +       extifregs_t *eir = NULL;
12351 +       chipcregs_t *cc = NULL;
12352 +       mipsregs_t *mipsr = NULL;
12353 +       volatile uint32 *clockcontrol_n, *clockcontrol_sb, *clockcontrol_pci, *clockcontrol_m2;
12354 +       uint32 orig_n, orig_sb, orig_pci, orig_m2, orig_mips, orig_ratio_parm, orig_ratio_cfg;
12355 +       uint32 pll_type, sync_mode;
12356 +       uint ic_size, ic_lsize;
12357 +       uint idx, i;
12358 +       typedef struct {
12359 +               uint32 mipsclock;
12360 +               uint16 n;
12361 +               uint32 sb;
12362 +               uint32 pci33;
12363 +               uint32 pci25;
12364 +       } n3m_table_t;
12365 +       static n3m_table_t BCMINITDATA(type1_table)[] = {
12366 +               {  96000000, 0x0303, 0x04020011, 0x11030011, 0x11050011 }, /*  96.000 32.000 24.000 */
12367 +               { 100000000, 0x0009, 0x04020011, 0x11030011, 0x11050011 }, /* 100.000 33.333 25.000 */
12368 +               { 104000000, 0x0802, 0x04020011, 0x11050009, 0x11090009 }, /* 104.000 31.200 24.960 */
12369 +               { 108000000, 0x0403, 0x04020011, 0x11050009, 0x02000802 }, /* 108.000 32.400 24.923 */
12370 +               { 112000000, 0x0205, 0x04020011, 0x11030021, 0x02000403 }, /* 112.000 32.000 24.889 */
12371 +               { 115200000, 0x0303, 0x04020009, 0x11030011, 0x11050011 }, /* 115.200 32.000 24.000 */
12372 +               { 120000000, 0x0011, 0x04020011, 0x11050011, 0x11090011 }, /* 120.000 30.000 24.000 */
12373 +               { 124800000, 0x0802, 0x04020009, 0x11050009, 0x11090009 }, /* 124.800 31.200 24.960 */
12374 +               { 128000000, 0x0305, 0x04020011, 0x11050011, 0x02000305 }, /* 128.000 32.000 24.000 */
12375 +               { 132000000, 0x0603, 0x04020011, 0x11050011, 0x02000305 }, /* 132.000 33.000 24.750 */
12376 +               { 136000000, 0x0c02, 0x04020011, 0x11090009, 0x02000603 }, /* 136.000 32.640 24.727 */
12377 +               { 140000000, 0x0021, 0x04020011, 0x11050021, 0x02000c02 }, /* 140.000 30.000 24.706 */
12378 +               { 144000000, 0x0405, 0x04020011, 0x01020202, 0x11090021 }, /* 144.000 30.857 24.686 */
12379 +               { 150857142, 0x0605, 0x04020021, 0x02000305, 0x02000605 }, /* 150.857 33.000 24.000 */
12380 +               { 152000000, 0x0e02, 0x04020011, 0x11050021, 0x02000e02 }, /* 152.000 32.571 24.000 */
12381 +               { 156000000, 0x0802, 0x04020005, 0x11050009, 0x11090009 }, /* 156.000 31.200 24.960 */
12382 +               { 160000000, 0x0309, 0x04020011, 0x11090011, 0x02000309 }, /* 160.000 32.000 24.000 */
12383 +               { 163200000, 0x0c02, 0x04020009, 0x11090009, 0x02000603 }, /* 163.200 32.640 24.727 */
12384 +               { 168000000, 0x0205, 0x04020005, 0x11030021, 0x02000403 }, /* 168.000 32.000 24.889 */
12385 +               { 176000000, 0x0602, 0x04020003, 0x11050005, 0x02000602 }, /* 176.000 33.000 24.000 */
12386 +       };
12387 +       typedef struct {
12388 +               uint32 mipsclock;
12389 +               uint16 n;
12390 +               uint32 m2; /* that is the clockcontrol_m2 */
12391 +       } type3_table_t;
12392 +       static type3_table_t type3_table[] = { /* for 5350, mips clock is always double sb clock */
12393 +               { 150000000, 0x311, 0x4020005 },
12394 +               { 200000000, 0x311, 0x4020003 },
12395 +       };
12396 +       typedef struct {
12397 +               uint32 mipsclock;
12398 +               uint32 sbclock;
12399 +               uint16 n;
12400 +               uint32 sb;
12401 +               uint32 pci33;
12402 +               uint32 m2;
12403 +               uint32 m3;
12404 +               uint32 ratio_cfg;
12405 +               uint32 ratio_parm;
12406 +       } n4m_table_t;
12407 +
12408 +       static n4m_table_t BCMINITDATA(type2_table)[] = {
12409 +               { 180000000,  80000000, 0x0403, 0x01010000, 0x01020300, 0x01020600, 0x05000100,  8, 0x012a00a9 },
12410 +               { 180000000,  90000000, 0x0403, 0x01000100, 0x01020300, 0x01000100, 0x05000100, 11, 0x0aaa0555 },
12411 +               { 200000000, 100000000, 0x0303, 0x02010000, 0x02040001, 0x02010000, 0x06000001, 11, 0x0aaa0555 },
12412 +               { 211200000, 105600000, 0x0902, 0x01000200, 0x01030400, 0x01000200, 0x05000200, 11, 0x0aaa0555 },
12413 +               { 220800000, 110400000, 0x1500, 0x01000200, 0x01030400, 0x01000200, 0x05000200, 11, 0x0aaa0555 },
12414 +               { 230400000, 115200000, 0x0604, 0x01000200, 0x01020600, 0x01000200, 0x05000200, 11, 0x0aaa0555 },
12415 +               { 234000000, 104000000, 0x0b01, 0x01010000, 0x01010700, 0x01020600, 0x05000100,  8, 0x012a00a9 },
12416 +               { 240000000, 120000000, 0x0803, 0x01000200, 0x01020600, 0x01000200, 0x05000200, 11, 0x0aaa0555 },
12417 +               { 252000000, 126000000, 0x0504, 0x01000100, 0x01020500, 0x01000100, 0x05000100, 11, 0x0aaa0555 },
12418 +               { 264000000, 132000000, 0x0903, 0x01000200, 0x01020700, 0x01000200, 0x05000200, 11, 0x0aaa0555 },
12419 +               { 270000000, 120000000, 0x0703, 0x01010000, 0x01030400, 0x01020600, 0x05000100,  8, 0x012a00a9 },
12420 +               { 276000000, 122666666, 0x1500, 0x01010000, 0x01030400, 0x01020600, 0x05000100,  8, 0x012a00a9 },
12421 +               { 280000000, 140000000, 0x0503, 0x01000000, 0x01010600, 0x01000000, 0x05000000, 11, 0x0aaa0555 },
12422 +               { 288000000, 128000000, 0x0604, 0x01010000, 0x01030400, 0x01020600, 0x05000100,  8, 0x012a00a9 },
12423 +               { 288000000, 144000000, 0x0404, 0x01000000, 0x01010600, 0x01000000, 0x05000000, 11, 0x0aaa0555 },
12424 +               { 300000000, 133333333, 0x0803, 0x01010000, 0x01020600, 0x01020600, 0x05000100,  8, 0x012a00a9 },
12425 +               { 300000000, 150000000, 0x0803, 0x01000100, 0x01020600, 0x01000100, 0x05000100, 11, 0x0aaa0555 }
12426 +       };
12427 +
12428 +       static n4m_table_t BCMINITDATA(type4_table)[] = {
12429 +               { 192000000,  96000000, 0x0702, 0x04000011, 0x11030011, 0x04000011, 0x04000003, 11, 0x0aaa0555 },
12430 +               { 198000000,  99000000, 0x0603, 0x11020005, 0x11030011, 0x11020005, 0x04000005, 11, 0x0aaa0555 },
12431 +               { 200000000, 100000000, 0x0009, 0x04020011, 0x11030011, 0x04020011, 0x04020003, 11, 0x0aaa0555 },
12432 +               { 204000000, 102000000, 0x0c02, 0x11020005, 0x01030303, 0x11020005, 0x04000005, 11, 0x0aaa0555 },
12433 +               { 208000000, 104000000, 0x0802, 0x11030002, 0x11090005, 0x11030002, 0x04000003, 11, 0x0aaa0555 },
12434 +               { 210000000, 105000000, 0x0209, 0x11020005, 0x01030303, 0x11020005, 0x04000005, 11, 0x0aaa0555 },
12435 +               { 216000000, 108000000, 0x0111, 0x11020005, 0x01030303, 0x11020005, 0x04000005, 11, 0x0aaa0555 },
12436 +               { 224000000, 112000000, 0x0205, 0x11030002, 0x02002103, 0x11030002, 0x04000003, 11, 0x0aaa0555 },
12437 +               { 228000000, 101333333, 0x0e02, 0x11030003, 0x11210005, 0x01030305, 0x04000005,  8, 0x012a00a9 },
12438 +               { 228000000, 114000000, 0x0e02, 0x11020005, 0x11210005, 0x11020005, 0x04000005, 11, 0x0aaa0555 },
12439 +               { 240000000, 102857143, 0x0109, 0x04000021, 0x01050203, 0x11030021, 0x04000003, 13, 0x254a14a9 },
12440 +               { 240000000, 120000000, 0x0109, 0x11030002, 0x01050203, 0x11030002, 0x04000003, 11, 0x0aaa0555 },
12441 +               { 252000000, 100800000, 0x0203, 0x04000009, 0x11050005, 0x02000209, 0x04000002,  9, 0x02520129 },
12442 +               { 252000000, 126000000, 0x0203, 0x04000005, 0x11050005, 0x04000005, 0x04000002, 11, 0x0aaa0555 },
12443 +               { 264000000, 132000000, 0x0602, 0x04000005, 0x11050005, 0x04000005, 0x04000002, 11, 0x0aaa0555 },
12444 +               { 272000000, 116571428, 0x0c02, 0x04000021, 0x02000909, 0x02000221, 0x04000003, 13, 0x254a14a9 },
12445 +               { 280000000, 120000000, 0x0209, 0x04000021, 0x01030303, 0x02000221, 0x04000003, 13, 0x254a14a9 },
12446 +               { 288000000, 123428571, 0x0111, 0x04000021, 0x01030303, 0x02000221, 0x04000003, 13, 0x254a14a9 },
12447 +               { 300000000, 120000000, 0x0009, 0x04000009, 0x01030203, 0x02000902, 0x04000002,  9, 0x02520129 },
12448 +               { 300000000, 150000000, 0x0009, 0x04000005, 0x01030203, 0x04000005, 0x04000002, 11, 0x0aaa0555 }
12449 +       };
12450 +
12451 +       static n4m_table_t BCMINITDATA(type7_table)[] = {
12452 +               { 183333333,  91666666, 0x0605, 0x04000011, 0x11030011, 0x04000011, 0x04000003, 11, 0x0aaa0555 },
12453 +               { 187500000,  93750000, 0x0a03, 0x04000011, 0x11030011, 0x04000011, 0x04000003, 11, 0x0aaa0555 },
12454 +               { 196875000,  98437500, 0x1003, 0x11020005, 0x11050011, 0x11020005, 0x04000005, 11, 0x0aaa0555 },
12455 +               { 200000000, 100000000, 0x0311, 0x04000011, 0x11030011, 0x04000009, 0x04000003, 11, 0x0aaa0555 },
12456 +               { 200000000, 100000000, 0x0311, 0x04020011, 0x11030011, 0x04020011, 0x04020003, 11, 0x0aaa0555 },
12457 +               { 206250000, 103125000, 0x1103, 0x11020005, 0x11050011, 0x11020005, 0x04000005, 11, 0x0aaa0555 },
12458 +               { 212500000, 106250000, 0x0c05, 0x11020005, 0x01030303, 0x11020005, 0x04000005, 11, 0x0aaa0555 },
12459 +               { 215625000, 107812500, 0x1203, 0x11090009, 0x11050005, 0x11020005, 0x04000005, 11, 0x0aaa0555 },
12460 +               { 216666666, 108333333, 0x0805, 0x11020003, 0x11030011, 0x11020003, 0x04000003, 11, 0x0aaa0555 },
12461 +               { 225000000, 112500000, 0x0d03, 0x11020003, 0x11030011, 0x11020003, 0x04000003, 11, 0x0aaa0555 },
12462 +               { 233333333, 116666666, 0x0905, 0x11020003, 0x11030011, 0x11020003, 0x04000003, 11, 0x0aaa0555 },
12463 +               { 237500000, 118750000, 0x0e05, 0x11020005, 0x11210005, 0x11020005, 0x04000005, 11, 0x0aaa0555 },
12464 +               { 240000000, 120000000, 0x0b11, 0x11020009, 0x11210009, 0x11020009, 0x04000009, 11, 0x0aaa0555 },
12465 +               { 250000000, 125000000, 0x0f03, 0x11020003, 0x11210003, 0x11020003, 0x04000003, 11, 0x0aaa0555 }
12466 +       };
12467 +
12468 +       ulong start, end, dst;
12469 +       bool ret = FALSE;
12470 +
12471 +       /* get index of the current core */
12472 +       idx = sb_coreidx(sbh);
12473 +       clockcontrol_m2 = NULL;
12474 +
12475 +       /* switch to extif or chipc core */
12476 +       if ((eir = (extifregs_t *) sb_setcore(sbh, SB_EXTIF, 0))) {
12477 +               pll_type = PLL_TYPE1;
12478 +               clockcontrol_n = &eir->clockcontrol_n;
12479 +               clockcontrol_sb = &eir->clockcontrol_sb;
12480 +               clockcontrol_pci = &eir->clockcontrol_pci;
12481 +               clockcontrol_m2 = &cc->clockcontrol_m2;
12482 +       } else if ((cc = (chipcregs_t *) sb_setcore(sbh, SB_CC, 0))) {
12483 +               pll_type = R_REG(&cc->capabilities) & CAP_PLL_MASK;
12484 +               if (pll_type == PLL_TYPE6) {
12485 +                       clockcontrol_n = NULL;
12486 +                       clockcontrol_sb = NULL;
12487 +                       clockcontrol_pci = NULL;
12488 +               } else {
12489 +                       clockcontrol_n = &cc->clockcontrol_n;
12490 +                       clockcontrol_sb = &cc->clockcontrol_sb;
12491 +                       clockcontrol_pci = &cc->clockcontrol_pci;
12492 +                       clockcontrol_m2 = &cc->clockcontrol_m2;
12493 +               }
12494 +       } else
12495 +               goto done;
12496 +
12497 +       if (pll_type == PLL_TYPE6) {
12498 +               /* Silence compilers */
12499 +               orig_n = orig_sb = orig_pci = 0;
12500 +       } else {
12501 +               /* Store the current clock register values */
12502 +               orig_n = R_REG(clockcontrol_n);
12503 +               orig_sb = R_REG(clockcontrol_sb);
12504 +               orig_pci = R_REG(clockcontrol_pci);
12505 +       }
12506 +
12507 +       if (pll_type == PLL_TYPE1) {
12508 +               /* Keep the current PCI clock if not specified */
12509 +               if (pciclock == 0) {
12510 +                       pciclock = sb_clock_rate(pll_type, R_REG(clockcontrol_n), R_REG(clockcontrol_pci));
12511 +                       pciclock = (pciclock <= 25000000) ? 25000000 : 33000000;
12512 +               }
12513 +
12514 +               /* Search for the closest MIPS clock less than or equal to a preferred value */
12515 +               for (i = 0; i < ARRAYSIZE(BCMINIT(type1_table)); i++) {
12516 +                       ASSERT(BCMINIT(type1_table)[i].mipsclock ==
12517 +                              sb_clock_rate(pll_type, BCMINIT(type1_table)[i].n, BCMINIT(type1_table)[i].sb));
12518 +                       if (BCMINIT(type1_table)[i].mipsclock > mipsclock)
12519 +                               break;
12520 +               }
12521 +               if (i == 0) {
12522 +                       ret = FALSE;
12523 +                       goto done;
12524 +               } else {
12525 +                       ret = TRUE;
12526 +                       i--;
12527 +               }
12528 +               ASSERT(BCMINIT(type1_table)[i].mipsclock <= mipsclock);
12529 +
12530 +               /* No PLL change */
12531 +               if ((orig_n == BCMINIT(type1_table)[i].n) &&
12532 +                   (orig_sb == BCMINIT(type1_table)[i].sb) &&
12533 +                   (orig_pci == BCMINIT(type1_table)[i].pci33))
12534 +                       goto done;
12535 +
12536 +               /* Set the PLL controls */
12537 +               W_REG(clockcontrol_n, BCMINIT(type1_table)[i].n);
12538 +               W_REG(clockcontrol_sb, BCMINIT(type1_table)[i].sb);
12539 +               if (pciclock == 25000000)
12540 +                       W_REG(clockcontrol_pci, BCMINIT(type1_table)[i].pci25);
12541 +               else
12542 +                       W_REG(clockcontrol_pci, BCMINIT(type1_table)[i].pci33);
12543 +
12544 +               /* Reset */
12545 +               sb_watchdog(sbh, 1);
12546 +
12547 +               while (1);
12548 +       } else if ((pll_type == PLL_TYPE3) &&
12549 +                  (BCMINIT(sb_chip)(sbh) != BCM5365_DEVICE_ID)) {
12550 +               /* 5350 */
12551 +               /* Search for the closest MIPS clock less than or equal to a preferred value */
12552 +
12553 +               for (i = 0; i < ARRAYSIZE(type3_table); i++) {
12554 +                       if (type3_table[i].mipsclock > mipsclock)
12555 +                               break;
12556 +               }
12557 +               if (i == 0) {
12558 +                       ret = FALSE;
12559 +                       goto done;
12560 +               } else {
12561 +                       ret = TRUE;
12562 +                       i--;
12563 +               }
12564 +               ASSERT(type3_table[i].mipsclock <= mipsclock);
12565 +
12566 +               /* No PLL change */
12567 +               orig_m2 = R_REG(&cc->clockcontrol_m2);
12568 +               if ((orig_n == type3_table[i].n) &&
12569 +                   (orig_m2 == type3_table[i].m2)) {
12570 +                       goto done;
12571 +               }
12572 +
12573 +               /* Set the PLL controls */
12574 +               W_REG(clockcontrol_n, type3_table[i].n);
12575 +               W_REG(clockcontrol_m2, type3_table[i].m2);
12576 +
12577 +               /* Reset */
12578 +               sb_watchdog(sbh, 1);
12579 +               while (1);
12580 +       } else if ((pll_type == PLL_TYPE2) ||
12581 +                  (pll_type == PLL_TYPE4) ||
12582 +                  (pll_type == PLL_TYPE6) ||
12583 +                  (pll_type == PLL_TYPE7)) {
12584 +               n4m_table_t *table = NULL, *te;
12585 +               uint tabsz = 0;
12586 +
12587 +               ASSERT(cc);
12588 +
12589 +               orig_mips = R_REG(&cc->clockcontrol_mips);
12590 +
12591 +               if (pll_type == PLL_TYPE6) {
12592 +                       uint32 new_mips = 0;
12593 +
12594 +                       ret = TRUE;
12595 +                       if (mipsclock <= SB2MIPS_T6(CC_T6_M1))
12596 +                               new_mips = CC_T6_MMASK;
12597 +
12598 +                       if (orig_mips == new_mips)
12599 +                               goto done;
12600 +
12601 +                       W_REG(&cc->clockcontrol_mips, new_mips);
12602 +                       goto end_fill;
12603 +               }
12604 +
12605 +               if (pll_type == PLL_TYPE2) {
12606 +                       table = BCMINIT(type2_table);
12607 +                       tabsz = ARRAYSIZE(BCMINIT(type2_table));
12608 +               } else if (pll_type == PLL_TYPE4) {
12609 +                       table = BCMINIT(type4_table);
12610 +                       tabsz = ARRAYSIZE(BCMINIT(type4_table));
12611 +               } else if (pll_type == PLL_TYPE7) {
12612 +                       table = BCMINIT(type7_table);
12613 +                       tabsz = ARRAYSIZE(BCMINIT(type7_table));
12614 +               } else
12615 +                       ASSERT("No table for plltype" == NULL);
12616 +
12617 +               /* Store the current clock register values */
12618 +               orig_m2 = R_REG(&cc->clockcontrol_m2);
12619 +               orig_ratio_parm = 0;
12620 +               orig_ratio_cfg = 0;
12621 +
12622 +               /* Look up current ratio */
12623 +               for (i = 0; i < tabsz; i++) {
12624 +                       if ((orig_n == table[i].n) &&
12625 +                           (orig_sb == table[i].sb) &&
12626 +                           (orig_pci == table[i].pci33) &&
12627 +                           (orig_m2 == table[i].m2) &&
12628 +                           (orig_mips == table[i].m3)) {
12629 +                               orig_ratio_parm = table[i].ratio_parm;
12630 +                               orig_ratio_cfg = table[i].ratio_cfg;
12631 +                               break;
12632 +                       }
12633 +               }
12634 +
12635 +               /* Search for the closest MIPS clock greater or equal to a preferred value */
12636 +               for (i = 0; i < tabsz; i++) {
12637 +                       ASSERT(table[i].mipsclock ==
12638 +                              sb_clock_rate(pll_type, table[i].n, table[i].m3));
12639 +                       if ((mipsclock <= table[i].mipsclock) &&
12640 +                           ((sbclock == 0) || (sbclock <= table[i].sbclock)))
12641 +                               break;
12642 +               }
12643 +               if (i == tabsz) {
12644 +                       ret = FALSE;
12645 +                       goto done;
12646 +               } else {
12647 +                       te = &table[i];
12648 +                       ret = TRUE;
12649 +               }
12650 +
12651 +               /* No PLL change */
12652 +               if ((orig_n == te->n) &&
12653 +                   (orig_sb == te->sb) &&
12654 +                   (orig_pci == te->pci33) &&
12655 +                   (orig_m2 == te->m2) &&
12656 +                   (orig_mips == te->m3))
12657 +                       goto done;
12658 +
12659 +               /* Set the PLL controls */
12660 +               W_REG(clockcontrol_n, te->n);
12661 +               W_REG(clockcontrol_sb, te->sb);
12662 +               W_REG(clockcontrol_pci, te->pci33);
12663 +               W_REG(&cc->clockcontrol_m2, te->m2);
12664 +               W_REG(&cc->clockcontrol_mips, te->m3);
12665 +
12666 +               /* Set the chipcontrol bit to change mipsref to the backplane divider if needed */
12667 +               if ((pll_type == PLL_TYPE7) &&
12668 +                   (te->sb != te->m2) &&
12669 +                   (sb_clock_rate(pll_type, te->n, te->m2) == 120000000))
12670 +                       W_REG(&cc->chipcontrol, R_REG(&cc->chipcontrol) | 0x100);
12671 +
12672 +               /* No ratio change */
12673 +               if (orig_ratio_parm == te->ratio_parm)
12674 +                       goto end_fill;
12675 +
12676 +               icache_probe(MFC0(C0_CONFIG, 1), &ic_size, &ic_lsize);
12677 +
12678 +               /* Preload the code into the cache */
12679 +               start = ((ulong) &&start_fill) & ~(ic_lsize - 1);
12680 +               end = ((ulong) &&end_fill + (ic_lsize - 1)) & ~(ic_lsize - 1);
12681 +               while (start < end) {
12682 +                       cache_op(start, Fill_I);
12683 +                       start += ic_lsize;
12684 +               }
12685 +
12686 +               /* Copy the handler */
12687 +               start = (ulong) &BCMINIT(handler);
12688 +               end = (ulong) &BCMINIT(afterhandler);
12689 +               dst = KSEG1ADDR(0x180);
12690 +               for (i = 0; i < (end - start); i += 4)
12691 +                       *((ulong *)(dst + i)) = *((ulong *)(start + i));
12692 +
12693 +               /* Preload handler into the cache one line at a time */
12694 +               for (i = 0; i < (end - start); i += 4)
12695 +                       cache_op(dst + i, Fill_I);
12696 +
12697 +               /* Clear BEV bit */
12698 +               MTC0(C0_STATUS, 0, MFC0(C0_STATUS, 0) & ~ST0_BEV);
12699 +
12700 +               /* Enable interrupts */
12701 +               MTC0(C0_STATUS, 0, MFC0(C0_STATUS, 0) | (ALLINTS | ST0_IE));
12702 +
12703 +               /* Enable MIPS timer interrupt */
12704 +               if (!(mipsr = sb_setcore(sbh, SB_MIPS, 0)) &&
12705 +                   !(mipsr = sb_setcore(sbh, SB_MIPS33, 0)))
12706 +                       ASSERT(mipsr);
12707 +               W_REG(&mipsr->intmask, 1);
12708 +
12709 +       start_fill:
12710 +               /* step 1, set clock ratios */
12711 +               MTC0(C0_BROADCOM, 3, te->ratio_parm);
12712 +               MTC0(C0_BROADCOM, 1, te->ratio_cfg);
12713 +
12714 +               /* step 2: program timer intr */
12715 +               W_REG(&mipsr->timer, 100);
12716 +               (void) R_REG(&mipsr->timer);
12717 +
12718 +               /* step 3, switch to async */
12719 +               sync_mode = MFC0(C0_BROADCOM, 4);
12720 +               MTC0(C0_BROADCOM, 4, 1 << 22);
12721 +
12722 +               /* step 4, set cfg active */
12723 +               MTC0(C0_BROADCOM, 2, 0x9);
12724 +
12725 +
12726 +               /* steps 5 & 6 */
12727 +               __asm__ __volatile__ (
12728 +                       ".set\tmips3\n\t"
12729 +                       "wait\n\t"
12730 +                       ".set\tmips0"
12731 +               );
12732 +
12733 +               /* step 7, clear cfg_active */
12734 +               MTC0(C0_BROADCOM, 2, 0);
12735 +
12736 +               /* Additional Step: set back to orig sync mode */
12737 +               MTC0(C0_BROADCOM, 4, sync_mode);
12738 +
12739 +               /* step 8, fake soft reset */
12740 +               MTC0(C0_BROADCOM, 5, MFC0(C0_BROADCOM, 5) | 4);
12741 +
12742 +       end_fill:
12743 +               /* step 9 set watchdog timer */
12744 +               sb_watchdog(sbh, 20);
12745 +               (void) R_REG(&cc->chipid);
12746 +
12747 +               /* step 11 */
12748 +               __asm__ __volatile__ (
12749 +                       ".set\tmips3\n\t"
12750 +                       "sync\n\t"
12751 +                       "wait\n\t"
12752 +                       ".set\tmips0"
12753 +               );
12754 +               while (1);
12755 +       }
12756 +
12757 +done:
12758 +       /* switch back to previous core */
12759 +       sb_setcoreidx(sbh, idx);
12760 +
12761 +       return ret;
12762 +}
12763 +
12764 +/*
12765 + *  This also must be run from the cache on 47xx
12766 + *  so there are no mips core BIU ops in progress
12767 + *  when the PFC is enabled.
12768 + */
12769 +
12770 +static void
12771 +BCMINITFN(_enable_pfc)(uint32 mode)
12772 +{
12773 +       /* write range */
12774 +       *(volatile uint32 *)PFC_CR1 = 0xffff0000;
12775 +
12776 +       /* enable */
12777 +       *(volatile uint32 *)PFC_CR0 = mode;
12778 +}
12779 +
12780 +void
12781 +BCMINITFN(enable_pfc)(uint32 mode)
12782 +{
12783 +       ulong start, end;
12784 +       int i;
12785 +
12786 +       /* If auto then choose the correct mode for this
12787 +          platform, currently we only ever select one mode */
12788 +       if (mode == PFC_AUTO)
12789 +               mode = PFC_INST;
12790 +
12791 +       /* enable prefetch cache if available */
12792 +       if (MFC0(C0_BROADCOM, 0) & BRCM_PFC_AVAIL) {
12793 +               start = (ulong) &BCMINIT(_enable_pfc);
12794 +               end = (ulong) &BCMINIT(enable_pfc);
12795 +
12796 +               /* Preload handler into the cache one line at a time */
12797 +               for (i = 0; i < (end - start); i += 4)
12798 +                       cache_op(start + i, Fill_I);
12799 +
12800 +               BCMINIT(_enable_pfc)(mode);
12801 +       }
12802 +}
12803 +
12804 +/* returns the ncdl value to be programmed into sdram_ncdl for calibration */
12805 +uint32
12806 +BCMINITFN(sb_memc_get_ncdl)(sb_t *sbh)
12807 +{
12808 +       sbmemcregs_t *memc;
12809 +       uint32 ret = 0;
12810 +       uint32 config, rd, wr, misc, dqsg, cd, sm, sd;
12811 +       uint idx, rev;
12812 +
12813 +       idx = sb_coreidx(sbh);
12814 +
12815 +       memc = (sbmemcregs_t *)sb_setcore(sbh, SB_MEMC, 0);
12816 +       if (memc == 0)
12817 +               goto out;
12818 +
12819 +       rev = sb_corerev(sbh);
12820 +
12821 +       config = R_REG(&memc->config);
12822 +       wr = R_REG(&memc->wrncdlcor);
12823 +       rd = R_REG(&memc->rdncdlcor);
12824 +       misc = R_REG(&memc->miscdlyctl);
12825 +       dqsg = R_REG(&memc->dqsgatencdl);
12826 +
12827 +       rd &= MEMC_RDNCDLCOR_RD_MASK;
12828 +       wr &= MEMC_WRNCDLCOR_WR_MASK;
12829 +       dqsg &= MEMC_DQSGATENCDL_G_MASK;
12830 +
12831 +       if (config & MEMC_CONFIG_DDR) {
12832 +               ret = (wr << 16) | (rd << 8) | dqsg;
12833 +       } else {
12834 +               if (rev > 0)
12835 +                       cd = rd;
12836 +               else
12837 +                       cd = (rd == MEMC_CD_THRESHOLD) ? rd : (wr + MEMC_CD_THRESHOLD);
12838 +               sm = (misc & MEMC_MISC_SM_MASK) >> MEMC_MISC_SM_SHIFT;
12839 +               sd = (misc & MEMC_MISC_SD_MASK) >> MEMC_MISC_SD_SHIFT;
12840 +               ret = (sm << 16) | (sd << 8) | cd;
12841 +       }
12842 +
12843 +out:
12844 +       /* switch back to previous core */
12845 +       sb_setcoreidx(sbh, idx);
12846 +
12847 +       return ret;
12848 +}
12849 +
12850 diff -Nur linux-2.4.32/arch/mips/bcm947xx/sbpci.c linux-2.4.32-brcm/arch/mips/bcm947xx/sbpci.c
12851 --- linux-2.4.32/arch/mips/bcm947xx/sbpci.c     1970-01-01 01:00:00.000000000 +0100
12852 +++ linux-2.4.32-brcm/arch/mips/bcm947xx/sbpci.c        2005-12-16 23:39:10.948837000 +0100
12853 @@ -0,0 +1,588 @@
12854 +/*
12855 + * Low-Level PCI and SB support for BCM47xx
12856 + *
12857 + * Copyright 2005, Broadcom Corporation
12858 + * All Rights Reserved.
12859 + *
12860 + * THIS SOFTWARE IS OFFERED "AS IS", AND BROADCOM GRANTS NO WARRANTIES OF ANY
12861 + * KIND, EXPRESS OR IMPLIED, BY STATUTE, COMMUNICATION OR OTHERWISE. BROADCOM
12862 + * SPECIFICALLY DISCLAIMS ANY IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS
12863 + * FOR A SPECIFIC PURPOSE OR NONINFRINGEMENT CONCERNING THIS SOFTWARE.
12864 + *
12865 + * $Id$
12866 + */
12867 +
12868 +#include <typedefs.h>
12869 +#include <pcicfg.h>
12870 +#include <bcmdevs.h>
12871 +#include <sbconfig.h>
12872 +#include <osl.h>
12873 +#include <sbutils.h>
12874 +#include <sbpci.h>
12875 +#include <bcmendian.h>
12876 +#include <bcmutils.h>
12877 +#include <bcmnvram.h>
12878 +#include <hndmips.h>
12879 +
12880 +/* Can free sbpci_init() memory after boot */
12881 +#ifndef linux
12882 +#define __init
12883 +#endif
12884 +
12885 +/* Emulated configuration space */
12886 +static pci_config_regs sb_config_regs[SB_MAXCORES];
12887 +
12888 +/* Banned cores */
12889 +static uint16 pci_ban[32] = { 0 };
12890 +static uint pci_banned = 0;
12891 +
12892 +/* CardBus mode */
12893 +static bool cardbus = FALSE;
12894 +
12895 +/* Disable PCI host core */
12896 +static bool pci_disabled = FALSE;
12897 +
12898 +/*
12899 + * Functions for accessing external PCI configuration space
12900 + */
12901 +
12902 +/* Assume one-hot slot wiring */
12903 +#define PCI_SLOT_MAX 16
12904 +
12905 +static uint32
12906 +config_cmd(sb_t *sbh, uint bus, uint dev, uint func, uint off)
12907 +{
12908 +       uint coreidx;
12909 +       sbpciregs_t *regs;
12910 +       uint32 addr = 0;
12911 +
12912 +       /* CardBusMode supports only one device */
12913 +       if (cardbus && dev > 1)
12914 +               return 0;
12915 +
12916 +       coreidx = sb_coreidx(sbh);
12917 +       regs = (sbpciregs_t *) sb_setcore(sbh, SB_PCI, 0);
12918 +
12919 +       /* Type 0 transaction */
12920 +       if (bus == 1) {
12921 +               /* Skip unwired slots */
12922 +               if (dev < PCI_SLOT_MAX) {
12923 +                       /* Slide the PCI window to the appropriate slot */
12924 +                       W_REG(&regs->sbtopci1, SBTOPCI_CFG0 | ((1 << (dev + 16)) & SBTOPCI1_MASK));
12925 +                       addr = SB_PCI_CFG | ((1 << (dev + 16)) & ~SBTOPCI1_MASK) |
12926 +                               (func << 8) | (off & ~3);
12927 +               }
12928 +       }
12929 +
12930 +       /* Type 1 transaction */
12931 +       else {
12932 +               W_REG(&regs->sbtopci1, SBTOPCI_CFG1);
12933 +               addr = SB_PCI_CFG | (bus << 16) | (dev << 11) | (func << 8) | (off & ~3);
12934 +       }
12935 +
12936 +       sb_setcoreidx(sbh, coreidx);
12937 +
12938 +       return addr;
12939 +}
12940 +
12941 +static int
12942 +extpci_read_config(sb_t *sbh, uint bus, uint dev, uint func, uint off, void *buf, int len)
12943 +{
12944 +       uint32 addr, *reg = NULL, val;
12945 +       int ret = 0;
12946 +
12947 +       if (pci_disabled ||
12948 +           !(addr = config_cmd(sbh, bus, dev, func, off)) ||
12949 +           !(reg = (uint32 *) REG_MAP(addr, len)) ||
12950 +           BUSPROBE(val, reg))
12951 +               val = 0xffffffff;
12952 +
12953 +       val >>= 8 * (off & 3);
12954 +       if (len == 4)
12955 +               *((uint32 *) buf) = val;
12956 +       else if (len == 2)
12957 +               *((uint16 *) buf) = (uint16) val;
12958 +       else if (len == 1)
12959 +               *((uint8 *) buf) = (uint8) val;
12960 +       else
12961 +               ret = -1;
12962 +
12963 +       if (reg)
12964 +               REG_UNMAP(reg);
12965 +
12966 +       return ret;
12967 +}
12968 +
12969 +static int
12970 +extpci_write_config(sb_t *sbh, uint bus, uint dev, uint func, uint off, void *buf, int len)
12971 +{
12972 +       uint32 addr, *reg = NULL, val;
12973 +       int ret = 0;
12974 +
12975 +       if (pci_disabled ||
12976 +           !(addr = config_cmd(sbh, bus, dev, func, off)) ||
12977 +           !(reg = (uint32 *) REG_MAP(addr, len)) ||
12978 +           BUSPROBE(val, reg))
12979 +               goto done;
12980 +
12981 +       if (len == 4)
12982 +               val = *((uint32 *) buf);
12983 +       else if (len == 2) {
12984 +               val &= ~(0xffff << (8 * (off & 3)));
12985 +               val |= *((uint16 *) buf) << (8 * (off & 3));
12986 +       } else if (len == 1) {
12987 +               val &= ~(0xff << (8 * (off & 3)));
12988 +               val |= *((uint8 *) buf) << (8 * (off & 3));
12989 +       } else
12990 +               ret = -1;
12991 +
12992 +       W_REG(reg, val);
12993 +
12994 + done:
12995 +       if (reg)
12996 +               REG_UNMAP(reg);
12997 +
12998 +       return ret;
12999 +}
13000 +
13001 +/*
13002 + * Functions for accessing translated SB configuration space
13003 + */
13004 +
13005 +static int
13006 +sb_read_config(sb_t *sbh, uint bus, uint dev, uint func, uint off, void *buf, int len)
13007 +{
13008 +       pci_config_regs *cfg;
13009 +
13010 +       if (dev >= SB_MAXCORES || (off + len) > sizeof(pci_config_regs))
13011 +               return -1;
13012 +       cfg = &sb_config_regs[dev];
13013 +
13014 +       ASSERT(ISALIGNED(off, len));
13015 +       ASSERT(ISALIGNED((uintptr)buf, len));
13016 +
13017 +       if (len == 4)
13018 +               *((uint32 *) buf) = ltoh32(*((uint32 *)((ulong) cfg + off)));
13019 +       else if (len == 2)
13020 +               *((uint16 *) buf) = ltoh16(*((uint16 *)((ulong) cfg + off)));
13021 +       else if (len == 1)
13022 +               *((uint8 *) buf) = *((uint8 *)((ulong) cfg + off));
13023 +       else
13024 +               return -1;
13025 +
13026 +       return 0;
13027 +}
13028 +
13029 +static int
13030 +sb_write_config(sb_t *sbh, uint bus, uint dev, uint func, uint off, void *buf, int len)
13031 +{
13032 +       uint coreidx, n;
13033 +       void *regs;
13034 +       sbconfig_t *sb;
13035 +       pci_config_regs *cfg;
13036 +
13037 +       if (dev >= SB_MAXCORES || (off + len) > sizeof(pci_config_regs))
13038 +               return -1;
13039 +       cfg = &sb_config_regs[dev];
13040 +
13041 +       ASSERT(ISALIGNED(off, len));
13042 +       ASSERT(ISALIGNED((uintptr)buf, len));
13043 +
13044 +       /* Emulate BAR sizing */
13045 +       if (off >= OFFSETOF(pci_config_regs, base[0]) && off <= OFFSETOF(pci_config_regs, base[3]) &&
13046 +           len == 4 && *((uint32 *) buf) == ~0) {
13047 +               coreidx = sb_coreidx(sbh);
13048 +               if ((regs = sb_setcoreidx(sbh, dev))) {
13049 +                       sb = (sbconfig_t *)((ulong) regs + SBCONFIGOFF);
13050 +                       /* Highest numbered address match register */
13051 +                       n = (R_REG(&sb->sbidlow) & SBIDL_AR_MASK) >> SBIDL_AR_SHIFT;
13052 +                       if (off == OFFSETOF(pci_config_regs, base[0]))
13053 +                               cfg->base[0] = ~(sb_size(R_REG(&sb->sbadmatch0)) - 1);
13054 +                       else if (off == OFFSETOF(pci_config_regs, base[1]) && n >= 1)
13055 +                               cfg->base[1] = ~(sb_size(R_REG(&sb->sbadmatch1)) - 1);
13056 +                       else if (off == OFFSETOF(pci_config_regs, base[2]) && n >= 2)
13057 +                               cfg->base[2] = ~(sb_size(R_REG(&sb->sbadmatch2)) - 1);
13058 +                       else if (off == OFFSETOF(pci_config_regs, base[3]) && n >= 3)
13059 +                               cfg->base[3] = ~(sb_size(R_REG(&sb->sbadmatch3)) - 1);
13060 +               }
13061 +               sb_setcoreidx(sbh, coreidx);
13062 +               return 0;
13063 +       }
13064 +
13065 +       if (len == 4)
13066 +               *((uint32 *)((ulong) cfg + off)) = htol32(*((uint32 *) buf));
13067 +       else if (len == 2)
13068 +               *((uint16 *)((ulong) cfg + off)) = htol16(*((uint16 *) buf));
13069 +       else if (len == 1)
13070 +               *((uint8 *)((ulong) cfg + off)) = *((uint8 *) buf);
13071 +       else
13072 +               return -1;
13073 +
13074 +       return 0;
13075 +}
13076 +
13077 +int
13078 +sbpci_read_config(sb_t *sbh, uint bus, uint dev, uint func, uint off, void *buf, int len)
13079 +{
13080 +       if (bus == 0)
13081 +               return sb_read_config(sbh, bus, dev, func, off, buf, len);
13082 +       else
13083 +               return extpci_read_config(sbh, bus, dev, func, off, buf, len);
13084 +}
13085 +
13086 +int
13087 +sbpci_write_config(sb_t *sbh, uint bus, uint dev, uint func, uint off, void *buf, int len)
13088 +{
13089 +       if (bus == 0)
13090 +               return sb_write_config(sbh, bus, dev, func, off, buf, len);
13091 +       else
13092 +               return extpci_write_config(sbh, bus, dev, func, off, buf, len);
13093 +}
13094 +
13095 +void
13096 +sbpci_ban(uint16 core)
13097 +{
13098 +       if (pci_banned < ARRAYSIZE(pci_ban))
13099 +               pci_ban[pci_banned++] = core;
13100 +}
13101 +
13102 +static int
13103 +sbpci_init_pci(sb_t *sbh)
13104 +{
13105 +       uint chip, chiprev, chippkg, host;
13106 +       uint32 boardflags;
13107 +       sbpciregs_t *pci;
13108 +       sbconfig_t *sb;
13109 +       uint32 val;
13110 +
13111 +       chip = sb_chip(sbh);
13112 +       chiprev = sb_chiprev(sbh);
13113 +       chippkg = sb_chippkg(sbh);
13114 +
13115 +       if (!(pci = (sbpciregs_t *) sb_setcore(sbh, SB_PCI, 0))) {
13116 +               printf("PCI: no core\n");
13117 +               pci_disabled = TRUE;
13118 +               return -1;
13119 +       }
13120 +       sb_core_reset(sbh, 0);
13121 +
13122 +       boardflags = (uint32) getintvar(NULL, "boardflags");
13123 +
13124 +       if ((chip == BCM4310_DEVICE_ID) && (chiprev == 0))
13125 +               pci_disabled = TRUE;
13126 +
13127 +       /*
13128 +        * The 200-pin BCM4712 package does not bond out PCI. Even when
13129 +        * PCI is bonded out, some boards may leave the pins
13130 +        * floating.
13131 +        */
13132 +       if (((chip == BCM4712_DEVICE_ID) &&
13133 +            ((chippkg == BCM4712SMALL_PKG_ID) ||
13134 +             (chippkg == BCM4712MID_PKG_ID))) ||
13135 +           (boardflags & BFL_NOPCI))
13136 +               pci_disabled = TRUE;
13137 +
13138 +       /*
13139 +        * If the PCI core should not be touched (disabled, not bonded
13140 +        * out, or pins floating), do not even attempt to access core
13141 +        * registers. Otherwise, try to determine if it is in host
13142 +        * mode.
13143 +        */
13144 +       if (pci_disabled)
13145 +               host = 0;
13146 +       else
13147 +               host = !BUSPROBE(val, &pci->control);
13148 +
13149 +       if (!host) {
13150 +               /* Disable PCI interrupts in client mode */
13151 +               sb = (sbconfig_t *)((ulong) pci + SBCONFIGOFF);
13152 +               W_REG(&sb->sbintvec, 0);
13153 +
13154 +               /* Disable the PCI bridge in client mode */
13155 +               sbpci_ban(SB_PCI);
13156 +               printf("PCI: Disabled\n");
13157 +       } else {
13158 +               /* Reset the external PCI bus and enable the clock */
13159 +               W_REG(&pci->control, 0x5);              /* enable the tristate drivers */
13160 +               W_REG(&pci->control, 0xd);              /* enable the PCI clock */
13161 +               OSL_DELAY(150);                         /* delay > 100 us */
13162 +               W_REG(&pci->control, 0xf);              /* deassert PCI reset */
13163 +               W_REG(&pci->arbcontrol, PCI_INT_ARB);   /* use internal arbiter */
13164 +               OSL_DELAY(1);                           /* delay 1 us */
13165 +
13166 +               /* Enable CardBusMode */
13167 +               cardbus = nvram_match("cardbus", "1");
13168 +               if (cardbus) {
13169 +                       printf("PCI: Enabling CardBus\n");
13170 +                       /* GPIO 1 resets the CardBus device on bcm94710ap */
13171 +                       sb_gpioout(sbh, 1, 1, GPIO_DRV_PRIORITY);
13172 +                       sb_gpioouten(sbh, 1, 1, GPIO_DRV_PRIORITY);
13173 +                       W_REG(&pci->sprom[0], R_REG(&pci->sprom[0]) | 0x400);
13174 +               }
13175 +
13176 +               /* 64 MB I/O access window */
13177 +               W_REG(&pci->sbtopci0, SBTOPCI_IO);
13178 +               /* 64 MB configuration access window */
13179 +               W_REG(&pci->sbtopci1, SBTOPCI_CFG0);
13180 +               /* 1 GB memory access window */
13181 +               W_REG(&pci->sbtopci2, SBTOPCI_MEM | SB_PCI_DMA);
13182 +
13183 +               /* Enable PCI bridge BAR0 prefetch and burst */
13184 +               val = 6;
13185 +               sbpci_write_config(sbh, 1, 0, 0, PCI_CFG_CMD, &val, sizeof(val));
13186 +
13187 +               /* Enable PCI interrupts */
13188 +               W_REG(&pci->intmask, PCI_INTA);
13189 +       }
13190 +
13191 +       return 0;
13192 +}
13193 +
13194 +static int
13195 +sbpci_init_cores(sb_t *sbh)
13196 +{
13197 +       uint chip, chiprev, chippkg, coreidx, i;
13198 +       sbconfig_t *sb;
13199 +       pci_config_regs *cfg;
13200 +       void *regs;
13201 +       char varname[8];
13202 +       uint wlidx = 0;
13203 +       uint16 vendor, core;
13204 +       uint8 class, subclass, progif;
13205 +       uint32 val;
13206 +       uint32 sbips_int_mask[] = { 0, SBIPS_INT1_MASK, SBIPS_INT2_MASK, SBIPS_INT3_MASK, SBIPS_INT4_MASK };
13207 +       uint32 sbips_int_shift[] = { 0, 0, SBIPS_INT2_SHIFT, SBIPS_INT3_SHIFT, SBIPS_INT4_SHIFT };
13208 +
13209 +       chip = sb_chip(sbh);
13210 +       chiprev = sb_chiprev(sbh);
13211 +       chippkg = sb_chippkg(sbh);
13212 +       coreidx = sb_coreidx(sbh);
13213 +
13214 +       /* Scan the SB bus */
13215 +       bzero(sb_config_regs, sizeof(sb_config_regs));
13216 +       for (cfg = sb_config_regs; cfg < &sb_config_regs[SB_MAXCORES]; cfg++) {
13217 +               cfg->vendor = 0xffff;
13218 +               if (!(regs = sb_setcoreidx(sbh, cfg - sb_config_regs)))
13219 +                       continue;
13220 +               sb = (sbconfig_t *)((ulong) regs + SBCONFIGOFF);
13221 +
13222 +               /* Read ID register and parse vendor and core */
13223 +               val = R_REG(&sb->sbidhigh);
13224 +               vendor = (val & SBIDH_VC_MASK) >> SBIDH_VC_SHIFT;
13225 +               core = (val & SBIDH_CC_MASK) >> SBIDH_CC_SHIFT;
13226 +               progif = 0;
13227 +
13228 +               /* Check if this core is banned */
13229 +               for (i = 0; i < pci_banned; i++)
13230 +                       if (core == pci_ban[i])
13231 +                               break;
13232 +               if (i < pci_banned)
13233 +                       continue;
13234 +
13235 +               /* Known vendor translations */
13236 +               switch (vendor) {
13237 +               case SB_VEND_BCM:
13238 +                       vendor = VENDOR_BROADCOM;
13239 +                       break;
13240 +               }
13241 +
13242 +               /* Determine class based on known core codes */
13243 +               switch (core) {
13244 +               case SB_ILINE20:
13245 +                       class = PCI_CLASS_NET;
13246 +                       subclass = PCI_NET_ETHER;
13247 +                       core = BCM47XX_ILINE_ID;
13248 +                       break;
13249 +               case SB_ILINE100:
13250 +                       class = PCI_CLASS_NET;
13251 +                       subclass = PCI_NET_ETHER;
13252 +                       core = BCM4610_ILINE_ID;
13253 +                       break;
13254 +               case SB_ENET:
13255 +                       class = PCI_CLASS_NET;
13256 +                       subclass = PCI_NET_ETHER;
13257 +                       core = BCM47XX_ENET_ID;
13258 +                       break;
13259 +               case SB_SDRAM:
13260 +               case SB_MEMC:
13261 +                       class = PCI_CLASS_MEMORY;
13262 +                       subclass = PCI_MEMORY_RAM;
13263 +                       break;
13264 +               case SB_PCI:
13265 +                       class = PCI_CLASS_BRIDGE;
13266 +                       subclass = PCI_BRIDGE_PCI;
13267 +                       break;
13268 +               case SB_MIPS:
13269 +               case SB_MIPS33:
13270 +                       class = PCI_CLASS_CPU;
13271 +                       subclass = PCI_CPU_MIPS;
13272 +                       break;
13273 +               case SB_CODEC:
13274 +                       class = PCI_CLASS_COMM;
13275 +                       subclass = PCI_COMM_MODEM;
13276 +                       core = BCM47XX_V90_ID;
13277 +                       break;
13278 +               case SB_USB:
13279 +                       class = PCI_CLASS_SERIAL;
13280 +                       subclass = PCI_SERIAL_USB;
13281 +                       progif = 0x10; /* OHCI */
13282 +                       core = BCM47XX_USB_ID;
13283 +                       break;
13284 +               case SB_USB11H:
13285 +                       class = PCI_CLASS_SERIAL;
13286 +                       subclass = PCI_SERIAL_USB;
13287 +                       progif = 0x10; /* OHCI */
13288 +                       core = BCM47XX_USBH_ID;
13289 +                       break;
13290 +               case SB_USB11D:
13291 +                       class = PCI_CLASS_SERIAL;
13292 +                       subclass = PCI_SERIAL_USB;
13293 +                       core = BCM47XX_USBD_ID;
13294 +                       break;
13295 +               case SB_IPSEC:
13296 +                       class = PCI_CLASS_CRYPT;
13297 +                       subclass = PCI_CRYPT_NETWORK;
13298 +                       core = BCM47XX_IPSEC_ID;
13299 +                       break;
13300 +               case SB_ROBO:
13301 +                       class = PCI_CLASS_NET;
13302 +                       subclass = PCI_NET_OTHER;
13303 +                       core = BCM47XX_ROBO_ID;
13304 +                       break;
13305 +               case SB_EXTIF:
13306 +               case SB_CC:
13307 +                       class = PCI_CLASS_MEMORY;
13308 +                       subclass = PCI_MEMORY_FLASH;
13309 +                       break;
13310 +               case SB_D11:
13311 +                       class = PCI_CLASS_NET;
13312 +                       subclass = PCI_NET_OTHER;
13313 +                       /* Let an nvram variable override this */
13314 +                       sprintf(varname, "wl%did", wlidx);
13315 +                       wlidx++;
13316 +                       if ((core = getintvar(NULL, varname)) == 0) {
13317 +                               if (chip == BCM4712_DEVICE_ID) {
13318 +                                       if (chippkg == BCM4712SMALL_PKG_ID)
13319 +                                               core = BCM4306_D11G_ID;
13320 +                                       else
13321 +                                               core = BCM4306_D11DUAL_ID;
13322 +                               } else {
13323 +                                       /* 4310 */
13324 +                                       core = BCM4310_D11B_ID;
13325 +                               }
13326 +                       }
13327 +                       break;
13328 +
13329 +               default:
13330 +                       class = subclass = progif = 0xff;
13331 +                       break;
13332 +               }
13333 +
13334 +               /* Supported translations */
13335 +               cfg->vendor = htol16(vendor);
13336 +               cfg->device = htol16(core);
13337 +               cfg->rev_id = chiprev;
13338 +               cfg->prog_if = progif;
13339 +               cfg->sub_class = subclass;
13340 +               cfg->base_class = class;
13341 +               cfg->base[0] = htol32(sb_base(R_REG(&sb->sbadmatch0)));
13342 +               cfg->base[1] = htol32(sb_base(R_REG(&sb->sbadmatch1)));
13343 +               cfg->base[2] = htol32(sb_base(R_REG(&sb->sbadmatch2)));
13344 +               cfg->base[3] = htol32(sb_base(R_REG(&sb->sbadmatch3)));
13345 +               cfg->base[4] = 0;
13346 +               cfg->base[5] = 0;
13347 +               if (class == PCI_CLASS_BRIDGE && subclass == PCI_BRIDGE_PCI)
13348 +                       cfg->header_type = PCI_HEADER_BRIDGE;
13349 +               else
13350 +                       cfg->header_type = PCI_HEADER_NORMAL;
13351 +               /* Save core interrupt flag */
13352 +               cfg->int_pin = R_REG(&sb->sbtpsflag) & SBTPS_NUM0_MASK;
13353 +               /* Default to MIPS shared interrupt 0 */
13354 +               cfg->int_line = 0;
13355 +               /* MIPS sbipsflag maps core interrupt flags to interrupts 1 through 4 */
13356 +               if ((regs = sb_setcore(sbh, SB_MIPS, 0)) ||
13357 +                   (regs = sb_setcore(sbh, SB_MIPS33, 0))) {
13358 +                       sb = (sbconfig_t *)((ulong) regs + SBCONFIGOFF);
13359 +                       val = R_REG(&sb->sbipsflag);
13360 +                       for (cfg->int_line = 1; cfg->int_line <= 4; cfg->int_line++) {
13361 +                               if (((val & sbips_int_mask[cfg->int_line]) >> sbips_int_shift[cfg->int_line]) == cfg->int_pin)
13362 +                                       break;
13363 +                       }
13364 +                       if (cfg->int_line > 4)
13365 +                               cfg->int_line = 0;
13366 +               }
13367 +               /* Emulated core */
13368 +               *((uint32 *) &cfg->sprom_control) = 0xffffffff;
13369 +       }
13370 +
13371 +       sb_setcoreidx(sbh, coreidx);
13372 +       return 0;
13373 +}
13374 +
13375 +int __init
13376 +sbpci_init(sb_t *sbh)
13377 +{
13378 +       sbpci_init_pci(sbh);
13379 +       sbpci_init_cores(sbh);
13380 +       return 0;
13381 +}
13382 +
13383 +void
13384 +sbpci_check(sb_t *sbh)
13385 +{
13386 +       uint coreidx;
13387 +       sbpciregs_t *pci;
13388 +       uint32 sbtopci1;
13389 +       uint32 buf[64], *ptr, i;
13390 +       ulong pa;
13391 +       volatile uint j;
13392 +
13393 +       coreidx = sb_coreidx(sbh);
13394 +       pci = (sbpciregs_t *) sb_setcore(sbh, SB_PCI, 0);
13395 +
13396 +       /* Clear the test array */
13397 +       pa = (ulong) DMA_MAP(NULL, buf, sizeof(buf), DMA_RX, NULL);
13398 +       ptr = (uint32 *) OSL_UNCACHED(&buf[0]);
13399 +       memset(ptr, 0, sizeof(buf));
13400 +
13401 +       /* Point PCI window 1 to memory */
13402 +       sbtopci1 = R_REG(&pci->sbtopci1);
13403 +       W_REG(&pci->sbtopci1, SBTOPCI_MEM | (pa & SBTOPCI1_MASK));
13404 +
13405 +       /* Fill the test array via PCI window 1 */
13406 +       ptr = (uint32 *) REG_MAP(SB_PCI_CFG + (pa & ~SBTOPCI1_MASK), sizeof(buf));
13407 +       for (i = 0; i < ARRAYSIZE(buf); i++) {
13408 +               for (j = 0; j < 2; j++);
13409 +               W_REG(&ptr[i], i);
13410 +       }
13411 +       REG_UNMAP(ptr);
13412 +
13413 +       /* Restore PCI window 1 */
13414 +       W_REG(&pci->sbtopci1, sbtopci1);
13415 +
13416 +       /* Check the test array */
13417 +       DMA_UNMAP(NULL, pa, sizeof(buf), DMA_RX, NULL);
13418 +       ptr = (uint32 *) OSL_UNCACHED(&buf[0]);
13419 +       for (i = 0; i < ARRAYSIZE(buf); i++) {
13420 +               if (ptr[i] != i)
13421 +                       break;
13422 +       }
13423 +
13424 +       /* Change the clock if the test fails */
13425 +       if (i < ARRAYSIZE(buf)) {
13426 +               uint32 req, cur;
13427 +
13428 +               cur = sb_clock(sbh);
13429 +               printf("PCI: Test failed at %d MHz\n", (cur + 500000) / 1000000);
13430 +               for (req = 104000000; req < 176000000; req += 4000000) {
13431 +                       printf("PCI: Resetting to %d MHz\n", (req + 500000) / 1000000);
13432 +                       /* This will only reset if the clocks are valid and have changed */
13433 +                       sb_mips_setclock(sbh, req, 0, 0);
13434 +               }
13435 +               /* Should not reach here */
13436 +               ASSERT(0);
13437 +       }
13438 +
13439 +       sb_setcoreidx(sbh, coreidx);
13440 +}
13441 +
13442 diff -Nur linux-2.4.32/arch/mips/bcm947xx/setup.c linux-2.4.32-brcm/arch/mips/bcm947xx/setup.c
13443 --- linux-2.4.32/arch/mips/bcm947xx/setup.c     1970-01-01 01:00:00.000000000 +0100
13444 +++ linux-2.4.32-brcm/arch/mips/bcm947xx/setup.c        2005-12-20 00:29:40.187416500 +0100
13445 @@ -0,0 +1,232 @@
13446 +/*
13447 + *  Generic setup routines for Broadcom MIPS boards
13448 + *
13449 + *  Copyright (C) 2005 Felix Fietkau <nbd@openwrt.org>
13450 + *
13451 + *  This program is free software; you can redistribute  it and/or modify it
13452 + *  under  the terms of  the GNU General  Public License as published by the
13453 + *  Free Software Foundation;  either version 2 of the  License, or (at your
13454 + *  option) any later version.
13455 + *
13456 + *  THIS  SOFTWARE  IS PROVIDED   ``AS  IS'' AND   ANY  EXPRESS OR IMPLIED
13457 + *  WARRANTIES,   INCLUDING, BUT NOT  LIMITED  TO, THE IMPLIED WARRANTIES OF
13458 + *  MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN
13459 + *  NO  EVENT  SHALL   THE AUTHOR  BE    LIABLE FOR ANY   DIRECT, INDIRECT,
13460 + *  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
13461 + *  NOT LIMITED   TO, PROCUREMENT OF  SUBSTITUTE GOODS  OR SERVICES; LOSS OF
13462 + *  USE, DATA,  OR PROFITS; OR  BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
13463 + *  ANY THEORY OF LIABILITY, WHETHER IN  CONTRACT, STRICT LIABILITY, OR TORT
13464 + *  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
13465 + *  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
13466 + *
13467 + *  You should have received a copy of the  GNU General Public License along
13468 + *  with this program; if not, write  to the Free Software Foundation, Inc.,
13469 + *  675 Mass Ave, Cambridge, MA 02139, USA.
13470 + *
13471 + *
13472 + * Copyright 2005, Broadcom Corporation
13473 + * All Rights Reserved.
13474 + *
13475 + * THIS SOFTWARE IS OFFERED "AS IS", AND BROADCOM GRANTS NO WARRANTIES OF ANY
13476 + * KIND, EXPRESS OR IMPLIED, BY STATUTE, COMMUNICATION OR OTHERWISE. BROADCOM
13477 + * SPECIFICALLY DISCLAIMS ANY IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS
13478 + * FOR A SPECIFIC PURPOSE OR NONINFRINGEMENT CONCERNING THIS SOFTWARE.
13479 + *
13480 + */
13481 +
13482 +#include <linux/config.h>
13483 +#include <linux/init.h>
13484 +#include <linux/kernel.h>
13485 +#include <linux/serialP.h>
13486 +#include <linux/ide.h>
13487 +#include <asm/bootinfo.h>
13488 +#include <asm/cpu.h>
13489 +#include <asm/time.h>
13490 +#include <asm/reboot.h>
13491 +
13492 +#include <typedefs.h>
13493 +#include <osl.h>
13494 +#include <sbutils.h>
13495 +#include <bcmutils.h>
13496 +#include <bcmnvram.h>
13497 +#include <sbmips.h>
13498 +#include <trxhdr.h>
13499 +
13500 +/* Global SB handle */
13501 +sb_t *bcm947xx_sbh = NULL;
13502 +spinlock_t bcm947xx_sbh_lock = SPIN_LOCK_UNLOCKED;
13503 +
13504 +/* Convenience */
13505 +#define sbh bcm947xx_sbh
13506 +#define sbh_lock bcm947xx_sbh_lock
13507 +
13508 +extern void bcm947xx_time_init(void);
13509 +extern void bcm947xx_timer_setup(struct irqaction *irq);
13510 +
13511 +#ifdef CONFIG_REMOTE_DEBUG
13512 +extern void set_debug_traps(void);
13513 +extern void rs_kgdb_hook(struct serial_state *);
13514 +extern void breakpoint(void);
13515 +#endif
13516 +
13517 +#if defined(CONFIG_BLK_DEV_IDE) || defined(CONFIG_BLK_DEV_IDE_MODULE)
13518 +extern struct ide_ops std_ide_ops;
13519 +#endif
13520 +
13521 +/* Kernel command line */
13522 +char arcs_cmdline[CL_SIZE] __initdata = CONFIG_CMDLINE;
13523 +
13524 +void
13525 +bcm947xx_machine_restart(char *command)
13526 +{
13527 +       printk("Please stand by while rebooting the system...\n");
13528 +
13529 +       /* Set the watchdog timer to reset immediately */
13530 +       __cli();
13531 +       sb_watchdog(sbh, 1);
13532 +       while (1);
13533 +}
13534 +
13535 +void
13536 +bcm947xx_machine_halt(void)
13537 +{
13538 +       printk("System halted\n");
13539 +
13540 +       /* Disable interrupts and watchdog and spin forever */
13541 +       __cli();
13542 +       sb_watchdog(sbh, 0);
13543 +       while (1);
13544 +}
13545 +
13546 +#ifdef CONFIG_SERIAL
13547 +
13548 +static int ser_line = 0;
13549 +
13550 +typedef struct {
13551 +        void *regs;
13552 +        uint irq;
13553 +        uint baud_base;
13554 +        uint reg_shift;
13555 +} serial_port;
13556 +
13557 +static serial_port ports[4];
13558 +static int num_ports = 0;
13559 +
13560 +static void
13561 +serial_add(void *regs, uint irq, uint baud_base, uint reg_shift)
13562 +{
13563 +        ports[num_ports].regs = regs;
13564 +        ports[num_ports].irq = irq;
13565 +        ports[num_ports].baud_base = baud_base;
13566 +        ports[num_ports].reg_shift = reg_shift;
13567 +        num_ports++;
13568 +}
13569 +
13570 +static void
13571 +do_serial_add(serial_port *port)
13572 +{
13573 +        void *regs;
13574 +        uint irq;
13575 +        uint baud_base;
13576 +        uint reg_shift;
13577 +        struct serial_struct s;
13578 +
13579 +        regs = port->regs;
13580 +        irq = port->irq;
13581 +        baud_base = port->baud_base;
13582 +        reg_shift = port->reg_shift;
13583 +
13584 +        memset(&s, 0, sizeof(s));
13585 +
13586 +        s.line = ser_line++;
13587 +        s.iomem_base = regs;
13588 +        s.irq = irq + 2;
13589 +        s.baud_base = baud_base / 16;
13590 +        s.flags = ASYNC_BOOT_AUTOCONF;
13591 +        s.io_type = SERIAL_IO_MEM;
13592 +        s.iomem_reg_shift = reg_shift;
13593 +
13594 +        if (early_serial_setup(&s) != 0) {
13595 +                printk(KERN_ERR "Serial setup failed!\n");
13596 +        }
13597 +}
13598 +
13599 +#endif /* CONFIG_SERIAL */
13600 +
13601 +void __init
13602 +brcm_setup(void)
13603 +{
13604 +       char *s;
13605 +       int i;
13606 +       char *value;
13607 +
13608 +       /* Get global SB handle */
13609 +       sbh = sb_kattach();
13610 +
13611 +       /* Initialize clocks and interrupts */
13612 +       sb_mips_init(sbh);
13613 +
13614 +       if (BCM330X(current_cpu_data.processor_id) &&
13615 +               (read_c0_diag() & BRCM_PFC_AVAIL)) {
13616 +               /*
13617 +                * Now that the sbh is inited set the  proper PFC value
13618 +                */
13619 +               printk("Setting the PFC to its default value\n");
13620 +               enable_pfc(PFC_AUTO);
13621 +       }
13622 +
13623 +
13624 +#ifdef CONFIG_SERIAL
13625 +       sb_serial_init(sbh, serial_add);
13626 +
13627 +       /* reverse serial ports if nvram variable starts with console=ttyS1 */
13628 +       /* Initialize UARTs */
13629 +       s = nvram_get("kernel_args");
13630 +       if (!s) s = "";
13631 +       if (!strncmp(s, "console=ttyS1", 13)) {
13632 +               for (i = num_ports; i; i--)
13633 +                       do_serial_add(&ports[i - 1]);
13634 +       } else {
13635 +               for (i = 0; i < num_ports; i++)
13636 +                       do_serial_add(&ports[i]);
13637 +       }
13638 +#endif
13639 +
13640 +#if defined(CONFIG_BLK_DEV_IDE) || defined(CONFIG_BLK_DEV_IDE_MODULE)
13641 +       ide_ops = &std_ide_ops;
13642 +#endif
13643 +
13644 +       /* Override default command line arguments */
13645 +       value = nvram_get("kernel_cmdline");
13646 +       if (value && strlen(value) && strncmp(value, "empty", 5))
13647 +               strncpy(arcs_cmdline, value, sizeof(arcs_cmdline));
13648 +
13649 +
13650 +       /* Generic setup */
13651 +       _machine_restart = bcm947xx_machine_restart;
13652 +       _machine_halt = bcm947xx_machine_halt;
13653 +       _machine_power_off = bcm947xx_machine_halt;
13654 +
13655 +       board_time_init = bcm947xx_time_init;
13656 +       board_timer_setup = bcm947xx_timer_setup;
13657 +}
13658 +
13659 +const char *
13660 +get_system_type(void)
13661 +{
13662 +       static char s[32];
13663 +
13664 +       if (bcm947xx_sbh) {
13665 +               sprintf(s, "Broadcom BCM%X chip rev %d", sb_chip(bcm947xx_sbh),
13666 +                       sb_chiprev(bcm947xx_sbh));
13667 +               return s;
13668 +       }
13669 +       else
13670 +               return "Broadcom BCM947XX";
13671 +}
13672 +
13673 +void __init
13674 +bus_error_init(void)
13675 +{
13676 +}
13677 +
13678 diff -Nur linux-2.4.32/arch/mips/bcm947xx/sflash.c linux-2.4.32-brcm/arch/mips/bcm947xx/sflash.c
13679 --- linux-2.4.32/arch/mips/bcm947xx/sflash.c    1970-01-01 01:00:00.000000000 +0100
13680 +++ linux-2.4.32-brcm/arch/mips/bcm947xx/sflash.c       2005-12-16 23:39:10.948837000 +0100
13681 @@ -0,0 +1,418 @@
13682 +/*
13683 + * Broadcom SiliconBackplane chipcommon serial flash interface
13684 + *
13685 + * Copyright 2005, Broadcom Corporation
13686 + * All Rights Reserved.
13687 + *
13688 + * THIS SOFTWARE IS OFFERED "AS IS", AND BROADCOM GRANTS NO WARRANTIES OF ANY
13689 + * KIND, EXPRESS OR IMPLIED, BY STATUTE, COMMUNICATION OR OTHERWISE. BROADCOM
13690 + * SPECIFICALLY DISCLAIMS ANY IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS
13691 + * FOR A SPECIFIC PURPOSE OR NONINFRINGEMENT CONCERNING THIS SOFTWARE.
13692 + *
13693 + * $Id$
13694 + */
13695 +
13696 +#include <osl.h>
13697 +#include <typedefs.h>
13698 +#include <sbconfig.h>
13699 +#include <sbchipc.h>
13700 +#include <mipsinc.h>
13701 +#include <bcmutils.h>
13702 +#include <bcmdevs.h>
13703 +#include <sflash.h>
13704 +
13705 +/* Private global state */
13706 +static struct sflash sflash;
13707 +
13708 +/* Issue a serial flash command */
13709 +static INLINE void
13710 +sflash_cmd(chipcregs_t *cc, uint opcode)
13711 +{
13712 +       W_REG(&cc->flashcontrol, SFLASH_START | opcode);
13713 +       while (R_REG(&cc->flashcontrol) & SFLASH_BUSY);
13714 +}
13715 +
13716 +/* Initialize serial flash access */
13717 +struct sflash *
13718 +sflash_init(chipcregs_t *cc)
13719 +{
13720 +       uint32 id, id2;
13721 +
13722 +       bzero(&sflash, sizeof(sflash));
13723 +
13724 +       sflash.type = R_REG(&cc->capabilities) & CAP_FLASH_MASK;
13725 +
13726 +       switch (sflash.type) {
13727 +       case SFLASH_ST:
13728 +               /* Probe for ST chips */
13729 +               sflash_cmd(cc, SFLASH_ST_DP);
13730 +               sflash_cmd(cc, SFLASH_ST_RES);
13731 +               id = R_REG(&cc->flashdata);
13732 +               switch (id) {
13733 +               case 0x11:
13734 +                       /* ST M25P20 2 Mbit Serial Flash */
13735 +                       sflash.blocksize = 64 * 1024;
13736 +                       sflash.numblocks = 4;
13737 +                       break;
13738 +               case 0x12:
13739 +                       /* ST M25P40 4 Mbit Serial Flash */
13740 +                       sflash.blocksize = 64 * 1024;
13741 +                       sflash.numblocks = 8;
13742 +                       break;
13743 +               case 0x13:
13744 +                       /* ST M25P80 8 Mbit Serial Flash */
13745 +                       sflash.blocksize = 64 * 1024;
13746 +                       sflash.numblocks = 16;
13747 +                       break;
13748 +               case 0x14:
13749 +                       /* ST M25P16 16 Mbit Serial Flash */
13750 +                       sflash.blocksize = 64 * 1024;
13751 +                       sflash.numblocks = 32;
13752 +                       break;
13753 +               case 0x15:
13754 +                       /* ST M25P32 32 Mbit Serial Flash */
13755 +                       sflash.blocksize = 64 * 1024;
13756 +                       sflash.numblocks = 64;
13757 +                       break;
13758 +               case 0xbf:
13759 +                       W_REG(&cc->flashaddress, 1);
13760 +                       sflash_cmd(cc, SFLASH_ST_RES);
13761 +                       id2 = R_REG(&cc->flashdata);
13762 +                       if (id2 == 0x44) {
13763 +                               /* SST M25VF80 4 Mbit Serial Flash */
13764 +                               sflash.blocksize = 64 * 1024;
13765 +                               sflash.numblocks = 8;
13766 +                       }
13767 +                       break;
13768 +               }
13769 +               break;
13770 +
13771 +       case SFLASH_AT:
13772 +               /* Probe for Atmel chips */
13773 +               sflash_cmd(cc, SFLASH_AT_STATUS);
13774 +               id = R_REG(&cc->flashdata) & 0x3c;
13775 +               switch (id) {
13776 +               case 0xc:
13777 +                       /* Atmel AT45DB011 1Mbit Serial Flash */
13778 +                       sflash.blocksize = 256;
13779 +                       sflash.numblocks = 512;
13780 +                       break;
13781 +               case 0x14:
13782 +                       /* Atmel AT45DB021 2Mbit Serial Flash */
13783 +                       sflash.blocksize = 256;
13784 +                       sflash.numblocks = 1024;
13785 +                       break;
13786 +               case 0x1c:
13787 +                       /* Atmel AT45DB041 4Mbit Serial Flash */
13788 +                       sflash.blocksize = 256;
13789 +                       sflash.numblocks = 2048;
13790 +                       break;
13791 +               case 0x24:
13792 +                       /* Atmel AT45DB081 8Mbit Serial Flash */
13793 +                       sflash.blocksize = 256;
13794 +                       sflash.numblocks = 4096;
13795 +                       break;
13796 +               case 0x2c:
13797 +                       /* Atmel AT45DB161 16Mbit Serial Flash */
13798 +                       sflash.blocksize = 512;
13799 +                       sflash.numblocks = 4096;
13800 +                       break;
13801 +               case 0x34:
13802 +                       /* Atmel AT45DB321 32Mbit Serial Flash */
13803 +                       sflash.blocksize = 512;
13804 +                       sflash.numblocks = 8192;
13805 +                       break;
13806 +               case 0x3c:
13807 +                       /* Atmel AT45DB642 64Mbit Serial Flash */
13808 +                       sflash.blocksize = 1024;
13809 +                       sflash.numblocks = 8192;
13810 +                       break;
13811 +               }
13812 +               break;
13813 +       }
13814 +
13815 +       sflash.size = sflash.blocksize * sflash.numblocks;
13816 +       return sflash.size ? &sflash : NULL;
13817 +}
13818 +
13819 +/* Read len bytes starting at offset into buf. Returns number of bytes read. */
13820 +int
13821 +sflash_read(chipcregs_t *cc, uint offset, uint len, uchar *buf)
13822 +{
13823 +       int cnt;
13824 +       uint32 *from, *to;
13825 +
13826 +       if (!len)
13827 +               return 0;
13828 +
13829 +       if ((offset + len) > sflash.size)
13830 +               return -22;
13831 +
13832 +       if ((len >= 4) && (offset & 3))
13833 +               cnt = 4 - (offset & 3);
13834 +       else if ((len >= 4) && ((uint32)buf & 3))
13835 +               cnt = 4 - ((uint32)buf & 3);
13836 +       else
13837 +               cnt = len;
13838 +
13839 +       from = (uint32 *)KSEG1ADDR(SB_FLASH2 + offset);
13840 +       to = (uint32 *)buf;
13841 +
13842 +       if (cnt < 4) {
13843 +               bcopy(from, to, cnt);
13844 +               return cnt;
13845 +       }
13846 +
13847 +       while (cnt >= 4) {
13848 +               *to++ = *from++;
13849 +               cnt -= 4;
13850 +       }
13851 +
13852 +       return (len - cnt);
13853 +}
13854 +
13855 +/* Poll for command completion. Returns zero when complete. */
13856 +int
13857 +sflash_poll(chipcregs_t *cc, uint offset)
13858 +{
13859 +       if (offset >= sflash.size)
13860 +               return -22;
13861 +
13862 +       switch (sflash.type) {
13863 +       case SFLASH_ST:
13864 +               /* Check for ST Write In Progress bit */
13865 +               sflash_cmd(cc, SFLASH_ST_RDSR);
13866 +               return R_REG(&cc->flashdata) & SFLASH_ST_WIP;
13867 +       case SFLASH_AT:
13868 +               /* Check for Atmel Ready bit */
13869 +               sflash_cmd(cc, SFLASH_AT_STATUS);
13870 +               return !(R_REG(&cc->flashdata) & SFLASH_AT_READY);
13871 +       }
13872 +
13873 +       return 0;
13874 +}
13875 +
13876 +/* Write len bytes starting at offset into buf. Returns number of bytes
13877 + * written. Caller should poll for completion.
13878 + */
13879 +int
13880 +sflash_write(chipcregs_t *cc, uint offset, uint len, const uchar *buf)
13881 +{
13882 +       struct sflash *sfl;
13883 +       int ret = 0;
13884 +       bool is4712b0;
13885 +       uint32 page, byte, mask;
13886 +
13887 +       if (!len)
13888 +               return 0;
13889 +
13890 +       if ((offset + len) > sflash.size)
13891 +               return -22;
13892 +
13893 +       sfl = &sflash;
13894 +       switch (sfl->type) {
13895 +       case SFLASH_ST:
13896 +               mask = R_REG(&cc->chipid);
13897 +               is4712b0 = (((mask & CID_ID_MASK) == BCM4712_DEVICE_ID) &&
13898 +                           ((mask & CID_REV_MASK) == (3 << CID_REV_SHIFT)));
13899 +               /* Enable writes */
13900 +               sflash_cmd(cc, SFLASH_ST_WREN);
13901 +               if (is4712b0) {
13902 +                       mask = 1 << 14;
13903 +                       W_REG(&cc->flashaddress, offset);
13904 +                       W_REG(&cc->flashdata, *buf++);
13905 +                       /* Set chip select */
13906 +                       OR_REG(&cc->gpioout, mask);
13907 +                       /* Issue a page program with the first byte */
13908 +                       sflash_cmd(cc, SFLASH_ST_PP);
13909 +                       ret = 1;
13910 +                       offset++;
13911 +                       len--;
13912 +                       while (len > 0) {
13913 +                               if ((offset & 255) == 0) {
13914 +                                       /* Page boundary, drop cs and return */
13915 +                                       AND_REG(&cc->gpioout, ~mask);
13916 +                                       if (!sflash_poll(cc, offset)) {
13917 +                                               /* Flash rejected command */
13918 +                                               return -11;
13919 +                                       }
13920 +                                       return ret;
13921 +                               } else {
13922 +                                       /* Write single byte */
13923 +                                       sflash_cmd(cc, *buf++);
13924 +                               }
13925 +                               ret++;
13926 +                               offset++;
13927 +                               len--;
13928 +                       }
13929 +                       /* All done, drop cs if needed */
13930 +                       if ((offset & 255) != 1) {
13931 +                               /* Drop cs */
13932 +                               AND_REG(&cc->gpioout, ~mask);
13933 +                               if (!sflash_poll(cc, offset)) {
13934 +                                       /* Flash rejected command */
13935 +                                       return -12;
13936 +                               }
13937 +                       }
13938 +               } else {
13939 +                       ret = 1;
13940 +                       W_REG(&cc->flashaddress, offset);
13941 +                       W_REG(&cc->flashdata, *buf);
13942 +                       /* Page program */
13943 +                       sflash_cmd(cc, SFLASH_ST_PP);
13944 +               }
13945 +               break;
13946 +       case SFLASH_AT:
13947 +               mask = sfl->blocksize - 1;
13948 +               page = (offset & ~mask) << 1;
13949 +               byte = offset & mask;
13950 +               /* Read main memory page into buffer 1 */
13951 +               if (byte || len < sfl->blocksize) {
13952 +                       W_REG(&cc->flashaddress, page);
13953 +                       sflash_cmd(cc, SFLASH_AT_BUF1_LOAD);
13954 +                       /* 250 us for AT45DB321B */
13955 +                       SPINWAIT(sflash_poll(cc, offset), 1000);
13956 +                       ASSERT(!sflash_poll(cc, offset));
13957 +               }
13958 +               /* Write into buffer 1 */
13959 +               for (ret = 0; ret < len && byte < sfl->blocksize; ret++) {
13960 +                       W_REG(&cc->flashaddress, byte++);
13961 +                       W_REG(&cc->flashdata, *buf++);
13962 +                       sflash_cmd(cc, SFLASH_AT_BUF1_WRITE);
13963 +               }
13964 +               /* Write buffer 1 into main memory page */
13965 +               W_REG(&cc->flashaddress, page);
13966 +               sflash_cmd(cc, SFLASH_AT_BUF1_PROGRAM);
13967 +               break;
13968 +       }
13969 +
13970 +       return ret;
13971 +}
13972 +
13973 +/* Erase a region. Returns number of bytes scheduled for erasure.
13974 + * Caller should poll for completion.
13975 + */
13976 +int
13977 +sflash_erase(chipcregs_t *cc, uint offset)
13978 +{
13979 +       struct sflash *sfl;
13980 +
13981 +       if (offset >= sflash.size)
13982 +               return -22;
13983 +
13984 +       sfl = &sflash;
13985 +       switch (sfl->type) {
13986 +       case SFLASH_ST:
13987 +               sflash_cmd(cc, SFLASH_ST_WREN);
13988 +               W_REG(&cc->flashaddress, offset);
13989 +               sflash_cmd(cc, SFLASH_ST_SE);
13990 +               return sfl->blocksize;
13991 +       case SFLASH_AT:
13992 +               W_REG(&cc->flashaddress, offset << 1);
13993 +               sflash_cmd(cc, SFLASH_AT_PAGE_ERASE);
13994 +               return sfl->blocksize;
13995 +       }
13996 +
13997 +       return 0;
13998 +}
13999 +
14000 +/*
14001 + * writes the appropriate range of flash, a NULL buf simply erases
14002 + * the region of flash
14003 + */
14004 +int
14005 +sflash_commit(chipcregs_t *cc, uint offset, uint len, const uchar *buf)
14006 +{
14007 +       struct sflash *sfl;
14008 +       uchar *block = NULL, *cur_ptr, *blk_ptr;
14009 +       uint blocksize = 0, mask, cur_offset, cur_length, cur_retlen, remainder;
14010 +       uint blk_offset, blk_len, copied;
14011 +       int bytes, ret = 0;
14012 +
14013 +       /* Check address range */
14014 +       if (len <= 0)
14015 +               return 0;
14016 +
14017 +       sfl = &sflash;
14018 +       if ((offset + len) > sfl->size)
14019 +               return -1;
14020 +
14021 +       blocksize = sfl->blocksize;
14022 +       mask = blocksize - 1;
14023 +
14024 +       /* Allocate a block of mem */
14025 +       if (!(block = MALLOC(NULL, blocksize)))
14026 +               return -1;
14027 +
14028 +       while (len) {
14029 +               /* Align offset */
14030 +               cur_offset = offset & ~mask;
14031 +               cur_length = blocksize;
14032 +               cur_ptr = block;
14033 +
14034 +               remainder = blocksize - (offset & mask);
14035 +               if (len < remainder)
14036 +                       cur_retlen = len;
14037 +               else
14038 +                       cur_retlen = remainder;
14039 +
14040 +               /* buf == NULL means erase only */
14041 +               if (buf) {
14042 +                       /* Copy existing data into holding block if necessary */
14043 +                       if ((offset & mask)  || (len < blocksize)) {
14044 +                               blk_offset = cur_offset;
14045 +                               blk_len = cur_length;
14046 +                               blk_ptr = cur_ptr;
14047 +
14048 +                               /* Copy entire block */
14049 +                               while(blk_len) {
14050 +                                       copied = sflash_read(cc, blk_offset, blk_len, blk_ptr);
14051 +                                       blk_offset += copied;
14052 +                                       blk_len -= copied;
14053 +                                       blk_ptr += copied;
14054 +                               }
14055 +                       }
14056 +
14057 +                       /* Copy input data into holding block */
14058 +                       memcpy(cur_ptr + (offset & mask), buf, cur_retlen);
14059 +               }
14060 +
14061 +               /* Erase block */
14062 +               if ((ret = sflash_erase(cc, (uint) cur_offset)) < 0)
14063 +                       goto done;
14064 +               while (sflash_poll(cc, (uint) cur_offset));
14065 +
14066 +               /* buf == NULL means erase only */
14067 +               if (!buf) {
14068 +                       offset += cur_retlen;
14069 +                       len -= cur_retlen;
14070 +                       continue;
14071 +               }
14072 +
14073 +               /* Write holding block */
14074 +               while (cur_length > 0) {
14075 +                       if ((bytes = sflash_write(cc,
14076 +                                                 (uint) cur_offset,
14077 +                                                 (uint) cur_length,
14078 +                                                 (uchar *) cur_ptr)) < 0) {
14079 +                               ret = bytes;
14080 +                               goto done;
14081 +                       }
14082 +                       while (sflash_poll(cc, (uint) cur_offset));
14083 +                       cur_offset += bytes;
14084 +                       cur_length -= bytes;
14085 +                       cur_ptr += bytes;
14086 +               }
14087 +
14088 +               offset += cur_retlen;
14089 +               len -= cur_retlen;
14090 +               buf += cur_retlen;
14091 +       }
14092 +
14093 +       ret = len;
14094 +done:
14095 +       if (block)
14096 +               MFREE(NULL, block, blocksize);
14097 +       return ret;
14098 +}
14099 +
14100 diff -Nur linux-2.4.32/arch/mips/bcm947xx/time.c linux-2.4.32-brcm/arch/mips/bcm947xx/time.c
14101 --- linux-2.4.32/arch/mips/bcm947xx/time.c      1970-01-01 01:00:00.000000000 +0100
14102 +++ linux-2.4.32-brcm/arch/mips/bcm947xx/time.c 2005-12-16 23:39:10.948837000 +0100
14103 @@ -0,0 +1,118 @@
14104 +/*
14105 + * Copyright 2004, Broadcom Corporation
14106 + * All Rights Reserved.
14107 + *
14108 + * THIS SOFTWARE IS OFFERED "AS IS", AND BROADCOM GRANTS NO WARRANTIES OF ANY
14109 + * KIND, EXPRESS OR IMPLIED, BY STATUTE, COMMUNICATION OR OTHERWISE. BROADCOM
14110 + * SPECIFICALLY DISCLAIMS ANY IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS
14111 + * FOR A SPECIFIC PURPOSE OR NONINFRINGEMENT CONCERNING THIS SOFTWARE.
14112 + *
14113 + * $Id: time.c,v 1.1 2005/03/16 13:49:59 wbx Exp $
14114 + */
14115 +#include <linux/config.h>
14116 +#include <linux/init.h>
14117 +#include <linux/kernel.h>
14118 +#include <linux/sched.h>
14119 +#include <linux/serial_reg.h>
14120 +#include <linux/interrupt.h>
14121 +#include <asm/addrspace.h>
14122 +#include <asm/io.h>
14123 +#include <asm/time.h>
14124 +
14125 +#include <typedefs.h>
14126 +#include <osl.h>
14127 +#include <sbutils.h>
14128 +#include <bcmnvram.h>
14129 +#include <sbconfig.h>
14130 +#include <sbextif.h>
14131 +#include <sbmips.h>
14132 +
14133 +/* Global SB handle */
14134 +extern void *bcm947xx_sbh;
14135 +extern spinlock_t bcm947xx_sbh_lock;
14136 +
14137 +/* Convenience */
14138 +#define sbh bcm947xx_sbh
14139 +#define sbh_lock bcm947xx_sbh_lock
14140 +
14141 +extern int panic_timeout;
14142 +static int watchdog = 0;
14143 +static u8 *mcr = NULL;
14144 +
14145 +void __init
14146 +bcm947xx_time_init(void)
14147 +{
14148 +       unsigned int hz;
14149 +       extifregs_t *eir;
14150 +
14151 +       /*
14152 +        * Use deterministic values for initial counter interrupt
14153 +        * so that calibrate delay avoids encountering a counter wrap.
14154 +        */
14155 +       write_c0_count(0);
14156 +       write_c0_compare(0xffff);
14157 +
14158 +       if (!(hz = sb_mips_clock(sbh)))
14159 +               hz = 100000000;
14160 +
14161 +       printk("CPU: BCM%04x rev %d at %d MHz\n", sb_chip(sbh), sb_chiprev(sbh),
14162 +              (hz + 500000) / 1000000);
14163 +
14164 +       /* Set MIPS counter frequency for fixed_rate_gettimeoffset() */
14165 +       mips_hpt_frequency = hz / 2;
14166 +
14167 +       /* Set watchdog interval in ms */
14168 +       watchdog = simple_strtoul(nvram_safe_get("watchdog"), NULL, 0);
14169 +
14170 +       /* Please set the watchdog to 3 sec if it is less than 3 but not equal to 0 */
14171 +       if (watchdog > 0) {
14172 +               if (watchdog < 3000)
14173 +                       watchdog = 3000;
14174 +       }
14175 +
14176 +
14177 +       /* Set panic timeout in seconds */
14178 +       panic_timeout = watchdog / 1000;
14179 +
14180 +       /* Setup blink */
14181 +       if ((eir = sb_setcore(sbh, SB_EXTIF, 0))) {
14182 +               sbconfig_t *sb = (sbconfig_t *)((unsigned int) eir + SBCONFIGOFF);
14183 +               unsigned long base = EXTIF_CFGIF_BASE(sb_base(readl(&sb->sbadmatch1)));
14184 +               mcr = (u8 *) ioremap_nocache(base + UART_MCR, 1);
14185 +       }
14186 +}
14187 +
14188 +static void
14189 +bcm947xx_timer_interrupt(int irq, void *dev_id, struct pt_regs *regs)
14190 +{
14191 +       /* Generic MIPS timer code */
14192 +       timer_interrupt(irq, dev_id, regs);
14193 +
14194 +       /* Set the watchdog timer to reset after the specified number of ms */
14195 +       if (watchdog > 0)
14196 +               sb_watchdog(sbh, WATCHDOG_CLOCK / 1000 * watchdog);
14197 +
14198 +#ifdef CONFIG_HWSIM
14199 +       (*((int *)0xa0000f1c))++;
14200 +#else
14201 +       /* Blink one of the LEDs in the external UART */
14202 +       if (mcr && !(jiffies % (HZ/2)))
14203 +               writeb(readb(mcr) ^ UART_MCR_OUT2, mcr);
14204 +#endif
14205 +}
14206 +
14207 +static struct irqaction bcm947xx_timer_irqaction = {
14208 +       bcm947xx_timer_interrupt,
14209 +       SA_INTERRUPT,
14210 +       0,
14211 +       "timer",
14212 +       NULL,
14213 +       NULL
14214 +};
14215 +
14216 +void __init
14217 +bcm947xx_timer_setup(struct irqaction *irq)
14218 +{
14219 +       /* Enable the timer interrupt */
14220 +       setup_irq(7, &bcm947xx_timer_irqaction);
14221 +}
14222 diff -Nur linux-2.4.32/arch/mips/config-shared.in linux-2.4.32-brcm/arch/mips/config-shared.in
14223 --- linux-2.4.32/arch/mips/config-shared.in     2005-01-19 15:09:27.000000000 +0100
14224 +++ linux-2.4.32-brcm/arch/mips/config-shared.in        2005-12-16 23:39:11.080845250 +0100
14225 @@ -205,6 +205,14 @@
14226     fi
14227     define_bool CONFIG_MIPS_RTC y
14228  fi
14229 +dep_bool 'Support for Broadcom MIPS-based boards' CONFIG_MIPS_BRCM $CONFIG_EXPERIMENTAL
14230 +dep_bool 'Support for Broadcom BCM947XX' CONFIG_BCM947XX $CONFIG_MIPS_BRCM
14231 +if [ "$CONFIG_BCM947XX" = "y" ] ; then
14232 +   bool '    Support for Broadcom BCM4710' CONFIG_BCM4710
14233 +   bool '    Support for Broadcom BCM4310' CONFIG_BCM4310
14234 +   bool '    Support for Broadcom BCM4704' CONFIG_BCM4704
14235 +   bool '    Support for Broadcom BCM5365' CONFIG_BCM5365
14236 +fi
14237  bool 'Support for SNI RM200 PCI' CONFIG_SNI_RM200_PCI
14238  bool 'Support for TANBAC TB0226 (Mbase)' CONFIG_TANBAC_TB0226
14239  bool 'Support for TANBAC TB0229 (VR4131DIMM)' CONFIG_TANBAC_TB0229
14240 @@ -226,6 +234,11 @@
14241  define_bool CONFIG_RWSEM_XCHGADD_ALGORITHM n
14242
14243  #
14244 +# Provide an option for a default kernel command line
14245 +#
14246 +string 'Default kernel command string' CONFIG_CMDLINE ""
14247 +
14248 +#
14249  # Select some configuration options automatically based on user selections.
14250  #
14251  if [ "$CONFIG_ACER_PICA_61" = "y" ]; then
14252 @@ -533,6 +546,13 @@
14253     define_bool CONFIG_SWAP_IO_SPACE_L y
14254     define_bool CONFIG_BOOT_ELF32 y
14255  fi
14256 +if [ "$CONFIG_BCM947XX" = "y" ] ; then
14257 +   define_bool CONFIG_PCI y
14258 +   define_bool CONFIG_NONCOHERENT_IO y
14259 +   define_bool CONFIG_NEW_TIME_C y
14260 +   define_bool CONFIG_NEW_IRQ y
14261 +   define_bool CONFIG_HND y
14262 +fi
14263  if [ "$CONFIG_SNI_RM200_PCI" = "y" ]; then
14264     define_bool CONFIG_ARC32 y
14265     define_bool CONFIG_ARC_MEMORY y
14266 @@ -1011,7 +1031,11 @@
14267
14268  bool 'Are you using a crosscompiler' CONFIG_CROSSCOMPILE
14269  bool 'Enable run-time debugging' CONFIG_RUNTIME_DEBUG
14270 -bool 'Remote GDB kernel debugging' CONFIG_KGDB
14271 +if [ "$CONFIG_BCM947XX" = "y" ] ; then
14272 +       bool 'Remote GDB kernel debugging' CONFIG_REMOTE_DEBUG
14273 +else
14274 +       bool 'Remote GDB kernel debugging' CONFIG_KGDB
14275 +fi
14276  dep_bool '  Console output to GDB' CONFIG_GDB_CONSOLE $CONFIG_KGDB
14277  if [ "$CONFIG_KGDB" = "y" ]; then
14278     define_bool CONFIG_DEBUG_INFO y
14279 diff -Nur linux-2.4.32/arch/mips/kernel/cpu-probe.c linux-2.4.32-brcm/arch/mips/kernel/cpu-probe.c
14280 --- linux-2.4.32/arch/mips/kernel/cpu-probe.c   2005-01-19 15:09:29.000000000 +0100
14281 +++ linux-2.4.32-brcm/arch/mips/kernel/cpu-probe.c      2005-12-16 23:39:11.084845500 +0100
14282 @@ -174,7 +174,7 @@
14283
14284  static inline void cpu_probe_legacy(struct cpuinfo_mips *c)
14285  {
14286 -       switch (c->processor_id & 0xff00) {
14287 +       switch (c->processor_id & PRID_IMP_MASK) {
14288         case PRID_IMP_R2000:
14289                 c->cputype = CPU_R2000;
14290                 c->isa_level = MIPS_CPU_ISA_I;
14291 @@ -184,7 +184,7 @@
14292                 c->tlbsize = 64;
14293                 break;
14294         case PRID_IMP_R3000:
14295 -               if ((c->processor_id & 0xff) == PRID_REV_R3000A)
14296 +               if ((c->processor_id & PRID_REV_MASK) == PRID_REV_R3000A)
14297                         if (cpu_has_confreg())
14298                                 c->cputype = CPU_R3081E;
14299                         else
14300 @@ -199,12 +199,12 @@
14301                 break;
14302         case PRID_IMP_R4000:
14303                 if (read_c0_config() & CONF_SC) {
14304 -                       if ((c->processor_id & 0xff) >= PRID_REV_R4400)
14305 +                       if ((c->processor_id & PRID_REV_MASK) >= PRID_REV_R4400)
14306                                 c->cputype = CPU_R4400PC;
14307                         else
14308                                 c->cputype = CPU_R4000PC;
14309                 } else {
14310 -                       if ((c->processor_id & 0xff) >= PRID_REV_R4400)
14311 +                       if ((c->processor_id & PRID_REV_MASK) >= PRID_REV_R4400)
14312                                 c->cputype = CPU_R4400SC;
14313                         else
14314                                 c->cputype = CPU_R4000SC;
14315 @@ -450,7 +450,7 @@
14316  static inline void cpu_probe_mips(struct cpuinfo_mips *c)
14317  {
14318         decode_config1(c);
14319 -       switch (c->processor_id & 0xff00) {
14320 +       switch (c->processor_id & PRID_IMP_MASK) {
14321         case PRID_IMP_4KC:
14322                 c->cputype = CPU_4KC;
14323                 c->isa_level = MIPS_CPU_ISA_M32;
14324 @@ -491,10 +491,10 @@
14325  {
14326         decode_config1(c);
14327         c->options |= MIPS_CPU_PREFETCH;
14328 -       switch (c->processor_id & 0xff00) {
14329 +       switch (c->processor_id & PRID_IMP_MASK) {
14330         case PRID_IMP_AU1_REV1:
14331         case PRID_IMP_AU1_REV2:
14332 -               switch ((c->processor_id >> 24) & 0xff) {
14333 +               switch ((c->processor_id >> 24) & PRID_REV_MASK) {
14334                 case 0:
14335                         c->cputype = CPU_AU1000;
14336                         break;
14337 @@ -522,10 +522,34 @@
14338         }
14339  }
14340
14341 +static inline void cpu_probe_broadcom(struct cpuinfo_mips *c)
14342 +{
14343 +       decode_config1(c);
14344 +       c->options |= MIPS_CPU_PREFETCH;
14345 +       switch (c->processor_id & PRID_IMP_MASK) {
14346 +       case PRID_IMP_BCM4710:
14347 +                       c->cputype = CPU_BCM4710;
14348 +                       c->options = MIPS_CPU_TLB | MIPS_CPU_4KEX |
14349 +                                                               MIPS_CPU_4KTLB | MIPS_CPU_COUNTER;
14350 +                       c->scache.flags = MIPS_CACHE_NOT_PRESENT;
14351 +                       break;
14352 +       case PRID_IMP_4KC:
14353 +       case PRID_IMP_BCM3302:
14354 +                       c->cputype = CPU_BCM3302;
14355 +                       c->options = MIPS_CPU_TLB | MIPS_CPU_4KEX |
14356 +                                                               MIPS_CPU_4KTLB | MIPS_CPU_COUNTER;
14357 +                       c->scache.flags = MIPS_CACHE_NOT_PRESENT;
14358 +                       break;
14359 +       default:
14360 +                       c->cputype = CPU_UNKNOWN;
14361 +                       break;
14362 +       }
14363 +}
14364 +
14365  static inline void cpu_probe_sibyte(struct cpuinfo_mips *c)
14366  {
14367         decode_config1(c);
14368 -       switch (c->processor_id & 0xff00) {
14369 +       switch (c->processor_id & PRID_IMP_MASK) {
14370         case PRID_IMP_SB1:
14371                 c->cputype = CPU_SB1;
14372                 c->isa_level = MIPS_CPU_ISA_M64;
14373 @@ -547,7 +571,7 @@
14374  static inline void cpu_probe_sandcraft(struct cpuinfo_mips *c)
14375  {
14376         decode_config1(c);
14377 -       switch (c->processor_id & 0xff00) {
14378 +       switch (c->processor_id & PRID_IMP_MASK) {
14379         case PRID_IMP_SR71000:
14380                 c->cputype = CPU_SR71000;
14381                 c->isa_level = MIPS_CPU_ISA_M64;
14382 @@ -572,7 +596,7 @@
14383         c->cputype      = CPU_UNKNOWN;
14384
14385         c->processor_id = read_c0_prid();
14386 -       switch (c->processor_id & 0xff0000) {
14387 +       switch (c->processor_id & PRID_COMP_MASK) {
14388
14389         case PRID_COMP_LEGACY:
14390                 cpu_probe_legacy(c);
14391 @@ -583,6 +607,9 @@
14392         case PRID_COMP_ALCHEMY:
14393                 cpu_probe_alchemy(c);
14394                 break;
14395 +       case PRID_COMP_BROADCOM:
14396 +               cpu_probe_broadcom(c);
14397 +               break;
14398         case PRID_COMP_SIBYTE:
14399                 cpu_probe_sibyte(c);
14400                 break;
14401 diff -Nur linux-2.4.32/arch/mips/kernel/head.S linux-2.4.32-brcm/arch/mips/kernel/head.S
14402 --- linux-2.4.32/arch/mips/kernel/head.S        2005-01-19 15:09:29.000000000 +0100
14403 +++ linux-2.4.32-brcm/arch/mips/kernel/head.S   2005-12-16 23:39:11.084845500 +0100
14404 @@ -28,12 +28,20 @@
14405  #include <asm/mipsregs.h>
14406  #include <asm/stackframe.h>
14407
14408 +#ifdef CONFIG_BCM4710
14409 +#undef eret
14410 +#define eret nop; nop; eret
14411 +#endif
14412 +
14413                 .text
14414 +               j       kernel_entry
14415 +               nop
14416 +
14417                 /*
14418                  * Reserved space for exception handlers.
14419                  * Necessary for machines which link their kernels at KSEG0.
14420                  */
14421 -               .fill   0x400
14422 +               .fill   0x3f4
14423
14424                 /* The following two symbols are used for kernel profiling. */
14425                 EXPORT(stext)
14426 diff -Nur linux-2.4.32/arch/mips/kernel/proc.c linux-2.4.32-brcm/arch/mips/kernel/proc.c
14427 --- linux-2.4.32/arch/mips/kernel/proc.c        2005-01-19 15:09:29.000000000 +0100
14428 +++ linux-2.4.32-brcm/arch/mips/kernel/proc.c   2005-12-16 23:39:11.084845500 +0100
14429 @@ -78,9 +78,10 @@
14430         [CPU_AU1550]    "Au1550",
14431         [CPU_24K]       "MIPS 24K",
14432         [CPU_AU1200]    "Au1200",
14433 +       [CPU_BCM4710]   "BCM4710",
14434 +       [CPU_BCM3302]   "BCM3302",
14435  };
14436
14437 -
14438  static int show_cpuinfo(struct seq_file *m, void *v)
14439  {
14440         unsigned int version = current_cpu_data.processor_id;
14441 diff -Nur linux-2.4.32/arch/mips/kernel/setup.c linux-2.4.32-brcm/arch/mips/kernel/setup.c
14442 --- linux-2.4.32/arch/mips/kernel/setup.c       2005-01-19 15:09:29.000000000 +0100
14443 +++ linux-2.4.32-brcm/arch/mips/kernel/setup.c  2005-12-16 23:39:11.140849000 +0100
14444 @@ -495,6 +495,7 @@
14445         void swarm_setup(void);
14446         void hp_setup(void);
14447         void au1x00_setup(void);
14448 +       void brcm_setup(void);
14449         void frame_info_init(void);
14450
14451         frame_info_init();
14452 @@ -693,6 +694,11 @@
14453                  pmc_yosemite_setup();
14454                  break;
14455  #endif
14456 +#if defined(CONFIG_BCM4710) || defined(CONFIG_BCM4310)
14457 +       case MACH_GROUP_BRCM:
14458 +                       brcm_setup();
14459 +                       break;
14460 +#endif
14461         default:
14462                 panic("Unsupported architecture");
14463         }
14464 diff -Nur linux-2.4.32/arch/mips/kernel/traps.c linux-2.4.32-brcm/arch/mips/kernel/traps.c
14465 --- linux-2.4.32/arch/mips/kernel/traps.c       2005-01-19 15:09:29.000000000 +0100
14466 +++ linux-2.4.32-brcm/arch/mips/kernel/traps.c  2005-12-16 23:39:11.140849000 +0100
14467 @@ -913,6 +913,7 @@
14468  void __init trap_init(void)
14469  {
14470         extern char except_vec1_generic;
14471 +       extern char except_vec2_generic;
14472         extern char except_vec3_generic, except_vec3_r4000;
14473         extern char except_vec_ejtag_debug;
14474         extern char except_vec4;
14475 @@ -922,6 +923,7 @@
14476
14477         /* Copy the generic exception handler code to it's final destination. */
14478         memcpy((void *)(KSEG0 + 0x80), &except_vec1_generic, 0x80);
14479 +       memcpy((void *)(KSEG0 + 0x100), &except_vec2_generic, 0x80);
14480
14481         /*
14482          * Setup default vectors
14483 @@ -980,6 +982,12 @@
14484         set_except_vector(13, handle_tr);
14485         set_except_vector(22, handle_mdmx);
14486
14487 +       if (current_cpu_data.cputype == CPU_SB1) {
14488 +               /* Enable timer interrupt and scd mapped interrupt */
14489 +               clear_c0_status(0xf000);
14490 +               set_c0_status(0xc00);
14491 +       }
14492 +
14493         if (cpu_has_fpu && !cpu_has_nofpuex)
14494                 set_except_vector(15, handle_fpe);
14495
14496 diff -Nur linux-2.4.32/arch/mips/Makefile linux-2.4.32-brcm/arch/mips/Makefile
14497 --- linux-2.4.32/arch/mips/Makefile     2005-01-19 15:09:26.000000000 +0100
14498 +++ linux-2.4.32-brcm/arch/mips/Makefile        2005-12-16 23:39:10.668819500 +0100
14499 @@ -715,6 +715,19 @@
14500  endif
14501
14502  #
14503 +# Broadcom BCM947XX variants
14504 +#
14505 +ifdef CONFIG_BCM947XX
14506 +LIBS           += arch/mips/bcm947xx/generic/brcm.o arch/mips/bcm947xx/bcm947xx.o
14507 +SUBDIRS                += arch/mips/bcm947xx/generic arch/mips/bcm947xx
14508 +LOADADDR       := 0x80001000
14509 +
14510 +zImage: vmlinux
14511 +       $(MAKE) -C arch/$(ARCH)/bcm947xx/compressed
14512 +export LOADADDR
14513 +endif
14514 +
14515 +#
14516  # Choosing incompatible machines durings configuration will result in
14517  # error messages during linking.  Select a default linkscript if
14518  # none has been choosen above.
14519 @@ -767,6 +780,7 @@
14520         $(MAKE) -C arch/$(ARCH)/tools clean
14521         $(MAKE) -C arch/mips/baget clean
14522         $(MAKE) -C arch/mips/lasat clean
14523 +       $(MAKE) -C arch/mips/bcm947xx/compressed clean
14524
14525  archmrproper:
14526         @$(MAKEBOOT) mrproper
14527 diff -Nur linux-2.4.32/arch/mips/mm/c-r4k.c linux-2.4.32-brcm/arch/mips/mm/c-r4k.c
14528 --- linux-2.4.32/arch/mips/mm/c-r4k.c   2005-01-19 15:09:29.000000000 +0100
14529 +++ linux-2.4.32-brcm/arch/mips/mm/c-r4k.c      2005-12-16 23:39:11.144849250 +0100
14530 @@ -1114,3 +1114,47 @@
14531         build_clear_page();
14532         build_copy_page();
14533  }
14534 +
14535 +#ifdef CONFIG_BCM4704
14536 +static void __init mips32_icache_fill(unsigned long addr, uint nbytes)
14537 +{
14538 +       unsigned long ic_lsize = current_cpu_data.icache.linesz;
14539 +       int i;
14540 +       for (i = 0; i < nbytes; i += ic_lsize)
14541 +               fill_icache_line((addr + i));
14542 +}
14543 +
14544 +/*
14545 + *  This must be run from the cache on 4704A0
14546 + *  so there are no mips core BIU ops in progress
14547 + *  when the PFC is enabled.
14548 + */
14549 +#define PFC_CR0         0xff400000      /* control reg 0 */
14550 +#define PFC_CR1         0xff400004      /* control reg 1 */
14551 +static void __init enable_pfc(u32 mode)
14552 +{
14553 +       /* write range */
14554 +       *(volatile u32 *)PFC_CR1 = 0xffff0000;
14555 +
14556 +       /* enable */
14557 +       *(volatile u32 *)PFC_CR0 = mode;
14558 +}
14559 +#endif
14560 +
14561 +
14562 +void check_enable_mips_pfc(int val)
14563 +{
14564 +
14565 +#ifdef CONFIG_BCM4704
14566 +       struct cpuinfo_mips *c = &current_cpu_data;
14567 +
14568 +       /* enable prefetch cache */
14569 +       if (((c->processor_id & (PRID_COMP_MASK | PRID_IMP_MASK)) == PRID_IMP_BCM3302)
14570 +               && (read_c0_diag() & (1 << 29))) {
14571 +                       mips32_icache_fill((unsigned long) &enable_pfc, 64);
14572 +                       enable_pfc(val);
14573 +       }
14574 +#endif
14575 +}
14576 +
14577 +
14578 diff -Nur linux-2.4.32/arch/mips/pci/Makefile linux-2.4.32-brcm/arch/mips/pci/Makefile
14579 --- linux-2.4.32/arch/mips/pci/Makefile 2005-01-19 15:09:29.000000000 +0100
14580 +++ linux-2.4.32-brcm/arch/mips/pci/Makefile    2005-12-16 23:39:11.144849250 +0100
14581 @@ -13,7 +13,9 @@
14582  obj-$(CONFIG_MIPS_MSC)         += ops-msc.o
14583  obj-$(CONFIG_MIPS_NILE4)       += ops-nile4.o
14584  obj-$(CONFIG_SNI_RM200_PCI)    += ops-sni.o
14585 +ifndef CONFIG_BCM947XX
14586  obj-y                          += pci.o
14587 +endif
14588  obj-$(CONFIG_PCI_AUTO)         += pci_auto.o
14589
14590  include $(TOPDIR)/Rules.make
14591 diff -Nur linux-2.4.32/drivers/char/serial.c linux-2.4.32-brcm/drivers/char/serial.c
14592 --- linux-2.4.32/drivers/char/serial.c  2005-11-16 20:12:54.000000000 +0100
14593 +++ linux-2.4.32-brcm/drivers/char/serial.c     2005-12-16 23:39:11.200852750 +0100
14594 @@ -422,6 +422,10 @@
14595                 return inb(info->port+1);
14596  #endif
14597         case SERIAL_IO_MEM:
14598 +#ifdef CONFIG_BCM4310
14599 +               readb((unsigned long) info->iomem_base +
14600 +                               (UART_SCR<<info->iomem_reg_shift));
14601 +#endif
14602                 return readb((unsigned long) info->iomem_base +
14603                              (offset<<info->iomem_reg_shift));
14604         default:
14605 @@ -442,6 +446,9 @@
14606         case SERIAL_IO_MEM:
14607                 writeb(value, (unsigned long) info->iomem_base +
14608                               (offset<<info->iomem_reg_shift));
14609 +#ifdef CONFIG_BCM4704
14610 +               *((volatile unsigned int *) KSEG1ADDR(0x18000000));
14611 +#endif
14612                 break;
14613         default:
14614                 outb(value, info->port+offset);
14615 @@ -1704,7 +1711,7 @@
14616                         /* Special case since 134 is really 134.5 */
14617                         quot = (2*baud_base / 269);
14618                 else if (baud)
14619 -                       quot = baud_base / baud;
14620 +                       quot = (baud_base + (baud / 2)) / baud;
14621         }
14622         /* If the quotient is zero refuse the change */
14623         if (!quot && old_termios) {
14624 @@ -1721,12 +1728,12 @@
14625                                 /* Special case since 134 is really 134.5 */
14626                                 quot = (2*baud_base / 269);
14627                         else if (baud)
14628 -                               quot = baud_base / baud;
14629 +                               quot = (baud_base + (baud / 2)) / baud;
14630                 }
14631         }
14632         /* As a last resort, if the quotient is zero, default to 9600 bps */
14633         if (!quot)
14634 -               quot = baud_base / 9600;
14635 +               quot = (baud_base + 4800) / 9600;
14636         /*
14637          * Work around a bug in the Oxford Semiconductor 952 rev B
14638          * chip which causes it to seriously miscalculate baud rates
14639 @@ -5982,6 +5989,13 @@
14640          *      Divisor, bytesize and parity
14641          */
14642         state = rs_table + co->index;
14643 +       /*
14644 +        * Safe guard: state structure must have been initialized
14645 +        */
14646 +       if (state->iomem_base == NULL) {
14647 +               printk("!unable to setup serial console!\n");
14648 +               return -1;
14649 +       }
14650         if (doflow)
14651                 state->flags |= ASYNC_CONS_FLOW;
14652         info = &async_sercons;
14653 @@ -5995,7 +6009,7 @@
14654         info->io_type = state->io_type;
14655         info->iomem_base = state->iomem_base;
14656         info->iomem_reg_shift = state->iomem_reg_shift;
14657 -       quot = state->baud_base / baud;
14658 +       quot = (state->baud_base + (baud / 2)) / baud;
14659         cval = cflag & (CSIZE | CSTOPB);
14660  #if defined(__powerpc__) || defined(__alpha__)
14661         cval >>= 8;
14662 diff -Nur linux-2.4.32/drivers/net/Config.in linux-2.4.32-brcm/drivers/net/Config.in
14663 --- linux-2.4.32/drivers/net/Config.in  2005-01-19 15:09:56.000000000 +0100
14664 +++ linux-2.4.32-brcm/drivers/net/Config.in     2005-12-16 23:39:11.232854750 +0100
14665 @@ -2,6 +2,8 @@
14666  # Network device configuration
14667  #
14668
14669 +tristate 'Broadcom Home Network Division' CONFIG_HND $CONFIG_PCI
14670 +
14671  source drivers/net/arcnet/Config.in
14672
14673  tristate 'Dummy net driver support' CONFIG_DUMMY
14674 @@ -173,6 +175,7 @@
14675
14676        dep_tristate '    Apricot Xen-II on board Ethernet' CONFIG_APRICOT $CONFIG_ISA
14677        dep_tristate '    Broadcom 4400 ethernet support (EXPERIMENTAL)' CONFIG_B44 $CONFIG_PCI $CONFIG_EXPERIMENTAL
14678 +      dep_tristate '    Proprietary Broadcom 10/100 Ethernet support' CONFIG_ET $CONFIG_PCI
14679        dep_tristate '    CS89x0 support' CONFIG_CS89x0 $CONFIG_ISA
14680        dep_tristate '    DECchip Tulip (dc21x4x) PCI support' CONFIG_TULIP $CONFIG_PCI
14681        if [ "$CONFIG_TULIP" = "y" -o "$CONFIG_TULIP" = "m" ]; then
14682 diff -Nur linux-2.4.32/drivers/net/et/Makefile linux-2.4.32-brcm/drivers/net/et/Makefile
14683 --- linux-2.4.32/drivers/net/et/Makefile        1970-01-01 01:00:00.000000000 +0100
14684 +++ linux-2.4.32-brcm/drivers/net/et/Makefile   2005-12-16 23:39:11.284858000 +0100
14685 @@ -0,0 +1,21 @@
14686 +#
14687 +# Makefile for the Broadcom et driver
14688 +#
14689 +# Copyright 2004, Broadcom Corporation
14690 +# All Rights Reserved.
14691 +#
14692 +# THIS SOFTWARE IS OFFERED "AS IS", AND BROADCOM GRANTS NO WARRANTIES OF ANY
14693 +# KIND, EXPRESS OR IMPLIED, BY STATUTE, COMMUNICATION OR OTHERWISE. BROADCOM
14694 +# SPECIFICALLY DISCLAIMS ANY IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS
14695 +# FOR A SPECIFIC PURPOSE OR NONINFRINGEMENT CONCERNING THIS SOFTWARE.
14696 +#
14697 +# $Id: Makefile,v 1.1 2005/03/16 13:50:00 wbx Exp $
14698 +#
14699 +
14700 +EXTRA_CFLAGS := -I$(TOPDIR)/arch/mips/bcm947xx/include -DBCM47XX_CHOPS -DDMA -DBCMDRIVER
14701 +
14702 +O_TARGET       := et.o
14703 +obj-y          := et_linux.o etc.o etc47xx.o etc_robo.o etc_adm.o
14704 +obj-m          := $(O_TARGET)
14705 +
14706 +include $(TOPDIR)/Rules.make
14707 diff -Nur linux-2.4.32/drivers/net/hnd/bcmsrom.c linux-2.4.32-brcm/drivers/net/hnd/bcmsrom.c
14708 --- linux-2.4.32/drivers/net/hnd/bcmsrom.c      1970-01-01 01:00:00.000000000 +0100
14709 +++ linux-2.4.32-brcm/drivers/net/hnd/bcmsrom.c 2005-12-16 23:39:11.284858000 +0100
14710 @@ -0,0 +1,936 @@
14711 +/*
14712 + *  Misc useful routines to access NIC SROM/OTP .
14713 + *
14714 + * Copyright 2005, Broadcom Corporation
14715 + * All Rights Reserved.
14716 + *
14717 + * THIS SOFTWARE IS OFFERED "AS IS", AND BROADCOM GRANTS NO WARRANTIES OF ANY
14718 + * KIND, EXPRESS OR IMPLIED, BY STATUTE, COMMUNICATION OR OTHERWISE. BROADCOM
14719 + * SPECIFICALLY DISCLAIMS ANY IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS
14720 + * FOR A SPECIFIC PURPOSE OR NONINFRINGEMENT CONCERNING THIS SOFTWARE.
14721 + * $Id$
14722 + */
14723 +
14724 +#include <typedefs.h>
14725 +#include <osl.h>
14726 +#include <bcmutils.h>
14727 +#include <bcmsrom.h>
14728 +#include <bcmdevs.h>
14729 +#include <bcmendian.h>
14730 +#include <sbpcmcia.h>
14731 +#include <pcicfg.h>
14732 +#include <sbutils.h>
14733 +#include <bcmnvram.h>
14734 +
14735 +#include <proto/ethernet.h>    /* for sprom content groking */
14736 +
14737 +#define        VARS_MAX        4096    /* should be reduced */
14738 +
14739 +#define WRITE_ENABLE_DELAY     500     /* 500 ms after write enable/disable toggle */
14740 +#define WRITE_WORD_DELAY       20      /* 20 ms between each word write */
14741 +
14742 +static int initvars_srom_pci(void *sbh, void *curmap, char **vars, int *count);
14743 +static int initvars_cis_pcmcia(void *sbh, osl_t *osh, char **vars, int *count);
14744 +static int initvars_flash_sb(void *sbh, char **vars, int *count);
14745 +static int srom_parsecis(osl_t *osh, uint8 *cis, char **vars, int *count);
14746 +static int sprom_cmd_pcmcia(osl_t *osh, uint8 cmd);
14747 +static int sprom_read_pcmcia(osl_t *osh, uint16 addr, uint16 *data);
14748 +static int sprom_write_pcmcia(osl_t *osh, uint16 addr, uint16 data);
14749 +static int sprom_read_pci(uint16 *sprom, uint wordoff, uint16 *buf, uint nwords, bool check_crc);
14750 +
14751 +static int initvars_table(osl_t *osh, char *start, char *end, char **vars, uint *count);
14752 +static int initvars_flash(osl_t *osh, char **vp, int len, char *devpath);
14753 +
14754 +/*
14755 + * Initialize local vars from the right source for this platform.
14756 + * Return 0 on success, nonzero on error.
14757 + */
14758 +int
14759 +srom_var_init(void *sbh, uint bustype, void *curmap, osl_t *osh, char **vars, int *count)
14760 +{
14761 +       ASSERT(bustype == BUSTYPE(bustype));
14762 +       if (vars == NULL || count == NULL)
14763 +               return (0);
14764 +
14765 +       switch (BUSTYPE(bustype)) {
14766 +       case SB_BUS:
14767 +       case JTAG_BUS:
14768 +               return initvars_flash_sb(sbh, vars, count);
14769 +
14770 +       case PCI_BUS:
14771 +               ASSERT(curmap); /* can not be NULL */
14772 +               return initvars_srom_pci(sbh, curmap, vars, count);
14773 +
14774 +       case PCMCIA_BUS:
14775 +               return initvars_cis_pcmcia(sbh, osh, vars, count);
14776 +
14777 +
14778 +       default:
14779 +               ASSERT(0);
14780 +       }
14781 +       return (-1);
14782 +}
14783 +
14784 +/* support only 16-bit word read from srom */
14785 +int
14786 +srom_read(uint bustype, void *curmap, osl_t *osh, uint byteoff, uint nbytes, uint16 *buf)
14787 +{
14788 +       void *srom;
14789 +       uint i, off, nw;
14790 +
14791 +       ASSERT(bustype == BUSTYPE(bustype));
14792 +
14793 +       /* check input - 16-bit access only */
14794 +       if (byteoff & 1 || nbytes & 1 || (byteoff + nbytes) > (SPROM_SIZE * 2))
14795 +               return 1;
14796 +
14797 +       off = byteoff / 2;
14798 +       nw = nbytes / 2;
14799 +
14800 +       if (BUSTYPE(bustype) == PCI_BUS) {
14801 +               if (!curmap)
14802 +                       return 1;
14803 +               srom = (uchar*)curmap + PCI_BAR0_SPROM_OFFSET;
14804 +               if (sprom_read_pci(srom, off, buf, nw, FALSE))
14805 +                       return 1;
14806 +       } else if (BUSTYPE(bustype) == PCMCIA_BUS) {
14807 +               for (i = 0; i < nw; i++) {
14808 +                       if (sprom_read_pcmcia(osh, (uint16)(off + i), (uint16*)(buf + i)))
14809 +                               return 1;
14810 +               }
14811 +       } else {
14812 +               return 1;
14813 +       }
14814 +
14815 +       return 0;
14816 +}
14817 +
14818 +/* support only 16-bit word write into srom */
14819 +int
14820 +srom_write(uint bustype, void *curmap, osl_t *osh, uint byteoff, uint nbytes, uint16 *buf)
14821 +{
14822 +       uint16 *srom;
14823 +       uint i, off, nw, crc_range;
14824 +       uint16 image[SPROM_SIZE], *p;
14825 +       uint8 crc;
14826 +       volatile uint32 val32;
14827 +
14828 +       ASSERT(bustype == BUSTYPE(bustype));
14829 +
14830 +       /* check input - 16-bit access only */
14831 +       if (byteoff & 1 || nbytes & 1 || (byteoff + nbytes) > (SPROM_SIZE * 2))
14832 +               return 1;
14833 +
14834 +       crc_range = (((BUSTYPE(bustype) == PCMCIA_BUS) || (BUSTYPE(bustype) == SDIO_BUS)) ? SPROM_SIZE : SPROM_CRC_RANGE) * 2;
14835 +
14836 +       /* if changes made inside crc cover range */
14837 +       if (byteoff < crc_range) {
14838 +               nw = (((byteoff + nbytes) > crc_range) ? byteoff + nbytes : crc_range) / 2;
14839 +               /* read data including entire first 64 words from srom */
14840 +               if (srom_read(bustype, curmap, osh, 0, nw * 2, image))
14841 +                       return 1;
14842 +               /* make changes */
14843 +               bcopy((void*)buf, (void*)&image[byteoff / 2], nbytes);
14844 +               /* calculate crc */
14845 +               htol16_buf(image, crc_range);
14846 +               crc = ~hndcrc8((uint8 *)image, crc_range - 1, CRC8_INIT_VALUE);
14847 +               ltoh16_buf(image, crc_range);
14848 +               image[(crc_range / 2) - 1] = (crc << 8) | (image[(crc_range / 2) - 1] & 0xff);
14849 +               p = image;
14850 +               off = 0;
14851 +       } else {
14852 +               p = buf;
14853 +               off = byteoff / 2;
14854 +               nw = nbytes / 2;
14855 +       }
14856 +
14857 +       if (BUSTYPE(bustype) == PCI_BUS) {
14858 +               srom = (uint16*)((uchar*)curmap + PCI_BAR0_SPROM_OFFSET);
14859 +               /* enable writes to the SPROM */
14860 +               val32 = OSL_PCI_READ_CONFIG(osh, PCI_SPROM_CONTROL, sizeof(uint32));
14861 +               val32 |= SPROM_WRITEEN;
14862 +               OSL_PCI_WRITE_CONFIG(osh, PCI_SPROM_CONTROL, sizeof(uint32), val32);
14863 +               bcm_mdelay(WRITE_ENABLE_DELAY);
14864 +               /* write srom */
14865 +               for (i = 0; i < nw; i++) {
14866 +                       W_REG(&srom[off + i], p[i]);
14867 +                       bcm_mdelay(WRITE_WORD_DELAY);
14868 +               }
14869 +               /* disable writes to the SPROM */
14870 +               OSL_PCI_WRITE_CONFIG(osh, PCI_SPROM_CONTROL, sizeof(uint32), val32 & ~SPROM_WRITEEN);
14871 +       } else if (BUSTYPE(bustype) == PCMCIA_BUS) {
14872 +               /* enable writes to the SPROM */
14873 +               if (sprom_cmd_pcmcia(osh, SROM_WEN))
14874 +                       return 1;
14875 +               bcm_mdelay(WRITE_ENABLE_DELAY);
14876 +               /* write srom */
14877 +               for (i = 0; i < nw; i++) {
14878 +                       sprom_write_pcmcia(osh, (uint16)(off + i), p[i]);
14879 +                       bcm_mdelay(WRITE_WORD_DELAY);
14880 +               }
14881 +               /* disable writes to the SPROM */
14882 +               if (sprom_cmd_pcmcia(osh, SROM_WDS))
14883 +                       return 1;
14884 +       } else {
14885 +               return 1;
14886 +       }
14887 +
14888 +       bcm_mdelay(WRITE_ENABLE_DELAY);
14889 +       return 0;
14890 +}
14891 +
14892 +
14893 +static int
14894 +srom_parsecis(osl_t *osh, uint8 *cis, char **vars, int *count)
14895 +{
14896 +       char eabuf[32];
14897 +       char *vp, *base;
14898 +       uint8 tup, tlen, sromrev = 1;
14899 +       int i, j;
14900 +       uint varsize;
14901 +       bool ag_init = FALSE;
14902 +       uint32 w32;
14903 +
14904 +       ASSERT(vars);
14905 +       ASSERT(count);
14906 +
14907 +       base = vp = MALLOC(osh, VARS_MAX);
14908 +       ASSERT(vp);
14909 +       if (!vp)
14910 +               return -2;
14911 +
14912 +       i = 0;
14913 +       do {
14914 +               tup = cis[i++];
14915 +               tlen = cis[i++];
14916 +               if ((i + tlen) >= CIS_SIZE)
14917 +                       break;
14918 +
14919 +               switch (tup) {
14920 +               case CISTPL_MANFID:
14921 +                       vp += sprintf(vp, "manfid=%d", (cis[i + 1] << 8) + cis[i]);
14922 +                       vp++;
14923 +                       vp += sprintf(vp, "prodid=%d", (cis[i + 3] << 8) + cis[i + 2]);
14924 +                       vp++;
14925 +                       break;
14926 +
14927 +               case CISTPL_FUNCE:
14928 +                       if (cis[i] == LAN_NID) {
14929 +                               ASSERT(cis[i + 1] == ETHER_ADDR_LEN);
14930 +                               bcm_ether_ntoa((uchar*)&cis[i + 2], eabuf);
14931 +                               vp += sprintf(vp, "il0macaddr=%s", eabuf);
14932 +                               vp++;
14933 +                       }
14934 +                       break;
14935 +
14936 +               case CISTPL_CFTABLE:
14937 +                       vp += sprintf(vp, "regwindowsz=%d", (cis[i + 7] << 8) | cis[i + 6]);
14938 +                       vp++;
14939 +                       break;
14940 +
14941 +               case CISTPL_BRCM_HNBU:
14942 +                       switch (cis[i]) {
14943 +                       case HNBU_SROMREV:
14944 +                               sromrev = cis[i + 1];
14945 +                               break;
14946 +
14947 +                       case HNBU_CHIPID:
14948 +                               vp += sprintf(vp, "vendid=%d", (cis[i + 2] << 8) + cis[i + 1]);
14949 +                               vp++;
14950 +                               vp += sprintf(vp, "devid=%d", (cis[i + 4] << 8) + cis[i + 3]);
14951 +                               vp++;
14952 +                               if (tlen == 7) {
14953 +                                       vp += sprintf(vp, "chiprev=%d", (cis[i + 6] << 8) + cis[i + 5]);
14954 +                                       vp++;
14955 +                               }
14956 +                               break;
14957 +
14958 +                       case HNBU_BOARDREV:
14959 +                               vp += sprintf(vp, "boardrev=%d", cis[i + 1]);
14960 +                               vp++;
14961 +                               break;
14962 +
14963 +                       case HNBU_AA:
14964 +                               vp += sprintf(vp, "aa0=%d", cis[i + 1]);
14965 +                               vp++;
14966 +                               break;
14967 +
14968 +                       case HNBU_AG:
14969 +                               vp += sprintf(vp, "ag0=%d", cis[i + 1]);
14970 +                               vp++;
14971 +                               ag_init = TRUE;
14972 +                               break;
14973 +
14974 +                       case HNBU_CC:
14975 +                               ASSERT(sromrev > 1);
14976 +                               vp += sprintf(vp, "cc=%d", cis[i + 1]);
14977 +                               vp++;
14978 +                               break;
14979 +
14980 +                       case HNBU_PAPARMS:
14981 +                               if (tlen == 2) {
14982 +                                       ASSERT(sromrev == 1);
14983 +                                       vp += sprintf(vp, "pa0maxpwr=%d", cis[i + 1]);
14984 +                                       vp++;
14985 +                               } else if (tlen >= 9) {
14986 +                                       if (tlen == 10) {
14987 +                                               ASSERT(sromrev == 2);
14988 +                                               vp += sprintf(vp, "opo=%d", cis[i + 9]);
14989 +                                               vp++;
14990 +                                       } else
14991 +                                               ASSERT(tlen == 9);
14992 +
14993 +                                       for (j = 0; j < 3; j++) {
14994 +                                               vp += sprintf(vp, "pa0b%d=%d", j,
14995 +                                                             (cis[i + (j * 2) + 2] << 8) + cis[i + (j * 2) + 1]);
14996 +                                               vp++;
14997 +                                       }
14998 +                                       vp += sprintf(vp, "pa0itssit=%d", cis[i + 7]);
14999 +                                       vp++;
15000 +                                       vp += sprintf(vp, "pa0maxpwr=%d", cis[i + 8]);
15001 +                                       vp++;
15002 +                               } else
15003 +                                       ASSERT(tlen >= 9);
15004 +                               break;
15005 +
15006 +                       case HNBU_OEM:
15007 +                               ASSERT(sromrev == 1);
15008 +                               vp += sprintf(vp, "oem=%02x%02x%02x%02x%02x%02x%02x%02x",
15009 +                                       cis[i + 1], cis[i + 2], cis[i + 3], cis[i + 4],
15010 +                                       cis[i + 5], cis[i + 6], cis[i + 7], cis[i + 8]);
15011 +                               vp++;
15012 +                               break;
15013 +
15014 +                       case HNBU_BOARDFLAGS:
15015 +                               w32 = (cis[i + 2] << 8) + cis[i + 1];
15016 +                               if (tlen == 5)
15017 +                                       w32 |= (cis[i + 4] << 24) + (cis[i + 3] << 16);
15018 +                               vp += sprintf(vp, "boardflags=0x%x", w32);
15019 +                               vp++;
15020 +                               break;
15021 +
15022 +                       case HNBU_LEDS:
15023 +                               if (cis[i + 1] != 0xff) {
15024 +                                       vp += sprintf(vp, "wl0gpio0=%d", cis[i + 1]);
15025 +                                       vp++;
15026 +                               }
15027 +                               if (cis[i + 2] != 0xff) {
15028 +                                       vp += sprintf(vp, "wl0gpio1=%d", cis[i + 2]);
15029 +                                       vp++;
15030 +                               }
15031 +                               if (cis[i + 3] != 0xff) {
15032 +                                       vp += sprintf(vp, "wl0gpio2=%d", cis[i + 3]);
15033 +                                       vp++;
15034 +                               }
15035 +                               if (cis[i + 4] != 0xff) {
15036 +                                       vp += sprintf(vp, "wl0gpio3=%d", cis[i + 4]);
15037 +                                       vp++;
15038 +                               }
15039 +                               break;
15040 +
15041 +                       case HNBU_CCODE:
15042 +                               ASSERT(sromrev > 1);
15043 +                               vp += sprintf(vp, "ccode=%c%c", cis[i + 1], cis[i + 2]);
15044 +                               vp++;
15045 +                               vp += sprintf(vp, "cctl=0x%x", cis[i + 3]);
15046 +                               vp++;
15047 +                               break;
15048 +
15049 +                       case HNBU_CCKPO:
15050 +                               ASSERT(sromrev > 2);
15051 +                               vp += sprintf(vp, "cckpo=0x%x", (cis[i + 2] << 8) | cis[i + 1]);
15052 +                               vp++;
15053 +                               break;
15054 +
15055 +                       case HNBU_OFDMPO:
15056 +                               ASSERT(sromrev > 2);
15057 +                               vp += sprintf(vp, "ofdmpo=0x%x", (cis[i + 4] << 24) |
15058 +                                             (cis[i + 3] << 16) | (cis[i + 2] << 8) | cis[i + 1]);
15059 +                               vp++;
15060 +                               break;
15061 +                       }
15062 +                       break;
15063 +
15064 +               }
15065 +               i += tlen;
15066 +       } while (tup != 0xff);
15067 +
15068 +       /* Set the srom version */
15069 +       vp += sprintf(vp, "sromrev=%d", sromrev);
15070 +       vp++;
15071 +
15072 +       /* if there is no antenna gain field, set default */
15073 +       if (ag_init == FALSE) {
15074 +               ASSERT(sromrev == 1);
15075 +               vp += sprintf(vp, "ag0=%d", 0xff);
15076 +               vp++;
15077 +       }
15078 +
15079 +       /* final nullbyte terminator */
15080 +       *vp++ = '\0';
15081 +       varsize = (uint)(vp - base);
15082 +
15083 +       ASSERT((vp - base) < VARS_MAX);
15084 +
15085 +       if (varsize == VARS_MAX) {
15086 +               *vars = base;
15087 +       } else {
15088 +               vp = MALLOC(osh, varsize);
15089 +               ASSERT(vp);
15090 +               if (vp)
15091 +                       bcopy(base, vp, varsize);
15092 +               MFREE(osh, base, VARS_MAX);
15093 +               *vars = vp;
15094 +               if (!vp) {
15095 +                       *count = 0;
15096 +                       return -2;
15097 +               }
15098 +       }
15099 +       *count = varsize;
15100 +
15101 +       return (0);
15102 +}
15103 +
15104 +
15105 +/* set PCMCIA sprom command register */
15106 +static int
15107 +sprom_cmd_pcmcia(osl_t *osh, uint8 cmd)
15108 +{
15109 +       uint8 status = 0;
15110 +       uint wait_cnt = 1000;
15111 +
15112 +       /* write sprom command register */
15113 +       OSL_PCMCIA_WRITE_ATTR(osh, SROM_CS, &cmd, 1);
15114 +
15115 +       /* wait status */
15116 +       while (wait_cnt--) {
15117 +               OSL_PCMCIA_READ_ATTR(osh, SROM_CS, &status, 1);
15118 +               if (status & SROM_DONE)
15119 +                       return 0;
15120 +       }
15121 +
15122 +       return 1;
15123 +}
15124 +
15125 +/* read a word from the PCMCIA srom */
15126 +static int
15127 +sprom_read_pcmcia(osl_t *osh, uint16 addr, uint16 *data)
15128 +{
15129 +       uint8 addr_l, addr_h, data_l, data_h;
15130 +
15131 +       addr_l = (uint8)((addr * 2) & 0xff);
15132 +       addr_h = (uint8)(((addr * 2) >> 8) & 0xff);
15133 +
15134 +       /* set address */
15135 +       OSL_PCMCIA_WRITE_ATTR(osh, SROM_ADDRH, &addr_h, 1);
15136 +       OSL_PCMCIA_WRITE_ATTR(osh, SROM_ADDRL, &addr_l, 1);
15137 +
15138 +       /* do read */
15139 +       if (sprom_cmd_pcmcia(osh, SROM_READ))
15140 +               return 1;
15141 +
15142 +       /* read data */
15143 +       data_h = data_l = 0;
15144 +       OSL_PCMCIA_READ_ATTR(osh, SROM_DATAH, &data_h, 1);
15145 +       OSL_PCMCIA_READ_ATTR(osh, SROM_DATAL, &data_l, 1);
15146 +
15147 +       *data = (data_h << 8) | data_l;
15148 +       return 0;
15149 +}
15150 +
15151 +/* write a word to the PCMCIA srom */
15152 +static int
15153 +sprom_write_pcmcia(osl_t *osh, uint16 addr, uint16 data)
15154 +{
15155 +       uint8 addr_l, addr_h, data_l, data_h;
15156 +
15157 +       addr_l = (uint8)((addr * 2) & 0xff);
15158 +       addr_h = (uint8)(((addr * 2) >> 8) & 0xff);
15159 +       data_l = (uint8)(data & 0xff);
15160 +       data_h = (uint8)((data >> 8) & 0xff);
15161 +
15162 +       /* set address */
15163 +       OSL_PCMCIA_WRITE_ATTR(osh, SROM_ADDRH, &addr_h, 1);
15164 +       OSL_PCMCIA_WRITE_ATTR(osh, SROM_ADDRL, &addr_l, 1);
15165 +
15166 +       /* write data */
15167 +       OSL_PCMCIA_WRITE_ATTR(osh, SROM_DATAH, &data_h, 1);
15168 +       OSL_PCMCIA_WRITE_ATTR(osh, SROM_DATAL, &data_l, 1);
15169 +
15170 +       /* do write */
15171 +       return sprom_cmd_pcmcia(osh, SROM_WRITE);
15172 +}
15173 +
15174 +/*
15175 + * Read in and validate sprom.
15176 + * Return 0 on success, nonzero on error.
15177 + */
15178 +static int
15179 +sprom_read_pci(uint16 *sprom, uint wordoff, uint16 *buf, uint nwords, bool check_crc)
15180 +{
15181 +       int err = 0;
15182 +       uint i;
15183 +
15184 +       /* read the sprom */
15185 +       for (i = 0; i < nwords; i++)
15186 +               buf[i] = R_REG(&sprom[wordoff + i]);
15187 +
15188 +       if (check_crc) {
15189 +               /* fixup the endianness so crc8 will pass */
15190 +               htol16_buf(buf, nwords * 2);
15191 +               if (hndcrc8((uint8*)buf, nwords * 2, CRC8_INIT_VALUE) != CRC8_GOOD_VALUE)
15192 +                       err = 1;
15193 +               /* now correct the endianness of the byte array */
15194 +               ltoh16_buf(buf, nwords * 2);
15195 +       }
15196 +
15197 +       return err;
15198 +}
15199 +
15200 +/*
15201 +* Create variable table from memory.
15202 +* Return 0 on success, nonzero on error.
15203 +*/
15204 +static int
15205 +initvars_table(osl_t *osh, char *start, char *end, char **vars, uint *count)
15206 +{
15207 +       int c = (int)(end - start);
15208 +
15209 +       /* do it only when there is more than just the null string */
15210 +       if (c > 1) {
15211 +               char *vp = MALLOC(osh, c);
15212 +               ASSERT(vp);
15213 +               if (!vp)
15214 +                       return BCME_NOMEM;
15215 +               bcopy(start, vp, c);
15216 +               *vars = vp;
15217 +               *count = c;
15218 +       }
15219 +       else {
15220 +               *vars = NULL;
15221 +               *count = 0;
15222 +       }
15223 +
15224 +       return 0;
15225 +}
15226 +
15227 +/*
15228 +* Find variables with <devpath> from flash. 'base' points to the beginning
15229 +* of the table upon enter and to the end of the table upon exit when success.
15230 +* Return 0 on success, nonzero on error.
15231 +*/
15232 +static int
15233 +initvars_flash(osl_t *osh, char **base, int size, char *devpath)
15234 +{
15235 +       char *vp = *base;
15236 +       char *flash;
15237 +       int err;
15238 +       char *s;
15239 +       uint l, dl, copy_len;
15240 +
15241 +       /* allocate memory and read in flash */
15242 +       if (!(flash = MALLOC(osh, NVRAM_SPACE)))
15243 +               return BCME_NOMEM;
15244 +       if ((err = BCMINIT(nvram_getall)(flash, NVRAM_SPACE)))
15245 +               goto exit;
15246 +
15247 +       /* grab vars with the <devpath> prefix in name */
15248 +       dl = strlen(devpath);
15249 +       for (s = flash; s && *s; s += l + 1) {
15250 +               l = strlen(s);
15251 +
15252 +               /* skip non-matching variable */
15253 +               if (strncmp(s, devpath, dl))
15254 +                       continue;
15255 +
15256 +               /* is there enough room to copy? */
15257 +               copy_len = l - dl + 1;
15258 +               if (size < (int)copy_len) {
15259 +                       err = BCME_BUFTOOSHORT;
15260 +                       goto exit;
15261 +               }
15262 +
15263 +               /* no prefix, just the name=value */
15264 +               strcpy(vp, &s[dl]);
15265 +               vp += copy_len;
15266 +               size -= copy_len;
15267 +       }
15268 +
15269 +       /* add null string as terminator */
15270 +       if (size < 1) {
15271 +               err = BCME_BUFTOOSHORT;
15272 +               goto exit;
15273 +       }
15274 +       *vp++ = '\0';
15275 +
15276 +       *base = vp;
15277 +
15278 +exit:  MFREE(osh, flash, NVRAM_SPACE);
15279 +       return err;
15280 +}
15281 +
15282 +/*
15283 + * Initialize nonvolatile variable table from flash.
15284 + * Return 0 on success, nonzero on error.
15285 + */
15286 +static int
15287 +initvars_flash_sb(void *sbh, char **vars, int *count)
15288 +{
15289 +       osl_t *osh = sb_osh(sbh);
15290 +       char devpath[SB_DEVPATH_BUFSZ];
15291 +       char *vp, *base;
15292 +       int err;
15293 +
15294 +       ASSERT(vars);
15295 +       ASSERT(count);
15296 +
15297 +       if ((err = sb_devpath(sbh, devpath, sizeof(devpath))))
15298 +               return err;
15299 +
15300 +       base = vp = MALLOC(osh, VARS_MAX);
15301 +       ASSERT(vp);
15302 +       if (!vp)
15303 +               return BCME_NOMEM;
15304 +
15305 +       if ((err = initvars_flash(osh, &vp, VARS_MAX, devpath)))
15306 +               goto err;
15307 +
15308 +       err = initvars_table(osh, base, vp, vars, count);
15309 +
15310 +err:   MFREE(osh, base, VARS_MAX);
15311 +       return err;
15312 +}
15313 +
15314 +/*
15315 + * Initialize nonvolatile variable table from sprom.
15316 + * Return 0 on success, nonzero on error.
15317 + */
15318 +static int
15319 +initvars_srom_pci(void *sbh, void *curmap, char **vars, int *count)
15320 +{
15321 +       uint16 w, b[64];
15322 +       uint8 sromrev;
15323 +       struct ether_addr ea;
15324 +       char eabuf[32];
15325 +       uint32 w32;
15326 +       int woff, i;
15327 +       char *vp, *base;
15328 +       osl_t *osh = sb_osh(sbh);
15329 +       bool flash = FALSE;
15330 +       char name[SB_DEVPATH_BUFSZ+16], *value;
15331 +       char devpath[SB_DEVPATH_BUFSZ];
15332 +       int err;
15333 +
15334 +       /*
15335 +       * Apply CRC over SROM content regardless SROM is present or not,
15336 +       * and use variable <devpath>sromrev's existance in flash to decide
15337 +       * if we should return an error when CRC fails or read SROM variables
15338 +       * from flash.
15339 +       */
15340 +       if (sprom_read_pci((void*)((int8*)curmap + PCI_BAR0_SPROM_OFFSET), 0, b, sizeof(b)/sizeof(b[0]), TRUE)) {
15341 +               if ((err = sb_devpath(sbh, devpath, sizeof(devpath))))
15342 +                       return err;
15343 +               sprintf(name, "%ssromrev", devpath);
15344 +               if (!(value = getvar(NULL, name)))
15345 +                       return (-1);
15346 +               sromrev = (uint8)bcm_strtoul(value, NULL, 0);
15347 +               flash = TRUE;
15348 +       }
15349 +       /* srom is good */
15350 +       else {
15351 +               /* top word of sprom contains version and crc8 */
15352 +               sromrev = b[63] & 0xff;
15353 +               /* bcm4401 sroms misprogrammed */
15354 +               if (sromrev == 0x10)
15355 +                       sromrev = 1;
15356 +       }
15357 +
15358 +       /* srom version check */
15359 +       if (sromrev > 3)
15360 +               return (-2);
15361 +
15362 +       ASSERT(vars);
15363 +       ASSERT(count);
15364 +
15365 +       base = vp = MALLOC(osh, VARS_MAX);
15366 +       ASSERT(vp);
15367 +       if (!vp)
15368 +               return -2;
15369 +
15370 +       /* read variables from flash */
15371 +       if (flash) {
15372 +               if ((err = initvars_flash(osh, &vp, VARS_MAX, devpath)))
15373 +                       goto err;
15374 +               goto done;
15375 +       }
15376 +
15377 +       vp += sprintf(vp, "sromrev=%d", sromrev);
15378 +       vp++;
15379 +
15380 +       if (sromrev >= 3) {
15381 +               /* New section takes over the 3th hardware function space */
15382 +
15383 +               /* Words 22+23 are 11a (mid) ofdm power offsets */
15384 +               w32 = ((uint32)b[23] << 16) | b[22];
15385 +               vp += sprintf(vp, "ofdmapo=%d", w32);
15386 +               vp++;
15387 +
15388 +               /* Words 24+25 are 11a (low) ofdm power offsets */
15389 +               w32 = ((uint32)b[25] << 16) | b[24];
15390 +               vp += sprintf(vp, "ofdmalpo=%d", w32);
15391 +               vp++;
15392 +
15393 +               /* Words 26+27 are 11a (high) ofdm power offsets */
15394 +               w32 = ((uint32)b[27] << 16) | b[26];
15395 +               vp += sprintf(vp, "ofdmahpo=%d", w32);
15396 +               vp++;
15397 +
15398 +               /*GPIO LED Powersave duty cycle (oncount >> 24) (offcount >> 8)*/
15399 +               w32 = ((uint32)b[43] << 24) | ((uint32)b[42] << 8);
15400 +               vp += sprintf(vp, "gpiotimerval=%d", w32);
15401 +
15402 +               /*GPIO LED Powersave duty cycle (oncount >> 24) (offcount >> 8)*/
15403 +               w32 = ((uint32)((unsigned char)(b[21] >> 8) & 0xFF) << 24) |  /* oncount*/
15404 +                       ((uint32)((unsigned char)(b[21] & 0xFF)) << 8); /* offcount */
15405 +               vp += sprintf(vp, "gpiotimerval=%d", w32);
15406 +
15407 +               vp++;
15408 +       }
15409 +
15410 +       if (sromrev >= 2) {
15411 +               /* New section takes over the 4th hardware function space */
15412 +
15413 +               /* Word 29 is max power 11a high/low */
15414 +               w = b[29];
15415 +               vp += sprintf(vp, "pa1himaxpwr=%d", w & 0xff);
15416 +               vp++;
15417 +               vp += sprintf(vp, "pa1lomaxpwr=%d", (w >> 8) & 0xff);
15418 +               vp++;
15419 +
15420 +               /* Words 30-32 set the 11alow pa settings,
15421 +                * 33-35 are the 11ahigh ones.
15422 +                */
15423 +               for (i = 0; i < 3; i++) {
15424 +                       vp += sprintf(vp, "pa1lob%d=%d", i, b[30 + i]);
15425 +                       vp++;
15426 +                       vp += sprintf(vp, "pa1hib%d=%d", i, b[33 + i]);
15427 +                       vp++;
15428 +               }
15429 +               w = b[59];
15430 +               if (w == 0)
15431 +                       vp += sprintf(vp, "ccode=");
15432 +               else
15433 +                       vp += sprintf(vp, "ccode=%c%c", (w >> 8), (w & 0xff));
15434 +               vp++;
15435 +
15436 +       }
15437 +
15438 +       /* parameter section of sprom starts at byte offset 72 */
15439 +       woff = 72/2;
15440 +
15441 +       /* first 6 bytes are il0macaddr */
15442 +       ea.octet[0] = (b[woff] >> 8) & 0xff;
15443 +       ea.octet[1] = b[woff] & 0xff;
15444 +       ea.octet[2] = (b[woff+1] >> 8) & 0xff;
15445 +       ea.octet[3] = b[woff+1] & 0xff;
15446 +       ea.octet[4] = (b[woff+2] >> 8) & 0xff;
15447 +       ea.octet[5] = b[woff+2] & 0xff;
15448 +       woff += ETHER_ADDR_LEN/2 ;
15449 +       bcm_ether_ntoa((uchar*)&ea, eabuf);
15450 +       vp += sprintf(vp, "il0macaddr=%s", eabuf);
15451 +       vp++;
15452 +
15453 +       /* next 6 bytes are et0macaddr */
15454 +       ea.octet[0] = (b[woff] >> 8) & 0xff;
15455 +       ea.octet[1] = b[woff] & 0xff;
15456 +       ea.octet[2] = (b[woff+1] >> 8) & 0xff;
15457 +       ea.octet[3] = b[woff+1] & 0xff;
15458 +       ea.octet[4] = (b[woff+2] >> 8) & 0xff;
15459 +       ea.octet[5] = b[woff+2] & 0xff;
15460 +       woff += ETHER_ADDR_LEN/2 ;
15461 +       bcm_ether_ntoa((uchar*)&ea, eabuf);
15462 +       vp += sprintf(vp, "et0macaddr=%s", eabuf);
15463 +       vp++;
15464 +
15465 +       /* next 6 bytes are et1macaddr */
15466 +       ea.octet[0] = (b[woff] >> 8) & 0xff;
15467 +       ea.octet[1] = b[woff] & 0xff;
15468 +       ea.octet[2] = (b[woff+1] >> 8) & 0xff;
15469 +       ea.octet[3] = b[woff+1] & 0xff;
15470 +       ea.octet[4] = (b[woff+2] >> 8) & 0xff;
15471 +       ea.octet[5] = b[woff+2] & 0xff;
15472 +       woff += ETHER_ADDR_LEN/2 ;
15473 +       bcm_ether_ntoa((uchar*)&ea, eabuf);
15474 +       vp += sprintf(vp, "et1macaddr=%s", eabuf);
15475 +       vp++;
15476 +
15477 +       /*
15478 +        * Enet phy settings one or two singles or a dual
15479 +        * Bits 4-0 : MII address for enet0 (0x1f for not there)
15480 +        * Bits 9-5 : MII address for enet1 (0x1f for not there)
15481 +        * Bit 14   : Mdio for enet0
15482 +        * Bit 15   : Mdio for enet1
15483 +        */
15484 +       w = b[woff];
15485 +       vp += sprintf(vp, "et0phyaddr=%d", (w & 0x1f));
15486 +       vp++;
15487 +       vp += sprintf(vp, "et1phyaddr=%d", ((w >> 5) & 0x1f));
15488 +       vp++;
15489 +       vp += sprintf(vp, "et0mdcport=%d", ((w >> 14) & 0x1));
15490 +       vp++;
15491 +       vp += sprintf(vp, "et1mdcport=%d", ((w >> 15) & 0x1));
15492 +       vp++;
15493 +
15494 +       /* Word 46 has board rev, antennas 0/1 & Country code/control */
15495 +       w = b[46];
15496 +       vp += sprintf(vp, "boardrev=%d", w & 0xff);
15497 +       vp++;
15498 +
15499 +       if (sromrev > 1)
15500 +               vp += sprintf(vp, "cctl=%d", (w >> 8) & 0xf);
15501 +       else
15502 +               vp += sprintf(vp, "cc=%d", (w >> 8) & 0xf);
15503 +       vp++;
15504 +
15505 +       vp += sprintf(vp, "aa0=%d", (w >> 12) & 0x3);
15506 +       vp++;
15507 +
15508 +       vp += sprintf(vp, "aa1=%d", (w >> 14) & 0x3);
15509 +       vp++;
15510 +
15511 +       /* Words 47-49 set the (wl) pa settings */
15512 +       woff = 47;
15513 +
15514 +       for (i = 0; i < 3; i++) {
15515 +               vp += sprintf(vp, "pa0b%d=%d", i, b[woff+i]);
15516 +               vp++;
15517 +               vp += sprintf(vp, "pa1b%d=%d", i, b[woff+i+6]);
15518 +               vp++;
15519 +       }
15520 +
15521 +       /*
15522 +        * Words 50-51 set the customer-configured wl led behavior.
15523 +        * 8 bits/gpio pin.  High bit:  activehi=0, activelo=1;
15524 +        * LED behavior values defined in wlioctl.h .
15525 +        */
15526 +       w = b[50];
15527 +       if ((w != 0) && (w != 0xffff)) {
15528 +               /* gpio0 */
15529 +               vp += sprintf(vp, "wl0gpio0=%d", (w & 0xff));
15530 +               vp++;
15531 +
15532 +               /* gpio1 */
15533 +               vp += sprintf(vp, "wl0gpio1=%d", (w >> 8) & 0xff);
15534 +               vp++;
15535 +       }
15536 +       w = b[51];
15537 +       if ((w != 0) && (w != 0xffff)) {
15538 +               /* gpio2 */
15539 +               vp += sprintf(vp, "wl0gpio2=%d", w & 0xff);
15540 +               vp++;
15541 +
15542 +               /* gpio3 */
15543 +               vp += sprintf(vp, "wl0gpio3=%d", (w >> 8) & 0xff);
15544 +               vp++;
15545 +       }
15546 +
15547 +       /* Word 52 is max power 0/1 */
15548 +       w = b[52];
15549 +       vp += sprintf(vp, "pa0maxpwr=%d", w & 0xff);
15550 +       vp++;
15551 +       vp += sprintf(vp, "pa1maxpwr=%d", (w >> 8) & 0xff);
15552 +       vp++;
15553 +
15554 +       /* Word 56 is idle tssi target 0/1 */
15555 +       w = b[56];
15556 +       vp += sprintf(vp, "pa0itssit=%d", w & 0xff);
15557 +       vp++;
15558 +       vp += sprintf(vp, "pa1itssit=%d", (w >> 8) & 0xff);
15559 +       vp++;
15560 +
15561 +       /* Word 57 is boardflags, if not programmed make it zero */
15562 +       w32 = (uint32)b[57];
15563 +       if (w32 == 0xffff) w32 = 0;
15564 +       if (sromrev > 1) {
15565 +               /* Word 28 is the high bits of boardflags */
15566 +               w32 |= (uint32)b[28] << 16;
15567 +       }
15568 +       vp += sprintf(vp, "boardflags=%d", w32);
15569 +       vp++;
15570 +
15571 +       /* Word 58 is antenna gain 0/1 */
15572 +       w = b[58];
15573 +       vp += sprintf(vp, "ag0=%d", w & 0xff);
15574 +       vp++;
15575 +
15576 +       vp += sprintf(vp, "ag1=%d", (w >> 8) & 0xff);
15577 +       vp++;
15578 +
15579 +       if (sromrev == 1) {
15580 +               /* set the oem string */
15581 +               vp += sprintf(vp, "oem=%02x%02x%02x%02x%02x%02x%02x%02x",
15582 +                             ((b[59] >> 8) & 0xff), (b[59] & 0xff),
15583 +                             ((b[60] >> 8) & 0xff), (b[60] & 0xff),
15584 +                             ((b[61] >> 8) & 0xff), (b[61] & 0xff),
15585 +                             ((b[62] >> 8) & 0xff), (b[62] & 0xff));
15586 +               vp++;
15587 +       } else if (sromrev == 2) {
15588 +               /* Word 60 OFDM tx power offset from CCK level */
15589 +               /* OFDM Power Offset - opo */
15590 +               vp += sprintf(vp, "opo=%d", b[60] & 0xff);
15591 +               vp++;
15592 +       } else {
15593 +               /* Word 60: cck power offsets */
15594 +               vp += sprintf(vp, "cckpo=%d", b[60]);
15595 +               vp++;
15596 +
15597 +               /* Words 61+62: 11g ofdm power offsets */
15598 +               w32 = ((uint32)b[62] << 16) | b[61];
15599 +               vp += sprintf(vp, "ofdmgpo=%d", w32);
15600 +               vp++;
15601 +       }
15602 +
15603 +       /* final nullbyte terminator */
15604 +       *vp++ = '\0';
15605 +
15606 +       ASSERT((vp - base) <= VARS_MAX);
15607 +
15608 +done:  err = initvars_table(osh, base, vp, vars, count);
15609 +
15610 +err:   MFREE(osh, base, VARS_MAX);
15611 +       return err;
15612 +}
15613 +
15614 +/*
15615 + * Read the cis and call parsecis to initialize the vars.
15616 + * Return 0 on success, nonzero on error.
15617 + */
15618 +static int
15619 +initvars_cis_pcmcia(void *sbh, osl_t *osh, char **vars, int *count)
15620 +{
15621 +       uint8 *cis = NULL;
15622 +       int rc;
15623 +       uint data_sz;
15624 +
15625 +       data_sz = (sb_pcmciarev(sbh) == 1) ? (SPROM_SIZE * 2) : CIS_SIZE;
15626 +
15627 +       if ((cis = MALLOC(osh, data_sz)) == NULL)
15628 +               return (-2);
15629 +
15630 +       if (sb_pcmciarev(sbh) == 1) {
15631 +               if (srom_read(PCMCIA_BUS, (void *)NULL, osh, 0, data_sz, (uint16 *)cis)) {
15632 +                       MFREE(osh, cis, data_sz);
15633 +                       return (-1);
15634 +               }
15635 +               /* fix up endianess for 16-bit data vs 8-bit parsing */
15636 +               ltoh16_buf((uint16 *)cis, data_sz);
15637 +       } else
15638 +               OSL_PCMCIA_READ_ATTR(osh, 0, cis, data_sz);
15639 +
15640 +       rc = srom_parsecis(osh, cis, vars, count);
15641 +
15642 +       MFREE(osh, cis, data_sz);
15643 +
15644 +       return (rc);
15645 +}
15646 +
15647 diff -Nur linux-2.4.32/drivers/net/hnd/bcmutils.c linux-2.4.32-brcm/drivers/net/hnd/bcmutils.c
15648 --- linux-2.4.32/drivers/net/hnd/bcmutils.c     1970-01-01 01:00:00.000000000 +0100
15649 +++ linux-2.4.32-brcm/drivers/net/hnd/bcmutils.c        2005-12-16 23:39:11.288858250 +0100
15650 @@ -0,0 +1,1081 @@
15651 +/*
15652 + * Misc useful OS-independent routines.
15653 + *
15654 + * Copyright 2005, Broadcom Corporation
15655 + * All Rights Reserved.
15656 + *
15657 + * THIS SOFTWARE IS OFFERED "AS IS", AND BROADCOM GRANTS NO WARRANTIES OF ANY
15658 + * KIND, EXPRESS OR IMPLIED, BY STATUTE, COMMUNICATION OR OTHERWISE. BROADCOM
15659 + * SPECIFICALLY DISCLAIMS ANY IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS
15660 + * FOR A SPECIFIC PURPOSE OR NONINFRINGEMENT CONCERNING THIS SOFTWARE.
15661 + * $Id$
15662 + */
15663 +
15664 +#include <typedefs.h>
15665 +#ifdef BCMDRIVER
15666 +#include <osl.h>
15667 +#include <sbutils.h>
15668 +#include <bcmnvram.h>
15669 +#else
15670 +#include <stdio.h>
15671 +#include <string.h>
15672 +#endif
15673 +#include <bcmutils.h>
15674 +#include <bcmendian.h>
15675 +#include <bcmdevs.h>
15676 +
15677 +#ifdef BCMDRIVER
15678 +/* copy a pkt buffer chain into a buffer */
15679 +uint
15680 +pktcopy(osl_t *osh, void *p, uint offset, int len, uchar *buf)
15681 +{
15682 +       uint n, ret = 0;
15683 +
15684 +       if (len < 0)
15685 +               len = 4096;     /* "infinite" */
15686 +
15687 +       /* skip 'offset' bytes */
15688 +       for (; p && offset; p = PKTNEXT(osh, p)) {
15689 +               if (offset < (uint)PKTLEN(osh, p))
15690 +                       break;
15691 +               offset -= PKTLEN(osh, p);
15692 +       }
15693 +
15694 +       if (!p)
15695 +               return 0;
15696 +
15697 +       /* copy the data */
15698 +       for (; p && len; p = PKTNEXT(osh, p)) {
15699 +               n = MIN((uint)PKTLEN(osh, p) - offset, (uint)len);
15700 +               bcopy(PKTDATA(osh, p) + offset, buf, n);
15701 +               buf += n;
15702 +               len -= n;
15703 +               ret += n;
15704 +               offset = 0;
15705 +       }
15706 +
15707 +       return ret;
15708 +}
15709 +
15710 +/* return total length of buffer chain */
15711 +uint
15712 +pkttotlen(osl_t *osh, void *p)
15713 +{
15714 +       uint total;
15715 +
15716 +       total = 0;
15717 +       for (; p; p = PKTNEXT(osh, p))
15718 +               total += PKTLEN(osh, p);
15719 +       return (total);
15720 +}
15721 +
15722 +void
15723 +pktq_init(struct pktq *q, uint maxlen, const uint8 prio_map[])
15724 +{
15725 +       q->head = q->tail = NULL;
15726 +       q->maxlen = maxlen;
15727 +       q->len = 0;
15728 +       if (prio_map) {
15729 +               q->priority = TRUE;
15730 +               bcopy(prio_map, q->prio_map, sizeof(q->prio_map));
15731 +       }
15732 +       else
15733 +               q->priority = FALSE;
15734 +}
15735 +
15736 +/* should always check pktq_full before calling pktenq */
15737 +void
15738 +pktenq(struct pktq *q, void *p, bool lifo)
15739 +{
15740 +       void *next, *prev;
15741 +
15742 +       /* allow 10 pkts slack */
15743 +       ASSERT(q->len < (q->maxlen + 10));
15744 +
15745 +       /* Queueing chains not allowed */
15746 +       ASSERT(PKTLINK(p) == NULL);
15747 +
15748 +       /* Queue is empty */
15749 +       if (q->tail == NULL) {
15750 +               ASSERT(q->head == NULL);
15751 +               q->head = q->tail = p;
15752 +       }
15753 +
15754 +       /* Insert at head or tail */
15755 +       else if (q->priority == FALSE) {
15756 +               /* Insert at head (LIFO) */
15757 +               if (lifo) {
15758 +                       PKTSETLINK(p, q->head);
15759 +                       q->head = p;
15760 +               }
15761 +               /* Insert at tail (FIFO) */
15762 +               else {
15763 +                       ASSERT(PKTLINK(q->tail) == NULL);
15764 +                       PKTSETLINK(q->tail, p);
15765 +                       PKTSETLINK(p, NULL);
15766 +                       q->tail = p;
15767 +               }
15768 +       }
15769 +
15770 +       /* Insert by priority */
15771 +       else {
15772 +               /* legal priorities 0-7 */
15773 +               ASSERT(PKTPRIO(p) <= MAXPRIO);
15774 +
15775 +               ASSERT(q->head);
15776 +               ASSERT(q->tail);
15777 +               /* Shortcut to insertion at tail */
15778 +               if (_pktq_pri(q, PKTPRIO(p)) < _pktq_pri(q, PKTPRIO(q->tail)) ||
15779 +                   (!lifo && _pktq_pri(q, PKTPRIO(p)) <= _pktq_pri(q, PKTPRIO(q->tail)))) {
15780 +                       prev = q->tail;
15781 +                       next = NULL;
15782 +               }
15783 +               /* Insert at head or in the middle */
15784 +               else {
15785 +                       prev = NULL;
15786 +                       next = q->head;
15787 +               }
15788 +               /* Walk the queue */
15789 +               for (; next; prev = next, next = PKTLINK(next)) {
15790 +                       /* Priority queue invariant */
15791 +                       ASSERT(!prev || _pktq_pri(q, PKTPRIO(prev)) >= _pktq_pri(q, PKTPRIO(next)));
15792 +                       /* Insert at head of string of packets of same priority (LIFO) */
15793 +                       if (lifo) {
15794 +                               if (_pktq_pri(q, PKTPRIO(p)) >= _pktq_pri(q, PKTPRIO(next)))
15795 +                                       break;
15796 +                       }
15797 +                       /* Insert at tail of string of packets of same priority (FIFO) */
15798 +                       else {
15799 +                               if (_pktq_pri(q, PKTPRIO(p)) > _pktq_pri(q, PKTPRIO(next)))
15800 +                                       break;
15801 +                       }
15802 +               }
15803 +               /* Insert at tail */
15804 +               if (next == NULL) {
15805 +                       ASSERT(PKTLINK(q->tail) == NULL);
15806 +                       PKTSETLINK(q->tail, p);
15807 +                       PKTSETLINK(p, NULL);
15808 +                       q->tail = p;
15809 +               }
15810 +               /* Insert in the middle */
15811 +               else if (prev) {
15812 +                       PKTSETLINK(prev, p);
15813 +                       PKTSETLINK(p, next);
15814 +               }
15815 +               /* Insert at head */
15816 +               else {
15817 +                       PKTSETLINK(p, q->head);
15818 +                       q->head = p;
15819 +               }
15820 +       }
15821 +
15822 +       /* List invariants after insertion */
15823 +       ASSERT(q->head);
15824 +       ASSERT(PKTLINK(q->tail) == NULL);
15825 +
15826 +       q->len++;
15827 +}
15828 +
15829 +/* dequeue packet at head */
15830 +void*
15831 +pktdeq(struct pktq *q)
15832 +{
15833 +       void *p;
15834 +
15835 +       if ((p = q->head)) {
15836 +               ASSERT(q->tail);
15837 +               q->head = PKTLINK(p);
15838 +               PKTSETLINK(p, NULL);
15839 +               q->len--;
15840 +               if (q->head == NULL)
15841 +                       q->tail = NULL;
15842 +       }
15843 +       else {
15844 +               ASSERT(q->tail == NULL);
15845 +       }
15846 +
15847 +       return (p);
15848 +}
15849 +
15850 +/* dequeue packet at tail */
15851 +void*
15852 +pktdeqtail(struct pktq *q)
15853 +{
15854 +       void *p;
15855 +       void *next, *prev;
15856 +
15857 +       if (q->head == q->tail) {  /* last packet on queue or queue empty */
15858 +               p = q->head;
15859 +               q->head = q->tail = NULL;
15860 +               q->len = 0;
15861 +               return(p);
15862 +       }
15863 +
15864 +       /* start walk at head */
15865 +       prev = NULL;
15866 +       next = q->head;
15867 +
15868 +       /* Walk the queue to find prev of q->tail */
15869 +       for (; next; prev = next, next = PKTLINK(next)) {
15870 +               if (next == q->tail)
15871 +                       break;
15872 +       }
15873 +
15874 +       ASSERT(prev);
15875 +
15876 +       PKTSETLINK(prev, NULL);
15877 +       q->tail = prev;
15878 +       q->len--;
15879 +       p = next;
15880 +
15881 +       return (p);
15882 +}
15883 +
15884 +unsigned char bcm_ctype[] = {
15885 +       _BCM_C,_BCM_C,_BCM_C,_BCM_C,_BCM_C,_BCM_C,_BCM_C,_BCM_C,                        /* 0-7 */
15886 +       _BCM_C,_BCM_C|_BCM_S,_BCM_C|_BCM_S,_BCM_C|_BCM_S,_BCM_C|_BCM_S,_BCM_C|_BCM_S,_BCM_C,_BCM_C,             /* 8-15 */
15887 +       _BCM_C,_BCM_C,_BCM_C,_BCM_C,_BCM_C,_BCM_C,_BCM_C,_BCM_C,                        /* 16-23 */
15888 +       _BCM_C,_BCM_C,_BCM_C,_BCM_C,_BCM_C,_BCM_C,_BCM_C,_BCM_C,                        /* 24-31 */
15889 +       _BCM_S|_BCM_SP,_BCM_P,_BCM_P,_BCM_P,_BCM_P,_BCM_P,_BCM_P,_BCM_P,                        /* 32-39 */
15890 +       _BCM_P,_BCM_P,_BCM_P,_BCM_P,_BCM_P,_BCM_P,_BCM_P,_BCM_P,                        /* 40-47 */
15891 +       _BCM_D,_BCM_D,_BCM_D,_BCM_D,_BCM_D,_BCM_D,_BCM_D,_BCM_D,                        /* 48-55 */
15892 +       _BCM_D,_BCM_D,_BCM_P,_BCM_P,_BCM_P,_BCM_P,_BCM_P,_BCM_P,                        /* 56-63 */
15893 +       _BCM_P,_BCM_U|_BCM_X,_BCM_U|_BCM_X,_BCM_U|_BCM_X,_BCM_U|_BCM_X,_BCM_U|_BCM_X,_BCM_U|_BCM_X,_BCM_U,      /* 64-71 */
15894 +       _BCM_U,_BCM_U,_BCM_U,_BCM_U,_BCM_U,_BCM_U,_BCM_U,_BCM_U,                        /* 72-79 */
15895 +       _BCM_U,_BCM_U,_BCM_U,_BCM_U,_BCM_U,_BCM_U,_BCM_U,_BCM_U,                        /* 80-87 */
15896 +       _BCM_U,_BCM_U,_BCM_U,_BCM_P,_BCM_P,_BCM_P,_BCM_P,_BCM_P,                        /* 88-95 */
15897 +       _BCM_P,_BCM_L|_BCM_X,_BCM_L|_BCM_X,_BCM_L|_BCM_X,_BCM_L|_BCM_X,_BCM_L|_BCM_X,_BCM_L|_BCM_X,_BCM_L,      /* 96-103 */
15898 +       _BCM_L,_BCM_L,_BCM_L,_BCM_L,_BCM_L,_BCM_L,_BCM_L,_BCM_L,                        /* 104-111 */
15899 +       _BCM_L,_BCM_L,_BCM_L,_BCM_L,_BCM_L,_BCM_L,_BCM_L,_BCM_L,                        /* 112-119 */
15900 +       _BCM_L,_BCM_L,_BCM_L,_BCM_P,_BCM_P,_BCM_P,_BCM_P,_BCM_C,                        /* 120-127 */
15901 +       0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,                /* 128-143 */
15902 +       0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,                /* 144-159 */
15903 +       _BCM_S|_BCM_SP,_BCM_P,_BCM_P,_BCM_P,_BCM_P,_BCM_P,_BCM_P,_BCM_P,_BCM_P,_BCM_P,_BCM_P,_BCM_P,_BCM_P,_BCM_P,_BCM_P,_BCM_P,   /* 160-175 */
15904 +       _BCM_P,_BCM_P,_BCM_P,_BCM_P,_BCM_P,_BCM_P,_BCM_P,_BCM_P,_BCM_P,_BCM_P,_BCM_P,_BCM_P,_BCM_P,_BCM_P,_BCM_P,_BCM_P,       /* 176-191 */
15905 +       _BCM_U,_BCM_U,_BCM_U,_BCM_U,_BCM_U,_BCM_U,_BCM_U,_BCM_U,_BCM_U,_BCM_U,_BCM_U,_BCM_U,_BCM_U,_BCM_U,_BCM_U,_BCM_U,       /* 192-207 */
15906 +       _BCM_U,_BCM_U,_BCM_U,_BCM_U,_BCM_U,_BCM_U,_BCM_U,_BCM_P,_BCM_U,_BCM_U,_BCM_U,_BCM_U,_BCM_U,_BCM_U,_BCM_U,_BCM_L,       /* 208-223 */
15907 +       _BCM_L,_BCM_L,_BCM_L,_BCM_L,_BCM_L,_BCM_L,_BCM_L,_BCM_L,_BCM_L,_BCM_L,_BCM_L,_BCM_L,_BCM_L,_BCM_L,_BCM_L,_BCM_L,       /* 224-239 */
15908 +       _BCM_L,_BCM_L,_BCM_L,_BCM_L,_BCM_L,_BCM_L,_BCM_L,_BCM_P,_BCM_L,_BCM_L,_BCM_L,_BCM_L,_BCM_L,_BCM_L,_BCM_L,_BCM_L        /* 240-255 */
15909 +};
15910 +
15911 +uchar
15912 +bcm_toupper(uchar c)
15913 +{
15914 +       if (bcm_islower(c))
15915 +               c -= 'a'-'A';
15916 +       return (c);
15917 +}
15918 +
15919 +ulong
15920 +bcm_strtoul(char *cp, char **endp, uint base)
15921 +{
15922 +       ulong result, value;
15923 +       bool minus;
15924 +
15925 +       minus = FALSE;
15926 +
15927 +       while (bcm_isspace(*cp))
15928 +               cp++;
15929 +
15930 +       if (cp[0] == '+')
15931 +               cp++;
15932 +       else if (cp[0] == '-') {
15933 +               minus = TRUE;
15934 +               cp++;
15935 +       }
15936 +
15937 +       if (base == 0) {
15938 +               if (cp[0] == '0') {
15939 +                       if ((cp[1] == 'x') || (cp[1] == 'X')) {
15940 +                               base = 16;
15941 +                               cp = &cp[2];
15942 +                       } else {
15943 +                               base = 8;
15944 +                               cp = &cp[1];
15945 +                       }
15946 +               } else
15947 +                       base = 10;
15948 +       } else if (base == 16 && (cp[0] == '0') && ((cp[1] == 'x') || (cp[1] == 'X'))) {
15949 +               cp = &cp[2];
15950 +       }
15951 +
15952 +       result = 0;
15953 +
15954 +       while (bcm_isxdigit(*cp) &&
15955 +              (value = bcm_isdigit(*cp) ? *cp-'0' : bcm_toupper(*cp)-'A'+10) < base) {
15956 +               result = result*base + value;
15957 +               cp++;
15958 +       }
15959 +
15960 +       if (minus)
15961 +               result = (ulong)(result * -1);
15962 +
15963 +       if (endp)
15964 +               *endp = (char *)cp;
15965 +
15966 +       return (result);
15967 +}
15968 +
15969 +uint
15970 +bcm_atoi(char *s)
15971 +{
15972 +       uint n;
15973 +
15974 +       n = 0;
15975 +
15976 +       while (bcm_isdigit(*s))
15977 +               n = (n * 10) + *s++ - '0';
15978 +       return (n);
15979 +}
15980 +
15981 +/* return pointer to location of substring 'needle' in 'haystack' */
15982 +char*
15983 +bcmstrstr(char *haystack, char *needle)
15984 +{
15985 +       int len, nlen;
15986 +       int i;
15987 +
15988 +       if ((haystack == NULL) || (needle == NULL))
15989 +               return (haystack);
15990 +
15991 +       nlen = strlen(needle);
15992 +       len = strlen(haystack) - nlen + 1;
15993 +
15994 +       for (i = 0; i < len; i++)
15995 +               if (bcmp(needle, &haystack[i], nlen) == 0)
15996 +                       return (&haystack[i]);
15997 +       return (NULL);
15998 +}
15999 +
16000 +char*
16001 +bcmstrcat(char *dest, const char *src)
16002 +{
16003 +       strcpy(&dest[strlen(dest)], src);
16004 +       return (dest);
16005 +}
16006 +
16007 +#if defined(CONFIG_USBRNDIS_RETAIL) || defined(NDIS_MINIPORT_DRIVER)
16008 +/* registry routine buffer preparation utility functions:
16009 + * parameter order is like strncpy, but returns count
16010 + * of bytes copied. Minimum bytes copied is null char(1)/wchar(2)
16011 + */
16012 +ulong
16013 +wchar2ascii(
16014 +       char *abuf,
16015 +       ushort *wbuf,
16016 +       ushort wbuflen,
16017 +       ulong abuflen
16018 +)
16019 +{
16020 +       ulong copyct = 1;
16021 +       ushort i;
16022 +
16023 +       if (abuflen == 0)
16024 +               return 0;
16025 +
16026 +       /* wbuflen is in bytes */
16027 +       wbuflen /= sizeof(ushort);
16028 +
16029 +       for (i = 0; i < wbuflen; ++i) {
16030 +               if (--abuflen == 0)
16031 +                       break;
16032 +               *abuf++ = (char) *wbuf++;
16033 +               ++copyct;
16034 +       }
16035 +       *abuf = '\0';
16036 +
16037 +       return copyct;
16038 +}
16039 +#endif
16040 +
16041 +char*
16042 +bcm_ether_ntoa(char *ea, char *buf)
16043 +{
16044 +       sprintf(buf,"%02x:%02x:%02x:%02x:%02x:%02x",
16045 +               (uchar)ea[0]&0xff, (uchar)ea[1]&0xff, (uchar)ea[2]&0xff,
16046 +               (uchar)ea[3]&0xff, (uchar)ea[4]&0xff, (uchar)ea[5]&0xff);
16047 +       return (buf);
16048 +}
16049 +
16050 +/* parse a xx:xx:xx:xx:xx:xx format ethernet address */
16051 +int
16052 +bcm_ether_atoe(char *p, char *ea)
16053 +{
16054 +       int i = 0;
16055 +
16056 +       for (;;) {
16057 +               ea[i++] = (char) bcm_strtoul(p, &p, 16);
16058 +               if (!*p++ || i == 6)
16059 +                       break;
16060 +       }
16061 +
16062 +       return (i == 6);
16063 +}
16064 +
16065 +void
16066 +bcm_mdelay(uint ms)
16067 +{
16068 +       uint i;
16069 +
16070 +       for (i = 0; i < ms; i++) {
16071 +               OSL_DELAY(1000);
16072 +       }
16073 +}
16074 +
16075 +/*
16076 + * Search the name=value vars for a specific one and return its value.
16077 + * Returns NULL if not found.
16078 + */
16079 +char*
16080 +getvar(char *vars, char *name)
16081 +{
16082 +       char *s;
16083 +       int len;
16084 +
16085 +       len = strlen(name);
16086 +
16087 +       /* first look in vars[] */
16088 +       for (s = vars; s && *s; ) {
16089 +               if ((bcmp(s, name, len) == 0) && (s[len] == '='))
16090 +                       return (&s[len+1]);
16091 +
16092 +               while (*s++)
16093 +                       ;
16094 +       }
16095 +
16096 +       /* then query nvram */
16097 +       return (BCMINIT(nvram_get)(name));
16098 +}
16099 +
16100 +/*
16101 + * Search the vars for a specific one and return its value as
16102 + * an integer. Returns 0 if not found.
16103 + */
16104 +int
16105 +getintvar(char *vars, char *name)
16106 +{
16107 +       char *val;
16108 +
16109 +       if ((val = getvar(vars, name)) == NULL)
16110 +               return (0);
16111 +
16112 +       return (bcm_strtoul(val, NULL, 0));
16113 +}
16114 +
16115 +
16116 +/* Search for token in comma separated token-string */
16117 +static int
16118 +findmatch(char *string, char *name)
16119 +{
16120 +       uint len;
16121 +       char *c;
16122 +
16123 +       len = strlen(name);
16124 +       while ((c = strchr(string, ',')) != NULL) {
16125 +               if (len == (uint)(c - string) && !strncmp(string, name, len))
16126 +                       return 1;
16127 +               string = c + 1;
16128 +       }
16129 +
16130 +       return (!strcmp(string, name));
16131 +}
16132 +
16133 +/* Return gpio pin number assigned to the named pin */
16134 +/*
16135 +* Variable should be in format:
16136 +*
16137 +*      gpio<N>=pin_name,pin_name
16138 +*
16139 +* This format allows multiple features to share the gpio with mutual
16140 +* understanding.
16141 +*
16142 +* 'def_pin' is returned if a specific gpio is not defined for the requested functionality
16143 +* and if def_pin is not used by others.
16144 +*/
16145 +uint
16146 +getgpiopin(char *vars, char *pin_name, uint def_pin)
16147 +{
16148 +       char name[] = "gpioXXXX";
16149 +       char *val;
16150 +       uint pin;
16151 +
16152 +       /* Go thru all possibilities till a match in pin name */
16153 +       for (pin = 0; pin < GPIO_NUMPINS; pin ++) {
16154 +               sprintf(name, "gpio%d", pin);
16155 +               val = getvar(vars, name);
16156 +               if (val && findmatch(val, pin_name))
16157 +                       return pin;
16158 +       }
16159 +
16160 +       if (def_pin != GPIO_PIN_NOTDEFINED) {
16161 +               /* make sure the default pin is not used by someone else */
16162 +               sprintf(name, "gpio%d", def_pin);
16163 +               if (getvar(vars, name)) {
16164 +                       def_pin =  GPIO_PIN_NOTDEFINED;
16165 +               }
16166 +       }
16167 +
16168 +       return def_pin;
16169 +}
16170 +
16171 +
16172 +static char bcm_undeferrstr[BCME_STRLEN];
16173 +
16174 +static const char *bcmerrorstrtable[] =  \
16175 +{      "OK",                           /* 0 */
16176 +       "Undefined error",              /* BCME_ERROR */
16177 +       "Bad Argument",                 /* BCME_BADARG*/
16178 +       "Bad Option",                   /* BCME_BADOPTION*/
16179 +       "Not up",                       /* BCME_NOTUP */
16180 +       "Not down",                     /* BCME_NOTDOWN */
16181 +       "Not AP",                       /* BCME_NOTAP */
16182 +       "Not STA",                      /* BCME_NOTSTA */
16183 +       "Bad Key Index",                /* BCME_BADKEYIDX */
16184 +       "Radio Off",                    /* BCME_RADIOOFF */
16185 +       "Not band locked",              /* BCME_NOTBANDLOCKED */
16186 +       "No clock",                     /* BCME_NOCLK */
16187 +       "Bad Rate valueset",            /* BCME_BADRATESET */
16188 +       "Bad Band",                     /* BCME_BADBAND */
16189 +       "Buffer too short",             /* BCME_BUFTOOSHORT */
16190 +       "Buffer too length",            /* BCME_BUFTOOLONG */
16191 +       "Busy",                         /* BCME_BUSY */
16192 +       "Not Associated",               /* BCME_NOTASSOCIATED */
16193 +       "Bad SSID len",                 /* BCME_BADSSIDLEN */
16194 +       "Out of Range Channel",         /* BCME_OUTOFRANGECHAN */
16195 +       "Bad Channel",                  /* BCME_BADCHAN */
16196 +       "Bad Address",                  /* BCME_BADADDR */
16197 +       "Not Enough Resources",         /* BCME_NORESOURCE */
16198 +       "Unsupported",                  /* BCME_UNSUPPORTED */
16199 +       "Bad length",                   /* BCME_BADLENGTH */
16200 +       "Not Ready",                    /* BCME_NOTREADY */
16201 +       "Not Permitted",                /* BCME_EPERM */
16202 +       "No Memory",                    /* BCME_NOMEM */
16203 +       "Associated",                   /* BCME_ASSOCIATED */
16204 +       "Not In Range",                 /* BCME_RANGE */
16205 +       "Not Found"                     /* BCME_NOTFOUND */
16206 +       };
16207 +
16208 +/* Convert the Error codes into related Error strings  */
16209 +const char *
16210 +bcmerrorstr(int bcmerror)
16211 +{
16212 +       int abs_bcmerror;
16213 +
16214 +       abs_bcmerror = ABS(bcmerror);
16215 +
16216 +       /* check if someone added a bcmerror code but forgot to add errorstring */
16217 +       ASSERT(ABS(BCME_LAST) == (ARRAYSIZE(bcmerrorstrtable) - 1));
16218 +       if ( (bcmerror > 0) || (abs_bcmerror > ABS(BCME_LAST))) {
16219 +               sprintf(bcm_undeferrstr, "undefined Error %d", bcmerror);
16220 +               return bcm_undeferrstr;
16221 +       }
16222 +
16223 +       ASSERT((strlen((char*)bcmerrorstrtable[abs_bcmerror])) < BCME_STRLEN);
16224 +
16225 +       return bcmerrorstrtable[abs_bcmerror];
16226 +}
16227 +#endif /* #ifdef BCMDRIVER */
16228 +
16229 +
16230 +/*******************************************************************************
16231 + * crc8
16232 + *
16233 + * Computes a crc8 over the input data using the polynomial:
16234 + *
16235 + *       x^8 + x^7 +x^6 + x^4 + x^2 + 1
16236 + *
16237 + * The caller provides the initial value (either CRC8_INIT_VALUE
16238 + * or the previous returned value) to allow for processing of
16239 + * discontiguous blocks of data.  When generating the CRC the
16240 + * caller is responsible for complementing the final return value
16241 + * and inserting it into the byte stream.  When checking, a final
16242 + * return value of CRC8_GOOD_VALUE indicates a valid CRC.
16243 + *
16244 + * Reference: Dallas Semiconductor Application Note 27
16245 + *   Williams, Ross N., "A Painless Guide to CRC Error Detection Algorithms",
16246 + *     ver 3, Aug 1993, ross@guest.adelaide.edu.au, Rocksoft Pty Ltd.,
16247 + *     ftp://ftp.rocksoft.com/clients/rocksoft/papers/crc_v3.txt
16248 + *
16249 + ******************************************************************************/
16250 +
16251 +static uint8 crc8_table[256] = {
16252 +    0x00, 0xF7, 0xB9, 0x4E, 0x25, 0xD2, 0x9C, 0x6B,
16253 +    0x4A, 0xBD, 0xF3, 0x04, 0x6F, 0x98, 0xD6, 0x21,
16254 +    0x94, 0x63, 0x2D, 0xDA, 0xB1, 0x46, 0x08, 0xFF,
16255 +    0xDE, 0x29, 0x67, 0x90, 0xFB, 0x0C, 0x42, 0xB5,
16256 +    0x7F, 0x88, 0xC6, 0x31, 0x5A, 0xAD, 0xE3, 0x14,
16257 +    0x35, 0xC2, 0x8C, 0x7B, 0x10, 0xE7, 0xA9, 0x5E,
16258 +    0xEB, 0x1C, 0x52, 0xA5, 0xCE, 0x39, 0x77, 0x80,
16259 +    0xA1, 0x56, 0x18, 0xEF, 0x84, 0x73, 0x3D, 0xCA,
16260 +    0xFE, 0x09, 0x47, 0xB0, 0xDB, 0x2C, 0x62, 0x95,
16261 +    0xB4, 0x43, 0x0D, 0xFA, 0x91, 0x66, 0x28, 0xDF,
16262 +    0x6A, 0x9D, 0xD3, 0x24, 0x4F, 0xB8, 0xF6, 0x01,
16263 +    0x20, 0xD7, 0x99, 0x6E, 0x05, 0xF2, 0xBC, 0x4B,
16264 +    0x81, 0x76, 0x38, 0xCF, 0xA4, 0x53, 0x1D, 0xEA,
16265 +    0xCB, 0x3C, 0x72, 0x85, 0xEE, 0x19, 0x57, 0xA0,
16266 +    0x15, 0xE2, 0xAC, 0x5B, 0x30, 0xC7, 0x89, 0x7E,
16267 +    0x5F, 0xA8, 0xE6, 0x11, 0x7A, 0x8D, 0xC3, 0x34,
16268 +    0xAB, 0x5C, 0x12, 0xE5, 0x8E, 0x79, 0x37, 0xC0,
16269 +    0xE1, 0x16, 0x58, 0xAF, 0xC4, 0x33, 0x7D, 0x8A,
16270 +    0x3F, 0xC8, 0x86, 0x71, 0x1A, 0xED, 0xA3, 0x54,
16271 +    0x75, 0x82, 0xCC, 0x3B, 0x50, 0xA7, 0xE9, 0x1E,
16272 +    0xD4, 0x23, 0x6D, 0x9A, 0xF1, 0x06, 0x48, 0xBF,
16273 +    0x9E, 0x69, 0x27, 0xD0, 0xBB, 0x4C, 0x02, 0xF5,
16274 +    0x40, 0xB7, 0xF9, 0x0E, 0x65, 0x92, 0xDC, 0x2B,
16275 +    0x0A, 0xFD, 0xB3, 0x44, 0x2F, 0xD8, 0x96, 0x61,
16276 +    0x55, 0xA2, 0xEC, 0x1B, 0x70, 0x87, 0xC9, 0x3E,
16277 +    0x1F, 0xE8, 0xA6, 0x51, 0x3A, 0xCD, 0x83, 0x74,
16278 +    0xC1, 0x36, 0x78, 0x8F, 0xE4, 0x13, 0x5D, 0xAA,
16279 +    0x8B, 0x7C, 0x32, 0xC5, 0xAE, 0x59, 0x17, 0xE0,
16280 +    0x2A, 0xDD, 0x93, 0x64, 0x0F, 0xF8, 0xB6, 0x41,
16281 +    0x60, 0x97, 0xD9, 0x2E, 0x45, 0xB2, 0xFC, 0x0B,
16282 +    0xBE, 0x49, 0x07, 0xF0, 0x9B, 0x6C, 0x22, 0xD5,
16283 +    0xF4, 0x03, 0x4D, 0xBA, 0xD1, 0x26, 0x68, 0x9F
16284 +};
16285 +
16286 +#define CRC_INNER_LOOP(n, c, x) \
16287 +    (c) = ((c) >> 8) ^ crc##n##_table[((c) ^ (x)) & 0xff]
16288 +
16289 +uint8
16290 +hndcrc8(
16291 +       uint8 *pdata,   /* pointer to array of data to process */
16292 +       uint  nbytes,   /* number of input data bytes to process */
16293 +       uint8 crc       /* either CRC8_INIT_VALUE or previous return value */
16294 +)
16295 +{
16296 +       /* hard code the crc loop instead of using CRC_INNER_LOOP macro
16297 +        * to avoid the undefined and unnecessary (uint8 >> 8) operation. */
16298 +       while (nbytes-- > 0)
16299 +               crc = crc8_table[(crc ^ *pdata++) & 0xff];
16300 +
16301 +       return crc;
16302 +}
16303 +
16304 +/*******************************************************************************
16305 + * crc16
16306 + *
16307 + * Computes a crc16 over the input data using the polynomial:
16308 + *
16309 + *       x^16 + x^12 +x^5 + 1
16310 + *
16311 + * The caller provides the initial value (either CRC16_INIT_VALUE
16312 + * or the previous returned value) to allow for processing of
16313 + * discontiguous blocks of data.  When generating the CRC the
16314 + * caller is responsible for complementing the final return value
16315 + * and inserting it into the byte stream.  When checking, a final
16316 + * return value of CRC16_GOOD_VALUE indicates a valid CRC.
16317 + *
16318 + * Reference: Dallas Semiconductor Application Note 27
16319 + *   Williams, Ross N., "A Painless Guide to CRC Error Detection Algorithms",
16320 + *     ver 3, Aug 1993, ross@guest.adelaide.edu.au, Rocksoft Pty Ltd.,
16321 + *     ftp://ftp.rocksoft.com/clients/rocksoft/papers/crc_v3.txt
16322 + *
16323 + ******************************************************************************/
16324 +
16325 +static uint16 crc16_table[256] = {
16326 +    0x0000, 0x1189, 0x2312, 0x329B, 0x4624, 0x57AD, 0x6536, 0x74BF,
16327 +    0x8C48, 0x9DC1, 0xAF5A, 0xBED3, 0xCA6C, 0xDBE5, 0xE97E, 0xF8F7,
16328 +    0x1081, 0x0108, 0x3393, 0x221A, 0x56A5, 0x472C, 0x75B7, 0x643E,
16329 +    0x9CC9, 0x8D40, 0xBFDB, 0xAE52, 0xDAED, 0xCB64, 0xF9FF, 0xE876,
16330 +    0x2102, 0x308B, 0x0210, 0x1399, 0x6726, 0x76AF, 0x4434, 0x55BD,
16331 +    0xAD4A, 0xBCC3, 0x8E58, 0x9FD1, 0xEB6E, 0xFAE7, 0xC87C, 0xD9F5,
16332 +    0x3183, 0x200A, 0x1291, 0x0318, 0x77A7, 0x662E, 0x54B5, 0x453C,
16333 +    0xBDCB, 0xAC42, 0x9ED9, 0x8F50, 0xFBEF, 0xEA66, 0xD8FD, 0xC974,
16334 +    0x4204, 0x538D, 0x6116, 0x709F, 0x0420, 0x15A9, 0x2732, 0x36BB,
16335 +    0xCE4C, 0xDFC5, 0xED5E, 0xFCD7, 0x8868, 0x99E1, 0xAB7A, 0xBAF3,
16336 +    0x5285, 0x430C, 0x7197, 0x601E, 0x14A1, 0x0528, 0x37B3, 0x263A,
16337 +    0xDECD, 0xCF44, 0xFDDF, 0xEC56, 0x98E9, 0x8960, 0xBBFB, 0xAA72,
16338 +    0x6306, 0x728F, 0x4014, 0x519D, 0x2522, 0x34AB, 0x0630, 0x17B9,
16339 +    0xEF4E, 0xFEC7, 0xCC5C, 0xDDD5, 0xA96A, 0xB8E3, 0x8A78, 0x9BF1,
16340 +    0x7387, 0x620E, 0x5095, 0x411C, 0x35A3, 0x242A, 0x16B1, 0x0738,
16341 +    0xFFCF, 0xEE46, 0xDCDD, 0xCD54, 0xB9EB, 0xA862, 0x9AF9, 0x8B70,
16342 +    0x8408, 0x9581, 0xA71A, 0xB693, 0xC22C, 0xD3A5, 0xE13E, 0xF0B7,
16343 +    0x0840, 0x19C9, 0x2B52, 0x3ADB, 0x4E64, 0x5FED, 0x6D76, 0x7CFF,
16344 +    0x9489, 0x8500, 0xB79B, 0xA612, 0xD2AD, 0xC324, 0xF1BF, 0xE036,
16345 +    0x18C1, 0x0948, 0x3BD3, 0x2A5A, 0x5EE5, 0x4F6C, 0x7DF7, 0x6C7E,
16346 +    0xA50A, 0xB483, 0x8618, 0x9791, 0xE32E, 0xF2A7, 0xC03C, 0xD1B5,
16347 +    0x2942, 0x38CB, 0x0A50, 0x1BD9, 0x6F66, 0x7EEF, 0x4C74, 0x5DFD,
16348 +    0xB58B, 0xA402, 0x9699, 0x8710, 0xF3AF, 0xE226, 0xD0BD, 0xC134,
16349 +    0x39C3, 0x284A, 0x1AD1, 0x0B58, 0x7FE7, 0x6E6E, 0x5CF5, 0x4D7C,
16350 +    0xC60C, 0xD785, 0xE51E, 0xF497, 0x8028, 0x91A1, 0xA33A, 0xB2B3,
16351 +    0x4A44, 0x5BCD, 0x6956, 0x78DF, 0x0C60, 0x1DE9, 0x2F72, 0x3EFB,
16352 +    0xD68D, 0xC704, 0xF59F, 0xE416, 0x90A9, 0x8120, 0xB3BB, 0xA232,
16353 +    0x5AC5, 0x4B4C, 0x79D7, 0x685E, 0x1CE1, 0x0D68, 0x3FF3, 0x2E7A,
16354 +    0xE70E, 0xF687, 0xC41C, 0xD595, 0xA12A, 0xB0A3, 0x8238, 0x93B1,
16355 +    0x6B46, 0x7ACF, 0x4854, 0x59DD, 0x2D62, 0x3CEB, 0x0E70, 0x1FF9,
16356 +    0xF78F, 0xE606, 0xD49D, 0xC514, 0xB1AB, 0xA022, 0x92B9, 0x8330,
16357 +    0x7BC7, 0x6A4E, 0x58D5, 0x495C, 0x3DE3, 0x2C6A, 0x1EF1, 0x0F78
16358 +};
16359 +
16360 +uint16
16361 +hndcrc16(
16362 +    uint8 *pdata,  /* pointer to array of data to process */
16363 +    uint nbytes, /* number of input data bytes to process */
16364 +    uint16 crc     /* either CRC16_INIT_VALUE or previous return value */
16365 +)
16366 +{
16367 +    while (nbytes-- > 0)
16368 +        CRC_INNER_LOOP(16, crc, *pdata++);
16369 +    return crc;
16370 +}
16371 +
16372 +static uint32 crc32_table[256] = {
16373 +    0x00000000, 0x77073096, 0xEE0E612C, 0x990951BA,
16374 +    0x076DC419, 0x706AF48F, 0xE963A535, 0x9E6495A3,
16375 +    0x0EDB8832, 0x79DCB8A4, 0xE0D5E91E, 0x97D2D988,
16376 +    0x09B64C2B, 0x7EB17CBD, 0xE7B82D07, 0x90BF1D91,
16377 +    0x1DB71064, 0x6AB020F2, 0xF3B97148, 0x84BE41DE,
16378 +    0x1ADAD47D, 0x6DDDE4EB, 0xF4D4B551, 0x83D385C7,
16379 +    0x136C9856, 0x646BA8C0, 0xFD62F97A, 0x8A65C9EC,
16380 +    0x14015C4F, 0x63066CD9, 0xFA0F3D63, 0x8D080DF5,
16381 +    0x3B6E20C8, 0x4C69105E, 0xD56041E4, 0xA2677172,
16382 +    0x3C03E4D1, 0x4B04D447, 0xD20D85FD, 0xA50AB56B,
16383 +    0x35B5A8FA, 0x42B2986C, 0xDBBBC9D6, 0xACBCF940,
16384 +    0x32D86CE3, 0x45DF5C75, 0xDCD60DCF, 0xABD13D59,
16385 +    0x26D930AC, 0x51DE003A, 0xC8D75180, 0xBFD06116,
16386 +    0x21B4F4B5, 0x56B3C423, 0xCFBA9599, 0xB8BDA50F,
16387 +    0x2802B89E, 0x5F058808, 0xC60CD9B2, 0xB10BE924,
16388 +    0x2F6F7C87, 0x58684C11, 0xC1611DAB, 0xB6662D3D,
16389 +    0x76DC4190, 0x01DB7106, 0x98D220BC, 0xEFD5102A,
16390 +    0x71B18589, 0x06B6B51F, 0x9FBFE4A5, 0xE8B8D433,
16391 +    0x7807C9A2, 0x0F00F934, 0x9609A88E, 0xE10E9818,
16392 +    0x7F6A0DBB, 0x086D3D2D, 0x91646C97, 0xE6635C01,
16393 +    0x6B6B51F4, 0x1C6C6162, 0x856530D8, 0xF262004E,
16394 +    0x6C0695ED, 0x1B01A57B, 0x8208F4C1, 0xF50FC457,
16395 +    0x65B0D9C6, 0x12B7E950, 0x8BBEB8EA, 0xFCB9887C,
16396 +    0x62DD1DDF, 0x15DA2D49, 0x8CD37CF3, 0xFBD44C65,
16397 +    0x4DB26158, 0x3AB551CE, 0xA3BC0074, 0xD4BB30E2,
16398 +    0x4ADFA541, 0x3DD895D7, 0xA4D1C46D, 0xD3D6F4FB,
16399 +    0x4369E96A, 0x346ED9FC, 0xAD678846, 0xDA60B8D0,
16400 +    0x44042D73, 0x33031DE5, 0xAA0A4C5F, 0xDD0D7CC9,
16401 +    0x5005713C, 0x270241AA, 0xBE0B1010, 0xC90C2086,
16402 +    0x5768B525, 0x206F85B3, 0xB966D409, 0xCE61E49F,
16403 +    0x5EDEF90E, 0x29D9C998, 0xB0D09822, 0xC7D7A8B4,
16404 +    0x59B33D17, 0x2EB40D81, 0xB7BD5C3B, 0xC0BA6CAD,
16405 +    0xEDB88320, 0x9ABFB3B6, 0x03B6E20C, 0x74B1D29A,
16406 +    0xEAD54739, 0x9DD277AF, 0x04DB2615, 0x73DC1683,
16407 +    0xE3630B12, 0x94643B84, 0x0D6D6A3E, 0x7A6A5AA8,
16408 +    0xE40ECF0B, 0x9309FF9D, 0x0A00AE27, 0x7D079EB1,
16409 +    0xF00F9344, 0x8708A3D2, 0x1E01F268, 0x6906C2FE,
16410 +    0xF762575D, 0x806567CB, 0x196C3671, 0x6E6B06E7,
16411 +    0xFED41B76, 0x89D32BE0, 0x10DA7A5A, 0x67DD4ACC,
16412 +    0xF9B9DF6F, 0x8EBEEFF9, 0x17B7BE43, 0x60B08ED5,
16413 +    0xD6D6A3E8, 0xA1D1937E, 0x38D8C2C4, 0x4FDFF252,
16414 +    0xD1BB67F1, 0xA6BC5767, 0x3FB506DD, 0x48B2364B,
16415 +    0xD80D2BDA, 0xAF0A1B4C, 0x36034AF6, 0x41047A60,
16416 +    0xDF60EFC3, 0xA867DF55, 0x316E8EEF, 0x4669BE79,
16417 +    0xCB61B38C, 0xBC66831A, 0x256FD2A0, 0x5268E236,
16418 +    0xCC0C7795, 0xBB0B4703, 0x220216B9, 0x5505262F,
16419 +    0xC5BA3BBE, 0xB2BD0B28, 0x2BB45A92, 0x5CB36A04,
16420 +    0xC2D7FFA7, 0xB5D0CF31, 0x2CD99E8B, 0x5BDEAE1D,
16421 +    0x9B64C2B0, 0xEC63F226, 0x756AA39C, 0x026D930A,
16422 +    0x9C0906A9, 0xEB0E363F, 0x72076785, 0x05005713,
16423 +    0x95BF4A82, 0xE2B87A14, 0x7BB12BAE, 0x0CB61B38,
16424 +    0x92D28E9B, 0xE5D5BE0D, 0x7CDCEFB7, 0x0BDBDF21,
16425 +    0x86D3D2D4, 0xF1D4E242, 0x68DDB3F8, 0x1FDA836E,
16426 +    0x81BE16CD, 0xF6B9265B, 0x6FB077E1, 0x18B74777,
16427 +    0x88085AE6, 0xFF0F6A70, 0x66063BCA, 0x11010B5C,
16428 +    0x8F659EFF, 0xF862AE69, 0x616BFFD3, 0x166CCF45,
16429 +    0xA00AE278, 0xD70DD2EE, 0x4E048354, 0x3903B3C2,
16430 +    0xA7672661, 0xD06016F7, 0x4969474D, 0x3E6E77DB,
16431 +    0xAED16A4A, 0xD9D65ADC, 0x40DF0B66, 0x37D83BF0,
16432 +    0xA9BCAE53, 0xDEBB9EC5, 0x47B2CF7F, 0x30B5FFE9,
16433 +    0xBDBDF21C, 0xCABAC28A, 0x53B39330, 0x24B4A3A6,
16434 +    0xBAD03605, 0xCDD70693, 0x54DE5729, 0x23D967BF,
16435 +    0xB3667A2E, 0xC4614AB8, 0x5D681B02, 0x2A6F2B94,
16436 +    0xB40BBE37, 0xC30C8EA1, 0x5A05DF1B, 0x2D02EF8D
16437 +};
16438 +
16439 +uint32
16440 +hndcrc32(
16441 +    uint8 *pdata,  /* pointer to array of data to process */
16442 +    uint   nbytes, /* number of input data bytes to process */
16443 +    uint32 crc     /* either CRC32_INIT_VALUE or previous return value */
16444 +)
16445 +{
16446 +    uint8 *pend;
16447 +#ifdef __mips__
16448 +    uint8 tmp[4];
16449 +    ulong *tptr = (ulong *)tmp;
16450 +
16451 +       /* in case the beginning of the buffer isn't aligned */
16452 +       pend = (uint8 *)((uint)(pdata + 3) & 0xfffffffc);
16453 +       nbytes -= (pend - pdata);
16454 +       while (pdata < pend)
16455 +               CRC_INNER_LOOP(32, crc, *pdata++);
16456 +
16457 +    /* handle bulk of data as 32-bit words */
16458 +    pend = pdata + (nbytes & 0xfffffffc);
16459 +    while (pdata < pend) {
16460 +               tptr = *((ulong *) pdata);
16461 +               *((ulong *) pdata) += 1;
16462 +        CRC_INNER_LOOP(32, crc, tmp[0]);
16463 +        CRC_INNER_LOOP(32, crc, tmp[1]);
16464 +        CRC_INNER_LOOP(32, crc, tmp[2]);
16465 +        CRC_INNER_LOOP(32, crc, tmp[3]);
16466 +    }
16467 +
16468 +    /* 1-3 bytes at end of buffer */
16469 +    pend = pdata + (nbytes & 0x03);
16470 +    while (pdata < pend)
16471 +        CRC_INNER_LOOP(32, crc, *pdata++);
16472 +#else
16473 +    pend = pdata + nbytes;
16474 +    while (pdata < pend)
16475 +        CRC_INNER_LOOP(32, crc, *pdata++);
16476 +#endif
16477 +
16478 +    return crc;
16479 +}
16480 +
16481 +#ifdef notdef
16482 +#define CLEN   1499
16483 +#define CBUFSIZ        (CLEN+4)
16484 +#define CNBUFS         5
16485 +
16486 +void testcrc32(void)
16487 +{
16488 +       uint j,k,l;
16489 +       uint8 *buf;
16490 +       uint len[CNBUFS];
16491 +       uint32 crcr;
16492 +       uint32 crc32tv[CNBUFS] =
16493 +               {0xd2cb1faa, 0xd385c8fa, 0xf5b4f3f3, 0x55789e20, 0x00343110};
16494 +
16495 +       ASSERT((buf = MALLOC(CBUFSIZ*CNBUFS)) != NULL);
16496 +
16497 +       /* step through all possible alignments */
16498 +       for (l=0;l<=4;l++) {
16499 +               for (j=0; j<CNBUFS; j++) {
16500 +                       len[j] = CLEN;
16501 +                       for (k=0; k<len[j]; k++)
16502 +                               *(buf + j*CBUFSIZ + (k+l)) = (j+k) & 0xff;
16503 +               }
16504 +
16505 +               for (j=0; j<CNBUFS; j++) {
16506 +                       crcr = crc32(buf + j*CBUFSIZ + l, len[j], CRC32_INIT_VALUE);
16507 +                       ASSERT(crcr == crc32tv[j]);
16508 +               }
16509 +       }
16510 +
16511 +       MFREE(buf, CBUFSIZ*CNBUFS);
16512 +       return;
16513 +}
16514 +#endif
16515 +
16516 +
16517 +/*
16518 + * Advance from the current 1-byte tag/1-byte length/variable-length value
16519 + * triple, to the next, returning a pointer to the next.
16520 + * If the current or next TLV is invalid (does not fit in given buffer length),
16521 + * NULL is returned.
16522 + * *buflen is not modified if the TLV elt parameter is invalid, or is decremented
16523 + * by the TLV paramter's length if it is valid.
16524 + */
16525 +bcm_tlv_t *
16526 +bcm_next_tlv(bcm_tlv_t *elt, int *buflen)
16527 +{
16528 +       int len;
16529 +
16530 +       /* validate current elt */
16531 +       if (!bcm_valid_tlv(elt, *buflen))
16532 +               return NULL;
16533 +
16534 +       /* advance to next elt */
16535 +       len = elt->len;
16536 +       elt = (bcm_tlv_t*)(elt->data + len);
16537 +       *buflen -= (2 + len);
16538 +
16539 +       /* validate next elt */
16540 +       if (!bcm_valid_tlv(elt, *buflen))
16541 +               return NULL;
16542 +
16543 +       return elt;
16544 +}
16545 +
16546 +/*
16547 + * Traverse a string of 1-byte tag/1-byte length/variable-length value
16548 + * triples, returning a pointer to the substring whose first element
16549 + * matches tag
16550 + */
16551 +bcm_tlv_t *
16552 +bcm_parse_tlvs(void *buf, int buflen, uint key)
16553 +{
16554 +       bcm_tlv_t *elt;
16555 +       int totlen;
16556 +
16557 +       elt = (bcm_tlv_t*)buf;
16558 +       totlen = buflen;
16559 +
16560 +       /* find tagged parameter */
16561 +       while (totlen >= 2) {
16562 +               int len = elt->len;
16563 +
16564 +               /* validate remaining totlen */
16565 +               if ((elt->id == key) && (totlen >= (len + 2)))
16566 +                       return (elt);
16567 +
16568 +               elt = (bcm_tlv_t*)((uint8*)elt + (len + 2));
16569 +               totlen -= (len + 2);
16570 +       }
16571 +
16572 +       return NULL;
16573 +}
16574 +
16575 +/*
16576 + * Traverse a string of 1-byte tag/1-byte length/variable-length value
16577 + * triples, returning a pointer to the substring whose first element
16578 + * matches tag.  Stop parsing when we see an element whose ID is greater
16579 + * than the target key.
16580 + */
16581 +bcm_tlv_t *
16582 +bcm_parse_ordered_tlvs(void *buf, int buflen, uint key)
16583 +{
16584 +       bcm_tlv_t *elt;
16585 +       int totlen;
16586 +
16587 +       elt = (bcm_tlv_t*)buf;
16588 +       totlen = buflen;
16589 +
16590 +       /* find tagged parameter */
16591 +       while (totlen >= 2) {
16592 +               uint id = elt->id;
16593 +               int len = elt->len;
16594 +
16595 +               /* Punt if we start seeing IDs > than target key */
16596 +               if (id > key)
16597 +                       return(NULL);
16598 +
16599 +               /* validate remaining totlen */
16600 +               if ((id == key) && (totlen >= (len + 2)))
16601 +                       return (elt);
16602 +
16603 +               elt = (bcm_tlv_t*)((uint8*)elt + (len + 2));
16604 +               totlen -= (len + 2);
16605 +       }
16606 +       return NULL;
16607 +}
16608 +/* routine to dump fields in a fileddesc structure */
16609 +
16610 +uint
16611 +bcmdumpfields(readreg_rtn read_rtn, void *arg0, void *arg1, struct fielddesc *fielddesc_array, char *buf, uint32 bufsize)
16612 +{
16613 +       uint  filled_len;
16614 +       uint len;
16615 +       struct fielddesc *cur_ptr;
16616 +
16617 +       filled_len = 0;
16618 +       cur_ptr = fielddesc_array;
16619 +
16620 +       while (bufsize > (filled_len + 64)) {
16621 +               if (cur_ptr->nameandfmt == NULL)
16622 +                       break;
16623 +               len = sprintf(buf, cur_ptr->nameandfmt, read_rtn(arg0, arg1, cur_ptr->offset));
16624 +               buf += len;
16625 +               filled_len += len;
16626 +               cur_ptr++;
16627 +       }
16628 +       return filled_len;
16629 +}
16630 +
16631 +uint
16632 +bcm_mkiovar(char *name, char *data, uint datalen, char *buf, uint buflen)
16633 +{
16634 +       uint len;
16635 +
16636 +       len = strlen(name) + 1;
16637 +
16638 +       if ((len + datalen) > buflen)
16639 +               return 0;
16640 +
16641 +       strcpy(buf, name);
16642 +
16643 +       /* append data onto the end of the name string */
16644 +       memcpy(&buf[len], data, datalen);
16645 +       len += datalen;
16646 +
16647 +       return len;
16648 +}
16649 +
16650 +/* Quarter dBm units to mW
16651 + * Table starts at QDBM_OFFSET, so the first entry is mW for qdBm=153
16652 + * Table is offset so the last entry is largest mW value that fits in
16653 + * a uint16.
16654 + */
16655 +
16656 +#define QDBM_OFFSET 153
16657 +#define QDBM_TABLE_LEN 40
16658 +
16659 +/* Smallest mW value that will round up to the first table entry, QDBM_OFFSET.
16660 + * Value is ( mW(QDBM_OFFSET - 1) + mW(QDBM_OFFSET) ) / 2
16661 + */
16662 +#define QDBM_TABLE_LOW_BOUND 6493
16663 +
16664 +/* Largest mW value that will round down to the last table entry,
16665 + * QDBM_OFFSET + QDBM_TABLE_LEN-1.
16666 + * Value is ( mW(QDBM_OFFSET + QDBM_TABLE_LEN - 1) + mW(QDBM_OFFSET + QDBM_TABLE_LEN) ) / 2.
16667 + */
16668 +#define QDBM_TABLE_HIGH_BOUND 64938
16669 +
16670 +static const uint16 nqdBm_to_mW_map[QDBM_TABLE_LEN] = {
16671 +/* qdBm:        +0             +1              +2              +3              +4              +5              +6              +7      */
16672 +/* 153: */      6683,  7079,   7499,   7943,   8414,   8913,   9441,   10000,
16673 +/* 161: */      10593, 11220,  11885,  12589,  13335,  14125,  14962,  15849,
16674 +/* 169: */      16788, 17783,  18836,  19953,  21135,  22387,  23714,  25119,
16675 +/* 177: */      26607, 28184,  29854,  31623,  33497,  35481,  37584,  39811,
16676 +/* 185: */      42170, 44668,  47315,  50119,  53088,  56234,  59566,  63096
16677 +};
16678 +
16679 +uint16
16680 +bcm_qdbm_to_mw(uint8 qdbm)
16681 +{
16682 +       uint factor = 1;
16683 +       int idx = qdbm - QDBM_OFFSET;
16684 +
16685 +       if (idx > QDBM_TABLE_LEN) {
16686 +               /* clamp to max uint16 mW value */
16687 +               return 0xFFFF;
16688 +       }
16689 +
16690 +       /* scale the qdBm index up to the range of the table 0-40
16691 +        * where an offset of 40 qdBm equals a factor of 10 mW.
16692 +        */
16693 +       while (idx < 0) {
16694 +               idx += 40;
16695 +               factor *= 10;
16696 +       }
16697 +
16698 +       /* return the mW value scaled down to the correct factor of 10,
16699 +        * adding in factor/2 to get proper rounding. */
16700 +       return ((nqdBm_to_mW_map[idx] + factor/2) / factor);
16701 +}
16702 +
16703 +uint8
16704 +bcm_mw_to_qdbm(uint16 mw)
16705 +{
16706 +       uint8 qdbm;
16707 +       int offset;
16708 +       uint mw_uint = mw;
16709 +       uint boundary;
16710 +
16711 +       /* handle boundary case */
16712 +       if (mw_uint <= 1)
16713 +               return 0;
16714 +
16715 +       offset = QDBM_OFFSET;
16716 +
16717 +       /* move mw into the range of the table */
16718 +       while (mw_uint < QDBM_TABLE_LOW_BOUND) {
16719 +               mw_uint *= 10;
16720 +               offset -= 40;
16721 +       }
16722 +
16723 +       for (qdbm = 0; qdbm < QDBM_TABLE_LEN-1; qdbm++) {
16724 +               boundary = nqdBm_to_mW_map[qdbm] + (nqdBm_to_mW_map[qdbm+1] - nqdBm_to_mW_map[qdbm])/2;
16725 +               if (mw_uint < boundary) break;
16726 +       }
16727 +
16728 +       qdbm += (uint8)offset;
16729 +
16730 +       return(qdbm);
16731 +}
16732 diff -Nur linux-2.4.32/drivers/net/hnd/hnddma.c linux-2.4.32-brcm/drivers/net/hnd/hnddma.c
16733 --- linux-2.4.32/drivers/net/hnd/hnddma.c       1970-01-01 01:00:00.000000000 +0100
16734 +++ linux-2.4.32-brcm/drivers/net/hnd/hnddma.c  2005-12-16 23:39:11.288858250 +0100
16735 @@ -0,0 +1,1527 @@
16736 +/*
16737 + * Generic Broadcom Home Networking Division (HND) DMA module.
16738 + * This supports the following chips: BCM42xx, 44xx, 47xx .
16739 + *
16740 + * Copyright 2005, Broadcom Corporation
16741 + * All Rights Reserved.
16742 + *
16743 + * THIS SOFTWARE IS OFFERED "AS IS", AND BROADCOM GRANTS NO WARRANTIES OF ANY
16744 + * KIND, EXPRESS OR IMPLIED, BY STATUTE, COMMUNICATION OR OTHERWISE. BROADCOM
16745 + * SPECIFICALLY DISCLAIMS ANY IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS
16746 + * FOR A SPECIFIC PURPOSE OR NONINFRINGEMENT CONCERNING THIS SOFTWARE.
16747 + *
16748 + * $Id$
16749 + */
16750 +
16751 +#include <typedefs.h>
16752 +#include <osl.h>
16753 +#include <bcmendian.h>
16754 +#include <sbconfig.h>
16755 +#include <bcmutils.h>
16756 +#include <bcmdevs.h>
16757 +#include <sbutils.h>
16758 +
16759 +struct dma_info;       /* forward declaration */
16760 +#define di_t struct dma_info
16761 +
16762 +#include <sbhnddma.h>
16763 +#include <hnddma.h>
16764 +
16765 +/* debug/trace */
16766 +#define        DMA_ERROR(args)
16767 +#define        DMA_TRACE(args)
16768 +
16769 +/* default dma message level (if input msg_level pointer is null in dma_attach()) */
16770 +static uint dma_msg_level =
16771 +       0;
16772 +
16773 +#define        MAXNAMEL        8
16774 +
16775 +/* dma engine software state */
16776 +typedef struct dma_info {
16777 +       hnddma_t        hnddma;         /* exported structure */
16778 +       uint            *msg_level;     /* message level pointer */
16779 +       char            name[MAXNAMEL]; /* callers name for diag msgs */
16780 +
16781 +       void            *osh;           /* os handle */
16782 +       sb_t            *sbh;           /* sb handle */
16783 +
16784 +       bool            dma64;          /* dma64 enabled */
16785 +       bool            addrext;        /* this dma engine supports DmaExtendedAddrChanges */
16786 +
16787 +       dma32regs_t     *d32txregs;     /* 32 bits dma tx engine registers */
16788 +       dma32regs_t     *d32rxregs;     /* 32 bits dma rx engine registers */
16789 +       dma64regs_t     *d64txregs;     /* 64 bits dma tx engine registers */
16790 +       dma64regs_t     *d64rxregs;     /* 64 bits dma rx engine registers */
16791 +
16792 +       uint32          dma64align;     /* either 8k or 4k depends on number of dd */
16793 +       dma32dd_t       *txd32;         /* pointer to dma32 tx descriptor ring */
16794 +       dma64dd_t       *txd64;         /* pointer to dma64 tx descriptor ring */
16795 +       uint            ntxd;           /* # tx descriptors tunable */
16796 +       uint            txin;           /* index of next descriptor to reclaim */
16797 +       uint            txout;          /* index of next descriptor to post */
16798 +       uint            txavail;        /* # free tx descriptors */
16799 +       void            **txp;          /* pointer to parallel array of pointers to packets */
16800 +       ulong           txdpa;          /* physical address of descriptor ring */
16801 +       uint            txdalign;       /* #bytes added to alloc'd mem to align txd */
16802 +       uint            txdalloc;       /* #bytes allocated for the ring */
16803 +
16804 +       dma32dd_t       *rxd32;         /* pointer to dma32 rx descriptor ring */
16805 +       dma64dd_t       *rxd64;         /* pointer to dma64 rx descriptor ring */
16806 +       uint            nrxd;           /* # rx descriptors tunable */
16807 +       uint            rxin;           /* index of next descriptor to reclaim */
16808 +       uint            rxout;          /* index of next descriptor to post */
16809 +       void            **rxp;          /* pointer to parallel array of pointers to packets */
16810 +       ulong           rxdpa;          /* physical address of descriptor ring */
16811 +       uint            rxdalign;       /* #bytes added to alloc'd mem to align rxd */
16812 +       uint            rxdalloc;       /* #bytes allocated for the ring */
16813 +
16814 +       /* tunables */
16815 +       uint            rxbufsize;      /* rx buffer size in bytes */
16816 +       uint            nrxpost;        /* # rx buffers to keep posted */
16817 +       uint            rxoffset;       /* rxcontrol offset */
16818 +       uint            ddoffsetlow;    /* add to get dma address of descriptor ring, low 32 bits */
16819 +       uint            ddoffsethigh;   /* add to get dma address of descriptor ring, high 32 bits */
16820 +       uint            dataoffsetlow;  /* add to get dma address of data buffer, low 32 bits */
16821 +       uint            dataoffsethigh; /* add to get dma address of data buffer, high 32 bits */
16822 +} dma_info_t;
16823 +
16824 +#ifdef BCMDMA64
16825 +#define        DMA64_ENAB(di)  ((di)->dma64)
16826 +#else
16827 +#define        DMA64_ENAB(di)  (0)
16828 +#endif
16829 +
16830 +/* descriptor bumping macros */
16831 +#define        XXD(x, n)       ((x) & ((n) - 1))
16832 +#define        TXD(x)          XXD((x), di->ntxd)
16833 +#define        RXD(x)          XXD((x), di->nrxd)
16834 +#define        NEXTTXD(i)      TXD(i + 1)
16835 +#define        PREVTXD(i)      TXD(i - 1)
16836 +#define        NEXTRXD(i)      RXD(i + 1)
16837 +#define        NTXDACTIVE(h, t)        TXD(t - h)
16838 +#define        NRXDACTIVE(h, t)        RXD(t - h)
16839 +
16840 +/* macros to convert between byte offsets and indexes */
16841 +#define        B2I(bytes, type)        ((bytes) / sizeof(type))
16842 +#define        I2B(index, type)        ((index) * sizeof(type))
16843 +
16844 +#define        PCI32ADDR_HIGH          0xc0000000      /* address[31:30] */
16845 +#define        PCI32ADDR_HIGH_SHIFT    30
16846 +
16847 +
16848 +/* prototypes */
16849 +static bool dma_isaddrext(dma_info_t *di);
16850 +static bool dma_alloc(dma_info_t *di, uint direction);
16851 +
16852 +static bool dma32_alloc(dma_info_t *di, uint direction);
16853 +static void dma32_txreset(dma_info_t *di);
16854 +static void dma32_rxreset(dma_info_t *di);
16855 +static bool dma32_txsuspendedidle(dma_info_t *di);
16856 +static int  dma32_txfast(dma_info_t *di, void *p0, uint32 coreflags);
16857 +static void* dma32_getnexttxp(dma_info_t *di, bool forceall);
16858 +static void* dma32_getnextrxp(dma_info_t *di, bool forceall);
16859 +static void dma32_txrotate(di_t *di);
16860 +
16861 +/* prototype or stubs */
16862 +#ifdef BCMDMA64
16863 +static bool dma64_alloc(dma_info_t *di, uint direction);
16864 +static void dma64_txreset(dma_info_t *di);
16865 +static void dma64_rxreset(dma_info_t *di);
16866 +static bool dma64_txsuspendedidle(dma_info_t *di);
16867 +static int  dma64_txfast(dma_info_t *di, void *p0, uint32 coreflags);
16868 +static void* dma64_getnexttxp(dma_info_t *di, bool forceall);
16869 +static void* dma64_getnextrxp(dma_info_t *di, bool forceall);
16870 +static void dma64_txrotate(di_t *di);
16871 +#else
16872 +static bool dma64_alloc(dma_info_t *di, uint direction) { return TRUE; }
16873 +static void dma64_txreset(dma_info_t *di) {}
16874 +static void dma64_rxreset(dma_info_t *di) {}
16875 +static bool dma64_txsuspendedidle(dma_info_t *di) { return TRUE;}
16876 +static int  dma64_txfast(dma_info_t *di, void *p0, uint32 coreflags) { return 0; }
16877 +static void* dma64_getnexttxp(dma_info_t *di, bool forceall) { return NULL; }
16878 +static void* dma64_getnextrxp(dma_info_t *di, bool forceall) { return NULL; }
16879 +static void dma64_txrotate(di_t *di) { return; }
16880 +#endif
16881 +
16882 +/* old dmaregs struct for compatibility */
16883 +typedef volatile struct {
16884 +       /* transmit channel */
16885 +       uint32  xmtcontrol;         /* enable, et al */
16886 +       uint32  xmtaddr;            /* descriptor ring base address (4K aligned) */
16887 +       uint32  xmtptr;             /* last descriptor posted to chip */
16888 +       uint32  xmtstatus;          /* current active descriptor, et al */
16889 +
16890 +       /* receive channel */
16891 +       uint32  rcvcontrol;         /* enable, et al */
16892 +       uint32  rcvaddr;            /* descriptor ring base address (4K aligned) */
16893 +       uint32  rcvptr;             /* last descriptor posted to chip */
16894 +       uint32  rcvstatus;          /* current active descriptor, et al */
16895 +} dmaregs_t;
16896 +
16897 +typedef struct {
16898 +       uint ddoffset;
16899 +       uint dataoffset;
16900 +} compat_data;
16901 +
16902 +static compat_data *ugly_hack = NULL;
16903 +
16904 +void*
16905 +dma_attold(void *drv, void *osh, char *name, dmaregs_t *regs, uint ntxd, uint nrxd,
16906 +               uint rxbufsize, uint nrxpost, uint rxoffset, uint ddoffset, uint dataoffset, uint *msg_level)
16907 +{
16908 +       dma32regs_t *dtx = regs;
16909 +       dma32regs_t *drx = dtx + 1;
16910 +
16911 +       ugly_hack = kmalloc(sizeof(ugly_hack), GFP_KERNEL);
16912 +       ugly_hack->ddoffset = ddoffset;
16913 +       ugly_hack->dataoffset = dataoffset;
16914 +       dma_attach((osl_t *) osh, name, NULL, dtx, drx, ntxd, nrxd, rxbufsize, nrxpost, rxoffset, msg_level);
16915 +       ugly_hack = NULL;
16916 +}
16917 +
16918 +
16919 +void*
16920 +dma_attach(osl_t *osh, char *name, sb_t *sbh, void *dmaregstx, void *dmaregsrx,
16921 +          uint ntxd, uint nrxd, uint rxbufsize, uint nrxpost, uint rxoffset, uint *msg_level)
16922 +{
16923 +       dma_info_t *di;
16924 +       uint size;
16925 +
16926 +       /* allocate private info structure */
16927 +       if ((di = MALLOC(osh, sizeof (dma_info_t))) == NULL) {
16928 +               return (NULL);
16929 +       }
16930 +       bzero((char*)di, sizeof (dma_info_t));
16931 +
16932 +       di->msg_level = msg_level ? msg_level : &dma_msg_level;
16933 +
16934 +       if (sbh != NULL)
16935 +               di->dma64 = ((sb_coreflagshi(sbh, 0, 0) & SBTMH_DMA64) == SBTMH_DMA64);
16936 +
16937 +#ifndef BCMDMA64
16938 +       if (di->dma64) {
16939 +               DMA_ERROR(("dma_attach: driver doesn't have the capability to support 64 bits DMA\n"));
16940 +               goto fail;
16941 +       }
16942 +#endif
16943 +
16944 +       /* check arguments */
16945 +       ASSERT(ISPOWEROF2(ntxd));
16946 +       ASSERT(ISPOWEROF2(nrxd));
16947 +       if (nrxd == 0)
16948 +               ASSERT(dmaregsrx == NULL);
16949 +       if (ntxd == 0)
16950 +               ASSERT(dmaregstx == NULL);
16951 +
16952 +
16953 +       /* init dma reg pointer */
16954 +       if (di->dma64) {
16955 +               ASSERT(ntxd <= D64MAXDD);
16956 +               ASSERT(nrxd <= D64MAXDD);
16957 +               di->d64txregs = (dma64regs_t *)dmaregstx;
16958 +               di->d64rxregs = (dma64regs_t *)dmaregsrx;
16959 +
16960 +               di->dma64align = D64RINGALIGN;
16961 +               if ((ntxd < D64MAXDD / 2) && (nrxd < D64MAXDD / 2)) {
16962 +                       /* for smaller dd table, HW relax the alignment requirement */
16963 +                       di->dma64align = D64RINGALIGN / 2;
16964 +               }
16965 +       } else {
16966 +               ASSERT(ntxd <= D32MAXDD);
16967 +               ASSERT(nrxd <= D32MAXDD);
16968 +               di->d32txregs = (dma32regs_t *)dmaregstx;
16969 +               di->d32rxregs = (dma32regs_t *)dmaregsrx;
16970 +       }
16971 +
16972 +
16973 +       /* make a private copy of our callers name */
16974 +       strncpy(di->name, name, MAXNAMEL);
16975 +       di->name[MAXNAMEL-1] = '\0';
16976 +
16977 +       di->osh = osh;
16978 +       di->sbh = sbh;
16979 +
16980 +       /* save tunables */
16981 +       di->ntxd = ntxd;
16982 +       di->nrxd = nrxd;
16983 +       di->rxbufsize = rxbufsize;
16984 +       di->nrxpost = nrxpost;
16985 +       di->rxoffset = rxoffset;
16986 +
16987 +       /*
16988 +        * figure out the DMA physical address offset for dd and data
16989 +        *   for old chips w/o sb, use zero
16990 +        *   for new chips w sb,
16991 +        *     PCI/PCIE: they map silicon backplace address to zero based memory, need offset
16992 +        *     Other bus: use zero
16993 +        *     SB_BUS BIGENDIAN kludge: use sdram swapped region for data buffer, not descriptor
16994 +        */
16995 +       di->ddoffsetlow = 0;
16996 +       di->dataoffsetlow = 0;
16997 +       if (ugly_hack != NULL) {
16998 +               di->ddoffsetlow = ugly_hack->ddoffset;
16999 +               di->dataoffsetlow = ugly_hack->dataoffset;
17000 +               di->ddoffsethigh = 0;
17001 +               di->dataoffsethigh = 0;
17002 +       } else if (sbh != NULL) {
17003 +               if (sbh->bustype == PCI_BUS) {  /* for pci bus, add offset */
17004 +                       if ((sbh->buscoretype == SB_PCIE) && di->dma64){
17005 +                               di->ddoffsetlow = 0;
17006 +                               di->ddoffsethigh = SB_PCIE_DMA_H32;
17007 +                       } else {
17008 +                               di->ddoffsetlow = SB_PCI_DMA;
17009 +                               di->ddoffsethigh = 0;
17010 +                       }
17011 +                       di->dataoffsetlow =  di->ddoffsetlow;
17012 +                       di->dataoffsethigh =  di->ddoffsethigh;
17013 +               }
17014 +#if defined(__mips__) && defined(IL_BIGENDIAN)
17015 +               /* use sdram swapped region for data buffers but not dma descriptors */
17016 +               di->dataoffsetlow = di->dataoffsetlow + SB_SDRAM_SWAPPED;
17017 +#endif
17018 +       }
17019 +
17020 +       di->addrext = ((ugly_hack == NULL) ? dma_isaddrext(di) : 0);
17021 +
17022 +       DMA_TRACE(("%s: dma_attach: osh %p ntxd %d nrxd %d rxbufsize %d nrxpost %d rxoffset %d ddoffset 0x%x dataoffset 0x%x\n",
17023 +                  name, osh, ntxd, nrxd, rxbufsize, nrxpost, rxoffset, di->ddoffsetlow, di->dataoffsetlow));
17024 +
17025 +       /* allocate tx packet pointer vector */
17026 +       if (ntxd) {
17027 +               size = ntxd * sizeof (void*);
17028 +               if ((di->txp = MALLOC(osh, size)) == NULL) {
17029 +                       DMA_ERROR(("%s: dma_attach: out of tx memory, malloced %d bytes\n", di->name, MALLOCED(osh)));
17030 +                       goto fail;
17031 +               }
17032 +               bzero((char*)di->txp, size);
17033 +       }
17034 +
17035 +       /* allocate rx packet pointer vector */
17036 +       if (nrxd) {
17037 +               size = nrxd * sizeof (void*);
17038 +               if ((di->rxp = MALLOC(osh, size)) == NULL) {
17039 +                       DMA_ERROR(("%s: dma_attach: out of rx memory, malloced %d bytes\n", di->name, MALLOCED(osh)));
17040 +                       goto fail;
17041 +               }
17042 +               bzero((char*)di->rxp, size);
17043 +       }
17044 +
17045 +       /* allocate transmit descriptor ring, only need ntxd descriptors but it must be aligned */
17046 +       if (ntxd) {
17047 +               if (!dma_alloc(di, DMA_TX))
17048 +                       goto fail;
17049 +       }
17050 +
17051 +       /* allocate receive descriptor ring, only need nrxd descriptors but it must be aligned */
17052 +       if (nrxd) {
17053 +               if (!dma_alloc(di, DMA_RX))
17054 +                       goto fail;
17055 +       }
17056 +
17057 +       if ((di->ddoffsetlow == SB_PCI_DMA) && (di->txdpa > SB_PCI_DMA_SZ) && !di->addrext) {
17058 +               DMA_ERROR(("%s: dma_attach: txdpa 0x%lx: addrext not supported\n", di->name, di->txdpa));
17059 +               goto fail;
17060 +       }
17061 +       if ((di->ddoffsetlow == SB_PCI_DMA) && (di->rxdpa > SB_PCI_DMA_SZ) && !di->addrext) {
17062 +               DMA_ERROR(("%s: dma_attach: rxdpa 0x%lx: addrext not supported\n", di->name, di->rxdpa));
17063 +               goto fail;
17064 +       }
17065 +
17066 +       return ((void*)di);
17067 +
17068 +fail:
17069 +       dma_detach((void*)di);
17070 +       return (NULL);
17071 +}
17072 +
17073 +static bool
17074 +dma_alloc(dma_info_t *di, uint direction)
17075 +{
17076 +       if (DMA64_ENAB(di)) {
17077 +               return dma64_alloc(di, direction);
17078 +       } else {
17079 +               return dma32_alloc(di, direction);
17080 +       }
17081 +}
17082 +
17083 +/* may be called with core in reset */
17084 +void
17085 +dma_detach(dma_info_t *di)
17086 +{
17087 +       if (di == NULL)
17088 +               return;
17089 +
17090 +       DMA_TRACE(("%s: dma_detach\n", di->name));
17091 +
17092 +       /* shouldn't be here if descriptors are unreclaimed */
17093 +       ASSERT(di->txin == di->txout);
17094 +       ASSERT(di->rxin == di->rxout);
17095 +
17096 +       /* free dma descriptor rings */
17097 +       if (di->txd32)
17098 +               DMA_FREE_CONSISTENT(di->osh, ((int8*)di->txd32 - di->txdalign), di->txdalloc, (di->txdpa - di->txdalign));
17099 +       if (di->rxd32)
17100 +               DMA_FREE_CONSISTENT(di->osh, ((int8*)di->rxd32 - di->rxdalign), di->rxdalloc, (di->rxdpa - di->rxdalign));
17101 +
17102 +       /* free packet pointer vectors */
17103 +       if (di->txp)
17104 +               MFREE(di->osh, (void*)di->txp, (di->ntxd * sizeof (void*)));
17105 +       if (di->rxp)
17106 +               MFREE(di->osh, (void*)di->rxp, (di->nrxd * sizeof (void*)));
17107 +
17108 +       /* free our private info structure */
17109 +       MFREE(di->osh, (void*)di, sizeof (dma_info_t));
17110 +}
17111 +
17112 +/* return TRUE if this dma engine supports DmaExtendedAddrChanges, otherwise FALSE */
17113 +static bool
17114 +dma_isaddrext(dma_info_t *di)
17115 +{
17116 +       uint32 w;
17117 +
17118 +       if (DMA64_ENAB(di)) {
17119 +               OR_REG(&di->d64txregs->control, D64_XC_AE);
17120 +               w = R_REG(&di->d32txregs->control);
17121 +               AND_REG(&di->d32txregs->control, ~D64_XC_AE);
17122 +               return ((w & XC_AE) == D64_XC_AE);
17123 +       } else {
17124 +               OR_REG(&di->d32txregs->control, XC_AE);
17125 +               w = R_REG(&di->d32txregs->control);
17126 +               AND_REG(&di->d32txregs->control, ~XC_AE);
17127 +               return ((w & XC_AE) == XC_AE);
17128 +       }
17129 +}
17130 +
17131 +void
17132 +dma_txreset(dma_info_t *di)
17133 +{
17134 +       DMA_TRACE(("%s: dma_txreset\n", di->name));
17135 +
17136 +       if (DMA64_ENAB(di))
17137 +               dma64_txreset(di);
17138 +       else
17139 +               dma32_txreset(di);
17140 +}
17141 +
17142 +void
17143 +dma_rxreset(dma_info_t *di)
17144 +{
17145 +       DMA_TRACE(("%s: dma_rxreset\n", di->name));
17146 +
17147 +       if (DMA64_ENAB(di))
17148 +               dma64_rxreset(di);
17149 +       else
17150 +               dma32_rxreset(di);
17151 +}
17152 +
17153 +/* initialize descriptor table base address */
17154 +static void
17155 +dma_ddtable_init(dma_info_t *di, uint direction, ulong pa)
17156 +{
17157 +       if (DMA64_ENAB(di)) {
17158 +               if (direction == DMA_TX) {
17159 +                       W_REG(&di->d64txregs->addrlow, pa + di->ddoffsetlow);
17160 +                       W_REG(&di->d64txregs->addrhigh, di->ddoffsethigh);
17161 +               } else {
17162 +                       W_REG(&di->d64rxregs->addrlow, pa + di->ddoffsetlow);
17163 +                       W_REG(&di->d64rxregs->addrhigh, di->ddoffsethigh);
17164 +               }
17165 +       } else {
17166 +               uint32 offset = di->ddoffsetlow;
17167 +               if ((offset != SB_PCI_DMA) || !(pa & PCI32ADDR_HIGH)) {
17168 +                       if (direction == DMA_TX)
17169 +                               W_REG(&di->d32txregs->addr, (pa + offset));
17170 +                       else
17171 +                               W_REG(&di->d32rxregs->addr, (pa + offset));
17172 +               } else {
17173 +                       /* dma32 address extension */
17174 +                       uint32 ae;
17175 +                       ASSERT(di->addrext);
17176 +                       ae = (pa & PCI32ADDR_HIGH) >> PCI32ADDR_HIGH_SHIFT;
17177 +
17178 +                       if (direction == DMA_TX) {
17179 +                               W_REG(&di->d32txregs->addr, ((pa & ~PCI32ADDR_HIGH) + offset));
17180 +                               SET_REG(&di->d32txregs->control, XC_AE, (ae << XC_AE_SHIFT));
17181 +                       } else {
17182 +                               W_REG(&di->d32rxregs->addr, ((pa & ~PCI32ADDR_HIGH) + offset));
17183 +                               SET_REG(&di->d32rxregs->control, RC_AE, (ae << RC_AE_SHIFT));
17184 +                       }
17185 +               }
17186 +       }
17187 +}
17188 +
17189 +/* init the tx or rx descriptor */
17190 +static INLINE void
17191 +dma32_dd_upd(dma_info_t *di, dma32dd_t *ddring, ulong pa, uint outidx, uint32 *ctrl)
17192 +{
17193 +       uint offset = di->dataoffsetlow;
17194 +
17195 +       if ((offset != SB_PCI_DMA) || !(pa & PCI32ADDR_HIGH)) {
17196 +               W_SM(&ddring[outidx].addr, BUS_SWAP32(pa + offset));
17197 +               W_SM(&ddring[outidx].ctrl, BUS_SWAP32(*ctrl));
17198 +       } else {
17199 +               /* address extension */
17200 +               uint32 ae;
17201 +               ASSERT(di->addrext);
17202 +               ae = (pa & PCI32ADDR_HIGH) >> PCI32ADDR_HIGH_SHIFT;
17203 +
17204 +               *ctrl |= (ae << CTRL_AE_SHIFT);
17205 +               W_SM(&ddring[outidx].addr, BUS_SWAP32((pa & ~PCI32ADDR_HIGH) + offset));
17206 +               W_SM(&ddring[outidx].ctrl, BUS_SWAP32(*ctrl));
17207 +       }
17208 +}
17209 +
17210 +/* init the tx or rx descriptor */
17211 +static INLINE void
17212 +dma64_dd_upd(dma_info_t *di, dma64dd_t *ddring, ulong pa, uint outidx, uint32 *flags, uint32 bufcount)
17213 +{
17214 +       uint32 bufaddr_low = pa + di->dataoffsetlow;
17215 +       uint32 bufaddr_high = 0 + di->dataoffsethigh;
17216 +
17217 +       uint32 ctrl2 = bufcount & D64_CTRL2_BC_MASK;
17218 +
17219 +       W_SM(&ddring[outidx].addrlow, BUS_SWAP32(bufaddr_low));
17220 +       W_SM(&ddring[outidx].addrhigh, BUS_SWAP32(bufaddr_high));
17221 +       W_SM(&ddring[outidx].ctrl1, BUS_SWAP32(*flags));
17222 +       W_SM(&ddring[outidx].ctrl2, BUS_SWAP32(ctrl2));
17223 +}
17224 +
17225 +void
17226 +dma_txinit(dma_info_t *di)
17227 +{
17228 +       DMA_TRACE(("%s: dma_txinit\n", di->name));
17229 +
17230 +       di->txin = di->txout = 0;
17231 +       di->txavail = di->ntxd - 1;
17232 +
17233 +       /* clear tx descriptor ring */
17234 +       if (DMA64_ENAB(di)) {
17235 +               BZERO_SM((void*)di->txd64, (di->ntxd * sizeof (dma64dd_t)));
17236 +               W_REG(&di->d64txregs->control, XC_XE);
17237 +               dma_ddtable_init(di, DMA_TX, di->txdpa);
17238 +       } else {
17239 +               BZERO_SM((void*)di->txd32, (di->ntxd * sizeof (dma32dd_t)));
17240 +               W_REG(&di->d32txregs->control, XC_XE);
17241 +               dma_ddtable_init(di, DMA_TX, di->txdpa);
17242 +       }
17243 +}
17244 +
17245 +bool
17246 +dma_txenabled(dma_info_t *di)
17247 +{
17248 +       uint32 xc;
17249 +
17250 +       /* If the chip is dead, it is not enabled :-) */
17251 +       if (DMA64_ENAB(di)) {
17252 +               xc = R_REG(&di->d64txregs->control);
17253 +               return ((xc != 0xffffffff) && (xc & D64_XC_XE));
17254 +       } else {
17255 +               xc = R_REG(&di->d32txregs->control);
17256 +               return ((xc != 0xffffffff) && (xc & XC_XE));
17257 +       }
17258 +}
17259 +
17260 +void
17261 +dma_txsuspend(dma_info_t *di)
17262 +{
17263 +       DMA_TRACE(("%s: dma_txsuspend\n", di->name));
17264 +       if (DMA64_ENAB(di))
17265 +               OR_REG(&di->d64txregs->control, D64_XC_SE);
17266 +       else
17267 +               OR_REG(&di->d32txregs->control, XC_SE);
17268 +}
17269 +
17270 +void
17271 +dma_txresume(dma_info_t *di)
17272 +{
17273 +       DMA_TRACE(("%s: dma_txresume\n", di->name));
17274 +       if (DMA64_ENAB(di))
17275 +               AND_REG(&di->d64txregs->control, ~D64_XC_SE);
17276 +       else
17277 +               AND_REG(&di->d32txregs->control, ~XC_SE);
17278 +}
17279 +
17280 +bool
17281 +dma_txsuspendedidle(dma_info_t *di)
17282 +{
17283 +       if (DMA64_ENAB(di))
17284 +               return dma64_txsuspendedidle(di);
17285 +       else
17286 +               return dma32_txsuspendedidle(di);
17287 +}
17288 +
17289 +bool
17290 +dma_txsuspended(dma_info_t *di)
17291 +{
17292 +       if (DMA64_ENAB(di))
17293 +               return ((R_REG(&di->d64txregs->control) & D64_XC_SE) == D64_XC_SE);
17294 +       else
17295 +               return ((R_REG(&di->d32txregs->control) & XC_SE) == XC_SE);
17296 +}
17297 +
17298 +bool
17299 +dma_txstopped(dma_info_t *di)
17300 +{
17301 +       if (DMA64_ENAB(di))
17302 +               return ((R_REG(&di->d64txregs->status0) & D64_XS0_XS_MASK) == D64_XS0_XS_STOPPED);
17303 +       else
17304 +               return ((R_REG(&di->d32txregs->status) & XS_XS_MASK) == XS_XS_STOPPED);
17305 +}
17306 +
17307 +bool
17308 +dma_rxstopped(dma_info_t *di)
17309 +{
17310 +       if (DMA64_ENAB(di))
17311 +               return ((R_REG(&di->d64rxregs->status0) & D64_RS0_RS_MASK) == D64_RS0_RS_STOPPED);
17312 +       else
17313 +               return ((R_REG(&di->d32rxregs->status) & RS_RS_MASK) == RS_RS_STOPPED);
17314 +}
17315 +
17316 +void
17317 +dma_fifoloopbackenable(dma_info_t *di)
17318 +{
17319 +       DMA_TRACE(("%s: dma_fifoloopbackenable\n", di->name));
17320 +       if (DMA64_ENAB(di))
17321 +               OR_REG(&di->d64txregs->control, D64_XC_LE);
17322 +       else
17323 +               OR_REG(&di->d32txregs->control, XC_LE);
17324 +}
17325 +
17326 +void
17327 +dma_rxinit(dma_info_t *di)
17328 +{
17329 +       DMA_TRACE(("%s: dma_rxinit\n", di->name));
17330 +
17331 +       di->rxin = di->rxout = 0;
17332 +
17333 +       /* clear rx descriptor ring */
17334 +       if (DMA64_ENAB(di)) {
17335 +                BZERO_SM((void*)di->rxd64, (di->nrxd * sizeof (dma64dd_t)));
17336 +               dma_rxenable(di);
17337 +               dma_ddtable_init(di, DMA_RX, di->rxdpa);
17338 +       } else {
17339 +               BZERO_SM((void*)di->rxd32, (di->nrxd * sizeof (dma32dd_t)));
17340 +               dma_rxenable(di);
17341 +               dma_ddtable_init(di, DMA_RX, di->rxdpa);
17342 +       }
17343 +}
17344 +
17345 +void
17346 +dma_rxenable(dma_info_t *di)
17347 +{
17348 +       DMA_TRACE(("%s: dma_rxenable\n", di->name));
17349 +       if (DMA64_ENAB(di))
17350 +               W_REG(&di->d64rxregs->control, ((di->rxoffset << D64_RC_RO_SHIFT) | D64_RC_RE));
17351 +       else
17352 +               W_REG(&di->d32rxregs->control, ((di->rxoffset << RC_RO_SHIFT) | RC_RE));
17353 +}
17354 +
17355 +bool
17356 +dma_rxenabled(dma_info_t *di)
17357 +{
17358 +       uint32 rc;
17359 +
17360 +       if (DMA64_ENAB(di)) {
17361 +               rc = R_REG(&di->d64rxregs->control);
17362 +               return ((rc != 0xffffffff) && (rc & D64_RC_RE));
17363 +       } else {
17364 +               rc = R_REG(&di->d32rxregs->control);
17365 +               return ((rc != 0xffffffff) && (rc & RC_RE));
17366 +       }
17367 +}
17368 +
17369 +
17370 +/* !! tx entry routine */
17371 +int
17372 +dma_txfast(dma_info_t *di, void *p0, uint32 coreflags)
17373 +{
17374 +       if (DMA64_ENAB(di)) {
17375 +               return dma64_txfast(di, p0, coreflags);
17376 +       } else {
17377 +               return dma32_txfast(di, p0, coreflags);
17378 +       }
17379 +}
17380 +
17381 +/* !! rx entry routine, returns a pointer to the next frame received, or NULL if there are no more */
17382 +void*
17383 +dma_rx(dma_info_t *di)
17384 +{
17385 +       void *p;
17386 +       uint len;
17387 +       int skiplen = 0;
17388 +
17389 +       while ((p = dma_getnextrxp(di, FALSE))) {
17390 +               /* skip giant packets which span multiple rx descriptors */
17391 +               if (skiplen > 0) {
17392 +                       skiplen -= di->rxbufsize;
17393 +                       if (skiplen < 0)
17394 +                               skiplen = 0;
17395 +                       PKTFREE(di->osh, p, FALSE);
17396 +                       continue;
17397 +               }
17398 +
17399 +               len = ltoh16(*(uint16*)(PKTDATA(di->osh, p)));
17400 +               DMA_TRACE(("%s: dma_rx len %d\n", di->name, len));
17401 +
17402 +               /* bad frame length check */
17403 +               if (len > (di->rxbufsize - di->rxoffset)) {
17404 +                       DMA_ERROR(("%s: dma_rx: bad frame length (%d)\n", di->name, len));
17405 +                       if (len > 0)
17406 +                               skiplen = len - (di->rxbufsize - di->rxoffset);
17407 +                       PKTFREE(di->osh, p, FALSE);
17408 +                       di->hnddma.rxgiants++;
17409 +                       continue;
17410 +               }
17411 +
17412 +               /* set actual length */
17413 +               PKTSETLEN(di->osh, p, (di->rxoffset + len));
17414 +
17415 +               break;
17416 +       }
17417 +
17418 +       return (p);
17419 +}
17420 +
17421 +/* post receive buffers */
17422 +void
17423 +dma_rxfill(dma_info_t *di)
17424 +{
17425 +       void *p;
17426 +       uint rxin, rxout;
17427 +       uint32 ctrl;
17428 +       uint n;
17429 +       uint i;
17430 +       uint32 pa;
17431 +       uint rxbufsize;
17432 +
17433 +       /*
17434 +        * Determine how many receive buffers we're lacking
17435 +        * from the full complement, allocate, initialize,
17436 +        * and post them, then update the chip rx lastdscr.
17437 +        */
17438 +
17439 +       rxin = di->rxin;
17440 +       rxout = di->rxout;
17441 +       rxbufsize = di->rxbufsize;
17442 +
17443 +       n = di->nrxpost - NRXDACTIVE(rxin, rxout);
17444 +
17445 +       DMA_TRACE(("%s: dma_rxfill: post %d\n", di->name, n));
17446 +
17447 +       for (i = 0; i < n; i++) {
17448 +               if ((p = PKTGET(di->osh, rxbufsize, FALSE)) == NULL) {
17449 +                       DMA_ERROR(("%s: dma_rxfill: out of rxbufs\n", di->name));
17450 +                       di->hnddma.rxnobuf++;
17451 +                       break;
17452 +               }
17453 +
17454 +               /* Do a cached write instead of uncached write since DMA_MAP
17455 +                * will flush the cache. */
17456 +               *(uint32*)(PKTDATA(di->osh, p)) = 0;
17457 +
17458 +               pa = (uint32) DMA_MAP(di->osh, PKTDATA(di->osh, p), rxbufsize, DMA_RX, p);
17459 +               ASSERT(ISALIGNED(pa, 4));
17460 +
17461 +               /* save the free packet pointer */
17462 +               ASSERT(di->rxp[rxout] == NULL);
17463 +               di->rxp[rxout] = p;
17464 +
17465 +               if (DMA64_ENAB(di)) {
17466 +                       /* prep the descriptor control value */
17467 +                       if (rxout == (di->nrxd - 1))
17468 +                               ctrl = CTRL_EOT;
17469 +
17470 +                       dma64_dd_upd(di, di->rxd64, pa, rxout, &ctrl, rxbufsize);
17471 +               } else {
17472 +                       /* prep the descriptor control value */
17473 +                       ctrl = rxbufsize;
17474 +                       if (rxout == (di->nrxd - 1))
17475 +                               ctrl |= CTRL_EOT;
17476 +                       dma32_dd_upd(di, di->rxd32, pa, rxout, &ctrl);
17477 +               }
17478 +
17479 +               rxout = NEXTRXD(rxout);
17480 +       }
17481 +
17482 +       di->rxout = rxout;
17483 +
17484 +       /* update the chip lastdscr pointer */
17485 +       if (DMA64_ENAB(di)) {
17486 +               W_REG(&di->d64rxregs->ptr, I2B(rxout, dma64dd_t));
17487 +       } else {
17488 +               W_REG(&di->d32rxregs->ptr, I2B(rxout, dma32dd_t));
17489 +       }
17490 +}
17491 +
17492 +void
17493 +dma_txreclaim(dma_info_t *di, bool forceall)
17494 +{
17495 +       void *p;
17496 +
17497 +       DMA_TRACE(("%s: dma_txreclaim %s\n", di->name, forceall ? "all" : ""));
17498 +
17499 +       while ((p = dma_getnexttxp(di, forceall)))
17500 +               PKTFREE(di->osh, p, TRUE);
17501 +}
17502 +
17503 +/*
17504 + * Reclaim next completed txd (txds if using chained buffers) and
17505 + * return associated packet.
17506 + * If 'force' is true, reclaim txd(s) and return associated packet
17507 + * regardless of the value of the hardware "curr" pointer.
17508 + */
17509 +void*
17510 +dma_getnexttxp(dma_info_t *di, bool forceall)
17511 +{
17512 +       if (DMA64_ENAB(di)) {
17513 +               return dma64_getnexttxp(di, forceall);
17514 +       } else {
17515 +               return dma32_getnexttxp(di, forceall);
17516 +       }
17517 +}
17518 +
17519 +/* like getnexttxp but no reclaim */
17520 +void*
17521 +dma_peeknexttxp(dma_info_t *di)
17522 +{
17523 +       uint end, i;
17524 +
17525 +       if (DMA64_ENAB(di)) {
17526 +               end = B2I(R_REG(&di->d64txregs->status0) & D64_XS0_CD_MASK, dma64dd_t);
17527 +       } else {
17528 +               end = B2I(R_REG(&di->d32txregs->status) & XS_CD_MASK, dma32dd_t);
17529 +       }
17530 +
17531 +       for (i = di->txin; i != end; i = NEXTTXD(i))
17532 +               if (di->txp[i])
17533 +                       return (di->txp[i]);
17534 +
17535 +       return (NULL);
17536 +}
17537 +
17538 +/*
17539 + * Rotate all active tx dma ring entries "forward" by (ActiveDescriptor - txin).
17540 + */
17541 +void
17542 +dma_txrotate(di_t *di)
17543 +{
17544 +       if (DMA64_ENAB(di)) {
17545 +               dma64_txrotate(di);
17546 +       } else {
17547 +               dma32_txrotate(di);
17548 +       }
17549 +}
17550 +
17551 +void
17552 +dma_rxreclaim(dma_info_t *di)
17553 +{
17554 +       void *p;
17555 +
17556 +       DMA_TRACE(("%s: dma_rxreclaim\n", di->name));
17557 +
17558 +       while ((p = dma_getnextrxp(di, TRUE)))
17559 +               PKTFREE(di->osh, p, FALSE);
17560 +}
17561 +
17562 +void *
17563 +dma_getnextrxp(dma_info_t *di, bool forceall)
17564 +{
17565 +       if (DMA64_ENAB(di)) {
17566 +               return dma64_getnextrxp(di, forceall);
17567 +       } else {
17568 +               return dma32_getnextrxp(di, forceall);
17569 +       }
17570 +}
17571 +
17572 +uintptr
17573 +dma_getvar(dma_info_t *di, char *name)
17574 +{
17575 +       if (!strcmp(name, "&txavail"))
17576 +               return ((uintptr) &di->txavail);
17577 +       else {
17578 +               ASSERT(0);
17579 +       }
17580 +       return (0);
17581 +}
17582 +
17583 +void
17584 +dma_txblock(dma_info_t *di)
17585 +{
17586 +       di->txavail = 0;
17587 +}
17588 +
17589 +void
17590 +dma_txunblock(dma_info_t *di)
17591 +{
17592 +       di->txavail = di->ntxd - NTXDACTIVE(di->txin, di->txout) - 1;
17593 +}
17594 +
17595 +uint
17596 +dma_txactive(dma_info_t *di)
17597 +{
17598 +       return (NTXDACTIVE(di->txin, di->txout));
17599 +}
17600 +
17601 +void
17602 +dma_rxpiomode(dma32regs_t *regs)
17603 +{
17604 +       W_REG(&regs->control, RC_FM);
17605 +}
17606 +
17607 +void
17608 +dma_txpioloopback(dma32regs_t *regs)
17609 +{
17610 +       OR_REG(&regs->control, XC_LE);
17611 +}
17612 +
17613 +
17614 +
17615 +
17616 +/*** 32 bits DMA non-inline functions ***/
17617 +static bool
17618 +dma32_alloc(dma_info_t *di, uint direction)
17619 +{
17620 +       uint size;
17621 +       uint ddlen;
17622 +       void *va;
17623 +
17624 +       ddlen = sizeof (dma32dd_t);
17625 +
17626 +       size = (direction == DMA_TX) ? (di->ntxd * ddlen) : (di->nrxd * ddlen);
17627 +
17628 +       if (!ISALIGNED(DMA_CONSISTENT_ALIGN, D32RINGALIGN))
17629 +               size += D32RINGALIGN;
17630 +
17631 +
17632 +       if (direction == DMA_TX) {
17633 +               if ((va = DMA_ALLOC_CONSISTENT(di->osh, size, &di->txdpa)) == NULL) {
17634 +                       DMA_ERROR(("%s: dma_attach: DMA_ALLOC_CONSISTENT(ntxd) failed\n", di->name));
17635 +                       return FALSE;
17636 +               }
17637 +
17638 +               di->txd32 = (dma32dd_t*) ROUNDUP((uintptr)va, D32RINGALIGN);
17639 +               di->txdalign = (uint)((int8*)di->txd32 - (int8*)va);
17640 +               di->txdpa += di->txdalign;
17641 +               di->txdalloc = size;
17642 +               ASSERT(ISALIGNED((uintptr)di->txd32, D32RINGALIGN));
17643 +       } else {
17644 +               if ((va = DMA_ALLOC_CONSISTENT(di->osh, size, &di->rxdpa)) == NULL) {
17645 +                       DMA_ERROR(("%s: dma_attach: DMA_ALLOC_CONSISTENT(nrxd) failed\n", di->name));
17646 +                       return FALSE;
17647 +               }
17648 +               di->rxd32 = (dma32dd_t*) ROUNDUP((uintptr)va, D32RINGALIGN);
17649 +               di->rxdalign = (uint)((int8*)di->rxd32 - (int8*)va);
17650 +               di->rxdpa += di->rxdalign;
17651 +               di->rxdalloc = size;
17652 +               ASSERT(ISALIGNED((uintptr)di->rxd32, D32RINGALIGN));
17653 +       }
17654 +
17655 +       return TRUE;
17656 +}
17657 +
17658 +static void
17659 +dma32_txreset(dma_info_t *di)
17660 +{
17661 +       uint32 status;
17662 +
17663 +       /* suspend tx DMA first */
17664 +       W_REG(&di->d32txregs->control, XC_SE);
17665 +       SPINWAIT((status = (R_REG(&di->d32txregs->status) & XS_XS_MASK)) != XS_XS_DISABLED &&
17666 +                status != XS_XS_IDLE &&
17667 +                status != XS_XS_STOPPED,
17668 +                10000);
17669 +
17670 +       W_REG(&di->d32txregs->control, 0);
17671 +       SPINWAIT((status = (R_REG(&di->d32txregs->status) & XS_XS_MASK)) != XS_XS_DISABLED,
17672 +                10000);
17673 +
17674 +       if (status != XS_XS_DISABLED) {
17675 +               DMA_ERROR(("%s: dma_txreset: dma cannot be stopped\n", di->name));
17676 +       }
17677 +
17678 +       /* wait for the last transaction to complete */
17679 +       OSL_DELAY(300);
17680 +}
17681 +
17682 +static void
17683 +dma32_rxreset(dma_info_t *di)
17684 +{
17685 +       uint32 status;
17686 +
17687 +       W_REG(&di->d32rxregs->control, 0);
17688 +       SPINWAIT((status = (R_REG(&di->d32rxregs->status) & RS_RS_MASK)) != RS_RS_DISABLED,
17689 +                10000);
17690 +
17691 +       if (status != RS_RS_DISABLED) {
17692 +               DMA_ERROR(("%s: dma_rxreset: dma cannot be stopped\n", di->name));
17693 +       }
17694 +}
17695 +
17696 +static bool
17697 +dma32_txsuspendedidle(dma_info_t *di)
17698 +{
17699 +       if (!(R_REG(&di->d32txregs->control) & XC_SE))
17700 +               return 0;
17701 +
17702 +       if ((R_REG(&di->d32txregs->status) & XS_XS_MASK) != XS_XS_IDLE)
17703 +               return 0;
17704 +
17705 +       OSL_DELAY(2);
17706 +       return ((R_REG(&di->d32txregs->status) & XS_XS_MASK) == XS_XS_IDLE);
17707 +}
17708 +
17709 +/*
17710 + * supports full 32bit dma engine buffer addressing so
17711 + * dma buffers can cross 4 Kbyte page boundaries.
17712 + */
17713 +static int
17714 +dma32_txfast(dma_info_t *di, void *p0, uint32 coreflags)
17715 +{
17716 +       void *p, *next;
17717 +       uchar *data;
17718 +       uint len;
17719 +       uint txout;
17720 +       uint32 ctrl;
17721 +       uint32 pa;
17722 +
17723 +       DMA_TRACE(("%s: dma_txfast\n", di->name));
17724 +
17725 +       txout = di->txout;
17726 +       ctrl = 0;
17727 +
17728 +       /*
17729 +        * Walk the chain of packet buffers
17730 +        * allocating and initializing transmit descriptor entries.
17731 +        */
17732 +       for (p = p0; p; p = next) {
17733 +               data = PKTDATA(di->osh, p);
17734 +               len = PKTLEN(di->osh, p);
17735 +               next = PKTNEXT(di->osh, p);
17736 +
17737 +               /* return nonzero if out of tx descriptors */
17738 +               if (NEXTTXD(txout) == di->txin)
17739 +                       goto outoftxd;
17740 +
17741 +               if (len == 0)
17742 +                       continue;
17743 +
17744 +               /* get physical address of buffer start */
17745 +               pa = (uint32) DMA_MAP(di->osh, data, len, DMA_TX, p);
17746 +
17747 +               /* build the descriptor control value */
17748 +               ctrl = len & CTRL_BC_MASK;
17749 +
17750 +               ctrl |= coreflags;
17751 +
17752 +               if (p == p0)
17753 +                       ctrl |= CTRL_SOF;
17754 +               if (next == NULL)
17755 +                       ctrl |= (CTRL_IOC | CTRL_EOF);
17756 +               if (txout == (di->ntxd - 1))
17757 +                       ctrl |= CTRL_EOT;
17758 +
17759 +               if (DMA64_ENAB(di)) {
17760 +                       dma64_dd_upd(di, di->txd64, pa, txout, &ctrl, len);
17761 +               } else {
17762 +                       dma32_dd_upd(di, di->txd32, pa, txout, &ctrl);
17763 +               }
17764 +
17765 +               ASSERT(di->txp[txout] == NULL);
17766 +
17767 +               txout = NEXTTXD(txout);
17768 +       }
17769 +
17770 +       /* if last txd eof not set, fix it */
17771 +       if (!(ctrl & CTRL_EOF))
17772 +               W_SM(&di->txd32[PREVTXD(txout)].ctrl, BUS_SWAP32(ctrl | CTRL_IOC | CTRL_EOF));
17773 +
17774 +       /* save the packet */
17775 +       di->txp[PREVTXD(txout)] = p0;
17776 +
17777 +       /* bump the tx descriptor index */
17778 +       di->txout = txout;
17779 +
17780 +       /* kick the chip */
17781 +       if (DMA64_ENAB(di)) {
17782 +               W_REG(&di->d64txregs->ptr, I2B(txout, dma64dd_t));
17783 +       } else {
17784 +               W_REG(&di->d32txregs->ptr, I2B(txout, dma32dd_t));
17785 +       }
17786 +
17787 +       /* tx flow control */
17788 +       di->txavail = di->ntxd - NTXDACTIVE(di->txin, di->txout) - 1;
17789 +
17790 +       return (0);
17791 +
17792 + outoftxd:
17793 +       DMA_ERROR(("%s: dma_txfast: out of txds\n", di->name));
17794 +       PKTFREE(di->osh, p0, TRUE);
17795 +       di->txavail = 0;
17796 +       di->hnddma.txnobuf++;
17797 +       return (-1);
17798 +}
17799 +
17800 +static void*
17801 +dma32_getnexttxp(dma_info_t *di, bool forceall)
17802 +{
17803 +       uint start, end, i;
17804 +       void *txp;
17805 +
17806 +       DMA_TRACE(("%s: dma_getnexttxp %s\n", di->name, forceall ? "all" : ""));
17807 +
17808 +       txp = NULL;
17809 +
17810 +       start = di->txin;
17811 +       if (forceall)
17812 +               end = di->txout;
17813 +       else
17814 +               end = B2I(R_REG(&di->d32txregs->status) & XS_CD_MASK, dma32dd_t);
17815 +
17816 +       if ((start == 0) && (end > di->txout))
17817 +               goto bogus;
17818 +
17819 +       for (i = start; i != end && !txp; i = NEXTTXD(i)) {
17820 +               DMA_UNMAP(di->osh, (BUS_SWAP32(R_SM(&di->txd32[i].addr)) - di->dataoffsetlow),
17821 +                         (BUS_SWAP32(R_SM(&di->txd32[i].ctrl)) & CTRL_BC_MASK), DMA_TX, di->txp[i]);
17822 +
17823 +               W_SM(&di->txd32[i].addr, 0xdeadbeef);
17824 +               txp = di->txp[i];
17825 +               di->txp[i] = NULL;
17826 +       }
17827 +
17828 +       di->txin = i;
17829 +
17830 +       /* tx flow control */
17831 +       di->txavail = di->ntxd - NTXDACTIVE(di->txin, di->txout) - 1;
17832 +
17833 +       return (txp);
17834 +
17835 +bogus:
17836 +/*
17837 +       DMA_ERROR(("dma_getnexttxp: bogus curr: start %d end %d txout %d force %d\n",
17838 +               start, end, di->txout, forceall));
17839 +*/
17840 +       return (NULL);
17841 +}
17842 +
17843 +static void *
17844 +dma32_getnextrxp(dma_info_t *di, bool forceall)
17845 +{
17846 +       uint i;
17847 +       void *rxp;
17848 +
17849 +       /* if forcing, dma engine must be disabled */
17850 +       ASSERT(!forceall || !dma_rxenabled(di));
17851 +
17852 +       i = di->rxin;
17853 +
17854 +       /* return if no packets posted */
17855 +       if (i == di->rxout)
17856 +               return (NULL);
17857 +
17858 +       /* ignore curr if forceall */
17859 +       if (!forceall && (i == B2I(R_REG(&di->d32rxregs->status) & RS_CD_MASK, dma32dd_t)))
17860 +               return (NULL);
17861 +
17862 +       /* get the packet pointer that corresponds to the rx descriptor */
17863 +       rxp = di->rxp[i];
17864 +       ASSERT(rxp);
17865 +       di->rxp[i] = NULL;
17866 +
17867 +       /* clear this packet from the descriptor ring */
17868 +       DMA_UNMAP(di->osh, (BUS_SWAP32(R_SM(&di->rxd32[i].addr)) - di->dataoffsetlow),
17869 +                 di->rxbufsize, DMA_RX, rxp);
17870 +       W_SM(&di->rxd32[i].addr, 0xdeadbeef);
17871 +
17872 +       di->rxin = NEXTRXD(i);
17873 +
17874 +       return (rxp);
17875 +}
17876 +
17877 +static void
17878 +dma32_txrotate(di_t *di)
17879 +{
17880 +       uint ad;
17881 +       uint nactive;
17882 +       uint rot;
17883 +       uint old, new;
17884 +       uint32 w;
17885 +       uint first, last;
17886 +
17887 +       ASSERT(dma_txsuspendedidle(di));
17888 +
17889 +       nactive = dma_txactive(di);
17890 +       ad = B2I(((R_REG(&di->d32txregs->status) & XS_AD_MASK) >> XS_AD_SHIFT), dma32dd_t);
17891 +       rot = TXD(ad - di->txin);
17892 +
17893 +       ASSERT(rot < di->ntxd);
17894 +
17895 +       /* full-ring case is a lot harder - don't worry about this */
17896 +       if (rot >= (di->ntxd - nactive)) {
17897 +               DMA_ERROR(("%s: dma_txrotate: ring full - punt\n", di->name));
17898 +               return;
17899 +       }
17900 +
17901 +       first = di->txin;
17902 +       last = PREVTXD(di->txout);
17903 +
17904 +       /* move entries starting at last and moving backwards to first */
17905 +       for (old = last; old != PREVTXD(first); old = PREVTXD(old)) {
17906 +               new = TXD(old + rot);
17907 +
17908 +               /*
17909 +                * Move the tx dma descriptor.
17910 +                * EOT is set only in the last entry in the ring.
17911 +                */
17912 +               w = R_SM(&di->txd32[old].ctrl) & ~CTRL_EOT;
17913 +               if (new == (di->ntxd - 1))
17914 +                       w |= CTRL_EOT;
17915 +               W_SM(&di->txd32[new].ctrl, w);
17916 +               W_SM(&di->txd32[new].addr, R_SM(&di->txd32[old].addr));
17917 +
17918 +               /* zap the old tx dma descriptor address field */
17919 +               W_SM(&di->txd32[old].addr, 0xdeadbeef);
17920 +
17921 +               /* move the corresponding txp[] entry */
17922 +               ASSERT(di->txp[new] == NULL);
17923 +               di->txp[new] = di->txp[old];
17924 +               di->txp[old] = NULL;
17925 +       }
17926 +
17927 +       /* update txin and txout */
17928 +       di->txin = ad;
17929 +       di->txout = TXD(di->txout + rot);
17930 +       di->txavail = di->ntxd - NTXDACTIVE(di->txin, di->txout) - 1;
17931 +
17932 +       /* kick the chip */
17933 +       W_REG(&di->d32txregs->ptr, I2B(di->txout, dma32dd_t));
17934 +}
17935 +
17936 +/*** 64 bits DMA non-inline functions ***/
17937 +
17938 +#ifdef BCMDMA64
17939 +
17940 +static bool
17941 +dma64_alloc(dma_info_t *di, uint direction)
17942 +{
17943 +       uint size;
17944 +       uint ddlen;
17945 +       uint32 alignbytes;
17946 +       void *va;
17947 +
17948 +       ddlen = sizeof (dma64dd_t);
17949 +
17950 +       size = (direction == DMA_TX) ? (di->ntxd * ddlen) : (di->nrxd * ddlen);
17951 +
17952 +       alignbytes = di->dma64align;
17953 +
17954 +       if (!ISALIGNED(DMA_CONSISTENT_ALIGN, alignbytes))
17955 +               size += alignbytes;
17956 +
17957 +
17958 +       if (direction == DMA_TX) {
17959 +               if ((va = DMA_ALLOC_CONSISTENT(di->osh, size, &di->txdpa)) == NULL) {
17960 +                       DMA_ERROR(("%s: dma_attach: DMA_ALLOC_CONSISTENT(ntxd) failed\n", di->name));
17961 +                       return FALSE;
17962 +               }
17963 +
17964 +               di->txd64 = (dma64dd_t*) ROUNDUP((uintptr)va, alignbytes);
17965 +               di->txdalign = (uint)((int8*)di->txd64 - (int8*)va);
17966 +               di->txdpa += di->txdalign;
17967 +               di->txdalloc = size;
17968 +               ASSERT(ISALIGNED((uintptr)di->txd64, alignbytes));
17969 +       } else {
17970 +               if ((va = DMA_ALLOC_CONSISTENT(di->osh, size, &di->rxdpa)) == NULL) {
17971 +                       DMA_ERROR(("%s: dma_attach: DMA_ALLOC_CONSISTENT(nrxd) failed\n", di->name));
17972 +                       return FALSE;
17973 +               }
17974 +               di->rxd64 = (dma64dd_t*) ROUNDUP((uintptr)va, alignbytes);
17975 +               di->rxdalign = (uint)((int8*)di->rxd64 - (int8*)va);
17976 +               di->rxdpa += di->rxdalign;
17977 +               di->rxdalloc = size;
17978 +               ASSERT(ISALIGNED((uintptr)di->rxd64, alignbytes));
17979 +       }
17980 +
17981 +       return TRUE;
17982 +}
17983 +
17984 +static void
17985 +dma64_txreset(dma_info_t *di)
17986 +{
17987 +       uint32 status;
17988 +
17989 +       /* suspend tx DMA first */
17990 +       W_REG(&di->d64txregs->control, D64_XC_SE);
17991 +       SPINWAIT((status = (R_REG(&di->d64txregs->status0) & D64_XS0_XS_MASK)) != D64_XS0_XS_DISABLED &&
17992 +                status != D64_XS0_XS_IDLE &&
17993 +                status != D64_XS0_XS_STOPPED,
17994 +                10000);
17995 +
17996 +       W_REG(&di->d64txregs->control, 0);
17997 +       SPINWAIT((status = (R_REG(&di->d64txregs->status0) & D64_XS0_XS_MASK)) != D64_XS0_XS_DISABLED,
17998 +                10000);
17999 +
18000 +       if (status != D64_XS0_XS_DISABLED) {
18001 +               DMA_ERROR(("%s: dma_txreset: dma cannot be stopped\n", di->name));
18002 +       }
18003 +
18004 +       /* wait for the last transaction to complete */
18005 +       OSL_DELAY(300);
18006 +}
18007 +
18008 +static void
18009 +dma64_rxreset(dma_info_t *di)
18010 +{
18011 +       uint32 status;
18012 +
18013 +       W_REG(&di->d64rxregs->control, 0);
18014 +       SPINWAIT((status = (R_REG(&di->d64rxregs->status0) & D64_RS0_RS_MASK)) != D64_RS0_RS_DISABLED,
18015 +                10000);
18016 +
18017 +       if (status != D64_RS0_RS_DISABLED) {
18018 +               DMA_ERROR(("%s: dma_rxreset: dma cannot be stopped\n", di->name));
18019 +       }
18020 +}
18021 +
18022 +static bool
18023 +dma64_txsuspendedidle(dma_info_t *di)
18024 +{
18025 +
18026 +       if (!(R_REG(&di->d64txregs->control) & D64_XC_SE))
18027 +               return 0;
18028 +
18029 +       if ((R_REG(&di->d64txregs->status0) & D64_XS0_XS_MASK) == D64_XS0_XS_IDLE)
18030 +               return 1;
18031 +
18032 +       return 0;
18033 +}
18034 +
18035 +/*
18036 + * supports full 32bit dma engine buffer addressing so
18037 + * dma buffers can cross 4 Kbyte page boundaries.
18038 + */
18039 +static int
18040 +dma64_txfast(dma_info_t *di, void *p0, uint32 coreflags)
18041 +{
18042 +       void *p, *next;
18043 +       uchar *data;
18044 +       uint len;
18045 +       uint txout;
18046 +       uint32 flags;
18047 +       uint32 pa;
18048 +
18049 +       DMA_TRACE(("%s: dma_txfast\n", di->name));
18050 +
18051 +       txout = di->txout;
18052 +       flags = 0;
18053 +
18054 +       /*
18055 +        * Walk the chain of packet buffers
18056 +        * allocating and initializing transmit descriptor entries.
18057 +        */
18058 +       for (p = p0; p; p = next) {
18059 +               data = PKTDATA(di->osh, p);
18060 +               len = PKTLEN(di->osh, p);
18061 +               next = PKTNEXT(di->osh, p);
18062 +
18063 +               /* return nonzero if out of tx descriptors */
18064 +               if (NEXTTXD(txout) == di->txin)
18065 +                       goto outoftxd;
18066 +
18067 +               if (len == 0)
18068 +                       continue;
18069 +
18070 +               /* get physical address of buffer start */
18071 +               pa = (uint32) DMA_MAP(di->osh, data, len, DMA_TX, p);
18072 +
18073 +               flags = coreflags;
18074 +
18075 +               if (p == p0)
18076 +                       flags |= D64_CTRL1_SOF;
18077 +               if (next == NULL)
18078 +                       flags |= (D64_CTRL1_IOC | D64_CTRL1_EOF);
18079 +               if (txout == (di->ntxd - 1))
18080 +                       flags |= D64_CTRL1_EOT;
18081 +
18082 +               dma64_dd_upd(di, di->txd64, pa, txout, &flags, len);
18083 +
18084 +               ASSERT(di->txp[txout] == NULL);
18085 +
18086 +               txout = NEXTTXD(txout);
18087 +       }
18088 +
18089 +       /* if last txd eof not set, fix it */
18090 +       if (!(flags & D64_CTRL1_EOF))
18091 +               W_SM(&di->txd64[PREVTXD(txout)].ctrl1, BUS_SWAP32(flags | D64_CTRL1_IOC | D64_CTRL1_EOF));
18092 +
18093 +       /* save the packet */
18094 +       di->txp[PREVTXD(txout)] = p0;
18095 +
18096 +       /* bump the tx descriptor index */
18097 +       di->txout = txout;
18098 +
18099 +       /* kick the chip */
18100 +       W_REG(&di->d64txregs->ptr, I2B(txout, dma64dd_t));
18101 +
18102 +       /* tx flow control */
18103 +       di->txavail = di->ntxd - NTXDACTIVE(di->txin, di->txout) - 1;
18104 +
18105 +       return (0);
18106 +
18107 +outoftxd:
18108 +       DMA_ERROR(("%s: dma_txfast: out of txds\n", di->name));
18109 +       PKTFREE(di->osh, p0, TRUE);
18110 +       di->txavail = 0;
18111 +       di->hnddma.txnobuf++;
18112 +       return (-1);
18113 +}
18114 +
18115 +static void*
18116 +dma64_getnexttxp(dma_info_t *di, bool forceall)
18117 +{
18118 +       uint start, end, i;
18119 +       void *txp;
18120 +
18121 +       DMA_TRACE(("%s: dma_getnexttxp %s\n", di->name, forceall ? "all" : ""));
18122 +
18123 +       txp = NULL;
18124 +
18125 +       start = di->txin;
18126 +       if (forceall)
18127 +               end = di->txout;
18128 +       else
18129 +               end = B2I(R_REG(&di->d64txregs->status0) & D64_XS0_CD_MASK, dma64dd_t);
18130 +
18131 +       if ((start == 0) && (end > di->txout))
18132 +               goto bogus;
18133 +
18134 +       for (i = start; i != end && !txp; i = NEXTTXD(i)) {
18135 +               DMA_UNMAP(di->osh, (BUS_SWAP32(R_SM(&di->txd64[i].addrlow)) - di->dataoffsetlow),
18136 +                         (BUS_SWAP32(R_SM(&di->txd64[i].ctrl2)) & D64_CTRL2_BC_MASK), DMA_TX, di->txp[i]);
18137 +
18138 +               W_SM(&di->txd64[i].addrlow, 0xdeadbeef);
18139 +               W_SM(&di->txd64[i].addrhigh, 0xdeadbeef);
18140 +
18141 +               txp = di->txp[i];
18142 +               di->txp[i] = NULL;
18143 +       }
18144 +
18145 +       di->txin = i;
18146 +
18147 +       /* tx flow control */
18148 +       di->txavail = di->ntxd - NTXDACTIVE(di->txin, di->txout) - 1;
18149 +
18150 +       return (txp);
18151 +
18152 +bogus:
18153 +/*
18154 +       DMA_ERROR(("dma_getnexttxp: bogus curr: start %d end %d txout %d force %d\n",
18155 +               start, end, di->txout, forceall));
18156 +*/
18157 +       return (NULL);
18158 +}
18159 +
18160 +static void *
18161 +dma64_getnextrxp(dma_info_t *di, bool forceall)
18162 +{
18163 +       uint i;
18164 +       void *rxp;
18165 +
18166 +       /* if forcing, dma engine must be disabled */
18167 +       ASSERT(!forceall || !dma_rxenabled(di));
18168 +
18169 +       i = di->rxin;
18170 +
18171 +       /* return if no packets posted */
18172 +       if (i == di->rxout)
18173 +               return (NULL);
18174 +
18175 +       /* ignore curr if forceall */
18176 +       if (!forceall && (i == B2I(R_REG(&di->d64rxregs->status0) & D64_RS0_CD_MASK, dma64dd_t)))
18177 +               return (NULL);
18178 +
18179 +       /* get the packet pointer that corresponds to the rx descriptor */
18180 +       rxp = di->rxp[i];
18181 +       ASSERT(rxp);
18182 +       di->rxp[i] = NULL;
18183 +
18184 +       /* clear this packet from the descriptor ring */
18185 +       DMA_UNMAP(di->osh, (BUS_SWAP32(R_SM(&di->rxd64[i].addrlow)) - di->dataoffsetlow),
18186 +                 di->rxbufsize, DMA_RX, rxp);
18187 +
18188 +       W_SM(&di->rxd64[i].addrlow, 0xdeadbeef);
18189 +       W_SM(&di->rxd64[i].addrhigh, 0xdeadbeef);
18190 +
18191 +       di->rxin = NEXTRXD(i);
18192 +
18193 +       return (rxp);
18194 +}
18195 +
18196 +static void
18197 +dma64_txrotate(di_t *di)
18198 +{
18199 +       uint ad;
18200 +       uint nactive;
18201 +       uint rot;
18202 +       uint old, new;
18203 +       uint32 w;
18204 +       uint first, last;
18205 +
18206 +       ASSERT(dma_txsuspendedidle(di));
18207 +
18208 +       nactive = dma_txactive(di);
18209 +       ad = B2I((R_REG(&di->d64txregs->status1) & D64_XS1_AD_MASK), dma64dd_t);
18210 +       rot = TXD(ad - di->txin);
18211 +
18212 +       ASSERT(rot < di->ntxd);
18213 +
18214 +       /* full-ring case is a lot harder - don't worry about this */
18215 +       if (rot >= (di->ntxd - nactive)) {
18216 +               DMA_ERROR(("%s: dma_txrotate: ring full - punt\n", di->name));
18217 +               return;
18218 +       }
18219 +
18220 +       first = di->txin;
18221 +       last = PREVTXD(di->txout);
18222 +
18223 +       /* move entries starting at last and moving backwards to first */
18224 +       for (old = last; old != PREVTXD(first); old = PREVTXD(old)) {
18225 +               new = TXD(old + rot);
18226 +
18227 +               /*
18228 +                * Move the tx dma descriptor.
18229 +                * EOT is set only in the last entry in the ring.
18230 +                */
18231 +               w = R_SM(&di->txd64[old].ctrl1) & ~D64_CTRL1_EOT;
18232 +               if (new == (di->ntxd - 1))
18233 +                       w |= D64_CTRL1_EOT;
18234 +               W_SM(&di->txd64[new].ctrl1, w);
18235 +
18236 +               w = R_SM(&di->txd64[old].ctrl2);
18237 +               W_SM(&di->txd64[new].ctrl2, w);
18238 +
18239 +               W_SM(&di->txd64[new].addrlow, R_SM(&di->txd64[old].addrlow));
18240 +               W_SM(&di->txd64[new].addrhigh, R_SM(&di->txd64[old].addrhigh));
18241 +
18242 +               /* zap the old tx dma descriptor address field */
18243 +               W_SM(&di->txd64[old].addrlow, 0xdeadbeef);
18244 +               W_SM(&di->txd64[old].addrhigh, 0xdeadbeef);
18245 +
18246 +               /* move the corresponding txp[] entry */
18247 +               ASSERT(di->txp[new] == NULL);
18248 +               di->txp[new] = di->txp[old];
18249 +               di->txp[old] = NULL;
18250 +       }
18251 +
18252 +       /* update txin and txout */
18253 +       di->txin = ad;
18254 +       di->txout = TXD(di->txout + rot);
18255 +       di->txavail = di->ntxd - NTXDACTIVE(di->txin, di->txout) - 1;
18256 +
18257 +       /* kick the chip */
18258 +       W_REG(&di->d64txregs->ptr, I2B(di->txout, dma64dd_t));
18259 +}
18260 +
18261 +#endif
18262 +
18263 diff -Nur linux-2.4.32/drivers/net/hnd/linux_osl.c linux-2.4.32-brcm/drivers/net/hnd/linux_osl.c
18264 --- linux-2.4.32/drivers/net/hnd/linux_osl.c    1970-01-01 01:00:00.000000000 +0100
18265 +++ linux-2.4.32-brcm/drivers/net/hnd/linux_osl.c       2005-12-16 23:39:11.292858500 +0100
18266 @@ -0,0 +1,708 @@
18267 +/*
18268 + * Linux OS Independent Layer
18269 + *
18270 + * Copyright 2005, Broadcom Corporation
18271 + * All Rights Reserved.
18272 + *
18273 + * THIS SOFTWARE IS OFFERED "AS IS", AND BROADCOM GRANTS NO WARRANTIES OF ANY
18274 + * KIND, EXPRESS OR IMPLIED, BY STATUTE, COMMUNICATION OR OTHERWISE. BROADCOM
18275 + * SPECIFICALLY DISCLAIMS ANY IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS
18276 + * FOR A SPECIFIC PURPOSE OR NONINFRINGEMENT CONCERNING THIS SOFTWARE.
18277 + *
18278 + * $Id$
18279 + */
18280 +
18281 +#define LINUX_OSL
18282 +
18283 +#include <typedefs.h>
18284 +#include <bcmendian.h>
18285 +#include <linux/module.h>
18286 +#include <linuxver.h>
18287 +#include <osl.h>
18288 +#include <bcmutils.h>
18289 +#include <linux/delay.h>
18290 +#ifdef mips
18291 +#include <asm/paccess.h>
18292 +#endif
18293 +#include <pcicfg.h>
18294 +
18295 +#define PCI_CFG_RETRY          10
18296 +
18297 +#define OS_HANDLE_MAGIC                0x1234abcd
18298 +#define BCM_MEM_FILENAME_LEN   24
18299 +
18300 +typedef struct bcm_mem_link {
18301 +       struct bcm_mem_link *prev;
18302 +       struct bcm_mem_link *next;
18303 +       uint    size;
18304 +       int     line;
18305 +       char    file[BCM_MEM_FILENAME_LEN];
18306 +} bcm_mem_link_t;
18307 +
18308 +struct os_handle {
18309 +       uint magic;
18310 +       void *pdev;
18311 +       uint malloced;
18312 +       uint failed;
18313 +       bcm_mem_link_t *dbgmem_list;
18314 +};
18315 +
18316 +static int16 linuxbcmerrormap[] =  \
18317 +{      0,                      /* 0 */
18318 +       -EINVAL,                /* BCME_ERROR */
18319 +       -EINVAL,                /* BCME_BADARG*/
18320 +       -EINVAL,                /* BCME_BADOPTION*/
18321 +       -EINVAL,                /* BCME_NOTUP */
18322 +       -EINVAL,                /* BCME_NOTDOWN */
18323 +       -EINVAL,                /* BCME_NOTAP */
18324 +       -EINVAL,                /* BCME_NOTSTA */
18325 +       -EINVAL,                /* BCME_BADKEYIDX */
18326 +       -EINVAL,                /* BCME_RADIOOFF */
18327 +       -EINVAL,                /* BCME_NOTBANDLOCKED */
18328 +       -EINVAL,                /* BCME_NOCLK */
18329 +       -EINVAL,                /* BCME_BADRATESET */
18330 +       -EINVAL,                /* BCME_BADBAND */
18331 +       -E2BIG,                 /* BCME_BUFTOOSHORT */
18332 +       -E2BIG,                 /* BCME_BUFTOOLONG */
18333 +       -EBUSY,                 /* BCME_BUSY */
18334 +       -EINVAL,                /* BCME_NOTASSOCIATED */
18335 +       -EINVAL,                /* BCME_BADSSIDLEN */
18336 +       -EINVAL,                /* BCME_OUTOFRANGECHAN */
18337 +       -EINVAL,                /* BCME_BADCHAN */
18338 +       -EFAULT,                /* BCME_BADADDR */
18339 +       -ENOMEM,                /* BCME_NORESOURCE */
18340 +       -EOPNOTSUPP,            /* BCME_UNSUPPORTED */
18341 +       -EMSGSIZE,              /* BCME_BADLENGTH */
18342 +       -EINVAL,                /* BCME_NOTREADY */
18343 +       -EPERM,                 /* BCME_NOTPERMITTED */
18344 +       -ENOMEM,                /* BCME_NOMEM */
18345 +       -EINVAL,                /* BCME_ASSOCIATED */
18346 +       -ERANGE,                /* BCME_RANGE */
18347 +       -EINVAL                 /* BCME_NOTFOUND */
18348 +};
18349 +
18350 +/* translate bcmerrors into linux errors*/
18351 +int
18352 +osl_error(int bcmerror)
18353 +{
18354 +       int abs_bcmerror;
18355 +       int array_size = ARRAYSIZE(linuxbcmerrormap);
18356 +
18357 +       abs_bcmerror = ABS(bcmerror);
18358 +
18359 +       if (bcmerror > 0)
18360 +               abs_bcmerror = 0;
18361 +
18362 +       else if (abs_bcmerror >= array_size)
18363 +               abs_bcmerror = BCME_ERROR;
18364 +
18365 +       return linuxbcmerrormap[abs_bcmerror];
18366 +}
18367 +
18368 +osl_t *
18369 +osl_attach(void *pdev)
18370 +{
18371 +       osl_t *osh;
18372 +
18373 +       osh = kmalloc(sizeof(osl_t), GFP_ATOMIC);
18374 +       ASSERT(osh);
18375 +
18376 +       /*
18377 +        * check the cases where
18378 +        * 1.Error code Added to bcmerror table, but forgot to add it to the OS
18379 +        * dependent error code
18380 +        * 2. Error code is added to the bcmerror table, but forgot to add the
18381 +        * corresponding errorstring(dummy call to bcmerrorstr)
18382 +        */
18383 +       bcmerrorstr(0);
18384 +       ASSERT(ABS(BCME_LAST) == (ARRAYSIZE(linuxbcmerrormap) - 1));
18385 +
18386 +       osh->magic = OS_HANDLE_MAGIC;
18387 +       osh->malloced = 0;
18388 +       osh->failed = 0;
18389 +       osh->dbgmem_list = NULL;
18390 +       osh->pdev = pdev;
18391 +
18392 +       return osh;
18393 +}
18394 +
18395 +void
18396 +osl_detach(osl_t *osh)
18397 +{
18398 +       ASSERT(osh && (osh->magic == OS_HANDLE_MAGIC));
18399 +       kfree(osh);
18400 +}
18401 +
18402 +void*
18403 +osl_pktget(osl_t *osh, uint len, bool send)
18404 +{
18405 +       struct sk_buff *skb;
18406 +
18407 +       if ((skb = dev_alloc_skb(len)) == NULL)
18408 +               return (NULL);
18409 +
18410 +       skb_put(skb, len);
18411 +
18412 +       /* ensure the cookie field is cleared */
18413 +       PKTSETCOOKIE(skb, NULL);
18414 +
18415 +       return ((void*) skb);
18416 +}
18417 +
18418 +void
18419 +osl_pktfree(void *p)
18420 +{
18421 +       struct sk_buff *skb, *nskb;
18422 +
18423 +       skb = (struct sk_buff*) p;
18424 +
18425 +       /* perversion: we use skb->next to chain multi-skb packets */
18426 +       while (skb) {
18427 +               nskb = skb->next;
18428 +               skb->next = NULL;
18429 +               if (skb->destructor) {
18430 +                       /* cannot kfree_skb() on hard IRQ (net/core/skbuff.c) if destructor exists */
18431 +                       dev_kfree_skb_any(skb);
18432 +               } else {
18433 +                       /* can free immediately (even in_irq()) if destructor does not exist */
18434 +                       dev_kfree_skb(skb);
18435 +               }
18436 +               skb = nskb;
18437 +       }
18438 +}
18439 +
18440 +uint32
18441 +osl_pci_read_config(osl_t *osh, uint offset, uint size)
18442 +{
18443 +       uint val;
18444 +       uint retry=PCI_CFG_RETRY;
18445 +
18446 +       ASSERT((osh && (osh->magic == OS_HANDLE_MAGIC)));
18447 +
18448 +       /* only 4byte access supported */
18449 +       ASSERT(size == 4);
18450 +
18451 +       do {
18452 +               pci_read_config_dword(osh->pdev, offset, &val);
18453 +               if (val != 0xffffffff)
18454 +                       break;
18455 +       } while (retry--);
18456 +
18457 +
18458 +       return (val);
18459 +}
18460 +
18461 +void
18462 +osl_pci_write_config(osl_t *osh, uint offset, uint size, uint val)
18463 +{
18464 +       uint retry=PCI_CFG_RETRY;
18465 +
18466 +       ASSERT((osh && (osh->magic == OS_HANDLE_MAGIC)));
18467 +
18468 +       /* only 4byte access supported */
18469 +       ASSERT(size == 4);
18470 +
18471 +       do {
18472 +               pci_write_config_dword(osh->pdev, offset, val);
18473 +               if (offset!=PCI_BAR0_WIN)
18474 +                       break;
18475 +               if (osl_pci_read_config(osh,offset,size) == val)
18476 +                       break;
18477 +       } while (retry--);
18478 +
18479 +}
18480 +
18481 +/* return bus # for the pci device pointed by osh->pdev */
18482 +uint
18483 +osl_pci_bus(osl_t *osh)
18484 +{
18485 +       ASSERT(osh && (osh->magic == OS_HANDLE_MAGIC) && osh->pdev);
18486 +
18487 +       return ((struct pci_dev *)osh->pdev)->bus->number;
18488 +}
18489 +
18490 +/* return slot # for the pci device pointed by osh->pdev */
18491 +uint
18492 +osl_pci_slot(osl_t *osh)
18493 +{
18494 +       ASSERT(osh && (osh->magic == OS_HANDLE_MAGIC) && osh->pdev);
18495 +
18496 +       return PCI_SLOT(((struct pci_dev *)osh->pdev)->devfn);
18497 +}
18498 +
18499 +static void
18500 +osl_pcmcia_attr(osl_t *osh, uint offset, char *buf, int size, bool write)
18501 +{
18502 +}
18503 +
18504 +void
18505 +osl_pcmcia_read_attr(osl_t *osh, uint offset, void *buf, int size)
18506 +{
18507 +       osl_pcmcia_attr(osh, offset, (char *) buf, size, FALSE);
18508 +}
18509 +
18510 +void
18511 +osl_pcmcia_write_attr(osl_t *osh, uint offset, void *buf, int size)
18512 +{
18513 +       osl_pcmcia_attr(osh, offset, (char *) buf, size, TRUE);
18514 +}
18515 +
18516 +
18517 +#ifdef BCMDBG_MEM
18518 +
18519 +void*
18520 +osl_debug_malloc(osl_t *osh, uint size, int line, char* file)
18521 +{
18522 +       bcm_mem_link_t *p;
18523 +       char* basename;
18524 +
18525 +       ASSERT(size);
18526 +
18527 +       if ((p = (bcm_mem_link_t*)osl_malloc(osh, sizeof(bcm_mem_link_t) + size)) == NULL)
18528 +               return (NULL);
18529 +
18530 +       p->size = size;
18531 +       p->line = line;
18532 +
18533 +       basename = strrchr(file, '/');
18534 +       /* skip the '/' */
18535 +       if (basename)
18536 +               basename++;
18537 +
18538 +       if (!basename)
18539 +               basename = file;
18540 +
18541 +       strncpy(p->file, basename, BCM_MEM_FILENAME_LEN);
18542 +       p->file[BCM_MEM_FILENAME_LEN - 1] = '\0';
18543 +
18544 +       /* link this block */
18545 +       p->prev = NULL;
18546 +       p->next = osh->dbgmem_list;
18547 +       if (p->next)
18548 +               p->next->prev = p;
18549 +       osh->dbgmem_list = p;
18550 +
18551 +       return p + 1;
18552 +}
18553 +
18554 +void
18555 +osl_debug_mfree(osl_t *osh, void *addr, uint size, int line, char* file)
18556 +{
18557 +       bcm_mem_link_t *p = (bcm_mem_link_t *)((int8*)addr - sizeof(bcm_mem_link_t));
18558 +
18559 +       ASSERT((osh && (osh->magic == OS_HANDLE_MAGIC)));
18560 +
18561 +       if (p->size == 0) {
18562 +               printk("osl_debug_mfree: double free on addr 0x%x size %d at line %d file %s\n",
18563 +                       (uint)addr, size, line, file);
18564 +               ASSERT(p->size);
18565 +               return;
18566 +       }
18567 +
18568 +       if (p->size != size) {
18569 +               printk("osl_debug_mfree: dealloc size %d does not match alloc size %d on addr 0x%x at line %d file %s\n",
18570 +                      size, p->size, (uint)addr, line, file);
18571 +               ASSERT(p->size == size);
18572 +               return;
18573 +       }
18574 +
18575 +       /* unlink this block */
18576 +       if (p->prev)
18577 +               p->prev->next = p->next;
18578 +       if (p->next)
18579 +               p->next->prev = p->prev;
18580 +       if (osh->dbgmem_list == p)
18581 +               osh->dbgmem_list = p->next;
18582 +       p->next = p->prev = NULL;
18583 +
18584 +       osl_mfree(osh, p, size + sizeof(bcm_mem_link_t));
18585 +}
18586 +
18587 +char*
18588 +osl_debug_memdump(osl_t *osh, char *buf, uint sz)
18589 +{
18590 +       bcm_mem_link_t *p;
18591 +       char *obuf;
18592 +
18593 +       ASSERT((osh && (osh->magic == OS_HANDLE_MAGIC)));
18594 +       obuf = buf;
18595 +
18596 +       buf += sprintf(buf, "   Address\tSize\tFile:line\n");
18597 +       for (p = osh->dbgmem_list; p && ((buf - obuf) < (sz - 128)); p = p->next)
18598 +               buf += sprintf(buf, "0x%08x\t%5d\t%s:%d\n",
18599 +                       (int)p + sizeof(bcm_mem_link_t), p->size, p->file, p->line);
18600 +
18601 +       return (obuf);
18602 +}
18603 +
18604 +#endif /* BCMDBG_MEM */
18605 +
18606 +void*
18607 +osl_malloc(osl_t *osh, uint size)
18608 +{
18609 +       void *addr;
18610 +
18611 +       /* only ASSERT if osh is defined */
18612 +       if (osh)
18613 +               ASSERT(osh->magic == OS_HANDLE_MAGIC);
18614 +
18615 +       if ((addr = kmalloc(size, GFP_ATOMIC)) == NULL) {
18616 +               if(osh)
18617 +                       osh->failed++;
18618 +               return (NULL);
18619 +       }
18620 +       if (osh)
18621 +               osh->malloced += size;
18622 +
18623 +       return (addr);
18624 +}
18625 +
18626 +void
18627 +osl_mfree(osl_t *osh, void *addr, uint size)
18628 +{
18629 +       if (osh) {
18630 +               ASSERT(osh->magic == OS_HANDLE_MAGIC);
18631 +               osh->malloced -= size;
18632 +       }
18633 +       kfree(addr);
18634 +}
18635 +
18636 +uint
18637 +osl_malloced(osl_t *osh)
18638 +{
18639 +       ASSERT((osh && (osh->magic == OS_HANDLE_MAGIC)));
18640 +       return (osh->malloced);
18641 +}
18642 +
18643 +uint osl_malloc_failed(osl_t *osh)
18644 +{
18645 +       ASSERT((osh && (osh->magic == OS_HANDLE_MAGIC)));
18646 +       return (osh->failed);
18647 +}
18648 +
18649 +void*
18650 +osl_dma_alloc_consistent(osl_t *osh, uint size, ulong *pap)
18651 +{
18652 +       ASSERT((osh && (osh->magic == OS_HANDLE_MAGIC)));
18653 +
18654 +       return (pci_alloc_consistent(osh->pdev, size, (dma_addr_t*)pap));
18655 +}
18656 +
18657 +void
18658 +osl_dma_free_consistent(osl_t *osh, void *va, uint size, ulong pa)
18659 +{
18660 +       ASSERT((osh && (osh->magic == OS_HANDLE_MAGIC)));
18661 +
18662 +       pci_free_consistent(osh->pdev, size, va, (dma_addr_t)pa);
18663 +}
18664 +
18665 +uint
18666 +osl_dma_map(osl_t *osh, void *va, uint size, int direction)
18667 +{
18668 +       int dir;
18669 +
18670 +       ASSERT((osh && (osh->magic == OS_HANDLE_MAGIC)));
18671 +       dir = (direction == DMA_TX)? PCI_DMA_TODEVICE: PCI_DMA_FROMDEVICE;
18672 +       return (pci_map_single(osh->pdev, va, size, dir));
18673 +}
18674 +
18675 +void
18676 +osl_dma_unmap(osl_t *osh, uint pa, uint size, int direction)
18677 +{
18678 +       int dir;
18679 +
18680 +       ASSERT((osh && (osh->magic == OS_HANDLE_MAGIC)));
18681 +       dir = (direction == DMA_TX)? PCI_DMA_TODEVICE: PCI_DMA_FROMDEVICE;
18682 +       pci_unmap_single(osh->pdev, (uint32)pa, size, dir);
18683 +}
18684 +
18685 +#if defined(BINOSL)
18686 +void
18687 +osl_assert(char *exp, char *file, int line)
18688 +{
18689 +       char tempbuf[255];
18690 +
18691 +       sprintf(tempbuf, "assertion \"%s\" failed: file \"%s\", line %d\n", exp, file, line);
18692 +       panic(tempbuf);
18693 +}
18694 +#endif /* BCMDBG || BINOSL */
18695 +
18696 +void
18697 +osl_delay(uint usec)
18698 +{
18699 +       uint d;
18700 +
18701 +       while (usec > 0) {
18702 +               d = MIN(usec, 1000);
18703 +               udelay(d);
18704 +               usec -= d;
18705 +       }
18706 +}
18707 +
18708 +/*
18709 + * BINOSL selects the slightly slower function-call-based binary compatible osl.
18710 + */
18711 +#ifdef BINOSL
18712 +
18713 +int
18714 +osl_printf(const char *format, ...)
18715 +{
18716 +       va_list args;
18717 +       char buf[1024];
18718 +       int len;
18719 +
18720 +       /* sprintf into a local buffer because there *is* no "vprintk()".. */
18721 +       va_start(args, format);
18722 +       len = vsprintf(buf, format, args);
18723 +       va_end(args);
18724 +
18725 +       if (len > sizeof (buf)) {
18726 +               printk("osl_printf: buffer overrun\n");
18727 +               return (0);
18728 +       }
18729 +
18730 +       return (printk(buf));
18731 +}
18732 +
18733 +int
18734 +osl_sprintf(char *buf, const char *format, ...)
18735 +{
18736 +       va_list args;
18737 +       int rc;
18738 +
18739 +       va_start(args, format);
18740 +       rc = vsprintf(buf, format, args);
18741 +       va_end(args);
18742 +       return (rc);
18743 +}
18744 +
18745 +int
18746 +osl_strcmp(const char *s1, const char *s2)
18747 +{
18748 +       return (strcmp(s1, s2));
18749 +}
18750 +
18751 +int
18752 +osl_strncmp(const char *s1, const char *s2, uint n)
18753 +{
18754 +       return (strncmp(s1, s2, n));
18755 +}
18756 +
18757 +int
18758 +osl_strlen(const char *s)
18759 +{
18760 +       return (strlen(s));
18761 +}
18762 +
18763 +char*
18764 +osl_strcpy(char *d, const char *s)
18765 +{
18766 +       return (strcpy(d, s));
18767 +}
18768 +
18769 +char*
18770 +osl_strncpy(char *d, const char *s, uint n)
18771 +{
18772 +       return (strncpy(d, s, n));
18773 +}
18774 +
18775 +void
18776 +bcopy(const void *src, void *dst, int len)
18777 +{
18778 +       memcpy(dst, src, len);
18779 +}
18780 +
18781 +int
18782 +bcmp(const void *b1, const void *b2, int len)
18783 +{
18784 +       return (memcmp(b1, b2, len));
18785 +}
18786 +
18787 +void
18788 +bzero(void *b, int len)
18789 +{
18790 +       memset(b, '\0', len);
18791 +}
18792 +
18793 +uint32
18794 +osl_readl(volatile uint32 *r)
18795 +{
18796 +       return (readl(r));
18797 +}
18798 +
18799 +uint16
18800 +osl_readw(volatile uint16 *r)
18801 +{
18802 +       return (readw(r));
18803 +}
18804 +
18805 +uint8
18806 +osl_readb(volatile uint8 *r)
18807 +{
18808 +       return (readb(r));
18809 +}
18810 +
18811 +void
18812 +osl_writel(uint32 v, volatile uint32 *r)
18813 +{
18814 +       writel(v, r);
18815 +}
18816 +
18817 +void
18818 +osl_writew(uint16 v, volatile uint16 *r)
18819 +{
18820 +       writew(v, r);
18821 +}
18822 +
18823 +void
18824 +osl_writeb(uint8 v, volatile uint8 *r)
18825 +{
18826 +       writeb(v, r);
18827 +}
18828 +
18829 +void *
18830 +osl_uncached(void *va)
18831 +{
18832 +#ifdef mips
18833 +       return ((void*)KSEG1ADDR(va));
18834 +#else
18835 +       return ((void*)va);
18836 +#endif
18837 +}
18838 +
18839 +uint
18840 +osl_getcycles(void)
18841 +{
18842 +       uint cycles;
18843 +
18844 +#if defined(mips)
18845 +       cycles = read_c0_count() * 2;
18846 +#elif defined(__i386__)
18847 +       rdtscl(cycles);
18848 +#else
18849 +       cycles = 0;
18850 +#endif
18851 +       return cycles;
18852 +}
18853 +
18854 +void *
18855 +osl_reg_map(uint32 pa, uint size)
18856 +{
18857 +       return (ioremap_nocache((unsigned long)pa, (unsigned long)size));
18858 +}
18859 +
18860 +void
18861 +osl_reg_unmap(void *va)
18862 +{
18863 +       iounmap(va);
18864 +}
18865 +
18866 +int
18867 +osl_busprobe(uint32 *val, uint32 addr)
18868 +{
18869 +#ifdef mips
18870 +       return get_dbe(*val, (uint32*)addr);
18871 +#else
18872 +       *val = readl(addr);
18873 +       return 0;
18874 +#endif
18875 +}
18876 +
18877 +uchar*
18878 +osl_pktdata(osl_t *osh, void *skb)
18879 +{
18880 +       return (((struct sk_buff*)skb)->data);
18881 +}
18882 +
18883 +uint
18884 +osl_pktlen(osl_t *osh, void *skb)
18885 +{
18886 +       return (((struct sk_buff*)skb)->len);
18887 +}
18888 +
18889 +uint
18890 +osl_pktheadroom(osl_t *osh, void *skb)
18891 +{
18892 +       return (uint) skb_headroom((struct sk_buff *) skb);
18893 +}
18894 +
18895 +uint
18896 +osl_pkttailroom(osl_t *osh, void *skb)
18897 +{
18898 +       return (uint) skb_tailroom((struct sk_buff *) skb);
18899 +}
18900 +
18901 +void*
18902 +osl_pktnext(osl_t *osh, void *skb)
18903 +{
18904 +       return (((struct sk_buff*)skb)->next);
18905 +}
18906 +
18907 +void
18908 +osl_pktsetnext(void *skb, void *x)
18909 +{
18910 +       ((struct sk_buff*)skb)->next = (struct sk_buff*)x;
18911 +}
18912 +
18913 +void
18914 +osl_pktsetlen(osl_t *osh, void *skb, uint len)
18915 +{
18916 +       __skb_trim((struct sk_buff*)skb, len);
18917 +}
18918 +
18919 +uchar*
18920 +osl_pktpush(osl_t *osh, void *skb, int bytes)
18921 +{
18922 +       return (skb_push((struct sk_buff*)skb, bytes));
18923 +}
18924 +
18925 +uchar*
18926 +osl_pktpull(osl_t *osh, void *skb, int bytes)
18927 +{
18928 +       return (skb_pull((struct sk_buff*)skb, bytes));
18929 +}
18930 +
18931 +void*
18932 +osl_pktdup(osl_t *osh, void *skb)
18933 +{
18934 +       return (skb_clone((struct sk_buff*)skb, GFP_ATOMIC));
18935 +}
18936 +
18937 +void*
18938 +osl_pktcookie(void *skb)
18939 +{
18940 +       return ((void*)((struct sk_buff*)skb)->csum);
18941 +}
18942 +
18943 +void
18944 +osl_pktsetcookie(void *skb, void *x)
18945 +{
18946 +       ((struct sk_buff*)skb)->csum = (uint)x;
18947 +}
18948 +
18949 +void*
18950 +osl_pktlink(void *skb)
18951 +{
18952 +       return (((struct sk_buff*)skb)->prev);
18953 +}
18954 +
18955 +void
18956 +osl_pktsetlink(void *skb, void *x)
18957 +{
18958 +       ((struct sk_buff*)skb)->prev = (struct sk_buff*)x;
18959 +}
18960 +
18961 +uint
18962 +osl_pktprio(void *skb)
18963 +{
18964 +       return (((struct sk_buff*)skb)->priority);
18965 +}
18966 +
18967 +void
18968 +osl_pktsetprio(void *skb, uint x)
18969 +{
18970 +       ((struct sk_buff*)skb)->priority = x;
18971 +}
18972 +
18973 +
18974 +#endif /* BINOSL */
18975 diff -Nur linux-2.4.32/drivers/net/hnd/Makefile linux-2.4.32-brcm/drivers/net/hnd/Makefile
18976 --- linux-2.4.32/drivers/net/hnd/Makefile       1970-01-01 01:00:00.000000000 +0100
18977 +++ linux-2.4.32-brcm/drivers/net/hnd/Makefile  2005-12-16 23:39:11.284858000 +0100
18978 @@ -0,0 +1,19 @@
18979 +#
18980 +# Makefile for the BCM47xx specific kernel interface routines
18981 +# under Linux.
18982 +#
18983 +
18984 +EXTRA_CFLAGS   += -I$(TOPDIR)/arch/mips/bcm947xx/include -DBCMDRIVER
18985 +
18986 +O_TARGET       := hnd.o
18987 +
18988 +HND_OBJS       := bcmutils.o hnddma.o linux_osl.o sbutils.o bcmsrom.o
18989 +
18990 +export-objs    := shared_ksyms.o
18991 +obj-y          := shared_ksyms.o $(HND_OBJS)
18992 +obj-m           := $(O_TARGET)
18993 +
18994 +include $(TOPDIR)/Rules.make
18995 +
18996 +shared_ksyms.c: shared_ksyms.sh $(HND_OBJS)
18997 +       sh -e $< $(HND_OBJS) > $@
18998 diff -Nur linux-2.4.32/drivers/net/hnd/sbutils.c linux-2.4.32-brcm/drivers/net/hnd/sbutils.c
18999 --- linux-2.4.32/drivers/net/hnd/sbutils.c      1970-01-01 01:00:00.000000000 +0100
19000 +++ linux-2.4.32-brcm/drivers/net/hnd/sbutils.c 2005-12-16 23:39:11.316860000 +0100
19001 @@ -0,0 +1,2837 @@
19002 +/*
19003 + * Misc utility routines for accessing chip-specific features
19004 + * of the SiliconBackplane-based Broadcom chips.
19005 + *
19006 + * Copyright 2005, Broadcom Corporation
19007 + * All Rights Reserved.
19008 + *
19009 + * THIS SOFTWARE IS OFFERED "AS IS", AND BROADCOM GRANTS NO WARRANTIES OF ANY
19010 + * KIND, EXPRESS OR IMPLIED, BY STATUTE, COMMUNICATION OR OTHERWISE. BROADCOM
19011 + * SPECIFICALLY DISCLAIMS ANY IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS
19012 + * FOR A SPECIFIC PURPOSE OR NONINFRINGEMENT CONCERNING THIS SOFTWARE.
19013 + * $Id$
19014 + */
19015 +
19016 +#include <typedefs.h>
19017 +#include <osl.h>
19018 +#include <sbutils.h>
19019 +#include <bcmutils.h>
19020 +#include <bcmdevs.h>
19021 +#include <sbconfig.h>
19022 +#include <sbchipc.h>
19023 +#include <sbpci.h>
19024 +#include <sbpcie.h>
19025 +#include <pcicfg.h>
19026 +#include <sbpcmcia.h>
19027 +#include <sbextif.h>
19028 +#include <bcmsrom.h>
19029 +
19030 +/* debug/trace */
19031 +#define        SB_ERROR(args)
19032 +
19033 +
19034 +typedef uint32 (*sb_intrsoff_t)(void *intr_arg);
19035 +typedef void (*sb_intrsrestore_t)(void *intr_arg, uint32 arg);
19036 +typedef bool (*sb_intrsenabled_t)(void *intr_arg);
19037 +
19038 +/* misc sb info needed by some of the routines */
19039 +typedef struct sb_info {
19040 +
19041 +       struct sb_pub   sb;                     /* back plane public state(must be first field of sb_info */
19042 +
19043 +       void    *osh;                   /* osl os handle */
19044 +       void    *sdh;                   /* bcmsdh handle */
19045 +
19046 +       void    *curmap;                /* current regs va */
19047 +       void    *regs[SB_MAXCORES];     /* other regs va */
19048 +
19049 +       uint    curidx;                 /* current core index */
19050 +       uint    dev_coreid;             /* the core provides driver functions */
19051 +
19052 +       bool    memseg;                 /* flag to toggle MEM_SEG register */
19053 +
19054 +       uint    gpioidx;                /* gpio control core index */
19055 +       uint    gpioid;                 /* gpio control coretype */
19056 +
19057 +       uint    numcores;               /* # discovered cores */
19058 +       uint    coreid[SB_MAXCORES];    /* id of each core */
19059 +
19060 +       void    *intr_arg;              /* interrupt callback function arg */
19061 +       sb_intrsoff_t           intrsoff_fn;            /* function turns chip interrupts off */
19062 +       sb_intrsrestore_t       intrsrestore_fn;        /* function restore chip interrupts */
19063 +       sb_intrsenabled_t       intrsenabled_fn;        /* function to check if chip interrupts are enabled */
19064 +
19065 +} sb_info_t;
19066 +
19067 +/* local prototypes */
19068 +static sb_info_t * BCMINIT(sb_doattach)(sb_info_t *si, uint devid, osl_t *osh, void *regs,
19069 +       uint bustype, void *sdh, char **vars, int *varsz);
19070 +static void BCMINIT(sb_scan)(sb_info_t *si);
19071 +static uint sb_corereg(sb_info_t *si, uint coreidx, uint regoff, uint mask, uint val);
19072 +static uint _sb_coreidx(sb_info_t *si);
19073 +static uint sb_findcoreidx(sb_info_t *si, uint coreid, uint coreunit);
19074 +static uint BCMINIT(sb_pcidev2chip)(uint pcidev);
19075 +static uint BCMINIT(sb_chip2numcores)(uint chip);
19076 +static bool sb_ispcie(sb_info_t *si);
19077 +static bool sb_find_pci_capability(sb_info_t *si, uint8 req_cap_id, uchar *buf, uint32 *buflen);
19078 +static int sb_pci_fixcfg(sb_info_t *si);
19079 +
19080 +/* routines to access mdio slave device registers */
19081 +static int sb_pcie_mdiowrite(sb_info_t *si,  uint physmedia, uint readdr, uint val);
19082 +static void BCMINIT(sb_war30841)(sb_info_t *si);
19083 +
19084 +/* delay needed between the mdio control/ mdiodata register data access */
19085 +#define PR28829_DELAY() OSL_DELAY(10)
19086 +
19087 +
19088 +/* global variable to indicate reservation/release of gpio's*/
19089 +static uint32 sb_gpioreservation = 0;
19090 +
19091 +#define        SB_INFO(sbh)    (sb_info_t*)sbh
19092 +#define        SET_SBREG(sbh, r, mask, val)    W_SBREG((sbh), (r), ((R_SBREG((sbh), (r)) & ~(mask)) | (val)))
19093 +#define        GOODCOREADDR(x) (((x) >= SB_ENUM_BASE) && ((x) <= SB_ENUM_LIM) && ISALIGNED((x), SB_CORE_SIZE))
19094 +#define        GOODREGS(regs)  ((regs) && ISALIGNED((uintptr)(regs), SB_CORE_SIZE))
19095 +#define        REGS2SB(va)     (sbconfig_t*) ((int8*)(va) + SBCONFIGOFF)
19096 +#define        GOODIDX(idx)    (((uint)idx) < SB_MAXCORES)
19097 +#define        BADIDX          (SB_MAXCORES+1)
19098 +#define        NOREV           -1
19099 +
19100 +#define PCI(si)                ((BUSTYPE(si->sb.bustype) == PCI_BUS) && (si->sb.buscoretype == SB_PCI))
19101 +#define PCIE(si)       ((BUSTYPE(si->sb.bustype) == PCI_BUS) && (si->sb.buscoretype == SB_PCIE))
19102 +
19103 +/* sonicsrev */
19104 +#define        SONICS_2_2      (SBIDL_RV_2_2 >> SBIDL_RV_SHIFT)
19105 +#define        SONICS_2_3      (SBIDL_RV_2_3 >> SBIDL_RV_SHIFT)
19106 +
19107 +#define        R_SBREG(sbh, sbr)       sb_read_sbreg((sbh), (sbr))
19108 +#define        W_SBREG(sbh, sbr, v)    sb_write_sbreg((sbh), (sbr), (v))
19109 +#define        AND_SBREG(sbh, sbr, v)  W_SBREG((sbh), (sbr), (R_SBREG((sbh), (sbr)) & (v)))
19110 +#define        OR_SBREG(sbh, sbr, v)   W_SBREG((sbh), (sbr), (R_SBREG((sbh), (sbr)) | (v)))
19111 +
19112 +/*
19113 + * Macros to disable/restore function core(D11, ENET, ILINE20, etc) interrupts before/
19114 + * after core switching to avoid invalid register accesss inside ISR.
19115 + */
19116 +#define INTR_OFF(si, intr_val) \
19117 +       if ((si)->intrsoff_fn && (si)->coreid[(si)->curidx] == (si)->dev_coreid) {      \
19118 +               intr_val = (*(si)->intrsoff_fn)((si)->intr_arg); }
19119 +#define INTR_RESTORE(si, intr_val) \
19120 +       if ((si)->intrsrestore_fn && (si)->coreid[(si)->curidx] == (si)->dev_coreid) {  \
19121 +               (*(si)->intrsrestore_fn)((si)->intr_arg, intr_val); }
19122 +
19123 +/* dynamic clock control defines */
19124 +#define        LPOMINFREQ      25000                   /* low power oscillator min */
19125 +#define        LPOMAXFREQ      43000                   /* low power oscillator max */
19126 +#define        XTALMINFREQ     19800000                /* 20 MHz - 1% */
19127 +#define        XTALMAXFREQ     20200000                /* 20 MHz + 1% */
19128 +#define        PCIMINFREQ      25000000                /* 25 MHz */
19129 +#define        PCIMAXFREQ      34000000                /* 33 MHz + fudge */
19130 +
19131 +#define        ILP_DIV_5MHZ    0                       /* ILP = 5 MHz */
19132 +#define        ILP_DIV_1MHZ    4                       /* ILP = 1 MHz */
19133 +
19134 +#define MIN_DUMPBUFLEN  32     /* debug */
19135 +
19136 +/* different register spaces to access thr'u pcie indirect access*/
19137 +#define PCIE_CONFIGREGS        1
19138 +#define PCIE_PCIEREGS          2
19139 +
19140 +/* GPIO Based LED powersave defines */
19141 +#define DEFAULT_GPIO_ONTIME    10
19142 +#define DEFAULT_GPIO_OFFTIME   90
19143 +
19144 +#define DEFAULT_GPIOTIMERVAL  ((DEFAULT_GPIO_ONTIME << GPIO_ONTIME_SHIFT) | DEFAULT_GPIO_OFFTIME)
19145 +
19146 +static uint32
19147 +sb_read_sbreg(sb_info_t *si, volatile uint32 *sbr)
19148 +{
19149 +       uint8 tmp;
19150 +       uint32 val, intr_val = 0;
19151 +
19152 +
19153 +       /*
19154 +        * compact flash only has 11 bits address, while we needs 12 bits address.
19155 +        * MEM_SEG will be OR'd with other 11 bits address in hardware,
19156 +        * so we program MEM_SEG with 12th bit when necessary(access sb regsiters).
19157 +        * For normal PCMCIA bus(CFTable_regwinsz > 2k), do nothing special
19158 +        */
19159 +       if(si->memseg) {
19160 +               INTR_OFF(si, intr_val);
19161 +               tmp = 1;
19162 +               OSL_PCMCIA_WRITE_ATTR(si->osh, MEM_SEG, &tmp, 1);
19163 +               sbr = (uint32) ((uintptr) sbr & ~(1 << 11));    /* mask out bit 11*/
19164 +       }
19165 +
19166 +       val = R_REG(sbr);
19167 +
19168 +       if(si->memseg) {
19169 +               tmp = 0;
19170 +               OSL_PCMCIA_WRITE_ATTR(si->osh, MEM_SEG, &tmp, 1);
19171 +               INTR_RESTORE(si, intr_val);
19172 +       }
19173 +
19174 +       return (val);
19175 +}
19176 +
19177 +static void
19178 +sb_write_sbreg(sb_info_t *si, volatile uint32 *sbr, uint32 v)
19179 +{
19180 +       uint8 tmp;
19181 +       volatile uint32 dummy;
19182 +       uint32 intr_val = 0;
19183 +
19184 +
19185 +       /*
19186 +        * compact flash only has 11 bits address, while we needs 12 bits address.
19187 +        * MEM_SEG will be OR'd with other 11 bits address in hardware,
19188 +        * so we program MEM_SEG with 12th bit when necessary(access sb regsiters).
19189 +        * For normal PCMCIA bus(CFTable_regwinsz > 2k), do nothing special
19190 +        */
19191 +       if(si->memseg) {
19192 +               INTR_OFF(si, intr_val);
19193 +               tmp = 1;
19194 +               OSL_PCMCIA_WRITE_ATTR(si->osh, MEM_SEG, &tmp, 1);
19195 +               sbr = (uint32) ((uintptr) sbr & ~(1 << 11));    /* mask out bit 11*/
19196 +       }
19197 +
19198 +       if (BUSTYPE(si->sb.bustype) == PCMCIA_BUS) {
19199 +#ifdef IL_BIGENDIAN
19200 +               dummy = R_REG(sbr);
19201 +               W_REG(((volatile uint16 *)sbr + 1), (uint16)((v >> 16) & 0xffff));
19202 +               dummy = R_REG(sbr);
19203 +               W_REG((volatile uint16 *)sbr, (uint16)(v & 0xffff));
19204 +#else
19205 +               dummy = R_REG(sbr);
19206 +               W_REG((volatile uint16 *)sbr, (uint16)(v & 0xffff));
19207 +               dummy = R_REG(sbr);
19208 +               W_REG(((volatile uint16 *)sbr + 1), (uint16)((v >> 16) & 0xffff));
19209 +#endif
19210 +       } else
19211 +               W_REG(sbr, v);
19212 +
19213 +       if(si->memseg) {
19214 +               tmp = 0;
19215 +               OSL_PCMCIA_WRITE_ATTR(si->osh, MEM_SEG, &tmp, 1);
19216 +               INTR_RESTORE(si, intr_val);
19217 +       }
19218 +}
19219 +
19220 +/*
19221 + * Allocate a sb handle.
19222 + * devid - pci device id (used to determine chip#)
19223 + * osh - opaque OS handle
19224 + * regs - virtual address of initial core registers
19225 + * bustype - pci/pcmcia/sb/sdio/etc
19226 + * vars - pointer to a pointer area for "environment" variables
19227 + * varsz - pointer to int to return the size of the vars
19228 + */
19229 +sb_t *
19230 +BCMINITFN(sb_attach)(uint devid, osl_t *osh, void *regs,
19231 +       uint bustype, void *sdh, char **vars, int *varsz)
19232 +{
19233 +       sb_info_t *si;
19234 +
19235 +       /* alloc sb_info_t */
19236 +       if ((si = MALLOC(osh, sizeof (sb_info_t))) == NULL) {
19237 +               SB_ERROR(("sb_attach: malloc failed! malloced %d bytes\n", MALLOCED(osh)));
19238 +               return (NULL);
19239 +       }
19240 +
19241 +       if (BCMINIT(sb_doattach)(si, devid, osh, regs, bustype, sdh, vars, varsz) == NULL) {
19242 +               MFREE(osh, si, sizeof (sb_info_t));
19243 +               return (NULL);
19244 +       }
19245 +       return (sb_t *)si;
19246 +}
19247 +
19248 +/* Using sb_kattach depends on SB_BUS support, either implicit  */
19249 +/* no limiting BCMBUSTYPE value) or explicit (value is SB_BUS). */
19250 +#if !defined(BCMBUSTYPE) || (BCMBUSTYPE == SB_BUS)
19251 +
19252 +/* global kernel resource */
19253 +static sb_info_t ksi;
19254 +
19255 +/* generic kernel variant of sb_attach() */
19256 +sb_t *
19257 +BCMINITFN(sb_kattach)()
19258 +{
19259 +       uint32 *regs;
19260 +
19261 +       if (ksi.curmap == NULL) {
19262 +               uint32 cid;
19263 +
19264 +               regs = (uint32 *)REG_MAP(SB_ENUM_BASE, SB_CORE_SIZE);
19265 +               cid = R_REG((uint32 *)regs);
19266 +               if (((cid & CID_ID_MASK) == BCM4712_DEVICE_ID) &&
19267 +                   ((cid & CID_PKG_MASK) != BCM4712LARGE_PKG_ID) &&
19268 +                   ((cid & CID_REV_MASK) <= (3 << CID_REV_SHIFT))) {
19269 +                       uint32 *scc, val;
19270 +
19271 +                       scc = (uint32 *)((uchar*)regs + OFFSETOF(chipcregs_t, slow_clk_ctl));
19272 +                       val = R_REG(scc);
19273 +                       SB_ERROR(("    initial scc = 0x%x\n", val));
19274 +                       val |= SCC_SS_XTAL;
19275 +                       W_REG(scc, val);
19276 +               }
19277 +
19278 +               if (BCMINIT(sb_doattach)(&ksi, BCM4710_DEVICE_ID, NULL, (void*)regs,
19279 +                       SB_BUS, NULL, NULL, NULL) == NULL) {
19280 +                       return NULL;
19281 +               }
19282 +       }
19283 +
19284 +       return (sb_t *)&ksi;
19285 +}
19286 +#endif
19287 +
19288 +static sb_info_t  *
19289 +BCMINITFN(sb_doattach)(sb_info_t *si, uint devid, osl_t *osh, void *regs,
19290 +       uint bustype, void *sdh, char **vars, int *varsz)
19291 +{
19292 +       uint origidx;
19293 +       chipcregs_t *cc;
19294 +       sbconfig_t *sb;
19295 +       uint32 w;
19296 +
19297 +       ASSERT(GOODREGS(regs));
19298 +
19299 +       bzero((uchar*)si, sizeof (sb_info_t));
19300 +
19301 +       si->sb.buscoreidx = si->gpioidx = BADIDX;
19302 +
19303 +       si->osh = osh;
19304 +       si->curmap = regs;
19305 +       si->sdh = sdh;
19306 +
19307 +       /* check to see if we are a sb core mimic'ing a pci core */
19308 +       if (bustype == PCI_BUS) {
19309 +               if (OSL_PCI_READ_CONFIG(osh, PCI_SPROM_CONTROL, sizeof (uint32)) == 0xffffffff)
19310 +                       bustype = SB_BUS;
19311 +               else
19312 +                       bustype = PCI_BUS;
19313 +       }
19314 +
19315 +       si->sb.bustype = bustype;
19316 +       if (si->sb.bustype != BUSTYPE(si->sb.bustype)) {
19317 +               SB_ERROR(("sb_doattach: bus type %d does not match configured bus type %d\n",
19318 +                         si->sb.bustype, BUSTYPE(si->sb.bustype)));
19319 +               return NULL;
19320 +       }
19321 +
19322 +       /* need to set memseg flag for CF card first before any sb registers access */
19323 +       if (BUSTYPE(si->sb.bustype) == PCMCIA_BUS)
19324 +               si->memseg = TRUE;
19325 +
19326 +       /* kludge to enable the clock on the 4306 which lacks a slowclock */
19327 +       if (BUSTYPE(si->sb.bustype) == PCI_BUS)
19328 +               sb_clkctl_xtal(&si->sb, XTAL|PLL, ON);
19329 +
19330 +       if (BUSTYPE(si->sb.bustype) == PCI_BUS) {
19331 +               w = OSL_PCI_READ_CONFIG(osh, PCI_BAR0_WIN, sizeof (uint32));
19332 +               if (!GOODCOREADDR(w))
19333 +                       OSL_PCI_WRITE_CONFIG(si->osh, PCI_BAR0_WIN, sizeof (uint32), SB_ENUM_BASE);
19334 +       }
19335 +
19336 +       /* initialize current core index value */
19337 +       si->curidx = _sb_coreidx(si);
19338 +
19339 +       if (si->curidx == BADIDX) {
19340 +               SB_ERROR(("sb_doattach: bad core index\n"));
19341 +               return NULL;
19342 +       }
19343 +
19344 +       /* get sonics backplane revision */
19345 +       sb = REGS2SB(si->curmap);
19346 +       si->sb.sonicsrev = (R_SBREG(si, &(sb)->sbidlow) & SBIDL_RV_MASK) >> SBIDL_RV_SHIFT;
19347 +
19348 +       /* keep and reuse the initial register mapping */
19349 +       origidx = si->curidx;
19350 +       if (BUSTYPE(si->sb.bustype) == SB_BUS)
19351 +               si->regs[origidx] = regs;
19352 +
19353 +       /* is core-0 a chipcommon core? */
19354 +       si->numcores = 1;
19355 +       cc = (chipcregs_t*) sb_setcoreidx(&si->sb, 0);
19356 +       if (sb_coreid(&si->sb) != SB_CC)
19357 +               cc = NULL;
19358 +
19359 +       /* determine chip id and rev */
19360 +       if (cc) {
19361 +               /* chip common core found! */
19362 +               si->sb.chip = R_REG(&cc->chipid) & CID_ID_MASK;
19363 +               si->sb.chiprev = (R_REG(&cc->chipid) & CID_REV_MASK) >> CID_REV_SHIFT;
19364 +               si->sb.chippkg = (R_REG(&cc->chipid) & CID_PKG_MASK) >> CID_PKG_SHIFT;
19365 +       } else {
19366 +               /* The only pcmcia chip without a chipcommon core is a 4301 */
19367 +               if (BUSTYPE(si->sb.bustype) == PCMCIA_BUS)
19368 +                       devid = BCM4301_DEVICE_ID;
19369 +
19370 +               /* no chip common core -- must convert device id to chip id */
19371 +               if ((si->sb.chip = BCMINIT(sb_pcidev2chip)(devid)) == 0) {
19372 +                       SB_ERROR(("sb_doattach: unrecognized device id 0x%04x\n", devid));
19373 +                       sb_setcoreidx(&si->sb, origidx);
19374 +                       return NULL;
19375 +               }
19376 +       }
19377 +
19378 +       /* get chipcommon rev */
19379 +       si->sb.ccrev = cc ? (int)sb_corerev(&si->sb) : NOREV;
19380 +
19381 +       /* determine numcores */
19382 +       if (cc && ((si->sb.ccrev == 4) || (si->sb.ccrev >= 6)))
19383 +               si->numcores = (R_REG(&cc->chipid) & CID_CC_MASK) >> CID_CC_SHIFT;
19384 +       else
19385 +               si->numcores = BCMINIT(sb_chip2numcores)(si->sb.chip);
19386 +
19387 +       /* return to original core */
19388 +       sb_setcoreidx(&si->sb, origidx);
19389 +
19390 +       /* sanity checks */
19391 +       ASSERT(si->sb.chip);
19392 +
19393 +       /* scan for cores */
19394 +       BCMINIT(sb_scan)(si);
19395 +
19396 +       /* fixup necessary chip/core configurations */
19397 +       if (BUSTYPE(si->sb.bustype) == PCI_BUS) {
19398 +               if (sb_pci_fixcfg(si)) {
19399 +                       SB_ERROR(("sb_doattach: sb_pci_fixcfg failed\n"));
19400 +                       return NULL;
19401 +               }
19402 +       }
19403 +
19404 +       /* srom_var_init() depends on sb_scan() info */
19405 +       if (srom_var_init(si, si->sb.bustype, si->curmap, osh, vars, varsz)) {
19406 +               SB_ERROR(("sb_doattach: srom_var_init failed: bad srom\n"));
19407 +               return (NULL);
19408 +       }
19409 +
19410 +       if (cc == NULL) {
19411 +               /*
19412 +                * The chip revision number is hardwired into all
19413 +                * of the pci function config rev fields and is
19414 +                * independent from the individual core revision numbers.
19415 +                * For example, the "A0" silicon of each chip is chip rev 0.
19416 +                * For PCMCIA we get it from the CIS instead.
19417 +                */
19418 +               if (BUSTYPE(si->sb.bustype) == PCMCIA_BUS) {
19419 +                       ASSERT(vars);
19420 +                       si->sb.chiprev = getintvar(*vars, "chiprev");
19421 +               } else if (BUSTYPE(si->sb.bustype) == PCI_BUS) {
19422 +                       w = OSL_PCI_READ_CONFIG(osh, PCI_CFG_REV, sizeof (uint32));
19423 +                       si->sb.chiprev = w & 0xff;
19424 +               } else
19425 +                       si->sb.chiprev = 0;
19426 +       }
19427 +
19428 +       if (BUSTYPE(si->sb.bustype) == PCMCIA_BUS) {
19429 +               w = getintvar(*vars, "regwindowsz");
19430 +               si->memseg = (w <= CFTABLE_REGWIN_2K) ? TRUE : FALSE;
19431 +       }
19432 +
19433 +       /* gpio control core is required */
19434 +       if (!GOODIDX(si->gpioidx)) {
19435 +               SB_ERROR(("sb_doattach: gpio control core not found\n"));
19436 +               return NULL;
19437 +       }
19438 +
19439 +       /* get boardtype and boardrev */
19440 +       switch (BUSTYPE(si->sb.bustype)) {
19441 +       case PCI_BUS:
19442 +               /* do a pci config read to get subsystem id and subvendor id */
19443 +               w = OSL_PCI_READ_CONFIG(osh, PCI_CFG_SVID, sizeof (uint32));
19444 +               si->sb.boardvendor = w & 0xffff;
19445 +               si->sb.boardtype = (w >> 16) & 0xffff;
19446 +               break;
19447 +
19448 +       case PCMCIA_BUS:
19449 +       case SDIO_BUS:
19450 +               si->sb.boardvendor = getintvar(*vars, "manfid");
19451 +               si->sb.boardtype = getintvar(*vars, "prodid");
19452 +               break;
19453 +
19454 +       case SB_BUS:
19455 +       case JTAG_BUS:
19456 +               si->sb.boardvendor = VENDOR_BROADCOM;
19457 +               if ((si->sb.boardtype = getintvar(NULL, "boardtype")) == 0)
19458 +                       si->sb.boardtype = 0xffff;
19459 +               break;
19460 +       }
19461 +
19462 +       if (si->sb.boardtype == 0) {
19463 +               SB_ERROR(("sb_doattach: unknown board type\n"));
19464 +               ASSERT(si->sb.boardtype);
19465 +       }
19466 +
19467 +       /* setup the GPIO based LED powersave register */
19468 +       if (si->sb.ccrev >= 16) {
19469 +               w = getintvar(*vars, "gpiotimerval");
19470 +               if (!w)
19471 +                       w = DEFAULT_GPIOTIMERVAL;
19472 +               sb_corereg(si, 0, OFFSETOF(chipcregs_t, gpiotimerval), ~0, w);
19473 +       }
19474 +
19475 +
19476 +       return (si);
19477 +}
19478 +
19479 +uint
19480 +sb_coreid(sb_t *sbh)
19481 +{
19482 +       sb_info_t *si;
19483 +       sbconfig_t *sb;
19484 +
19485 +       si = SB_INFO(sbh);
19486 +       sb = REGS2SB(si->curmap);
19487 +
19488 +       return ((R_SBREG(si, &(sb)->sbidhigh) & SBIDH_CC_MASK) >> SBIDH_CC_SHIFT);
19489 +}
19490 +
19491 +uint
19492 +sb_coreidx(sb_t *sbh)
19493 +{
19494 +       sb_info_t *si;
19495 +
19496 +       si = SB_INFO(sbh);
19497 +       return (si->curidx);
19498 +}
19499 +
19500 +/* return current index of core */
19501 +static uint
19502 +_sb_coreidx(sb_info_t *si)
19503 +{
19504 +       sbconfig_t *sb;
19505 +       uint32 sbaddr = 0;
19506 +
19507 +       ASSERT(si);
19508 +
19509 +       switch (BUSTYPE(si->sb.bustype)) {
19510 +       case SB_BUS:
19511 +               sb = REGS2SB(si->curmap);
19512 +               sbaddr = sb_base(R_SBREG(si, &sb->sbadmatch0));
19513 +               break;
19514 +
19515 +       case PCI_BUS:
19516 +               sbaddr = OSL_PCI_READ_CONFIG(si->osh, PCI_BAR0_WIN, sizeof (uint32));
19517 +               break;
19518 +
19519 +       case PCMCIA_BUS: {
19520 +               uint8 tmp = 0;
19521 +
19522 +               OSL_PCMCIA_READ_ATTR(si->osh, PCMCIA_ADDR0, &tmp, 1);
19523 +               sbaddr  = (uint)tmp << 12;
19524 +               OSL_PCMCIA_READ_ATTR(si->osh, PCMCIA_ADDR1, &tmp, 1);
19525 +               sbaddr |= (uint)tmp << 16;
19526 +               OSL_PCMCIA_READ_ATTR(si->osh, PCMCIA_ADDR2, &tmp, 1);
19527 +               sbaddr |= (uint)tmp << 24;
19528 +               break;
19529 +       }
19530 +
19531 +#ifdef BCMJTAG
19532 +       case JTAG_BUS:
19533 +               sbaddr = (uint32)si->curmap;
19534 +               break;
19535 +#endif /* BCMJTAG */
19536 +
19537 +       default:
19538 +               ASSERT(0);
19539 +       }
19540 +
19541 +       if (!GOODCOREADDR(sbaddr))
19542 +               return BADIDX;
19543 +
19544 +       return ((sbaddr - SB_ENUM_BASE) / SB_CORE_SIZE);
19545 +}
19546 +
19547 +uint
19548 +sb_corevendor(sb_t *sbh)
19549 +{
19550 +       sb_info_t *si;
19551 +       sbconfig_t *sb;
19552 +
19553 +       si = SB_INFO(sbh);
19554 +       sb = REGS2SB(si->curmap);
19555 +
19556 +       return ((R_SBREG(si, &(sb)->sbidhigh) & SBIDH_VC_MASK) >> SBIDH_VC_SHIFT);
19557 +}
19558 +
19559 +uint
19560 +sb_corerev(sb_t *sbh)
19561 +{
19562 +       sb_info_t *si;
19563 +       sbconfig_t *sb;
19564 +       uint sbidh;
19565 +
19566 +       si = SB_INFO(sbh);
19567 +       sb = REGS2SB(si->curmap);
19568 +       sbidh = R_SBREG(si, &(sb)->sbidhigh);
19569 +
19570 +       return (SBCOREREV(sbidh));
19571 +}
19572 +
19573 +void *
19574 +sb_osh(sb_t *sbh)
19575 +{
19576 +       sb_info_t *si;
19577 +
19578 +       si = SB_INFO(sbh);
19579 +       return si->osh;
19580 +}
19581 +
19582 +#define        SBTML_ALLOW     (SBTML_PE | SBTML_FGC | SBTML_FL_MASK)
19583 +
19584 +/* set/clear sbtmstatelow core-specific flags */
19585 +uint32
19586 +sb_coreflags(sb_t *sbh, uint32 mask, uint32 val)
19587 +{
19588 +       sb_info_t *si;
19589 +       sbconfig_t *sb;
19590 +       uint32 w;
19591 +
19592 +       si = SB_INFO(sbh);
19593 +       sb = REGS2SB(si->curmap);
19594 +
19595 +       ASSERT((val & ~mask) == 0);
19596 +       ASSERT((mask & ~SBTML_ALLOW) == 0);
19597 +
19598 +       /* mask and set */
19599 +       if (mask || val) {
19600 +               w = (R_SBREG(si, &sb->sbtmstatelow) & ~mask) | val;
19601 +               W_SBREG(si, &sb->sbtmstatelow, w);
19602 +       }
19603 +
19604 +       /* return the new value */
19605 +       return (R_SBREG(si, &sb->sbtmstatelow) & SBTML_ALLOW);
19606 +}
19607 +
19608 +/* set/clear sbtmstatehigh core-specific flags */
19609 +uint32
19610 +sb_coreflagshi(sb_t *sbh, uint32 mask, uint32 val)
19611 +{
19612 +       sb_info_t *si;
19613 +       sbconfig_t *sb;
19614 +       uint32 w;
19615 +
19616 +       si = SB_INFO(sbh);
19617 +       sb = REGS2SB(si->curmap);
19618 +
19619 +       ASSERT((val & ~mask) == 0);
19620 +       ASSERT((mask & ~SBTMH_FL_MASK) == 0);
19621 +
19622 +       /* mask and set */
19623 +       if (mask || val) {
19624 +               w = (R_SBREG(si, &sb->sbtmstatehigh) & ~mask) | val;
19625 +               W_SBREG(si, &sb->sbtmstatehigh, w);
19626 +       }
19627 +
19628 +       /* return the new value */
19629 +       return (R_SBREG(si, &sb->sbtmstatehigh) & SBTMH_FL_MASK);
19630 +}
19631 +
19632 +/* caller needs to take care of core-specific bist hazards */
19633 +int
19634 +sb_corebist(sb_t *sbh, uint coreid, uint coreunit)
19635 +{
19636 +       uint32 sblo;
19637 +       uint coreidx;
19638 +       sb_info_t *si;
19639 +       int result = 0;
19640 +
19641 +       si = SB_INFO(sbh);
19642 +
19643 +       coreidx = sb_findcoreidx(si, coreid, coreunit);
19644 +       if (!GOODIDX(coreidx))
19645 +               result = BCME_ERROR;
19646 +       else {
19647 +               sblo = sb_corereg(si, coreidx, SBCONFIGOFF + OFFSETOF(sbconfig_t, sbtmstatelow), 0, 0);
19648 +               sb_corereg(si, coreidx, SBCONFIGOFF + OFFSETOF(sbconfig_t, sbtmstatelow), ~0, (sblo | SBTML_FGC | SBTML_BE));
19649 +
19650 +               SPINWAIT(((sb_corereg(si, coreidx, SBCONFIGOFF + OFFSETOF(sbconfig_t, sbtmstatehigh), 0, 0) & SBTMH_BISTD) == 0), 100000);
19651 +
19652 +               if (sb_corereg(si, coreidx, SBCONFIGOFF + OFFSETOF(sbconfig_t, sbtmstatehigh), 0, 0) & SBTMH_BISTF)
19653 +                       result = BCME_ERROR;
19654 +
19655 +               sb_corereg(si, coreidx, SBCONFIGOFF + OFFSETOF(sbconfig_t, sbtmstatelow), ~0, sblo);
19656 +       }
19657 +
19658 +       return result;
19659 +}
19660 +
19661 +bool
19662 +sb_iscoreup(sb_t *sbh)
19663 +{
19664 +       sb_info_t *si;
19665 +       sbconfig_t *sb;
19666 +
19667 +       si = SB_INFO(sbh);
19668 +       sb = REGS2SB(si->curmap);
19669 +
19670 +       return ((R_SBREG(si, &(sb)->sbtmstatelow) & (SBTML_RESET | SBTML_REJ_MASK | SBTML_CLK)) == SBTML_CLK);
19671 +}
19672 +
19673 +/*
19674 + * Switch to 'coreidx', issue a single arbitrary 32bit register mask&set operation,
19675 + * switch back to the original core, and return the new value.
19676 + */
19677 +static uint
19678 +sb_corereg(sb_info_t *si, uint coreidx, uint regoff, uint mask, uint val)
19679 +{
19680 +       uint origidx;
19681 +       uint32 *r;
19682 +       uint w;
19683 +       uint intr_val = 0;
19684 +
19685 +       ASSERT(GOODIDX(coreidx));
19686 +       ASSERT(regoff < SB_CORE_SIZE);
19687 +       ASSERT((val & ~mask) == 0);
19688 +
19689 +       INTR_OFF(si, intr_val);
19690 +
19691 +       /* save current core index */
19692 +       origidx = sb_coreidx(&si->sb);
19693 +
19694 +       /* switch core */
19695 +       r = (uint32*) ((uchar*) sb_setcoreidx(&si->sb, coreidx) + regoff);
19696 +
19697 +       /* mask and set */
19698 +       if (mask || val) {
19699 +               if (regoff >= SBCONFIGOFF) {
19700 +                       w = (R_SBREG(si, r) & ~mask) | val;
19701 +                       W_SBREG(si, r, w);
19702 +               } else {
19703 +                       w = (R_REG(r) & ~mask) | val;
19704 +                       W_REG(r, w);
19705 +               }
19706 +       }
19707 +
19708 +       /* readback */
19709 +       if (regoff >= SBCONFIGOFF)
19710 +               w = R_SBREG(si, r);
19711 +       else
19712 +               w = R_REG(r);
19713 +
19714 +       /* restore core index */
19715 +       if (origidx != coreidx)
19716 +               sb_setcoreidx(&si->sb, origidx);
19717 +
19718 +       INTR_RESTORE(si, intr_val);
19719 +       return (w);
19720 +}
19721 +
19722 +#define DWORD_ALIGN(x)  (x & ~(0x03))
19723 +#define BYTE_POS(x) (x & 0x3)
19724 +#define WORD_POS(x) (x & 0x1)
19725 +
19726 +#define BYTE_SHIFT(x)  (8 * BYTE_POS(x))
19727 +#define WORD_SHIFT(x)  (16 * WORD_POS(x))
19728 +
19729 +#define BYTE_VAL(a, x) ((a >> BYTE_SHIFT(x)) & 0xFF)
19730 +#define WORD_VAL(a, x) ((a >> WORD_SHIFT(x)) & 0xFFFF)
19731 +
19732 +#define read_pci_cfg_byte(a) \
19733 +       (BYTE_VAL(OSL_PCI_READ_CONFIG(si->osh, DWORD_ALIGN(a), 4), a) & 0xff)
19734 +
19735 +#define read_pci_cfg_write(a) \
19736 +       (WORD_VAL(OSL_PCI_READ_CONFIG(si->osh, DWORD_ALIGN(a), 4), a) & 0xffff)
19737 +
19738 +
19739 +/* return TRUE if requested capability exists in the PCI config space */
19740 +static bool
19741 +sb_find_pci_capability(sb_info_t *si, uint8 req_cap_id, uchar *buf, uint32 *buflen)
19742 +{
19743 +       uint8 cap_id;
19744 +       uint8 cap_ptr;
19745 +       uint32  bufsize;
19746 +       uint8 byte_val;
19747 +
19748 +       if (BUSTYPE(si->sb.bustype) != PCI_BUS)
19749 +               return FALSE;
19750 +
19751 +       /* check for Header type 0*/
19752 +       byte_val = read_pci_cfg_byte(PCI_CFG_HDR);
19753 +       if ((byte_val & 0x7f) != PCI_HEADER_NORMAL)
19754 +               return FALSE;
19755 +
19756 +       /* check if the capability pointer field exists */
19757 +       byte_val = read_pci_cfg_byte(PCI_CFG_STAT);
19758 +       if (!(byte_val & PCI_CAPPTR_PRESENT))
19759 +               return FALSE;
19760 +
19761 +       cap_ptr = read_pci_cfg_byte(PCI_CFG_CAPPTR);
19762 +       /* check if the capability pointer is 0x00 */
19763 +       if (cap_ptr == 0x00)
19764 +               return FALSE;
19765 +
19766 +
19767 +       /* loop thr'u the capability list and see if the pcie capabilty exists */
19768 +
19769 +       cap_id = read_pci_cfg_byte(cap_ptr);
19770 +
19771 +       while (cap_id != req_cap_id) {
19772 +               cap_ptr = read_pci_cfg_byte((cap_ptr+1));
19773 +               if (cap_ptr == 0x00) break;
19774 +               cap_id = read_pci_cfg_byte(cap_ptr);
19775 +       }
19776 +       if (cap_id != req_cap_id) {
19777 +               return FALSE;
19778 +       }
19779 +       /* found the caller requested capability */
19780 +       if ((buf != NULL) &&  (buflen != NULL)) {
19781 +               bufsize = *buflen;
19782 +               if (!bufsize) goto end;
19783 +               *buflen = 0;
19784 +               /* copy the cpability data excluding cap ID and next ptr */
19785 +               cap_ptr += 2;
19786 +               if ((bufsize + cap_ptr)  > SZPCR)
19787 +                       bufsize = SZPCR - cap_ptr;
19788 +               *buflen = bufsize;
19789 +               while (bufsize--) {
19790 +                       *buf = read_pci_cfg_byte(cap_ptr);
19791 +                       cap_ptr++;
19792 +                       buf++;
19793 +               }
19794 +       }
19795 +end:
19796 +       return TRUE;
19797 +}
19798 +
19799 +/* return TRUE if PCIE capability exists the pci config space */
19800 +static bool
19801 +sb_ispcie(sb_info_t *si)
19802 +{
19803 +       return(sb_find_pci_capability(si, PCI_CAP_PCIECAP_ID, NULL, NULL));
19804 +}
19805 +
19806 +/* scan the sb enumerated space to identify all cores */
19807 +static void
19808 +BCMINITFN(sb_scan)(sb_info_t *si)
19809 +{
19810 +       uint origidx;
19811 +       uint i;
19812 +       bool pci;
19813 +       bool pcie;
19814 +       uint pciidx;
19815 +       uint pcieidx;
19816 +       uint pcirev;
19817 +       uint pcierev;
19818 +
19819 +
19820 +
19821 +       /* numcores should already be set */
19822 +       ASSERT((si->numcores > 0) && (si->numcores <= SB_MAXCORES));
19823 +
19824 +       /* save current core index */
19825 +       origidx = sb_coreidx(&si->sb);
19826 +
19827 +       si->sb.buscorerev = NOREV;
19828 +       si->sb.buscoreidx = BADIDX;
19829 +
19830 +       si->gpioidx = BADIDX;
19831 +
19832 +       pci = pcie = FALSE;
19833 +       pcirev = pcierev = NOREV;
19834 +       pciidx = pcieidx = BADIDX;
19835 +
19836 +       for (i = 0; i < si->numcores; i++) {
19837 +               sb_setcoreidx(&si->sb, i);
19838 +               si->coreid[i] = sb_coreid(&si->sb);
19839 +
19840 +               if (si->coreid[i] == SB_PCI) {
19841 +                       pciidx = i;
19842 +                       pcirev = sb_corerev(&si->sb);
19843 +                       pci = TRUE;
19844 +               } else if (si->coreid[i] == SB_PCIE) {
19845 +                       pcieidx = i;
19846 +                       pcierev = sb_corerev(&si->sb);
19847 +                       pcie = TRUE;
19848 +               } else if (si->coreid[i] == SB_PCMCIA) {
19849 +                       si->sb.buscorerev = sb_corerev(&si->sb);
19850 +                       si->sb.buscoretype = si->coreid[i];
19851 +                       si->sb.buscoreidx = i;
19852 +               }
19853 +       }
19854 +       if (pci && pcie) {
19855 +               if (sb_ispcie(si))
19856 +                       pci = FALSE;
19857 +               else
19858 +                       pcie = FALSE;
19859 +       }
19860 +       if (pci) {
19861 +               si->sb.buscoretype = SB_PCI;
19862 +               si->sb.buscorerev = pcirev;
19863 +               si->sb.buscoreidx = pciidx;
19864 +       }
19865 +       else if (pcie) {
19866 +               si->sb.buscoretype = SB_PCIE;
19867 +               si->sb.buscorerev = pcierev;
19868 +               si->sb.buscoreidx = pcieidx;
19869 +       }
19870 +
19871 +       /*
19872 +        * Find the gpio "controlling core" type and index.
19873 +        * Precedence:
19874 +        * - if there's a chip common core - use that
19875 +        * - else if there's a pci core (rev >= 2) - use that
19876 +        * - else there had better be an extif core (4710 only)
19877 +        */
19878 +       if (GOODIDX(sb_findcoreidx(si, SB_CC, 0))) {
19879 +               si->gpioidx = sb_findcoreidx(si, SB_CC, 0);
19880 +               si->gpioid = SB_CC;
19881 +       } else if (PCI(si) && (si->sb.buscorerev >= 2)) {
19882 +               si->gpioidx = si->sb.buscoreidx;
19883 +               si->gpioid = SB_PCI;
19884 +       } else if (sb_findcoreidx(si, SB_EXTIF, 0)) {
19885 +               si->gpioidx = sb_findcoreidx(si, SB_EXTIF, 0);
19886 +               si->gpioid = SB_EXTIF;
19887 +       } else
19888 +               ASSERT(si->gpioidx != BADIDX);
19889 +
19890 +       /* return to original core index */
19891 +       sb_setcoreidx(&si->sb, origidx);
19892 +}
19893 +
19894 +/* may be called with core in reset */
19895 +void
19896 +sb_detach(sb_t *sbh)
19897 +{
19898 +       sb_info_t *si;
19899 +       uint idx;
19900 +
19901 +       si = SB_INFO(sbh);
19902 +
19903 +       if (si == NULL)
19904 +               return;
19905 +
19906 +       if (BUSTYPE(si->sb.bustype) == SB_BUS)
19907 +               for (idx = 0; idx < SB_MAXCORES; idx++)
19908 +                       if (si->regs[idx]) {
19909 +                               REG_UNMAP(si->regs[idx]);
19910 +                               si->regs[idx] = NULL;
19911 +                       }
19912 +
19913 +       if (si != &ksi)
19914 +               MFREE(si->osh, si, sizeof (sb_info_t));
19915 +}
19916 +
19917 +/* use pci dev id to determine chip id for chips not having a chipcommon core */
19918 +static uint
19919 +BCMINITFN(sb_pcidev2chip)(uint pcidev)
19920 +{
19921 +       if ((pcidev >= BCM4710_DEVICE_ID) && (pcidev <= BCM47XX_USB_ID))
19922 +               return (BCM4710_DEVICE_ID);
19923 +       if ((pcidev >= BCM4402_DEVICE_ID) && (pcidev <= BCM4402_V90_ID))
19924 +               return (BCM4402_DEVICE_ID);
19925 +       if (pcidev == BCM4401_ENET_ID)
19926 +               return (BCM4402_DEVICE_ID);
19927 +       if ((pcidev >= BCM4307_V90_ID) && (pcidev <= BCM4307_D11B_ID))
19928 +               return (BCM4307_DEVICE_ID);
19929 +       if (pcidev == BCM4301_DEVICE_ID)
19930 +               return (BCM4301_DEVICE_ID);
19931 +
19932 +       return (0);
19933 +}
19934 +
19935 +/* convert chip number to number of i/o cores */
19936 +static uint
19937 +BCMINITFN(sb_chip2numcores)(uint chip)
19938 +{
19939 +       if (chip == BCM4710_DEVICE_ID)
19940 +               return (9);
19941 +       if (chip == BCM4402_DEVICE_ID)
19942 +               return (3);
19943 +       if ((chip == BCM4301_DEVICE_ID) || (chip == BCM4307_DEVICE_ID))
19944 +               return (5);
19945 +       if (chip == BCM4306_DEVICE_ID)  /* < 4306c0 */
19946 +               return (6);
19947 +       if (chip == BCM4704_DEVICE_ID)
19948 +               return (9);
19949 +       if (chip == BCM5365_DEVICE_ID)
19950 +               return (7);
19951 +
19952 +       SB_ERROR(("sb_chip2numcores: unsupported chip 0x%x\n", chip));
19953 +       ASSERT(0);
19954 +       return (1);
19955 +}
19956 +
19957 +/* return index of coreid or BADIDX if not found */
19958 +static uint
19959 +sb_findcoreidx( sb_info_t *si, uint coreid, uint coreunit)
19960 +{
19961 +       uint found;
19962 +       uint i;
19963 +
19964 +       found = 0;
19965 +
19966 +       for (i = 0; i < si->numcores; i++)
19967 +               if (si->coreid[i] == coreid) {
19968 +                       if (found == coreunit)
19969 +                               return (i);
19970 +                       found++;
19971 +               }
19972 +
19973 +       return (BADIDX);
19974 +}
19975 +
19976 +/*
19977 + * this function changes logical "focus" to the indiciated core,
19978 + * must be called with interrupt off.
19979 + * Moreover, callers should keep interrupts off during switching out of and back to d11 core
19980 + */
19981 +void*
19982 +sb_setcoreidx(sb_t *sbh, uint coreidx)
19983 +{
19984 +       sb_info_t *si;
19985 +       uint32 sbaddr;
19986 +       uint8 tmp;
19987 +
19988 +       si = SB_INFO(sbh);
19989 +
19990 +       if (coreidx >= si->numcores)
19991 +               return (NULL);
19992 +
19993 +       /*
19994 +        * If the user has provided an interrupt mask enabled function,
19995 +        * then assert interrupts are disabled before switching the core.
19996 +        */
19997 +       ASSERT((si->intrsenabled_fn == NULL) || !(*(si)->intrsenabled_fn)((si)->intr_arg));
19998 +
19999 +       sbaddr = SB_ENUM_BASE + (coreidx * SB_CORE_SIZE);
20000 +
20001 +       switch (BUSTYPE(si->sb.bustype)) {
20002 +       case SB_BUS:
20003 +               /* map new one */
20004 +               if (!si->regs[coreidx]) {
20005 +                       si->regs[coreidx] = (void*)REG_MAP(sbaddr, SB_CORE_SIZE);
20006 +                       ASSERT(GOODREGS(si->regs[coreidx]));
20007 +               }
20008 +               si->curmap = si->regs[coreidx];
20009 +               break;
20010 +
20011 +       case PCI_BUS:
20012 +               /* point bar0 window */
20013 +               OSL_PCI_WRITE_CONFIG(si->osh, PCI_BAR0_WIN, 4, sbaddr);
20014 +               break;
20015 +
20016 +       case PCMCIA_BUS:
20017 +               tmp = (sbaddr >> 12) & 0x0f;
20018 +               OSL_PCMCIA_WRITE_ATTR(si->osh, PCMCIA_ADDR0, &tmp, 1);
20019 +               tmp = (sbaddr >> 16) & 0xff;
20020 +               OSL_PCMCIA_WRITE_ATTR(si->osh, PCMCIA_ADDR1, &tmp, 1);
20021 +               tmp = (sbaddr >> 24) & 0xff;
20022 +               OSL_PCMCIA_WRITE_ATTR(si->osh, PCMCIA_ADDR2, &tmp, 1);
20023 +               break;
20024 +#ifdef BCMJTAG
20025 +       case JTAG_BUS:
20026 +               /* map new one */
20027 +               if (!si->regs[coreidx]) {
20028 +                       si->regs[coreidx] = (void *)sbaddr;
20029 +                       ASSERT(GOODREGS(si->regs[coreidx]));
20030 +               }
20031 +               si->curmap = si->regs[coreidx];
20032 +               break;
20033 +#endif /* BCMJTAG */
20034 +       }
20035 +
20036 +       si->curidx = coreidx;
20037 +
20038 +       return (si->curmap);
20039 +}
20040 +
20041 +/*
20042 + * this function changes logical "focus" to the indiciated core,
20043 + * must be called with interrupt off.
20044 + * Moreover, callers should keep interrupts off during switching out of and back to d11 core
20045 + */
20046 +void*
20047 +sb_setcore(sb_t *sbh, uint coreid, uint coreunit)
20048 +{
20049 +       sb_info_t *si;
20050 +       uint idx;
20051 +
20052 +       si = SB_INFO(sbh);
20053 +       idx = sb_findcoreidx(si, coreid, coreunit);
20054 +       if (!GOODIDX(idx))
20055 +               return (NULL);
20056 +
20057 +       return (sb_setcoreidx(sbh, idx));
20058 +}
20059 +
20060 +/* return chip number */
20061 +uint
20062 +BCMINITFN(sb_chip)(sb_t *sbh)
20063 +{
20064 +       sb_info_t *si;
20065 +
20066 +       si = SB_INFO(sbh);
20067 +       return (si->sb.chip);
20068 +}
20069 +
20070 +/* return chip revision number */
20071 +uint
20072 +BCMINITFN(sb_chiprev)(sb_t *sbh)
20073 +{
20074 +       sb_info_t *si;
20075 +
20076 +       si = SB_INFO(sbh);
20077 +       return (si->sb.chiprev);
20078 +}
20079 +
20080 +/* return chip common revision number */
20081 +uint
20082 +BCMINITFN(sb_chipcrev)(sb_t *sbh)
20083 +{
20084 +       sb_info_t *si;
20085 +
20086 +       si = SB_INFO(sbh);
20087 +       return (si->sb.ccrev);
20088 +}
20089 +
20090 +/* return chip package option */
20091 +uint
20092 +BCMINITFN(sb_chippkg)(sb_t *sbh)
20093 +{
20094 +       sb_info_t *si;
20095 +
20096 +       si = SB_INFO(sbh);
20097 +       return (si->sb.chippkg);
20098 +}
20099 +
20100 +/* return PCI core rev. */
20101 +uint
20102 +BCMINITFN(sb_pcirev)(sb_t *sbh)
20103 +{
20104 +       sb_info_t *si;
20105 +
20106 +       si = SB_INFO(sbh);
20107 +       return (si->sb.buscorerev);
20108 +}
20109 +
20110 +bool
20111 +BCMINITFN(sb_war16165)(sb_t *sbh)
20112 +{
20113 +       sb_info_t *si;
20114 +
20115 +       si = SB_INFO(sbh);
20116 +
20117 +       return (PCI(si) && (si->sb.buscorerev <= 10));
20118 +}
20119 +
20120 +static void
20121 +BCMINITFN(sb_war30841)(sb_info_t *si)
20122 +{
20123 +       sb_pcie_mdiowrite(si, MDIODATA_DEV_RX, SERDES_RX_TIMER1, 0x8128);
20124 +       sb_pcie_mdiowrite(si, MDIODATA_DEV_RX, SERDES_RX_CDR, 0x0100);
20125 +       sb_pcie_mdiowrite(si, MDIODATA_DEV_RX, SERDES_RX_CDRBW, 0x1466);
20126 +}
20127 +
20128 +/* return PCMCIA core rev. */
20129 +uint
20130 +BCMINITFN(sb_pcmciarev)(sb_t *sbh)
20131 +{
20132 +       sb_info_t *si;
20133 +
20134 +       si = SB_INFO(sbh);
20135 +       return (si->sb.buscorerev);
20136 +}
20137 +
20138 +/* return board vendor id */
20139 +uint
20140 +BCMINITFN(sb_boardvendor)(sb_t *sbh)
20141 +{
20142 +       sb_info_t *si;
20143 +
20144 +       si = SB_INFO(sbh);
20145 +       return (si->sb.boardvendor);
20146 +}
20147 +
20148 +/* return boardtype */
20149 +uint
20150 +BCMINITFN(sb_boardtype)(sb_t *sbh)
20151 +{
20152 +       sb_info_t *si;
20153 +       char *var;
20154 +
20155 +       si = SB_INFO(sbh);
20156 +
20157 +       if (BUSTYPE(si->sb.bustype) == SB_BUS && si->sb.boardtype == 0xffff) {
20158 +               /* boardtype format is a hex string */
20159 +               si->sb.boardtype = getintvar(NULL, "boardtype");
20160 +
20161 +               /* backward compatibility for older boardtype string format */
20162 +               if ((si->sb.boardtype == 0) && (var = getvar(NULL, "boardtype"))) {
20163 +                       if (!strcmp(var, "bcm94710dev"))
20164 +                               si->sb.boardtype = BCM94710D_BOARD;
20165 +                       else if (!strcmp(var, "bcm94710ap"))
20166 +                               si->sb.boardtype = BCM94710AP_BOARD;
20167 +                       else if (!strcmp(var, "bu4710"))
20168 +                               si->sb.boardtype = BU4710_BOARD;
20169 +                       else if (!strcmp(var, "bcm94702mn"))
20170 +                               si->sb.boardtype = BCM94702MN_BOARD;
20171 +                       else if (!strcmp(var, "bcm94710r1"))
20172 +                               si->sb.boardtype = BCM94710R1_BOARD;
20173 +                       else if (!strcmp(var, "bcm94710r4"))
20174 +                               si->sb.boardtype = BCM94710R4_BOARD;
20175 +                       else if (!strcmp(var, "bcm94702cpci"))
20176 +                               si->sb.boardtype = BCM94702CPCI_BOARD;
20177 +                       else if (!strcmp(var, "bcm95380_rr"))
20178 +                               si->sb.boardtype = BCM95380RR_BOARD;
20179 +               }
20180 +       }
20181 +
20182 +       return (si->sb.boardtype);
20183 +}
20184 +
20185 +/* return bus type of sbh device */
20186 +uint
20187 +sb_bus(sb_t *sbh)
20188 +{
20189 +       sb_info_t *si;
20190 +
20191 +       si = SB_INFO(sbh);
20192 +       return (si->sb.bustype);
20193 +}
20194 +
20195 +/* return bus core type */
20196 +uint
20197 +sb_buscoretype(sb_t *sbh)
20198 +{
20199 +       sb_info_t *si;
20200 +
20201 +       si = SB_INFO(sbh);
20202 +
20203 +       return (si->sb.buscoretype);
20204 +}
20205 +
20206 +/* return bus core revision */
20207 +uint
20208 +sb_buscorerev(sb_t *sbh)
20209 +{
20210 +       sb_info_t *si;
20211 +       si = SB_INFO(sbh);
20212 +
20213 +       return (si->sb.buscorerev);
20214 +}
20215 +
20216 +/* return list of found cores */
20217 +uint
20218 +sb_corelist(sb_t *sbh, uint coreid[])
20219 +{
20220 +       sb_info_t *si;
20221 +
20222 +       si = SB_INFO(sbh);
20223 +
20224 +       bcopy((uchar*)si->coreid, (uchar*)coreid, (si->numcores * sizeof (uint)));
20225 +       return (si->numcores);
20226 +}
20227 +
20228 +/* return current register mapping */
20229 +void *
20230 +sb_coreregs(sb_t *sbh)
20231 +{
20232 +       sb_info_t *si;
20233 +
20234 +       si = SB_INFO(sbh);
20235 +       ASSERT(GOODREGS(si->curmap));
20236 +
20237 +       return (si->curmap);
20238 +}
20239 +
20240 +
20241 +/* do buffered registers update */
20242 +void
20243 +sb_commit(sb_t *sbh)
20244 +{
20245 +       sb_info_t *si;
20246 +       uint origidx;
20247 +       uint intr_val = 0;
20248 +
20249 +       si = SB_INFO(sbh);
20250 +
20251 +       origidx = si->curidx;
20252 +       ASSERT(GOODIDX(origidx));
20253 +
20254 +       INTR_OFF(si, intr_val);
20255 +
20256 +       /* switch over to chipcommon core if there is one, else use pci */
20257 +       if (si->sb.ccrev != NOREV) {
20258 +               chipcregs_t *ccregs = (chipcregs_t *)sb_setcore(sbh, SB_CC, 0);
20259 +
20260 +               /* do the buffer registers update */
20261 +               W_REG(&ccregs->broadcastaddress, SB_COMMIT);
20262 +               W_REG(&ccregs->broadcastdata, 0x0);
20263 +       } else if (PCI(si)) {
20264 +               sbpciregs_t *pciregs = (sbpciregs_t *)sb_setcore(sbh, SB_PCI, 0);
20265 +
20266 +               /* do the buffer registers update */
20267 +               W_REG(&pciregs->bcastaddr, SB_COMMIT);
20268 +               W_REG(&pciregs->bcastdata, 0x0);
20269 +       } else
20270 +               ASSERT(0);
20271 +
20272 +       /* restore core index */
20273 +       sb_setcoreidx(sbh, origidx);
20274 +       INTR_RESTORE(si, intr_val);
20275 +}
20276 +
20277 +/* reset and re-enable a core */
20278 +void
20279 +sb_core_reset(sb_t *sbh, uint32 bits)
20280 +{
20281 +       sb_info_t *si;
20282 +       sbconfig_t *sb;
20283 +       volatile uint32 dummy;
20284 +
20285 +       si = SB_INFO(sbh);
20286 +       ASSERT(GOODREGS(si->curmap));
20287 +       sb = REGS2SB(si->curmap);
20288 +
20289 +       /*
20290 +        * Must do the disable sequence first to work for arbitrary current core state.
20291 +        */
20292 +       sb_core_disable(sbh, bits);
20293 +
20294 +       /*
20295 +        * Now do the initialization sequence.
20296 +        */
20297 +
20298 +       /* set reset while enabling the clock and forcing them on throughout the core */
20299 +       W_SBREG(si, &sb->sbtmstatelow, (SBTML_FGC | SBTML_CLK | SBTML_RESET | bits));
20300 +       dummy = R_SBREG(si, &sb->sbtmstatelow);
20301 +       OSL_DELAY(1);
20302 +
20303 +       if (R_SBREG(si, &sb->sbtmstatehigh) & SBTMH_SERR) {
20304 +               W_SBREG(si, &sb->sbtmstatehigh, 0);
20305 +       }
20306 +       if ((dummy = R_SBREG(si, &sb->sbimstate)) & (SBIM_IBE | SBIM_TO)) {
20307 +               AND_SBREG(si, &sb->sbimstate, ~(SBIM_IBE | SBIM_TO));
20308 +       }
20309 +
20310 +       /* clear reset and allow it to propagate throughout the core */
20311 +       W_SBREG(si, &sb->sbtmstatelow, (SBTML_FGC | SBTML_CLK | bits));
20312 +       dummy = R_SBREG(si, &sb->sbtmstatelow);
20313 +       OSL_DELAY(1);
20314 +
20315 +       /* leave clock enabled */
20316 +       W_SBREG(si, &sb->sbtmstatelow, (SBTML_CLK | bits));
20317 +       dummy = R_SBREG(si, &sb->sbtmstatelow);
20318 +       OSL_DELAY(1);
20319 +}
20320 +
20321 +void
20322 +sb_core_tofixup(sb_t *sbh)
20323 +{
20324 +       sb_info_t *si;
20325 +       sbconfig_t *sb;
20326 +
20327 +       si = SB_INFO(sbh);
20328 +
20329 +       if ( (BUSTYPE(si->sb.bustype) != PCI_BUS) || PCIE(si) || (PCI(si) && (si->sb.buscorerev >= 5)) )
20330 +               return;
20331 +
20332 +       ASSERT(GOODREGS(si->curmap));
20333 +       sb = REGS2SB(si->curmap);
20334 +
20335 +       if (BUSTYPE(si->sb.bustype) == SB_BUS) {
20336 +               SET_SBREG(si, &sb->sbimconfiglow,
20337 +                         SBIMCL_RTO_MASK | SBIMCL_STO_MASK,
20338 +                         (0x5 << SBIMCL_RTO_SHIFT) | 0x3);
20339 +       } else {
20340 +               if (sb_coreid(sbh) == SB_PCI) {
20341 +                       SET_SBREG(si, &sb->sbimconfiglow,
20342 +                                 SBIMCL_RTO_MASK | SBIMCL_STO_MASK,
20343 +                                 (0x3 << SBIMCL_RTO_SHIFT) | 0x2);
20344 +               } else {
20345 +                       SET_SBREG(si, &sb->sbimconfiglow, (SBIMCL_RTO_MASK | SBIMCL_STO_MASK), 0);
20346 +               }
20347 +       }
20348 +
20349 +       sb_commit(sbh);
20350 +}
20351 +
20352 +/*
20353 + * Set the initiator timeout for the "master core".
20354 + * The master core is defined to be the core in control
20355 + * of the chip and so it issues accesses to non-memory
20356 + * locations (Because of dma *any* core can access memeory).
20357 + *
20358 + * The routine uses the bus to decide who is the master:
20359 + *     SB_BUS => mips
20360 + *     JTAG_BUS => chipc
20361 + *     PCI_BUS => pci or pcie
20362 + *     PCMCIA_BUS => pcmcia
20363 + *     SDIO_BUS => pcmcia
20364 + *
20365 + * This routine exists so callers can disable initiator
20366 + * timeouts so accesses to very slow devices like otp
20367 + * won't cause an abort. The routine allows arbitrary
20368 + * settings of the service and request timeouts, though.
20369 + *
20370 + * Returns the timeout state before changing it or -1
20371 + * on error.
20372 + */
20373 +
20374 +#define        TO_MASK (SBIMCL_RTO_MASK | SBIMCL_STO_MASK)
20375 +
20376 +uint32
20377 +sb_set_initiator_to(sb_t *sbh, uint32 to)
20378 +{
20379 +       sb_info_t *si;
20380 +       uint origidx, idx;
20381 +       uint intr_val = 0;
20382 +       uint32 tmp, ret = 0xffffffff;
20383 +       sbconfig_t *sb;
20384 +
20385 +       si = SB_INFO(sbh);
20386 +
20387 +       if ((to & ~TO_MASK) != 0)
20388 +               return ret;
20389 +
20390 +       /* Figure out the master core */
20391 +       idx = BADIDX;
20392 +       switch (BUSTYPE(si->sb.bustype)) {
20393 +       case PCI_BUS:
20394 +               idx = si->sb.buscoreidx;
20395 +               break;
20396 +       case JTAG_BUS:
20397 +               idx = SB_CC_IDX;
20398 +               break;
20399 +       case PCMCIA_BUS:
20400 +       case SDIO_BUS:
20401 +               idx = sb_findcoreidx(si, SB_PCMCIA, 0);
20402 +               break;
20403 +       case SB_BUS:
20404 +               if ((idx = sb_findcoreidx(si, SB_MIPS33, 0)) == BADIDX)
20405 +                       idx = sb_findcoreidx(si, SB_MIPS, 0);
20406 +               break;
20407 +       default:
20408 +               ASSERT(0);
20409 +       }
20410 +       if (idx == BADIDX)
20411 +               return ret;
20412 +
20413 +       INTR_OFF(si, intr_val);
20414 +       origidx = sb_coreidx(sbh);
20415 +
20416 +       sb = REGS2SB(sb_setcoreidx(sbh, idx));
20417 +
20418 +       tmp = R_SBREG(si, &sb->sbimconfiglow);
20419 +       ret = tmp & TO_MASK;
20420 +       W_SBREG(si, &sb->sbimconfiglow, (tmp & ~TO_MASK) | to);
20421 +
20422 +       sb_commit(sbh);
20423 +       sb_setcoreidx(sbh, origidx);
20424 +       INTR_RESTORE(si, intr_val);
20425 +       return ret;
20426 +}
20427 +
20428 +void
20429 +sb_core_disable(sb_t *sbh, uint32 bits)
20430 +{
20431 +       sb_info_t *si;
20432 +       volatile uint32 dummy;
20433 +       uint32 rej;
20434 +       sbconfig_t *sb;
20435 +
20436 +       si = SB_INFO(sbh);
20437 +
20438 +       ASSERT(GOODREGS(si->curmap));
20439 +       sb = REGS2SB(si->curmap);
20440 +
20441 +       /* if core is already in reset, just return */
20442 +       if (R_SBREG(si, &sb->sbtmstatelow) & SBTML_RESET)
20443 +               return;
20444 +
20445 +       /* reject value changed between sonics 2.2 and 2.3 */
20446 +       if (si->sb.sonicsrev == SONICS_2_2)
20447 +               rej = (1 << SBTML_REJ_SHIFT);
20448 +       else
20449 +               rej = (2 << SBTML_REJ_SHIFT);
20450 +
20451 +       /* if clocks are not enabled, put into reset and return */
20452 +       if ((R_SBREG(si, &sb->sbtmstatelow) & SBTML_CLK) == 0)
20453 +               goto disable;
20454 +
20455 +       /* set target reject and spin until busy is clear (preserve core-specific bits) */
20456 +       OR_SBREG(si, &sb->sbtmstatelow, rej);
20457 +       dummy = R_SBREG(si, &sb->sbtmstatelow);
20458 +       OSL_DELAY(1);
20459 +       SPINWAIT((R_SBREG(si, &sb->sbtmstatehigh) & SBTMH_BUSY), 100000);
20460 +
20461 +       if (R_SBREG(si, &sb->sbidlow) & SBIDL_INIT) {
20462 +               OR_SBREG(si, &sb->sbimstate, SBIM_RJ);
20463 +               dummy = R_SBREG(si, &sb->sbimstate);
20464 +               OSL_DELAY(1);
20465 +               SPINWAIT((R_SBREG(si, &sb->sbimstate) & SBIM_BY), 100000);
20466 +       }
20467 +
20468 +       /* set reset and reject while enabling the clocks */
20469 +       W_SBREG(si, &sb->sbtmstatelow, (bits | SBTML_FGC | SBTML_CLK | rej | SBTML_RESET));
20470 +       dummy = R_SBREG(si, &sb->sbtmstatelow);
20471 +       OSL_DELAY(10);
20472 +
20473 +       /* don't forget to clear the initiator reject bit */
20474 +       if (R_SBREG(si, &sb->sbidlow) & SBIDL_INIT)
20475 +               AND_SBREG(si, &sb->sbimstate, ~SBIM_RJ);
20476 +
20477 +disable:
20478 +       /* leave reset and reject asserted */
20479 +       W_SBREG(si, &sb->sbtmstatelow, (bits | rej | SBTML_RESET));
20480 +       OSL_DELAY(1);
20481 +}
20482 +
20483 +/* set chip watchdog reset timer to fire in 'ticks' backplane cycles */
20484 +void
20485 +sb_watchdog(sb_t *sbh, uint ticks)
20486 +{
20487 +       sb_info_t *si = SB_INFO(sbh);
20488 +
20489 +       /* instant NMI */
20490 +       switch (si->gpioid) {
20491 +       case SB_CC:
20492 +               sb_corereg(si, 0, OFFSETOF(chipcregs_t, watchdog), ~0, ticks);
20493 +               break;
20494 +       case SB_EXTIF:
20495 +               sb_corereg(si, si->gpioidx, OFFSETOF(extifregs_t, watchdog), ~0, ticks);
20496 +               break;
20497 +       }
20498 +}
20499 +
20500 +/* initialize the pcmcia core */
20501 +void
20502 +sb_pcmcia_init(sb_t *sbh)
20503 +{
20504 +       sb_info_t *si;
20505 +       uint8 cor;
20506 +
20507 +       si = SB_INFO(sbh);
20508 +
20509 +       /* enable d11 mac interrupts */
20510 +       if (si->sb.chip == BCM4301_DEVICE_ID) {
20511 +               /* Have to use FCR2 in 4301 */
20512 +               OSL_PCMCIA_READ_ATTR(si->osh, PCMCIA_FCR2 + PCMCIA_COR, &cor, 1);
20513 +               cor |= COR_IRQEN | COR_FUNEN;
20514 +               OSL_PCMCIA_WRITE_ATTR(si->osh, PCMCIA_FCR2 + PCMCIA_COR, &cor, 1);
20515 +       } else {
20516 +               OSL_PCMCIA_READ_ATTR(si->osh, PCMCIA_FCR0 + PCMCIA_COR, &cor, 1);
20517 +               cor |= COR_IRQEN | COR_FUNEN;
20518 +               OSL_PCMCIA_WRITE_ATTR(si->osh, PCMCIA_FCR0 + PCMCIA_COR, &cor, 1);
20519 +       }
20520 +
20521 +}
20522 +
20523 +
20524 +/*
20525 + * Configure the pci core for pci client (NIC) action
20526 + * coremask is the bitvec of cores by index to be enabled.
20527 + */
20528 +void
20529 +sb_pci_setup(sb_t *sbh, uint coremask)
20530 +{
20531 +       sb_info_t *si;
20532 +       sbconfig_t *sb;
20533 +       sbpciregs_t *pciregs;
20534 +       uint32 sbflag;
20535 +       uint32 w;
20536 +       uint idx;
20537 +       int reg_val;
20538 +
20539 +       si = SB_INFO(sbh);
20540 +
20541 +       /* if not pci bus, we're done */
20542 +       if (BUSTYPE(si->sb.bustype) != PCI_BUS)
20543 +               return;
20544 +
20545 +       ASSERT(PCI(si) || PCIE(si));
20546 +       ASSERT(si->sb.buscoreidx != BADIDX);
20547 +
20548 +       /* get current core index */
20549 +       idx = si->curidx;
20550 +
20551 +       /* we interrupt on this backplane flag number */
20552 +       ASSERT(GOODREGS(si->curmap));
20553 +       sb = REGS2SB(si->curmap);
20554 +       sbflag = R_SBREG(si, &sb->sbtpsflag) & SBTPS_NUM0_MASK;
20555 +
20556 +       /* switch over to pci core */
20557 +       pciregs = (sbpciregs_t*) sb_setcoreidx(sbh, si->sb.buscoreidx);
20558 +       sb = REGS2SB(pciregs);
20559 +
20560 +       /*
20561 +        * Enable sb->pci interrupts.  Assume
20562 +        * PCI rev 2.3 support was added in pci core rev 6 and things changed..
20563 +        */
20564 +       if (PCIE(si) || (PCI(si) && ((si->sb.buscorerev) >= 6))) {
20565 +               /* pci config write to set this core bit in PCIIntMask */
20566 +               w = OSL_PCI_READ_CONFIG(si->osh, PCI_INT_MASK, sizeof(uint32));
20567 +               w |= (coremask << PCI_SBIM_SHIFT);
20568 +               OSL_PCI_WRITE_CONFIG(si->osh, PCI_INT_MASK, sizeof(uint32), w);
20569 +       } else {
20570 +               /* set sbintvec bit for our flag number */
20571 +               OR_SBREG(si, &sb->sbintvec, (1 << sbflag));
20572 +       }
20573 +
20574 +       if (PCI(si)) {
20575 +               OR_REG(&pciregs->sbtopci2, (SBTOPCI_PREF|SBTOPCI_BURST));
20576 +               if (si->sb.buscorerev >= 11)
20577 +                       OR_REG(&pciregs->sbtopci2, SBTOPCI_RC_READMULTI);
20578 +               if (si->sb.buscorerev < 5) {
20579 +                       SET_SBREG(si, &sb->sbimconfiglow, SBIMCL_RTO_MASK | SBIMCL_STO_MASK,
20580 +                               (0x3 << SBIMCL_RTO_SHIFT) | 0x2);
20581 +                       sb_commit(sbh);
20582 +               }
20583 +       }
20584 +
20585 +       if (PCIE(si) && (si->sb.buscorerev == 0)) {
20586 +               reg_val = sb_pcie_readreg((void *)sbh, (void *)PCIE_PCIEREGS, PCIE_TLP_WORKAROUNDSREG);
20587 +               reg_val |= 0x8;
20588 +               sb_pcie_writereg((void *)sbh, (void *)PCIE_PCIEREGS, PCIE_TLP_WORKAROUNDSREG, reg_val);
20589 +
20590 +               reg_val = sb_pcie_readreg((void *)sbh, (void *)PCIE_PCIEREGS, PCIE_DLLP_LCREG);
20591 +               reg_val &= ~(0x40);
20592 +               sb_pcie_writereg(sbh, (void *)PCIE_PCIEREGS, PCIE_DLLP_LCREG, reg_val);
20593 +
20594 +               BCMINIT(sb_war30841)(si);
20595 +       }
20596 +
20597 +       /* switch back to previous core */
20598 +       sb_setcoreidx(sbh, idx);
20599 +}
20600 +
20601 +uint32
20602 +sb_base(uint32 admatch)
20603 +{
20604 +       uint32 base;
20605 +       uint type;
20606 +
20607 +       type = admatch & SBAM_TYPE_MASK;
20608 +       ASSERT(type < 3);
20609 +
20610 +       base = 0;
20611 +
20612 +       if (type == 0) {
20613 +               base = admatch & SBAM_BASE0_MASK;
20614 +       } else if (type == 1) {
20615 +               ASSERT(!(admatch & SBAM_ADNEG));        /* neg not supported */
20616 +               base = admatch & SBAM_BASE1_MASK;
20617 +       } else if (type == 2) {
20618 +               ASSERT(!(admatch & SBAM_ADNEG));        /* neg not supported */
20619 +               base = admatch & SBAM_BASE2_MASK;
20620 +       }
20621 +
20622 +       return (base);
20623 +}
20624 +
20625 +uint32
20626 +sb_size(uint32 admatch)
20627 +{
20628 +       uint32 size;
20629 +       uint type;
20630 +
20631 +       type = admatch & SBAM_TYPE_MASK;
20632 +       ASSERT(type < 3);
20633 +
20634 +       size = 0;
20635 +
20636 +       if (type == 0) {
20637 +               size = 1 << (((admatch & SBAM_ADINT0_MASK) >> SBAM_ADINT0_SHIFT) + 1);
20638 +       } else if (type == 1) {
20639 +               ASSERT(!(admatch & SBAM_ADNEG));        /* neg not supported */
20640 +               size = 1 << (((admatch & SBAM_ADINT1_MASK) >> SBAM_ADINT1_SHIFT) + 1);
20641 +       } else if (type == 2) {
20642 +               ASSERT(!(admatch & SBAM_ADNEG));        /* neg not supported */
20643 +               size = 1 << (((admatch & SBAM_ADINT2_MASK) >> SBAM_ADINT2_SHIFT) + 1);
20644 +       }
20645 +
20646 +       return (size);
20647 +}
20648 +
20649 +/* return the core-type instantiation # of the current core */
20650 +uint
20651 +sb_coreunit(sb_t *sbh)
20652 +{
20653 +       sb_info_t *si;
20654 +       uint idx;
20655 +       uint coreid;
20656 +       uint coreunit;
20657 +       uint i;
20658 +
20659 +       si = SB_INFO(sbh);
20660 +       coreunit = 0;
20661 +
20662 +       idx = si->curidx;
20663 +
20664 +       ASSERT(GOODREGS(si->curmap));
20665 +       coreid = sb_coreid(sbh);
20666 +
20667 +       /* count the cores of our type */
20668 +       for (i = 0; i < idx; i++)
20669 +               if (si->coreid[i] == coreid)
20670 +                       coreunit++;
20671 +
20672 +       return (coreunit);
20673 +}
20674 +
20675 +static INLINE uint32
20676 +factor6(uint32 x)
20677 +{
20678 +       switch (x) {
20679 +       case CC_F6_2:   return 2;
20680 +       case CC_F6_3:   return 3;
20681 +       case CC_F6_4:   return 4;
20682 +       case CC_F6_5:   return 5;
20683 +       case CC_F6_6:   return 6;
20684 +       case CC_F6_7:   return 7;
20685 +       default:        return 0;
20686 +       }
20687 +}
20688 +
20689 +/* calculate the speed the SB would run at given a set of clockcontrol values */
20690 +uint32
20691 +sb_clock_rate(uint32 pll_type, uint32 n, uint32 m)
20692 +{
20693 +       uint32 n1, n2, clock, m1, m2, m3, mc;
20694 +
20695 +       n1 = n & CN_N1_MASK;
20696 +       n2 = (n & CN_N2_MASK) >> CN_N2_SHIFT;
20697 +
20698 +       if (pll_type == PLL_TYPE6) {
20699 +               if (m & CC_T6_MMASK)
20700 +                       return CC_T6_M1;
20701 +               else
20702 +                       return CC_T6_M0;
20703 +       } else if ((pll_type == PLL_TYPE1) ||
20704 +                  (pll_type == PLL_TYPE3) ||
20705 +                  (pll_type == PLL_TYPE4) ||
20706 +                  (pll_type == PLL_TYPE7)) {
20707 +               n1 = factor6(n1);
20708 +               n2 += CC_F5_BIAS;
20709 +       } else if (pll_type == PLL_TYPE2) {
20710 +               n1 += CC_T2_BIAS;
20711 +               n2 += CC_T2_BIAS;
20712 +               ASSERT((n1 >= 2) && (n1 <= 7));
20713 +               ASSERT((n2 >= 5) && (n2 <= 23));
20714 +       } else if (pll_type == PLL_TYPE5) {
20715 +               return (100000000);
20716 +       } else
20717 +               ASSERT(0);
20718 +       /* PLL types 3 and 7 use BASE2 (25Mhz) */
20719 +       if ((pll_type == PLL_TYPE3) ||
20720 +           (pll_type == PLL_TYPE7)) {
20721 +               clock =  CC_CLOCK_BASE2 * n1 * n2;
20722 +       }
20723 +       else
20724 +               clock = CC_CLOCK_BASE1 * n1 * n2;
20725 +
20726 +       if (clock == 0)
20727 +               return 0;
20728 +
20729 +       m1 = m & CC_M1_MASK;
20730 +       m2 = (m & CC_M2_MASK) >> CC_M2_SHIFT;
20731 +       m3 = (m & CC_M3_MASK) >> CC_M3_SHIFT;
20732 +       mc = (m & CC_MC_MASK) >> CC_MC_SHIFT;
20733 +
20734 +       if ((pll_type == PLL_TYPE1) ||
20735 +           (pll_type == PLL_TYPE3) ||
20736 +           (pll_type == PLL_TYPE4) ||
20737 +           (pll_type == PLL_TYPE7)) {
20738 +               m1 = factor6(m1);
20739 +               if ((pll_type == PLL_TYPE1) || (pll_type == PLL_TYPE3))
20740 +                       m2 += CC_F5_BIAS;
20741 +               else
20742 +                       m2 = factor6(m2);
20743 +               m3 = factor6(m3);
20744 +
20745 +               switch (mc) {
20746 +               case CC_MC_BYPASS:      return (clock);
20747 +               case CC_MC_M1:          return (clock / m1);
20748 +               case CC_MC_M1M2:        return (clock / (m1 * m2));
20749 +               case CC_MC_M1M2M3:      return (clock / (m1 * m2 * m3));
20750 +               case CC_MC_M1M3:        return (clock / (m1 * m3));
20751 +               default:                return (0);
20752 +               }
20753 +       } else {
20754 +               ASSERT(pll_type == PLL_TYPE2);
20755 +
20756 +               m1 += CC_T2_BIAS;
20757 +               m2 += CC_T2M2_BIAS;
20758 +               m3 += CC_T2_BIAS;
20759 +               ASSERT((m1 >= 2) && (m1 <= 7));
20760 +               ASSERT((m2 >= 3) && (m2 <= 10));
20761 +               ASSERT((m3 >= 2) && (m3 <= 7));
20762 +
20763 +               if ((mc & CC_T2MC_M1BYP) == 0)
20764 +                       clock /= m1;
20765 +               if ((mc & CC_T2MC_M2BYP) == 0)
20766 +                       clock /= m2;
20767 +               if ((mc & CC_T2MC_M3BYP) == 0)
20768 +                       clock /= m3;
20769 +
20770 +               return(clock);
20771 +       }
20772 +}
20773 +
20774 +/* returns the current speed the SB is running at */
20775 +uint32
20776 +sb_clock(sb_t *sbh)
20777 +{
20778 +       sb_info_t *si;
20779 +       extifregs_t *eir;
20780 +       chipcregs_t *cc;
20781 +       uint32 n, m;
20782 +       uint idx;
20783 +       uint32 pll_type, rate;
20784 +       uint intr_val = 0;
20785 +
20786 +       si = SB_INFO(sbh);
20787 +       idx = si->curidx;
20788 +       pll_type = PLL_TYPE1;
20789 +
20790 +       INTR_OFF(si, intr_val);
20791 +
20792 +       /* switch to extif or chipc core */
20793 +       if ((eir = (extifregs_t *) sb_setcore(sbh, SB_EXTIF, 0))) {
20794 +               n = R_REG(&eir->clockcontrol_n);
20795 +               m = R_REG(&eir->clockcontrol_sb);
20796 +       } else if ((cc = (chipcregs_t *) sb_setcore(sbh, SB_CC, 0))) {
20797 +               pll_type = R_REG(&cc->capabilities) & CAP_PLL_MASK;
20798 +               n = R_REG(&cc->clockcontrol_n);
20799 +               if (pll_type == PLL_TYPE6)
20800 +                       m = R_REG(&cc->clockcontrol_mips);
20801 +               else if (pll_type == PLL_TYPE3)
20802 +               {
20803 +                       // Added by Chen-I for 5365
20804 +                       if (BCMINIT(sb_chip)(sbh) == BCM5365_DEVICE_ID)
20805 +                               m = R_REG(&cc->clockcontrol_sb);
20806 +                       else
20807 +                               m = R_REG(&cc->clockcontrol_m2);
20808 +               }
20809 +               else
20810 +                       m = R_REG(&cc->clockcontrol_sb);
20811 +       } else {
20812 +               INTR_RESTORE(si, intr_val);
20813 +               return 0;
20814 +       }
20815 +
20816 +       // Added by Chen-I for 5365
20817 +       if (BCMINIT(sb_chip)(sbh) == BCM5365_DEVICE_ID)
20818 +       {
20819 +               rate = 100000000;
20820 +       }
20821 +       else
20822 +       {
20823 +               /* calculate rate */
20824 +               rate = sb_clock_rate(pll_type, n, m);
20825 +               if (pll_type == PLL_TYPE3)
20826 +                       rate = rate / 2;
20827 +       }
20828 +
20829 +       /* switch back to previous core */
20830 +       sb_setcoreidx(sbh, idx);
20831 +
20832 +       INTR_RESTORE(si, intr_val);
20833 +
20834 +       return rate;
20835 +}
20836 +
20837 +/* change logical "focus" to the gpio core for optimized access */
20838 +void*
20839 +sb_gpiosetcore(sb_t *sbh)
20840 +{
20841 +       sb_info_t *si;
20842 +
20843 +       si = SB_INFO(sbh);
20844 +
20845 +       return (sb_setcoreidx(sbh, si->gpioidx));
20846 +}
20847 +
20848 +/* mask&set gpiocontrol bits */
20849 +uint32
20850 +sb_gpiocontrol(sb_t *sbh, uint32 mask, uint32 val, uint8 priority)
20851 +{
20852 +       sb_info_t *si;
20853 +       uint regoff;
20854 +
20855 +       si = SB_INFO(sbh);
20856 +       regoff = 0;
20857 +
20858 +       priority = GPIO_DRV_PRIORITY; /* compatibility hack */
20859 +
20860 +       /* gpios could be shared on router platforms */
20861 +       if ((BUSTYPE(si->sb.bustype) == SB_BUS) && (val || mask)) {
20862 +               mask = priority ? (sb_gpioreservation & mask) :
20863 +                       ((sb_gpioreservation | mask) & ~(sb_gpioreservation));
20864 +               val &= mask;
20865 +       }
20866 +
20867 +       switch (si->gpioid) {
20868 +       case SB_CC:
20869 +               regoff = OFFSETOF(chipcregs_t, gpiocontrol);
20870 +               break;
20871 +
20872 +       case SB_PCI:
20873 +               regoff = OFFSETOF(sbpciregs_t, gpiocontrol);
20874 +               break;
20875 +
20876 +       case SB_EXTIF:
20877 +               return (0);
20878 +       }
20879 +
20880 +       return (sb_corereg(si, si->gpioidx, regoff, mask, val));
20881 +}
20882 +
20883 +/* mask&set gpio output enable bits */
20884 +uint32
20885 +sb_gpioouten(sb_t *sbh, uint32 mask, uint32 val, uint8 priority)
20886 +{
20887 +       sb_info_t *si;
20888 +       uint regoff;
20889 +
20890 +       si = SB_INFO(sbh);
20891 +       regoff = 0;
20892 +
20893 +       priority = GPIO_DRV_PRIORITY; /* compatibility hack */
20894 +
20895 +       /* gpios could be shared on router platforms */
20896 +       if ((BUSTYPE(si->sb.bustype) == SB_BUS) && (val || mask)) {
20897 +               mask = priority ? (sb_gpioreservation & mask) :
20898 +                       ((sb_gpioreservation | mask) & ~(sb_gpioreservation));
20899 +               val &= mask;
20900 +       }
20901 +
20902 +       switch (si->gpioid) {
20903 +       case SB_CC:
20904 +               regoff = OFFSETOF(chipcregs_t, gpioouten);
20905 +               break;
20906 +
20907 +       case SB_PCI:
20908 +               regoff = OFFSETOF(sbpciregs_t, gpioouten);
20909 +               break;
20910 +
20911 +       case SB_EXTIF:
20912 +               regoff = OFFSETOF(extifregs_t, gpio[0].outen);
20913 +               break;
20914 +       }
20915 +
20916 +       return (sb_corereg(si, si->gpioidx, regoff, mask, val));
20917 +}
20918 +
20919 +/* mask&set gpio output bits */
20920 +uint32
20921 +sb_gpioout(sb_t *sbh, uint32 mask, uint32 val, uint8 priority)
20922 +{
20923 +       sb_info_t *si;
20924 +       uint regoff;
20925 +
20926 +       si = SB_INFO(sbh);
20927 +       regoff = 0;
20928 +
20929 +       priority = GPIO_DRV_PRIORITY; /* compatibility hack */
20930 +
20931 +       /* gpios could be shared on router platforms */
20932 +       if ((BUSTYPE(si->sb.bustype) == SB_BUS) && (val || mask)) {
20933 +               mask = priority ? (sb_gpioreservation & mask) :
20934 +                       ((sb_gpioreservation | mask) & ~(sb_gpioreservation));
20935 +               val &= mask;
20936 +       }
20937 +
20938 +       switch (si->gpioid) {
20939 +       case SB_CC:
20940 +               regoff = OFFSETOF(chipcregs_t, gpioout);
20941 +               break;
20942 +
20943 +       case SB_PCI:
20944 +               regoff = OFFSETOF(sbpciregs_t, gpioout);
20945 +               break;
20946 +
20947 +       case SB_EXTIF:
20948 +               regoff = OFFSETOF(extifregs_t, gpio[0].out);
20949 +               break;
20950 +       }
20951 +
20952 +       return (sb_corereg(si, si->gpioidx, regoff, mask, val));
20953 +}
20954 +
20955 +/* reserve one gpio */
20956 +uint32
20957 +sb_gpioreserve(sb_t *sbh, uint32 gpio_bitmask, uint8 priority)
20958 +{
20959 +       sb_info_t *si;
20960 +
20961 +       si = SB_INFO(sbh);
20962 +
20963 +       priority = GPIO_DRV_PRIORITY; /* compatibility hack */
20964 +
20965 +       /* only cores on SB_BUS share GPIO's and only applcation users need to reserve/release GPIO */
20966 +       if ( (BUSTYPE(si->sb.bustype) != SB_BUS) || (!priority))  {
20967 +               ASSERT((BUSTYPE(si->sb.bustype) == SB_BUS) && (priority));
20968 +               return -1;
20969 +       }
20970 +       /* make sure only one bit is set */
20971 +       if ((!gpio_bitmask) || ((gpio_bitmask) & (gpio_bitmask - 1))) {
20972 +               ASSERT((gpio_bitmask) && !((gpio_bitmask) & (gpio_bitmask - 1)));
20973 +               return -1;
20974 +       }
20975 +
20976 +       /* already reserved */
20977 +       if (sb_gpioreservation & gpio_bitmask)
20978 +               return -1;
20979 +       /* set reservation */
20980 +       sb_gpioreservation |= gpio_bitmask;
20981 +
20982 +       return sb_gpioreservation;
20983 +}
20984 +
20985 +/* release one gpio */
20986 +/*
20987 + * releasing the gpio doesn't change the current value on the GPIO last write value
20988 + * persists till some one overwrites it
20989 +*/
20990 +
20991 +uint32
20992 +sb_gpiorelease(sb_t *sbh, uint32 gpio_bitmask, uint8 priority)
20993 +{
20994 +       sb_info_t *si;
20995 +
20996 +       si = SB_INFO(sbh);
20997 +
20998 +       priority = GPIO_DRV_PRIORITY; /* compatibility hack */
20999 +
21000 +       /* only cores on SB_BUS share GPIO's and only applcation users need to reserve/release GPIO */
21001 +       if ( (BUSTYPE(si->sb.bustype) != SB_BUS) || (!priority))  {
21002 +               ASSERT((BUSTYPE(si->sb.bustype) == SB_BUS) && (priority));
21003 +               return -1;
21004 +       }
21005 +       /* make sure only one bit is set */
21006 +       if ((!gpio_bitmask) || ((gpio_bitmask) & (gpio_bitmask - 1))) {
21007 +               ASSERT((gpio_bitmask) && !((gpio_bitmask) & (gpio_bitmask - 1)));
21008 +               return -1;
21009 +       }
21010 +
21011 +       /* already released */
21012 +       if (!(sb_gpioreservation & gpio_bitmask))
21013 +               return -1;
21014 +
21015 +       /* clear reservation */
21016 +       sb_gpioreservation &= ~gpio_bitmask;
21017 +
21018 +       return sb_gpioreservation;
21019 +}
21020 +
21021 +/* return the current gpioin register value */
21022 +uint32
21023 +sb_gpioin(sb_t *sbh)
21024 +{
21025 +       sb_info_t *si;
21026 +       uint regoff;
21027 +
21028 +       si = SB_INFO(sbh);
21029 +       regoff = 0;
21030 +
21031 +       switch (si->gpioid) {
21032 +       case SB_CC:
21033 +               regoff = OFFSETOF(chipcregs_t, gpioin);
21034 +               break;
21035 +
21036 +       case SB_PCI:
21037 +               regoff = OFFSETOF(sbpciregs_t, gpioin);
21038 +               break;
21039 +
21040 +       case SB_EXTIF:
21041 +               regoff = OFFSETOF(extifregs_t, gpioin);
21042 +               break;
21043 +       }
21044 +
21045 +       return (sb_corereg(si, si->gpioidx, regoff, 0, 0));
21046 +}
21047 +
21048 +/* mask&set gpio interrupt polarity bits */
21049 +uint32
21050 +sb_gpiointpolarity(sb_t *sbh, uint32 mask, uint32 val, uint8 priority)
21051 +{
21052 +       sb_info_t *si;
21053 +       uint regoff;
21054 +
21055 +       si = SB_INFO(sbh);
21056 +       regoff = 0;
21057 +
21058 +       priority = GPIO_DRV_PRIORITY; /* compatibility hack */
21059 +
21060 +       /* gpios could be shared on router platforms */
21061 +       if ((BUSTYPE(si->sb.bustype) == SB_BUS) && (val || mask)) {
21062 +               mask = priority ? (sb_gpioreservation & mask) :
21063 +                       ((sb_gpioreservation | mask) & ~(sb_gpioreservation));
21064 +               val &= mask;
21065 +       }
21066 +
21067 +       switch (si->gpioid) {
21068 +       case SB_CC:
21069 +               regoff = OFFSETOF(chipcregs_t, gpiointpolarity);
21070 +               break;
21071 +
21072 +       case SB_PCI:
21073 +               /* pci gpio implementation does not support interrupt polarity */
21074 +               ASSERT(0);
21075 +               break;
21076 +
21077 +       case SB_EXTIF:
21078 +               regoff = OFFSETOF(extifregs_t, gpiointpolarity);
21079 +               break;
21080 +       }
21081 +
21082 +       return (sb_corereg(si, si->gpioidx, regoff, mask, val));
21083 +}
21084 +
21085 +/* mask&set gpio interrupt mask bits */
21086 +uint32
21087 +sb_gpiointmask(sb_t *sbh, uint32 mask, uint32 val, uint8 priority)
21088 +{
21089 +       sb_info_t *si;
21090 +       uint regoff;
21091 +
21092 +       si = SB_INFO(sbh);
21093 +       regoff = 0;
21094 +
21095 +       priority = GPIO_DRV_PRIORITY; /* compatibility hack */
21096 +
21097 +       /* gpios could be shared on router platforms */
21098 +       if ((BUSTYPE(si->sb.bustype) == SB_BUS) && (val || mask)) {
21099 +               mask = priority ? (sb_gpioreservation & mask) :
21100 +                       ((sb_gpioreservation | mask) & ~(sb_gpioreservation));
21101 +               val &= mask;
21102 +       }
21103 +
21104 +       switch (si->gpioid) {
21105 +       case SB_CC:
21106 +               regoff = OFFSETOF(chipcregs_t, gpiointmask);
21107 +               break;
21108 +
21109 +       case SB_PCI:
21110 +               /* pci gpio implementation does not support interrupt mask */
21111 +               ASSERT(0);
21112 +               break;
21113 +
21114 +       case SB_EXTIF:
21115 +               regoff = OFFSETOF(extifregs_t, gpiointmask);
21116 +               break;
21117 +       }
21118 +
21119 +       return (sb_corereg(si, si->gpioidx, regoff, mask, val));
21120 +}
21121 +
21122 +/* assign the gpio to an led */
21123 +uint32
21124 +sb_gpioled(sb_t *sbh, uint32 mask, uint32 val)
21125 +{
21126 +       sb_info_t *si;
21127 +
21128 +       si = SB_INFO(sbh);
21129 +       if (si->sb.ccrev < 16)
21130 +               return -1;
21131 +
21132 +       /* gpio led powersave reg */
21133 +       return(sb_corereg(si, 0, OFFSETOF(chipcregs_t, gpiotimeroutmask), mask, val));
21134 +}
21135 +
21136 +/* mask&set gpio timer val */
21137 +uint32
21138 +sb_gpiotimerval(sb_t *sbh, uint32 mask, uint32 gpiotimerval)
21139 +{
21140 +       sb_info_t *si;
21141 +       si = SB_INFO(sbh);
21142 +
21143 +       if (si->sb.ccrev < 16)
21144 +               return -1;
21145 +
21146 +       return(sb_corereg(si, 0, OFFSETOF(chipcregs_t, gpiotimerval), mask, gpiotimerval));
21147 +}
21148 +
21149 +
21150 +/* return the slow clock source - LPO, XTAL, or PCI */
21151 +static uint
21152 +sb_slowclk_src(sb_info_t *si)
21153 +{
21154 +       chipcregs_t *cc;
21155 +
21156 +
21157 +       ASSERT(sb_coreid(&si->sb) == SB_CC);
21158 +
21159 +       if (si->sb.ccrev < 6) {
21160 +               if ((BUSTYPE(si->sb.bustype) == PCI_BUS)
21161 +                       && (OSL_PCI_READ_CONFIG(si->osh, PCI_GPIO_OUT, sizeof (uint32)) & PCI_CFG_GPIO_SCS))
21162 +                       return (SCC_SS_PCI);
21163 +               else
21164 +                       return (SCC_SS_XTAL);
21165 +       } else if (si->sb.ccrev < 10) {
21166 +               cc = (chipcregs_t*) sb_setcoreidx(&si->sb, si->curidx);
21167 +               return (R_REG(&cc->slow_clk_ctl) & SCC_SS_MASK);
21168 +       } else  /* Insta-clock */
21169 +               return (SCC_SS_XTAL);
21170 +}
21171 +
21172 +/* return the ILP (slowclock) min or max frequency */
21173 +static uint
21174 +sb_slowclk_freq(sb_info_t *si, bool max)
21175 +{
21176 +       chipcregs_t *cc;
21177 +       uint32 slowclk;
21178 +       uint div;
21179 +
21180 +
21181 +       ASSERT(sb_coreid(&si->sb) == SB_CC);
21182 +
21183 +       cc = (chipcregs_t*) sb_setcoreidx(&si->sb, si->curidx);
21184 +
21185 +       /* shouldn't be here unless we've established the chip has dynamic clk control */
21186 +       ASSERT(R_REG(&cc->capabilities) & CAP_PWR_CTL);
21187 +
21188 +       slowclk = sb_slowclk_src(si);
21189 +       if (si->sb.ccrev < 6) {
21190 +               if (slowclk == SCC_SS_PCI)
21191 +                       return (max? (PCIMAXFREQ/64) : (PCIMINFREQ/64));
21192 +               else
21193 +                       return (max? (XTALMAXFREQ/32) : (XTALMINFREQ/32));
21194 +       } else if (si->sb.ccrev < 10) {
21195 +               div = 4 * (((R_REG(&cc->slow_clk_ctl) & SCC_CD_MASK) >> SCC_CD_SHIFT) + 1);
21196 +               if (slowclk == SCC_SS_LPO)
21197 +                       return (max? LPOMAXFREQ : LPOMINFREQ);
21198 +               else if (slowclk == SCC_SS_XTAL)
21199 +                       return (max? (XTALMAXFREQ/div) : (XTALMINFREQ/div));
21200 +               else if (slowclk == SCC_SS_PCI)
21201 +                       return (max? (PCIMAXFREQ/div) : (PCIMINFREQ/div));
21202 +               else
21203 +                       ASSERT(0);
21204 +       } else {
21205 +               /* Chipc rev 10 is InstaClock */
21206 +               div = R_REG(&cc->system_clk_ctl) >> SYCC_CD_SHIFT;
21207 +               div = 4 * (div + 1);
21208 +               return (max ? XTALMAXFREQ : (XTALMINFREQ/div));
21209 +       }
21210 +       return (0);
21211 +}
21212 +
21213 +static void
21214 +sb_clkctl_setdelay(sb_info_t *si, void *chipcregs)
21215 +{
21216 +       chipcregs_t * cc;
21217 +       uint slowmaxfreq, pll_delay, slowclk;
21218 +       uint pll_on_delay, fref_sel_delay;
21219 +
21220 +       pll_delay = PLL_DELAY;
21221 +
21222 +       /* If the slow clock is not sourced by the xtal then add the xtal_on_delay
21223 +        * since the xtal will also be powered down by dynamic clk control logic.
21224 +        */
21225 +       slowclk = sb_slowclk_src(si);
21226 +       if (slowclk != SCC_SS_XTAL)
21227 +               pll_delay += XTAL_ON_DELAY;
21228 +
21229 +       /* Starting with 4318 it is ILP that is used for the delays */
21230 +       slowmaxfreq = sb_slowclk_freq(si, (si->sb.ccrev >= 10) ? FALSE : TRUE);
21231 +
21232 +       pll_on_delay = ((slowmaxfreq * pll_delay) + 999999) / 1000000;
21233 +       fref_sel_delay = ((slowmaxfreq * FREF_DELAY) + 999999) / 1000000;
21234 +
21235 +       cc = (chipcregs_t *)chipcregs;
21236 +       W_REG(&cc->pll_on_delay, pll_on_delay);
21237 +       W_REG(&cc->fref_sel_delay, fref_sel_delay);
21238 +}
21239 +
21240 +int
21241 +sb_pwrctl_slowclk(void *sbh, bool set, uint *div)
21242 +{
21243 +       sb_info_t *si;
21244 +       uint origidx;
21245 +       chipcregs_t *cc;
21246 +       uint intr_val = 0;
21247 +       uint err = 0;
21248 +
21249 +       si = SB_INFO(sbh);
21250 +
21251 +       /* chipcommon cores prior to rev6 don't support slowclkcontrol */
21252 +       if (si->sb.ccrev < 6)
21253 +               return 1;
21254 +
21255 +       /* chipcommon cores rev10 are a whole new ball game */
21256 +       if (si->sb.ccrev >= 10)
21257 +               return 1;
21258 +
21259 +       if (set && ((*div % 4) || (*div < 4)))
21260 +               return 2;
21261 +
21262 +       INTR_OFF(si, intr_val);
21263 +       origidx = si->curidx;
21264 +       cc = (chipcregs_t*) sb_setcore(sbh, SB_CC, 0);
21265 +       ASSERT(cc != NULL);
21266 +
21267 +       if (!(R_REG(&cc->capabilities) & CAP_PWR_CTL)) {
21268 +               err = 3;
21269 +               goto done;
21270 +       }
21271 +
21272 +       if (set) {
21273 +               SET_REG(&cc->slow_clk_ctl, SCC_CD_MASK, ((*div / 4 - 1) << SCC_CD_SHIFT));
21274 +               sb_clkctl_setdelay(sbh, (void *)cc);
21275 +       } else
21276 +               *div = 4 * (((R_REG(&cc->slow_clk_ctl) & SCC_CD_MASK) >> SCC_CD_SHIFT) + 1);
21277 +
21278 +done:
21279 +       sb_setcoreidx(sbh, origidx);
21280 +       INTR_RESTORE(si, intr_val);
21281 +       return err;
21282 +}
21283 +
21284 +/* initialize power control delay registers */
21285 +void sb_clkctl_init(sb_t *sbh)
21286 +{
21287 +       sb_info_t *si;
21288 +       uint origidx;
21289 +       chipcregs_t *cc;
21290 +
21291 +       si = SB_INFO(sbh);
21292 +
21293 +       origidx = si->curidx;
21294 +
21295 +       if ((cc = (chipcregs_t*) sb_setcore(sbh, SB_CC, 0)) == NULL)
21296 +               return;
21297 +
21298 +       if (!(R_REG(&cc->capabilities) & CAP_PWR_CTL))
21299 +               goto done;
21300 +
21301 +       /* 4317pc does not work with SlowClock less than 5 MHz */
21302 +       if ((BUSTYPE(si->sb.bustype) == PCMCIA_BUS) && (si->sb.ccrev >= 6) && (si->sb.ccrev < 10))
21303 +               SET_REG(&cc->slow_clk_ctl, SCC_CD_MASK, (ILP_DIV_5MHZ << SCC_CD_SHIFT));
21304 +
21305 +       /* set all Instaclk chip ILP to 1 MHz */
21306 +       else if (si->sb.ccrev >= 10)
21307 +               SET_REG(&cc->system_clk_ctl, SYCC_CD_MASK, (ILP_DIV_1MHZ << SYCC_CD_SHIFT));
21308 +
21309 +       sb_clkctl_setdelay(si, (void *)cc);
21310 +
21311 +done:
21312 +       sb_setcoreidx(sbh, origidx);
21313 +}
21314 +void sb_pwrctl_init(sb_t *sbh)
21315 +{
21316 +sb_clkctl_init(sbh);
21317 +}
21318 +/* return the value suitable for writing to the dot11 core FAST_PWRUP_DELAY register */
21319 +uint16
21320 +sb_clkctl_fast_pwrup_delay(sb_t *sbh)
21321 +{
21322 +       sb_info_t *si;
21323 +       uint origidx;
21324 +       chipcregs_t *cc;
21325 +       uint slowminfreq;
21326 +       uint16 fpdelay;
21327 +       uint intr_val = 0;
21328 +
21329 +       si = SB_INFO(sbh);
21330 +       fpdelay = 0;
21331 +       origidx = si->curidx;
21332 +
21333 +       INTR_OFF(si, intr_val);
21334 +
21335 +       if ((cc = (chipcregs_t*) sb_setcore(sbh, SB_CC, 0)) == NULL)
21336 +               goto done;
21337 +
21338 +       if (!(R_REG(&cc->capabilities) & CAP_PWR_CTL))
21339 +               goto done;
21340 +
21341 +       slowminfreq = sb_slowclk_freq(si, FALSE);
21342 +       fpdelay = (((R_REG(&cc->pll_on_delay) + 2) * 1000000) + (slowminfreq - 1)) / slowminfreq;
21343 +
21344 +done:
21345 +       sb_setcoreidx(sbh, origidx);
21346 +       INTR_RESTORE(si, intr_val);
21347 +       return (fpdelay);
21348 +}
21349 +uint16 sb_pwrctl_fast_pwrup_delay(sb_t *sbh)
21350 +{
21351 +return sb_clkctl_fast_pwrup_delay(sbh);
21352 +}
21353 +/* turn primary xtal and/or pll off/on */
21354 +int
21355 +sb_clkctl_xtal(sb_t *sbh, uint what, bool on)
21356 +{
21357 +       sb_info_t *si;
21358 +       uint32 in, out, outen;
21359 +
21360 +       si = SB_INFO(sbh);
21361 +
21362 +       switch (BUSTYPE(si->sb.bustype)) {
21363 +
21364 +
21365 +               case PCMCIA_BUS:
21366 +                       return (0);
21367 +
21368 +
21369 +               case PCI_BUS:
21370 +
21371 +                       /* pcie core doesn't have any mapping to control the xtal pu */
21372 +                       if (PCIE(si))
21373 +                               return -1;
21374 +
21375 +                       in = OSL_PCI_READ_CONFIG(si->osh, PCI_GPIO_IN, sizeof (uint32));
21376 +                       out = OSL_PCI_READ_CONFIG(si->osh, PCI_GPIO_OUT, sizeof (uint32));
21377 +                       outen = OSL_PCI_READ_CONFIG(si->osh, PCI_GPIO_OUTEN, sizeof (uint32));
21378 +
21379 +                       /*
21380 +                        * Avoid glitching the clock if GPRS is already using it.
21381 +                        * We can't actually read the state of the PLLPD so we infer it
21382 +                        * by the value of XTAL_PU which *is* readable via gpioin.
21383 +                        */
21384 +                       if (on && (in & PCI_CFG_GPIO_XTAL))
21385 +                               return (0);
21386 +
21387 +                       if (what & XTAL)
21388 +                               outen |= PCI_CFG_GPIO_XTAL;
21389 +                       if (what & PLL)
21390 +                               outen |= PCI_CFG_GPIO_PLL;
21391 +
21392 +                       if (on) {
21393 +                               /* turn primary xtal on */
21394 +                               if (what & XTAL) {
21395 +                                       out |= PCI_CFG_GPIO_XTAL;
21396 +                                       if (what & PLL)
21397 +                                               out |= PCI_CFG_GPIO_PLL;
21398 +                                       OSL_PCI_WRITE_CONFIG(si->osh, PCI_GPIO_OUT, sizeof (uint32), out);
21399 +                                       OSL_PCI_WRITE_CONFIG(si->osh, PCI_GPIO_OUTEN, sizeof (uint32), outen);
21400 +                                       OSL_DELAY(XTAL_ON_DELAY);
21401 +                               }
21402 +
21403 +                               /* turn pll on */
21404 +                               if (what & PLL) {
21405 +                                       out &= ~PCI_CFG_GPIO_PLL;
21406 +                                       OSL_PCI_WRITE_CONFIG(si->osh, PCI_GPIO_OUT, sizeof (uint32), out);
21407 +                                       OSL_DELAY(2000);
21408 +                               }
21409 +                       } else {
21410 +                               if (what & XTAL)
21411 +                                       out &= ~PCI_CFG_GPIO_XTAL;
21412 +                               if (what & PLL)
21413 +                                       out |= PCI_CFG_GPIO_PLL;
21414 +                               OSL_PCI_WRITE_CONFIG(si->osh, PCI_GPIO_OUT, sizeof (uint32), out);
21415 +                               OSL_PCI_WRITE_CONFIG(si->osh, PCI_GPIO_OUTEN, sizeof (uint32), outen);
21416 +                       }
21417 +
21418 +               default:
21419 +                       return (-1);
21420 +       }
21421 +
21422 +       return (0);
21423 +}
21424 +
21425 +int sb_pwrctl_xtal(sb_t *sbh, uint what, bool on)
21426 +{
21427 +return sb_clkctl_xtal(sbh,what,on);
21428 +}
21429 +
21430 +/* set dynamic clk control mode (forceslow, forcefast, dynamic) */
21431 +/*   returns true if ignore pll off is set and false if it is not */
21432 +bool
21433 +sb_clkctl_clk(sb_t *sbh, uint mode)
21434 +{
21435 +       sb_info_t *si;
21436 +       uint origidx;
21437 +       chipcregs_t *cc;
21438 +       uint32 scc;
21439 +       bool forcefastclk=FALSE;
21440 +       uint intr_val = 0;
21441 +
21442 +       si = SB_INFO(sbh);
21443 +
21444 +       /* chipcommon cores prior to rev6 don't support dynamic clock control */
21445 +       if (si->sb.ccrev < 6)
21446 +               return (FALSE);
21447 +
21448 +       /* chipcommon cores rev10 are a whole new ball game */
21449 +       if (si->sb.ccrev >= 10)
21450 +               return (FALSE);
21451 +
21452 +       INTR_OFF(si, intr_val);
21453 +
21454 +       origidx = si->curidx;
21455 +
21456 +       cc = (chipcregs_t*) sb_setcore(sbh, SB_CC, 0);
21457 +       ASSERT(cc != NULL);
21458 +
21459 +       if (!(R_REG(&cc->capabilities) & CAP_PWR_CTL))
21460 +               goto done;
21461 +
21462 +       switch (mode) {
21463 +       case CLK_FAST:  /* force fast (pll) clock */
21464 +               /* don't forget to force xtal back on before we clear SCC_DYN_XTAL.. */
21465 +               sb_clkctl_xtal(&si->sb, XTAL, ON);
21466 +
21467 +               SET_REG(&cc->slow_clk_ctl, (SCC_XC | SCC_FS | SCC_IP), SCC_IP);
21468 +               break;
21469 +
21470 +       case CLK_DYNAMIC:       /* enable dynamic clock control */
21471 +               scc = R_REG(&cc->slow_clk_ctl);
21472 +               scc &= ~(SCC_FS | SCC_IP | SCC_XC);
21473 +               if ((scc & SCC_SS_MASK) != SCC_SS_XTAL)
21474 +                       scc |= SCC_XC;
21475 +               W_REG(&cc->slow_clk_ctl, scc);
21476 +
21477 +               /* for dynamic control, we have to release our xtal_pu "force on" */
21478 +               if (scc & SCC_XC)
21479 +                       sb_clkctl_xtal(&si->sb, XTAL, OFF);
21480 +               break;
21481 +
21482 +       default:
21483 +               ASSERT(0);
21484 +       }
21485 +
21486 +       /* Is the h/w forcing the use of the fast clk */
21487 +       forcefastclk = (bool)((R_REG(&cc->slow_clk_ctl) & SCC_IP) == SCC_IP);
21488 +
21489 +done:
21490 +       sb_setcoreidx(sbh, origidx);
21491 +       INTR_RESTORE(si, intr_val);
21492 +       return (forcefastclk);
21493 +}
21494 +
21495 +bool sb_pwrctl_clk(sb_t *sbh, uint mode)
21496 +{
21497 +return sb_clkctl_clk(sbh, mode);
21498 +}
21499 +/* register driver interrupt disabling and restoring callback functions */
21500 +void
21501 +sb_register_intr_callback(sb_t *sbh, void *intrsoff_fn, void *intrsrestore_fn, void *intrsenabled_fn, void *intr_arg)
21502 +{
21503 +       sb_info_t *si;
21504 +
21505 +       si = SB_INFO(sbh);
21506 +       si->intr_arg = intr_arg;
21507 +       si->intrsoff_fn = (sb_intrsoff_t)intrsoff_fn;
21508 +       si->intrsrestore_fn = (sb_intrsrestore_t)intrsrestore_fn;
21509 +       si->intrsenabled_fn = (sb_intrsenabled_t)intrsenabled_fn;
21510 +       /* save current core id.  when this function called, the current core
21511 +        * must be the core which provides driver functions(il, et, wl, etc.)
21512 +        */
21513 +       si->dev_coreid = si->coreid[si->curidx];
21514 +}
21515 +
21516 +
21517 +void
21518 +sb_corepciid(sb_t *sbh, uint16 *pcivendor, uint16 *pcidevice,
21519 +       uint8 *pciclass, uint8 *pcisubclass, uint8 *pciprogif)
21520 +{
21521 +       uint vendor, core, unit;
21522 +       uint chip, chippkg;
21523 +       char varname[8];
21524 +       uint8 class, subclass, progif;
21525 +
21526 +       vendor = sb_corevendor(sbh);
21527 +       core = sb_coreid(sbh);
21528 +       unit = sb_coreunit(sbh);
21529 +
21530 +       chip = BCMINIT(sb_chip)(sbh);
21531 +       chippkg = BCMINIT(sb_chippkg)(sbh);
21532 +
21533 +       progif = 0;
21534 +
21535 +       /* Known vendor translations */
21536 +       switch (vendor) {
21537 +       case SB_VEND_BCM:
21538 +               vendor = VENDOR_BROADCOM;
21539 +               break;
21540 +       }
21541 +
21542 +       /* Determine class based on known core codes */
21543 +       switch (core) {
21544 +       case SB_ILINE20:
21545 +               class = PCI_CLASS_NET;
21546 +               subclass = PCI_NET_ETHER;
21547 +               core = BCM47XX_ILINE_ID;
21548 +               break;
21549 +       case SB_ENET:
21550 +               class = PCI_CLASS_NET;
21551 +               subclass = PCI_NET_ETHER;
21552 +               core = BCM47XX_ENET_ID;
21553 +               break;
21554 +       case SB_SDRAM:
21555 +       case SB_MEMC:
21556 +               class = PCI_CLASS_MEMORY;
21557 +               subclass = PCI_MEMORY_RAM;
21558 +               break;
21559 +       case SB_PCI:
21560 +       case SB_PCIE:
21561 +               class = PCI_CLASS_BRIDGE;
21562 +               subclass = PCI_BRIDGE_PCI;
21563 +               break;
21564 +       case SB_MIPS:
21565 +       case SB_MIPS33:
21566 +               class = PCI_CLASS_CPU;
21567 +               subclass = PCI_CPU_MIPS;
21568 +               break;
21569 +       case SB_CODEC:
21570 +               class = PCI_CLASS_COMM;
21571 +               subclass = PCI_COMM_MODEM;
21572 +               core = BCM47XX_V90_ID;
21573 +               break;
21574 +       case SB_USB:
21575 +               class = PCI_CLASS_SERIAL;
21576 +               subclass = PCI_SERIAL_USB;
21577 +               progif = 0x10; /* OHCI */
21578 +               core = BCM47XX_USB_ID;
21579 +               break;
21580 +       case SB_USB11H:
21581 +               class = PCI_CLASS_SERIAL;
21582 +               subclass = PCI_SERIAL_USB;
21583 +               progif = 0x10; /* OHCI */
21584 +               core = BCM47XX_USBH_ID;
21585 +               break;
21586 +       case SB_USB11D:
21587 +               class = PCI_CLASS_SERIAL;
21588 +               subclass = PCI_SERIAL_USB;
21589 +               core = BCM47XX_USBD_ID;
21590 +               break;
21591 +       case SB_IPSEC:
21592 +               class = PCI_CLASS_CRYPT;
21593 +               subclass = PCI_CRYPT_NETWORK;
21594 +               core = BCM47XX_IPSEC_ID;
21595 +               break;
21596 +       case SB_ROBO:
21597 +               class = PCI_CLASS_NET;
21598 +               subclass = PCI_NET_OTHER;
21599 +               core = BCM47XX_ROBO_ID;
21600 +               break;
21601 +       case SB_EXTIF:
21602 +       case SB_CC:
21603 +               class = PCI_CLASS_MEMORY;
21604 +               subclass = PCI_MEMORY_FLASH;
21605 +               break;
21606 +       case SB_D11:
21607 +               class = PCI_CLASS_NET;
21608 +               subclass = PCI_NET_OTHER;
21609 +               /* Let an nvram variable override this */
21610 +               sprintf(varname, "wl%did", unit);
21611 +               if ((core = getintvar(NULL, varname)) == 0) {
21612 +                       if (chip == BCM4712_DEVICE_ID) {
21613 +                               if (chippkg == BCM4712SMALL_PKG_ID)
21614 +                                       core = BCM4306_D11G_ID;
21615 +                               else
21616 +                                       core = BCM4306_D11DUAL_ID;
21617 +                       }
21618 +               }
21619 +               break;
21620 +
21621 +       default:
21622 +               class = subclass = progif = 0xff;
21623 +               break;
21624 +       }
21625 +
21626 +       *pcivendor = (uint16)vendor;
21627 +       *pcidevice = (uint16)core;
21628 +       *pciclass = class;
21629 +       *pcisubclass = subclass;
21630 +       *pciprogif = progif;
21631 +}
21632 +
21633 +
21634 +
21635 +
21636 +/* use the mdio interface to write to mdio slaves */
21637 +static int
21638 +sb_pcie_mdiowrite(sb_info_t *si,  uint physmedia, uint regaddr, uint val)
21639 +{
21640 +       uint mdiodata;
21641 +       uint i = 0;
21642 +       sbpcieregs_t *pcieregs;
21643 +
21644 +       pcieregs = (sbpcieregs_t*) sb_setcoreidx(&si->sb, si->sb.buscoreidx);
21645 +       ASSERT (pcieregs);
21646 +
21647 +       /* enable mdio access to SERDES */
21648 +       W_REG((&pcieregs->mdiocontrol), MDIOCTL_PREAM_EN | MDIOCTL_DIVISOR_VAL);
21649 +
21650 +       mdiodata = MDIODATA_START | MDIODATA_WRITE |
21651 +               (physmedia << MDIODATA_DEVADDR_SHF) |
21652 +               (regaddr << MDIODATA_REGADDR_SHF) | MDIODATA_TA | val;
21653 +
21654 +       W_REG((&pcieregs->mdiodata), mdiodata);
21655 +
21656 +       PR28829_DELAY();
21657 +
21658 +       /* retry till the transaction is complete */
21659 +       while ( i < 10 ) {
21660 +               if (R_REG(&(pcieregs->mdiocontrol)) & MDIOCTL_ACCESS_DONE) {
21661 +                       /* Disable mdio access to SERDES */
21662 +                       W_REG((&pcieregs->mdiocontrol), 0);
21663 +                       return 0;
21664 +               }
21665 +               OSL_DELAY(1000);
21666 +               i++;
21667 +       }
21668 +
21669 +       SB_ERROR(("sb_pcie_mdiowrite: timed out\n"));
21670 +       /* Disable mdio access to SERDES */
21671 +       W_REG((&pcieregs->mdiocontrol), 0);
21672 +       ASSERT(0);
21673 +       return 1;
21674 +
21675 +}
21676 +
21677 +/* indirect way to read pcie config regs*/
21678 +uint
21679 +sb_pcie_readreg(void *sb, void* arg1, uint offset)
21680 +{
21681 +       sb_info_t *si;
21682 +       sb_t   *sbh;
21683 +       uint retval = 0xFFFFFFFF;
21684 +       sbpcieregs_t *pcieregs;
21685 +       uint addrtype;
21686 +
21687 +       sbh = (sb_t *)sb;
21688 +       si = SB_INFO(sbh);
21689 +       ASSERT (PCIE(si));
21690 +
21691 +       pcieregs = (sbpcieregs_t *)sb_setcore(sbh, SB_PCIE, 0);
21692 +       ASSERT (pcieregs);
21693 +
21694 +       addrtype = (uint)((uintptr)arg1);
21695 +       switch(addrtype) {
21696 +               case PCIE_CONFIGREGS:
21697 +                       W_REG((&pcieregs->configaddr),offset);
21698 +                       retval = R_REG(&(pcieregs->configdata));
21699 +                       break;
21700 +               case PCIE_PCIEREGS:
21701 +                       W_REG(&(pcieregs->pcieaddr),offset);
21702 +                       retval = R_REG(&(pcieregs->pciedata));
21703 +                       break;
21704 +               default:
21705 +                       ASSERT(0);
21706 +                       break;
21707 +       }
21708 +       return retval;
21709 +}
21710 +
21711 +/* indirect way to write pcie config/mdio/pciecore regs*/
21712 +uint
21713 +sb_pcie_writereg(sb_t *sbh, void *arg1,  uint offset, uint val)
21714 +{
21715 +       sb_info_t *si;
21716 +       sbpcieregs_t *pcieregs;
21717 +       uint addrtype;
21718 +
21719 +       si = SB_INFO(sbh);
21720 +       ASSERT (PCIE(si));
21721 +
21722 +       pcieregs = (sbpcieregs_t *)sb_setcore(sbh, SB_PCIE, 0);
21723 +       ASSERT (pcieregs);
21724 +
21725 +       addrtype = (uint)((uintptr)arg1);
21726 +
21727 +       switch(addrtype) {
21728 +               case PCIE_CONFIGREGS:
21729 +                       W_REG((&pcieregs->configaddr),offset);
21730 +                       W_REG((&pcieregs->configdata),val);
21731 +                       break;
21732 +               case PCIE_PCIEREGS:
21733 +                       W_REG((&pcieregs->pcieaddr),offset);
21734 +                       W_REG((&pcieregs->pciedata),val);
21735 +                       break;
21736 +               default:
21737 +                       ASSERT(0);
21738 +                       break;
21739 +       }
21740 +       return 0;
21741 +}
21742 +
21743 +
21744 +/* Build device path. Support SB, PCI, and JTAG for now. */
21745 +int
21746 +sb_devpath(sb_t *sbh, char *path, int size)
21747 +{
21748 +       ASSERT(path);
21749 +       ASSERT(size >= SB_DEVPATH_BUFSZ);
21750 +
21751 +       switch (BUSTYPE((SB_INFO(sbh))->sb.bustype)) {
21752 +       case SB_BUS:
21753 +       case JTAG_BUS:
21754 +               sprintf(path, "sb/%u/", sb_coreidx(sbh));
21755 +               break;
21756 +       case PCI_BUS:
21757 +               ASSERT((SB_INFO(sbh))->osh);
21758 +               sprintf(path, "pci/%u/%u/", OSL_PCI_BUS((SB_INFO(sbh))->osh),
21759 +                       OSL_PCI_SLOT((SB_INFO(sbh))->osh));
21760 +               break;
21761 +       case PCMCIA_BUS:
21762 +               SB_ERROR(("sb_devpath: OSL_PCMCIA_BUS() not implemented, bus 1 assumed\n"));
21763 +               SB_ERROR(("sb_devpath: OSL_PCMCIA_SLOT() not implemented, slot 1 assumed\n"));
21764 +               sprintf(path, "pc/%u/%u/", 1, 1);
21765 +               break;
21766 +       case SDIO_BUS:
21767 +               SB_ERROR(("sb_devpath: device 0 assumed\n"));
21768 +               sprintf(path, "sd/%u/", sb_coreidx(sbh));
21769 +               break;
21770 +       default:
21771 +               ASSERT(0);
21772 +               break;
21773 +       }
21774 +
21775 +       return 0;
21776 +}
21777 +
21778 +/* Fix chip's configuration. The current core may be changed upon return */
21779 +static int
21780 +sb_pci_fixcfg(sb_info_t *si)
21781 +{
21782 +       uint origidx, pciidx;
21783 +       sbpciregs_t *pciregs;
21784 +       sbpcieregs_t *pcieregs;
21785 +       uint16 val16, *reg16;
21786 +       char name[SB_DEVPATH_BUFSZ+16], *value;
21787 +       char devpath[SB_DEVPATH_BUFSZ];
21788 +
21789 +       ASSERT(BUSTYPE(si->sb.bustype) == PCI_BUS);
21790 +
21791 +       /* Fix PCI(e) SROM shadow area */
21792 +       /* save the current index */
21793 +       origidx = sb_coreidx(&si->sb);
21794 +
21795 +       /* check 'pi' is correct and fix it if not */
21796 +       if (si->sb.buscoretype == SB_PCIE) {
21797 +               pcieregs = (sbpcieregs_t *)sb_setcore(&si->sb, SB_PCIE, 0);
21798 +               ASSERT(pcieregs);
21799 +               reg16 = &pcieregs->sprom[SRSH_PI_OFFSET];
21800 +       }
21801 +       else if (si->sb.buscoretype == SB_PCI) {
21802 +               pciregs = (sbpciregs_t *)sb_setcore(&si->sb, SB_PCI, 0);
21803 +               ASSERT(pciregs);
21804 +               reg16 = &pciregs->sprom[SRSH_PI_OFFSET];
21805 +       }
21806 +       else {
21807 +               ASSERT(0);
21808 +               return -1;
21809 +       }
21810 +       pciidx = sb_coreidx(&si->sb);
21811 +       val16 = R_REG(reg16);
21812 +       if (((val16 & SRSH_PI_MASK) >> SRSH_PI_SHIFT) != (uint16)pciidx) {
21813 +               val16 = (uint16)(pciidx << SRSH_PI_SHIFT) | (val16 & ~SRSH_PI_MASK);
21814 +               W_REG(reg16, val16);
21815 +       }
21816 +
21817 +       /* restore the original index */
21818 +       sb_setcoreidx(&si->sb, origidx);
21819 +
21820 +       /* Fix bar0window */
21821 +       /* !do it last, it changes the current core! */
21822 +       if (sb_devpath(&si->sb, devpath, sizeof(devpath)))
21823 +               return -1;
21824 +       sprintf(name, "%sb0w", devpath);
21825 +       if ((value = getvar(NULL, name))) {
21826 +               OSL_PCI_WRITE_CONFIG(si->osh, PCI_BAR0_WIN, sizeof(uint32),
21827 +                       bcm_strtoul(value, NULL, 16));
21828 +               /* update curidx since the current core is changed */
21829 +               si->curidx = _sb_coreidx(si);
21830 +               if (si->curidx == BADIDX) {
21831 +                       SB_ERROR(("sb_pci_fixcfg: bad core index\n"));
21832 +                       return -1;
21833 +               }
21834 +       }
21835 +
21836 +       return 0;
21837 +}
21838 +
21839 diff -Nur linux-2.4.32/drivers/net/hnd/shared_ksyms.sh linux-2.4.32-brcm/drivers/net/hnd/shared_ksyms.sh
21840 --- linux-2.4.32/drivers/net/hnd/shared_ksyms.sh        1970-01-01 01:00:00.000000000 +0100
21841 +++ linux-2.4.32-brcm/drivers/net/hnd/shared_ksyms.sh   2005-12-16 23:39:11.316860000 +0100
21842 @@ -0,0 +1,21 @@
21843 +#!/bin/sh
21844 +#
21845 +# Copyright 2004, Broadcom Corporation
21846 +# All Rights Reserved.
21847 +#
21848 +# THIS SOFTWARE IS OFFERED "AS IS", AND BROADCOM GRANTS NO WARRANTIES OF ANY
21849 +# KIND, EXPRESS OR IMPLIED, BY STATUTE, COMMUNICATION OR OTHERWISE. BROADCOM
21850 +# SPECIFICALLY DISCLAIMS ANY IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS
21851 +# FOR A SPECIFIC PURPOSE OR NONINFRINGEMENT CONCERNING THIS SOFTWARE.
21852 +#
21853 +# $Id: shared_ksyms.sh,v 1.1 2005/03/16 13:50:00 wbx Exp $
21854 +#
21855 +
21856 +cat <<EOF
21857 +#include <linux/config.h>
21858 +#include <linux/module.h>
21859 +EOF
21860 +
21861 +for file in $* ; do
21862 +    ${NM} $file | sed -ne 's/[0-9A-Fa-f]* [DT] \([^ ]*\)/extern void \1; EXPORT_SYMBOL(\1);/p'
21863 +done
21864 diff -Nur linux-2.4.32/drivers/net/Makefile linux-2.4.32-brcm/drivers/net/Makefile
21865 --- linux-2.4.32/drivers/net/Makefile   2005-01-19 15:09:56.000000000 +0100
21866 +++ linux-2.4.32-brcm/drivers/net/Makefile      2005-12-16 23:39:11.284858000 +0100
21867 @@ -3,6 +3,8 @@
21868  # Makefile for the Linux network (ethercard) device drivers.
21869  #
21870
21871 +EXTRA_CFLAGS := -I$(TOPDIR)/arch/mips/bcm947xx/include
21872 +
21873  obj-y           :=
21874  obj-m           :=
21875  obj-n           :=
21876 @@ -39,6 +41,9 @@
21877    obj-$(CONFIG_ISDN) += slhc.o
21878  endif
21879
21880 +subdir-$(CONFIG_HND) += hnd
21881 +subdir-$(CONFIG_ET) += et
21882 +subdir-$(CONFIG_WL) += wl
21883  subdir-$(CONFIG_NET_PCMCIA) += pcmcia
21884  subdir-$(CONFIG_NET_WIRELESS) += wireless
21885  subdir-$(CONFIG_TULIP) += tulip
21886 @@ -69,6 +74,16 @@
21887  obj-$(CONFIG_MYRI_SBUS) += myri_sbus.o
21888  obj-$(CONFIG_SUNGEM) += sungem.o
21889
21890 +ifeq ($(CONFIG_HND),y)
21891 +  obj-y += hnd/hnd.o
21892 +endif
21893 +ifeq ($(CONFIG_ET),y)
21894 +  obj-y += et/et.o
21895 +endif
21896 +ifeq ($(CONFIG_WL),y)
21897 +  obj-y += wl/wl.o
21898 +endif
21899 +
21900  obj-$(CONFIG_MACE) += mace.o
21901  obj-$(CONFIG_BMAC) += bmac.o
21902  obj-$(CONFIG_GMAC) += gmac.o
21903 @@ -265,6 +280,7 @@
21904  endif
21905  endif
21906
21907 +
21908  include $(TOPDIR)/Rules.make
21909
21910  clean:
21911 diff -Nur linux-2.4.32/drivers/net/wireless/Config.in linux-2.4.32-brcm/drivers/net/wireless/Config.in
21912 --- linux-2.4.32/drivers/net/wireless/Config.in 2004-11-17 12:54:21.000000000 +0100
21913 +++ linux-2.4.32-brcm/drivers/net/wireless/Config.in    2005-12-16 23:39:11.364863000 +0100
21914 @@ -13,6 +13,7 @@
21915  fi
21916
21917  if [ "$CONFIG_PCI" = "y" ]; then
21918 +   dep_tristate '    Proprietary Broadcom BCM43xx 802.11 Wireless support' CONFIG_WL
21919     dep_tristate '    Hermes in PLX9052 based PCI adaptor support (Netgear MA301 etc.) (EXPERIMENTAL)' CONFIG_PLX_HERMES $CONFIG_HERMES $CONFIG_EXPERIMENTAL
21920     dep_tristate '    Hermes in TMD7160/NCP130 based PCI adaptor support (Pheecom WL-PCI etc.) (EXPERIMENTAL)' CONFIG_TMD_HERMES $CONFIG_HERMES $CONFIG_EXPERIMENTAL
21921     dep_tristate '    Prism 2.5 PCI 802.11b adaptor support (EXPERIMENTAL)' CONFIG_PCI_HERMES $CONFIG_HERMES $CONFIG_EXPERIMENTAL
21922 diff -Nur linux-2.4.32/drivers/net/wl/Makefile linux-2.4.32-brcm/drivers/net/wl/Makefile
21923 --- linux-2.4.32/drivers/net/wl/Makefile        1970-01-01 01:00:00.000000000 +0100
21924 +++ linux-2.4.32-brcm/drivers/net/wl/Makefile   2005-12-16 23:39:11.364863000 +0100
21925 @@ -0,0 +1,26 @@
21926 +#
21927 +# Makefile for the Broadcom wl driver
21928 +#
21929 +# Copyright 2004, Broadcom Corporation
21930 +# All Rights Reserved.
21931 +#
21932 +# THIS SOFTWARE IS OFFERED "AS IS", AND BROADCOM GRANTS NO WARRANTIES OF ANY
21933 +# KIND, EXPRESS OR IMPLIED, BY STATUTE, COMMUNICATION OR OTHERWISE. BROADCOM
21934 +# SPECIFICALLY DISCLAIMS ANY IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS
21935 +# FOR A SPECIFIC PURPOSE OR NONINFRINGEMENT CONCERNING THIS SOFTWARE.
21936 +#
21937 +# $Id: Makefile,v 1.2 2005/03/29 03:32:18 mbm Exp $
21938 +
21939 +EXTRA_CFLAGS += -I$(TOPDIR)/arch/mips/bcm947xx/include
21940 +
21941 +O_TARGET       := wl.o
21942 +
21943 +obj-y          := apsta_aeskeywrap.o apsta_aes.o apsta_bcmwpa.o apsta_d11ucode.o
21944 +obj-y          += apsta_hmac.o apsta_md5.o apsta_passhash.o apsta_prf.o apsta_rc4.o
21945 +obj-y          += apsta_rijndael-alg-fst.o apsta_sha1.o apsta_tkhash.o apsta_wlc_led.o
21946 +obj-y          += apsta_wlc_phy.o apsta_wlc_rate.o apsta_wlc_security.o
21947 +obj-y          += apsta_wlc_sup.o apsta_wlc_wet.o apsta_wl_linux.o apsta_wlc.o
21948 +
21949 +obj-m          := $(O_TARGET)
21950 +
21951 +include $(TOPDIR)/Rules.make
21952 diff -Nur linux-2.4.32/drivers/parport/Config.in linux-2.4.32-brcm/drivers/parport/Config.in
21953 --- linux-2.4.32/drivers/parport/Config.in      2004-02-18 14:36:31.000000000 +0100
21954 +++ linux-2.4.32-brcm/drivers/parport/Config.in 2005-12-16 23:39:11.364863000 +0100
21955 @@ -11,6 +11,7 @@
21956  tristate 'Parallel port support' CONFIG_PARPORT
21957  if [ "$CONFIG_PARPORT" != "n" ]; then
21958     dep_tristate '  PC-style hardware' CONFIG_PARPORT_PC $CONFIG_PARPORT
21959 +   dep_tristate '  Asus WL500g parallel port' CONFIG_PARPORT_SPLINK $CONFIG_PARPORT
21960     if [ "$CONFIG_PARPORT_PC" != "n" -a "$CONFIG_SERIAL" != "n" ]; then
21961        if [ "$CONFIG_SERIAL" = "m" ]; then
21962           define_tristate CONFIG_PARPORT_PC_CML1 m
21963 diff -Nur linux-2.4.32/drivers/parport/Makefile linux-2.4.32-brcm/drivers/parport/Makefile
21964 --- linux-2.4.32/drivers/parport/Makefile       2004-08-08 01:26:05.000000000 +0200
21965 +++ linux-2.4.32-brcm/drivers/parport/Makefile  2005-12-16 23:39:11.364863000 +0100
21966 @@ -22,6 +22,7 @@
21967
21968  obj-$(CONFIG_PARPORT)          += parport.o
21969  obj-$(CONFIG_PARPORT_PC)       += parport_pc.o
21970 +obj-$(CONFIG_PARPORT_SPLINK)   += parport_splink.o
21971  obj-$(CONFIG_PARPORT_PC_PCMCIA)        += parport_cs.o
21972  obj-$(CONFIG_PARPORT_AMIGA)    += parport_amiga.o
21973  obj-$(CONFIG_PARPORT_MFC3)     += parport_mfc3.o
21974 diff -Nur linux-2.4.32/drivers/parport/parport_splink.c linux-2.4.32-brcm/drivers/parport/parport_splink.c
21975 --- linux-2.4.32/drivers/parport/parport_splink.c       1970-01-01 01:00:00.000000000 +0100
21976 +++ linux-2.4.32-brcm/drivers/parport/parport_splink.c  2005-12-16 23:39:11.364863000 +0100
21977 @@ -0,0 +1,345 @@
21978 +/* Low-level parallel port routines for the ASUS WL-500g built-in port
21979 + *
21980 + * Author: Nuno Grilo <nuno.grilo@netcabo.pt>
21981 + * Based on parport_pc source
21982 + */
21983 +
21984 +#include <linux/config.h>
21985 +#include <linux/module.h>
21986 +#include <linux/init.h>
21987 +#include <linux/ioport.h>
21988 +#include <linux/kernel.h>
21989 +#include <linux/slab.h>
21990 +#include <linux/parport.h>
21991 +#include <linux/parport_pc.h>
21992 +
21993 +#define SPLINK_ADDRESS 0xBF800010
21994 +
21995 +#undef DEBUG
21996 +
21997 +#ifdef DEBUG
21998 +#define DPRINTK  printk
21999 +#else
22000 +#define DPRINTK(stuff...)
22001 +#endif
22002 +
22003 +
22004 +/* __parport_splink_frob_control differs from parport_splink_frob_control in that
22005 + * it doesn't do any extra masking. */
22006 +static __inline__ unsigned char __parport_splink_frob_control (struct parport *p,
22007 +                                                          unsigned char mask,
22008 +                                                          unsigned char val)
22009 +{
22010 +       struct parport_pc_private *priv = p->physport->private_data;
22011 +       unsigned char *io = (unsigned char *) p->base;
22012 +       unsigned char ctr = priv->ctr;
22013 +#ifdef DEBUG_PARPORT
22014 +       printk (KERN_DEBUG
22015 +               "__parport_splink_frob_control(%02x,%02x): %02x -> %02x\n",
22016 +               mask, val, ctr, ((ctr & ~mask) ^ val) & priv->ctr_writable);
22017 +#endif
22018 +       ctr = (ctr & ~mask) ^ val;
22019 +       ctr &= priv->ctr_writable; /* only write writable bits. */
22020 +       *(io+2) = ctr;
22021 +       priv->ctr = ctr;        /* Update soft copy */
22022 +       return ctr;
22023 +}
22024 +
22025 +
22026 +
22027 +static void parport_splink_data_forward (struct parport *p)
22028 +{
22029 +       DPRINTK(KERN_DEBUG "parport_splink: parport_data_forward called\n");
22030 +       __parport_splink_frob_control (p, 0x20, 0);
22031 +}
22032 +
22033 +static void parport_splink_data_reverse (struct parport *p)
22034 +{
22035 +       DPRINTK(KERN_DEBUG "parport_splink: parport_data_forward called\n");
22036 +       __parport_splink_frob_control (p, 0x20, 0x20);
22037 +}
22038 +
22039 +/*
22040 +static void parport_splink_interrupt(int irq, void *dev_id, struct pt_regs *regs)
22041 +{
22042 +       DPRINTK(KERN_DEBUG "parport_splink: IRQ handler called\n");
22043 +        parport_generic_irq(irq, (struct parport *) dev_id, regs);
22044 +}
22045 +*/
22046 +
22047 +static void parport_splink_enable_irq(struct parport *p)
22048 +{
22049 +       DPRINTK(KERN_DEBUG "parport_splink: parport_splink_enable_irq called\n");
22050 +       __parport_splink_frob_control (p, 0x10, 0x10);
22051 +}
22052 +
22053 +static void parport_splink_disable_irq(struct parport *p)
22054 +{
22055 +       DPRINTK(KERN_DEBUG "parport_splink: parport_splink_disable_irq called\n");
22056 +       __parport_splink_frob_control (p, 0x10, 0);
22057 +}
22058 +
22059 +static void parport_splink_init_state(struct pardevice *dev, struct parport_state *s)
22060 +{
22061 +       DPRINTK(KERN_DEBUG "parport_splink: parport_splink_init_state called\n");
22062 +       s->u.pc.ctr = 0xc | (dev->irq_func ? 0x10 : 0x0);
22063 +       if (dev->irq_func &&
22064 +            dev->port->irq != PARPORT_IRQ_NONE)
22065 +                /* Set ackIntEn */
22066 +                s->u.pc.ctr |= 0x10;
22067 +}
22068 +
22069 +static void parport_splink_save_state(struct parport *p, struct parport_state *s)
22070 +{
22071 +       const struct parport_pc_private *priv = p->physport->private_data;
22072 +       DPRINTK(KERN_DEBUG "parport_splink: parport_splink_save_state called\n");
22073 +       s->u.pc.ctr = priv->ctr;
22074 +}
22075 +
22076 +static void parport_splink_restore_state(struct parport *p, struct parport_state *s)
22077 +{
22078 +       struct parport_pc_private *priv = p->physport->private_data;
22079 +       unsigned char *io = (unsigned char *) p->base;
22080 +       unsigned char ctr = s->u.pc.ctr;
22081 +
22082 +       DPRINTK(KERN_DEBUG "parport_splink: parport_splink_restore_state called\n");
22083 +        *(io+2) = ctr;
22084 +       priv->ctr = ctr;
22085 +}
22086 +
22087 +static void parport_splink_setup_interrupt(void) {
22088 +        return;
22089 +}
22090 +
22091 +static void parport_splink_write_data(struct parport *p, unsigned char d) {
22092 +       DPRINTK(KERN_DEBUG "parport_splink: write data called\n");
22093 +        unsigned char *io = (unsigned char *) p->base;
22094 +        *io = d;
22095 +}
22096 +
22097 +static unsigned char parport_splink_read_data(struct parport *p) {
22098 +       DPRINTK(KERN_DEBUG "parport_splink: read data called\n");
22099 +        unsigned char *io = (unsigned char *) p->base;
22100 +        return *io;
22101 +}
22102 +
22103 +static void parport_splink_write_control(struct parport *p, unsigned char d)
22104 +{
22105 +       const unsigned char wm = (PARPORT_CONTROL_STROBE |
22106 +                                 PARPORT_CONTROL_AUTOFD |
22107 +                                 PARPORT_CONTROL_INIT |
22108 +                                 PARPORT_CONTROL_SELECT);
22109 +
22110 +       DPRINTK(KERN_DEBUG "parport_splink: write control called\n");
22111 +       /* Take this out when drivers have adapted to the newer interface. */
22112 +       if (d & 0x20) {
22113 +               printk (KERN_DEBUG "%s (%s): use data_reverse for this!\n",
22114 +                       p->name, p->cad->name);
22115 +               parport_splink_data_reverse (p);
22116 +       }
22117 +
22118 +       __parport_splink_frob_control (p, wm, d & wm);
22119 +}
22120 +
22121 +static unsigned char parport_splink_read_control(struct parport *p)
22122 +{
22123 +       const unsigned char wm = (PARPORT_CONTROL_STROBE |
22124 +                                 PARPORT_CONTROL_AUTOFD |
22125 +                                 PARPORT_CONTROL_INIT |
22126 +                                 PARPORT_CONTROL_SELECT);
22127 +       DPRINTK(KERN_DEBUG "parport_splink: read control called\n");
22128 +       const struct parport_pc_private *priv = p->physport->private_data;
22129 +       return priv->ctr & wm; /* Use soft copy */
22130 +}
22131 +
22132 +static unsigned char parport_splink_frob_control (struct parport *p, unsigned char mask,
22133 +                                      unsigned char val)
22134 +{
22135 +       const unsigned char wm = (PARPORT_CONTROL_STROBE |
22136 +                                 PARPORT_CONTROL_AUTOFD |
22137 +                                 PARPORT_CONTROL_INIT |
22138 +                                 PARPORT_CONTROL_SELECT);
22139 +
22140 +       DPRINTK(KERN_DEBUG "parport_splink: frob control called\n");
22141 +       /* Take this out when drivers have adapted to the newer interface. */
22142 +       if (mask & 0x20) {
22143 +               printk (KERN_DEBUG "%s (%s): use data_%s for this!\n",
22144 +                       p->name, p->cad->name,
22145 +                       (val & 0x20) ? "reverse" : "forward");
22146 +               if (val & 0x20)
22147 +                       parport_splink_data_reverse (p);
22148 +               else
22149 +                       parport_splink_data_forward (p);
22150 +       }
22151 +
22152 +       /* Restrict mask and val to control lines. */
22153 +       mask &= wm;
22154 +       val &= wm;
22155 +
22156 +       return __parport_splink_frob_control (p, mask, val);
22157 +}
22158 +
22159 +static unsigned char parport_splink_read_status(struct parport *p)
22160 +{
22161 +       DPRINTK(KERN_DEBUG "parport_splink: read status called\n");
22162 +        unsigned char *io = (unsigned char *) p->base;
22163 +        return *(io+1);
22164 +}
22165 +
22166 +static void parport_splink_inc_use_count(void)
22167 +{
22168 +#ifdef MODULE
22169 +       MOD_INC_USE_COUNT;
22170 +#endif
22171 +}
22172 +
22173 +static void parport_splink_dec_use_count(void)
22174 +{
22175 +#ifdef MODULE
22176 +       MOD_DEC_USE_COUNT;
22177 +#endif
22178 +}
22179 +
22180 +static struct parport_operations parport_splink_ops =
22181 +{
22182 +       parport_splink_write_data,
22183 +       parport_splink_read_data,
22184 +
22185 +       parport_splink_write_control,
22186 +       parport_splink_read_control,
22187 +       parport_splink_frob_control,
22188 +
22189 +       parport_splink_read_status,
22190 +
22191 +       parport_splink_enable_irq,
22192 +       parport_splink_disable_irq,
22193 +
22194 +       parport_splink_data_forward,
22195 +       parport_splink_data_reverse,
22196 +
22197 +       parport_splink_init_state,
22198 +       parport_splink_save_state,
22199 +       parport_splink_restore_state,
22200 +
22201 +       parport_splink_inc_use_count,
22202 +       parport_splink_dec_use_count,
22203 +
22204 +       parport_ieee1284_epp_write_data,
22205 +       parport_ieee1284_epp_read_data,
22206 +       parport_ieee1284_epp_write_addr,
22207 +       parport_ieee1284_epp_read_addr,
22208 +
22209 +       parport_ieee1284_ecp_write_data,
22210 +       parport_ieee1284_ecp_read_data,
22211 +       parport_ieee1284_ecp_write_addr,
22212 +
22213 +       parport_ieee1284_write_compat,
22214 +       parport_ieee1284_read_nibble,
22215 +       parport_ieee1284_read_byte,
22216 +};
22217 +
22218 +/* --- Initialisation code -------------------------------- */
22219 +
22220 +static struct parport *parport_splink_probe_port (unsigned long int base)
22221 +{
22222 +       struct parport_pc_private *priv;
22223 +       struct parport_operations *ops;
22224 +       struct parport *p;
22225 +
22226 +       if (check_mem_region(base, 3)) {
22227 +               printk (KERN_DEBUG "parport (0x%lx): iomem region not available\n", base);
22228 +               return NULL;
22229 +       }
22230 +       priv = kmalloc (sizeof (struct parport_pc_private), GFP_KERNEL);
22231 +       if (!priv) {
22232 +               printk (KERN_DEBUG "parport (0x%lx): no memory!\n", base);
22233 +               return NULL;
22234 +       }
22235 +       ops = kmalloc (sizeof (struct parport_operations), GFP_KERNEL);
22236 +       if (!ops) {
22237 +               printk (KERN_DEBUG "parport (0x%lx): no memory for ops!\n",
22238 +                       base);
22239 +               kfree (priv);
22240 +               return NULL;
22241 +       }
22242 +       memcpy (ops, &parport_splink_ops, sizeof (struct parport_operations));
22243 +       priv->ctr = 0xc;
22244 +       priv->ctr_writable = 0xff;
22245 +
22246 +       if (!(p = parport_register_port(base, PARPORT_IRQ_NONE,
22247 +                                       PARPORT_DMA_NONE, ops))) {
22248 +               printk (KERN_DEBUG "parport (0x%lx): registration failed!\n",
22249 +                       base);
22250 +               kfree (priv);
22251 +               kfree (ops);
22252 +               return NULL;
22253 +       }
22254 +
22255 +       p->modes = PARPORT_MODE_PCSPP | PARPORT_MODE_SAFEININT;
22256 +       p->size = (p->modes & PARPORT_MODE_EPP)?8:3;
22257 +       p->private_data = priv;
22258 +
22259 +       parport_proc_register(p);
22260 +       request_mem_region (p->base, 3, p->name);
22261 +
22262 +       /* Done probing.  Now put the port into a sensible start-up state. */
22263 +       parport_splink_write_data(p, 0);
22264 +       parport_splink_data_forward (p);
22265 +
22266 +       /* Now that we've told the sharing engine about the port, and
22267 +          found out its characteristics, let the high-level drivers
22268 +          know about it. */
22269 +       parport_announce_port (p);
22270 +
22271 +       DPRINTK(KERN_DEBUG "parport (0x%lx): init ok!\n",
22272 +               base);
22273 +       return p;
22274 +}
22275 +
22276 +static void parport_splink_unregister_port(struct parport *p) {
22277 +       struct parport_pc_private *priv = p->private_data;
22278 +       struct parport_operations *ops = p->ops;
22279 +
22280 +        if (p->irq != PARPORT_IRQ_NONE)
22281 +               free_irq(p->irq, p);
22282 +       release_mem_region(p->base, 3);
22283 +        parport_proc_unregister(p);
22284 +        kfree (priv);
22285 +        parport_unregister_port(p);
22286 +        kfree (ops);
22287 +}
22288 +
22289 +
22290 +int parport_splink_init(void)
22291 +{
22292 +        int ret;
22293 +
22294 +       DPRINTK(KERN_DEBUG "parport_splink init called\n");
22295 +        parport_splink_setup_interrupt();
22296 +        ret = !parport_splink_probe_port(SPLINK_ADDRESS);
22297 +
22298 +        return ret;
22299 +}
22300 +
22301 +void parport_splink_cleanup(void) {
22302 +        struct parport *p = parport_enumerate(), *tmp;
22303 +       DPRINTK(KERN_DEBUG "parport_splink cleanup called\n");
22304 +        if (p->size) {
22305 +                if (p->modes & PARPORT_MODE_PCSPP) {
22306 +                        while(p) {
22307 +                                tmp = p->next;
22308 +                                parport_splink_unregister_port(p);
22309 +                                p = tmp;
22310 +                        }
22311 +                }
22312 +        }
22313 +}
22314 +
22315 +MODULE_AUTHOR("Nuno Grilo <nuno.grilo@netcabo.pt>");
22316 +MODULE_DESCRIPTION("Parport Driver for ASUS WL-500g router builtin Port");
22317 +MODULE_SUPPORTED_DEVICE("ASUS WL-500g builtin Parallel Port");
22318 +MODULE_LICENSE("GPL");
22319 +
22320 +module_init(parport_splink_init)
22321 +module_exit(parport_splink_cleanup)
22322 +
22323 diff -Nur linux-2.4.32/drivers/pcmcia/bcm4710_generic.c linux-2.4.32-brcm/drivers/pcmcia/bcm4710_generic.c
22324 --- linux-2.4.32/drivers/pcmcia/bcm4710_generic.c       1970-01-01 01:00:00.000000000 +0100
22325 +++ linux-2.4.32-brcm/drivers/pcmcia/bcm4710_generic.c  2005-12-16 23:39:11.368863250 +0100
22326 @@ -0,0 +1,912 @@
22327 +/*
22328 + *
22329 + * bcm47xx pcmcia driver
22330 + *
22331 + * Copyright 2004, Broadcom Corporation
22332 + * All Rights Reserved.
22333 + *
22334 + * THIS SOFTWARE IS OFFERED "AS IS", AND BROADCOM GRANTS NO WARRANTIES OF ANY
22335 + * KIND, EXPRESS OR IMPLIED, BY STATUTE, COMMUNICATION OR OTHERWISE. BROADCOM
22336 + * SPECIFICALLY DISCLAIMS ANY IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS
22337 + * FOR A SPECIFIC PURPOSE OR NONINFRINGEMENT CONCERNING THIS SOFTWARE.
22338 + *
22339 + * Based on sa1100_generic.c from www.handhelds.org,
22340 + *     and au1000_generic.c from oss.sgi.com.
22341 + *
22342 + * $Id: bcm4710_generic.c,v 1.1 2005/03/16 13:50:00 wbx Exp $
22343 + */
22344 +#include <linux/module.h>
22345 +#include <linux/init.h>
22346 +#include <linux/config.h>
22347 +#include <linux/delay.h>
22348 +#include <linux/ioport.h>
22349 +#include <linux/kernel.h>
22350 +#include <linux/tqueue.h>
22351 +#include <linux/timer.h>
22352 +#include <linux/mm.h>
22353 +#include <linux/proc_fs.h>
22354 +#include <linux/version.h>
22355 +#include <linux/types.h>
22356 +#include <linux/vmalloc.h>
22357 +
22358 +#include <pcmcia/version.h>
22359 +#include <pcmcia/cs_types.h>
22360 +#include <pcmcia/cs.h>
22361 +#include <pcmcia/ss.h>
22362 +#include <pcmcia/bulkmem.h>
22363 +#include <pcmcia/cistpl.h>
22364 +#include <pcmcia/bus_ops.h>
22365 +#include "cs_internal.h"
22366 +
22367 +#include <asm/io.h>
22368 +#include <asm/irq.h>
22369 +#include <asm/system.h>
22370 +
22371 +#include <typedefs.h>
22372 +#include <bcm4710.h>
22373 +#include <sbextif.h>
22374 +
22375 +#include "bcm4710pcmcia.h"
22376 +
22377 +#ifdef PCMCIA_DEBUG
22378 +static int pc_debug = PCMCIA_DEBUG;
22379 +#endif
22380 +
22381 +MODULE_DESCRIPTION("Linux PCMCIA Card Services: bcm47xx Socket Controller");
22382 +
22383 +/* This structure maintains housekeeping state for each socket, such
22384 + * as the last known values of the card detect pins, or the Card Services
22385 + * callback value associated with the socket:
22386 + */
22387 +static struct bcm47xx_pcmcia_socket *pcmcia_socket;
22388 +static int socket_count;
22389 +
22390 +
22391 +/* Returned by the low-level PCMCIA interface: */
22392 +static struct pcmcia_low_level *pcmcia_low_level;
22393 +
22394 +/* Event poll timer structure */
22395 +static struct timer_list poll_timer;
22396 +
22397 +
22398 +/* Prototypes for routines which are used internally: */
22399 +
22400 +static int  bcm47xx_pcmcia_driver_init(void);
22401 +static void bcm47xx_pcmcia_driver_shutdown(void);
22402 +static void bcm47xx_pcmcia_task_handler(void *data);
22403 +static void bcm47xx_pcmcia_poll_event(unsigned long data);
22404 +static void bcm47xx_pcmcia_interrupt(int irq, void *dev, struct pt_regs *regs);
22405 +static struct tq_struct bcm47xx_pcmcia_task;
22406 +
22407 +#ifdef CONFIG_PROC_FS
22408 +static int bcm47xx_pcmcia_proc_status(char *buf, char **start,
22409 +               off_t pos, int count, int *eof, void *data);
22410 +#endif
22411 +
22412 +
22413 +/* Prototypes for operations which are exported to the
22414 + * in-kernel PCMCIA core:
22415 + */
22416 +
22417 +static int bcm47xx_pcmcia_init(unsigned int sock);
22418 +static int bcm47xx_pcmcia_suspend(unsigned int sock);
22419 +static int bcm47xx_pcmcia_register_callback(unsigned int sock,
22420 +               void (*handler)(void *, unsigned int), void *info);
22421 +static int bcm47xx_pcmcia_inquire_socket(unsigned int sock, socket_cap_t *cap);
22422 +static int bcm47xx_pcmcia_get_status(unsigned int sock, u_int *value);
22423 +static int bcm47xx_pcmcia_get_socket(unsigned int sock, socket_state_t *state);
22424 +static int bcm47xx_pcmcia_set_socket(unsigned int sock, socket_state_t *state);
22425 +static int bcm47xx_pcmcia_get_io_map(unsigned int sock, struct pccard_io_map *io);
22426 +static int bcm47xx_pcmcia_set_io_map(unsigned int sock, struct pccard_io_map *io);
22427 +static int bcm47xx_pcmcia_get_mem_map(unsigned int sock, struct pccard_mem_map *mem);
22428 +static int bcm47xx_pcmcia_set_mem_map(unsigned int sock, struct pccard_mem_map *mem);
22429 +#ifdef CONFIG_PROC_FS
22430 +static void bcm47xx_pcmcia_proc_setup(unsigned int sock, struct proc_dir_entry *base);
22431 +#endif
22432 +
22433 +static struct pccard_operations bcm47xx_pcmcia_operations = {
22434 +       bcm47xx_pcmcia_init,
22435 +       bcm47xx_pcmcia_suspend,
22436 +       bcm47xx_pcmcia_register_callback,
22437 +       bcm47xx_pcmcia_inquire_socket,
22438 +       bcm47xx_pcmcia_get_status,
22439 +       bcm47xx_pcmcia_get_socket,
22440 +       bcm47xx_pcmcia_set_socket,
22441 +       bcm47xx_pcmcia_get_io_map,
22442 +       bcm47xx_pcmcia_set_io_map,
22443 +       bcm47xx_pcmcia_get_mem_map,
22444 +       bcm47xx_pcmcia_set_mem_map,
22445 +#ifdef CONFIG_PROC_FS
22446 +       bcm47xx_pcmcia_proc_setup
22447 +#endif
22448 +};
22449 +
22450 +
22451 +/*
22452 + * bcm47xx_pcmcia_driver_init()
22453 + *
22454 + * This routine performs a basic sanity check to ensure that this
22455 + * kernel has been built with the appropriate board-specific low-level
22456 + * PCMCIA support, performs low-level PCMCIA initialization, registers
22457 + * this socket driver with Card Services, and then spawns the daemon
22458 + * thread which is the real workhorse of the socket driver.
22459 + *
22460 + * Please see linux/Documentation/arm/SA1100/PCMCIA for more information
22461 + * on the low-level kernel interface.
22462 + *
22463 + * Returns: 0 on success, -1 on error
22464 + */
22465 +static int __init bcm47xx_pcmcia_driver_init(void)
22466 +{
22467 +       servinfo_t info;
22468 +       struct pcmcia_init pcmcia_init;
22469 +       struct pcmcia_state state;
22470 +       unsigned int i;
22471 +       unsigned long tmp;
22472 +
22473 +
22474 +       printk("\nBCM47XX PCMCIA (CS release %s)\n", CS_RELEASE);
22475 +
22476 +       CardServices(GetCardServicesInfo, &info);
22477 +
22478 +       if (info.Revision != CS_RELEASE_CODE) {
22479 +               printk(KERN_ERR "Card Services release codes do not match\n");
22480 +               return -1;
22481 +       }
22482 +
22483 +#ifdef CONFIG_BCM4710
22484 +       pcmcia_low_level=&bcm4710_pcmcia_ops;
22485 +#else
22486 +#error Unsupported Broadcom BCM47XX board.
22487 +#endif
22488 +
22489 +       pcmcia_init.handler=bcm47xx_pcmcia_interrupt;
22490 +
22491 +       if ((socket_count = pcmcia_low_level->init(&pcmcia_init)) < 0) {
22492 +               printk(KERN_ERR "Unable to initialize PCMCIA service.\n");
22493 +               return -EIO;
22494 +       } else {
22495 +               printk("\t%d PCMCIA sockets initialized.\n", socket_count);
22496 +       }
22497 +
22498 +       pcmcia_socket =
22499 +               kmalloc(sizeof(struct bcm47xx_pcmcia_socket) * socket_count,
22500 +                               GFP_KERNEL);
22501 +       memset(pcmcia_socket, 0,
22502 +                       sizeof(struct bcm47xx_pcmcia_socket) * socket_count);
22503 +       if (!pcmcia_socket) {
22504 +               printk(KERN_ERR "Card Services can't get memory \n");
22505 +               return -1;
22506 +       }
22507 +
22508 +       for (i = 0; i < socket_count; i++) {
22509 +               if (pcmcia_low_level->socket_state(i, &state) < 0) {
22510 +                       printk(KERN_ERR "Unable to get PCMCIA status\n");
22511 +                       return -EIO;
22512 +               }
22513 +               pcmcia_socket[i].k_state = state;
22514 +               pcmcia_socket[i].cs_state.csc_mask = SS_DETECT;
22515 +
22516 +               if (i == 0) {
22517 +                       pcmcia_socket[i].virt_io =
22518 +                               (unsigned long)ioremap_nocache(EXTIF_PCMCIA_IOBASE(BCM4710_EXTIF), 0x1000);
22519 +                       /* Substract ioport base which gets added by in/out */
22520 +                       pcmcia_socket[i].virt_io -= mips_io_port_base;
22521 +                       pcmcia_socket[i].phys_attr =
22522 +                               (unsigned long)EXTIF_PCMCIA_CFGBASE(BCM4710_EXTIF);
22523 +                       pcmcia_socket[i].phys_mem =
22524 +                               (unsigned long)EXTIF_PCMCIA_MEMBASE(BCM4710_EXTIF);
22525 +               } else  {
22526 +                       printk(KERN_ERR "bcm4710: socket 1 not supported\n");
22527 +                       return 1;
22528 +               }
22529 +       }
22530 +
22531 +       /* Only advertise as many sockets as we can detect: */
22532 +       if (register_ss_entry(socket_count, &bcm47xx_pcmcia_operations) < 0) {
22533 +               printk(KERN_ERR "Unable to register socket service routine\n");
22534 +               return -ENXIO;
22535 +       }
22536 +
22537 +       /* Start the event poll timer.
22538 +        * It will reschedule by itself afterwards.
22539 +        */
22540 +       bcm47xx_pcmcia_poll_event(0);
22541 +
22542 +       DEBUG(1, "bcm4710: initialization complete\n");
22543 +       return 0;
22544 +
22545 +}
22546 +
22547 +module_init(bcm47xx_pcmcia_driver_init);
22548 +
22549 +
22550 +/*
22551 + * bcm47xx_pcmcia_driver_shutdown()
22552 + *
22553 + * Invokes the low-level kernel service to free IRQs associated with this
22554 + * socket controller and reset GPIO edge detection.
22555 + */
22556 +static void __exit bcm47xx_pcmcia_driver_shutdown(void)
22557 +{
22558 +       int i;
22559 +
22560 +       del_timer_sync(&poll_timer);
22561 +       unregister_ss_entry(&bcm47xx_pcmcia_operations);
22562 +       pcmcia_low_level->shutdown();
22563 +       flush_scheduled_tasks();
22564 +       for (i = 0; i < socket_count; i++) {
22565 +               if (pcmcia_socket[i].virt_io)
22566 +                       iounmap((void *)pcmcia_socket[i].virt_io);
22567 +               if (pcmcia_socket[i].phys_attr)
22568 +                       iounmap((void *)pcmcia_socket[i].phys_attr);
22569 +               if (pcmcia_socket[i].phys_mem)
22570 +                       iounmap((void *)pcmcia_socket[i].phys_mem);
22571 +       }
22572 +       DEBUG(1, "bcm4710: shutdown complete\n");
22573 +}
22574 +
22575 +module_exit(bcm47xx_pcmcia_driver_shutdown);
22576 +
22577 +/*
22578 + * bcm47xx_pcmcia_init()
22579 + * We perform all of the interesting initialization tasks in
22580 + * bcm47xx_pcmcia_driver_init().
22581 + *
22582 + * Returns: 0
22583 + */
22584 +static int bcm47xx_pcmcia_init(unsigned int sock)
22585 +{
22586 +       DEBUG(1, "%s(): initializing socket %u\n", __FUNCTION__, sock);
22587 +
22588 +       return 0;
22589 +}
22590 +
22591 +/*
22592 + * bcm47xx_pcmcia_suspend()
22593 + *
22594 + * We don't currently perform any actions on a suspend.
22595 + *
22596 + * Returns: 0
22597 + */
22598 +static int bcm47xx_pcmcia_suspend(unsigned int sock)
22599 +{
22600 +       DEBUG(1, "%s(): suspending socket %u\n", __FUNCTION__, sock);
22601 +
22602 +       return 0;
22603 +}
22604 +
22605 +
22606 +/*
22607 + * bcm47xx_pcmcia_events()
22608 + *
22609 + * Helper routine to generate a Card Services event mask based on
22610 + * state information obtained from the kernel low-level PCMCIA layer
22611 + * in a recent (and previous) sampling. Updates `prev_state'.
22612 + *
22613 + * Returns: an event mask for the given socket state.
22614 + */
22615 +static inline unsigned
22616 +bcm47xx_pcmcia_events(struct pcmcia_state *state,
22617 +               struct pcmcia_state *prev_state,
22618 +               unsigned int mask, unsigned int flags)
22619 +{
22620 +       unsigned int events=0;
22621 +
22622 +       if (state->bvd1 != prev_state->bvd1) {
22623 +
22624 +               DEBUG(3, "%s(): card BVD1 value %u\n", __FUNCTION__, state->bvd1);
22625 +
22626 +               events |= mask & (flags & SS_IOCARD) ? SS_STSCHG : SS_BATDEAD;
22627 +       }
22628 +
22629 +       if (state->bvd2 != prev_state->bvd2) {
22630 +
22631 +               DEBUG(3, "%s(): card BVD2 value %u\n", __FUNCTION__, state->bvd2);
22632 +
22633 +               events |= mask & (flags & SS_IOCARD) ? 0 : SS_BATWARN;
22634 +       }
22635 +
22636 +       if (state->detect != prev_state->detect) {
22637 +
22638 +               DEBUG(3, "%s(): card detect value %u\n", __FUNCTION__, state->detect);
22639 +
22640 +               events |= mask & SS_DETECT;
22641 +       }
22642 +
22643 +
22644 +       if (state->ready != prev_state->ready) {
22645 +
22646 +               DEBUG(3, "%s(): card ready value %u\n", __FUNCTION__, state->ready);
22647 +
22648 +               events |= mask & ((flags & SS_IOCARD) ? 0 : SS_READY);
22649 +       }
22650 +
22651 +       if (events != 0) {
22652 +               DEBUG(2, "events: %s%s%s%s%s\n",
22653 +                     (events & SS_DETECT) ? "DETECT " : "",
22654 +                     (events & SS_READY) ? "READY " : "",
22655 +                     (events & SS_BATDEAD) ? "BATDEAD " : "",
22656 +                     (events & SS_BATWARN) ? "BATWARN " : "",
22657 +                     (events & SS_STSCHG) ? "STSCHG " : "");
22658 +       }
22659 +
22660 +       *prev_state=*state;
22661 +       return events;
22662 +}
22663 +
22664 +
22665 +/*
22666 + * bcm47xx_pcmcia_task_handler()
22667 + *
22668 + * Processes serviceable socket events using the "eventd" thread context.
22669 + *
22670 + * Event processing (specifically, the invocation of the Card Services event
22671 + * callback) occurs in this thread rather than in the actual interrupt
22672 + * handler due to the use of scheduling operations in the PCMCIA core.
22673 + */
22674 +static void bcm47xx_pcmcia_task_handler(void *data)
22675 +{
22676 +       struct pcmcia_state state;
22677 +       int i, events, irq_status;
22678 +
22679 +       DEBUG(4, "%s(): entering PCMCIA monitoring thread\n", __FUNCTION__);
22680 +
22681 +       for (i = 0; i < socket_count; i++)  {
22682 +               if ((irq_status = pcmcia_low_level->socket_state(i, &state)) < 0)
22683 +                       printk(KERN_ERR "Error in kernel low-level PCMCIA service.\n");
22684 +
22685 +               events = bcm47xx_pcmcia_events(&state,
22686 +                                              &pcmcia_socket[i].k_state,
22687 +                                              pcmcia_socket[i].cs_state.csc_mask,
22688 +                                              pcmcia_socket[i].cs_state.flags);
22689 +
22690 +               if (pcmcia_socket[i].handler != NULL) {
22691 +                       pcmcia_socket[i].handler(pcmcia_socket[i].handler_info,
22692 +                                                events);
22693 +               }
22694 +       }
22695 +}
22696 +
22697 +static struct tq_struct bcm47xx_pcmcia_task = {
22698 +       routine: bcm47xx_pcmcia_task_handler
22699 +};
22700 +
22701 +
22702 +/*
22703 + * bcm47xx_pcmcia_poll_event()
22704 + *
22705 + * Let's poll for events in addition to IRQs since IRQ only is unreliable...
22706 + */
22707 +static void bcm47xx_pcmcia_poll_event(unsigned long dummy)
22708 +{
22709 +       DEBUG(4, "%s(): polling for events\n", __FUNCTION__);
22710 +
22711 +       poll_timer.function = bcm47xx_pcmcia_poll_event;
22712 +       poll_timer.expires = jiffies + BCM47XX_PCMCIA_POLL_PERIOD;
22713 +       add_timer(&poll_timer);
22714 +       schedule_task(&bcm47xx_pcmcia_task);
22715 +}
22716 +
22717 +
22718 +/*
22719 + * bcm47xx_pcmcia_interrupt()
22720 + *
22721 + * Service routine for socket driver interrupts (requested by the
22722 + * low-level PCMCIA init() operation via bcm47xx_pcmcia_thread()).
22723 + *
22724 + * The actual interrupt-servicing work is performed by
22725 + * bcm47xx_pcmcia_task(), largely because the Card Services event-
22726 + * handling code performs scheduling operations which cannot be
22727 + * executed from within an interrupt context.
22728 + */
22729 +static void
22730 +bcm47xx_pcmcia_interrupt(int irq, void *dev, struct pt_regs *regs)
22731 +{
22732 +       DEBUG(3, "%s(): servicing IRQ %d\n", __FUNCTION__, irq);
22733 +       schedule_task(&bcm47xx_pcmcia_task);
22734 +}
22735 +
22736 +
22737 +/*
22738 + * bcm47xx_pcmcia_register_callback()
22739 + *
22740 + * Implements the register_callback() operation for the in-kernel
22741 + * PCMCIA service (formerly SS_RegisterCallback in Card Services). If
22742 + * the function pointer `handler' is not NULL, remember the callback
22743 + * location in the state for `sock', and increment the usage counter
22744 + * for the driver module. (The callback is invoked from the interrupt
22745 + * service routine, bcm47xx_pcmcia_interrupt(), to notify Card Services
22746 + * of interesting events.) Otherwise, clear the callback pointer in the
22747 + * socket state and decrement the module usage count.
22748 + *
22749 + * Returns: 0
22750 + */
22751 +static int
22752 +bcm47xx_pcmcia_register_callback(unsigned int sock,
22753 +               void (*handler)(void *, unsigned int), void *info)
22754 +{
22755 +       if (handler == NULL) {
22756 +               pcmcia_socket[sock].handler = NULL;
22757 +               MOD_DEC_USE_COUNT;
22758 +       } else {
22759 +               MOD_INC_USE_COUNT;
22760 +               pcmcia_socket[sock].handler = handler;
22761 +               pcmcia_socket[sock].handler_info = info;
22762 +       }
22763 +       return 0;
22764 +}
22765 +
22766 +
22767 +/*
22768 + * bcm47xx_pcmcia_inquire_socket()
22769 + *
22770 + * Implements the inquire_socket() operation for the in-kernel PCMCIA
22771 + * service (formerly SS_InquireSocket in Card Services). Of note is
22772 + * the setting of the SS_CAP_PAGE_REGS bit in the `features' field of
22773 + * `cap' to "trick" Card Services into tolerating large "I/O memory"
22774 + * addresses. Also set is SS_CAP_STATIC_MAP, which disables the memory
22775 + * resource database check. (Mapped memory is set up within the socket
22776 + * driver itself.)
22777 + *
22778 + * In conjunction with the STATIC_MAP capability is a new field,
22779 + * `io_offset', recommended by David Hinds. Rather than go through
22780 + * the SetIOMap interface (which is not quite suited for communicating
22781 + * window locations up from the socket driver), we just pass up
22782 + * an offset which is applied to client-requested base I/O addresses
22783 + * in alloc_io_space().
22784 + *
22785 + * Returns: 0 on success, -1 if no pin has been configured for `sock'
22786 + */
22787 +static int
22788 +bcm47xx_pcmcia_inquire_socket(unsigned int sock, socket_cap_t *cap)
22789 +{
22790 +       struct pcmcia_irq_info irq_info;
22791 +
22792 +       if (sock >= socket_count) {
22793 +               printk(KERN_ERR "bcm47xx: socket %u not configured\n", sock);
22794 +               return -1;
22795 +       }
22796 +
22797 +       /* SS_CAP_PAGE_REGS: used by setup_cis_mem() in cistpl.c to set the
22798 +        *   force_low argument to validate_mem() in rsrc_mgr.c -- since in
22799 +        *   general, the mapped * addresses of the PCMCIA memory regions
22800 +        *   will not be within 0xffff, setting force_low would be
22801 +        *   undesirable.
22802 +        *
22803 +        * SS_CAP_STATIC_MAP: don't bother with the (user-configured) memory
22804 +        *   resource database; we instead pass up physical address ranges
22805 +        *   and allow other parts of Card Services to deal with remapping.
22806 +        *
22807 +        * SS_CAP_PCCARD: we can deal with 16-bit PCMCIA & CF cards, but
22808 +        *   not 32-bit CardBus devices.
22809 +        */
22810 +       cap->features = (SS_CAP_PAGE_REGS  | SS_CAP_STATIC_MAP | SS_CAP_PCCARD);
22811 +
22812 +       irq_info.sock = sock;
22813 +       irq_info.irq = -1;
22814 +
22815 +       if (pcmcia_low_level->get_irq_info(&irq_info) < 0) {
22816 +               printk(KERN_ERR "Error obtaining IRQ info socket %u\n", sock);
22817 +               return -1;
22818 +       }
22819 +
22820 +       cap->irq_mask = 0;
22821 +       cap->map_size = PAGE_SIZE;
22822 +       cap->pci_irq = irq_info.irq;
22823 +       cap->io_offset = pcmcia_socket[sock].virt_io;
22824 +
22825 +       return 0;
22826 +}
22827 +
22828 +
22829 +/*
22830 + * bcm47xx_pcmcia_get_status()
22831 + *
22832 + * Implements the get_status() operation for the in-kernel PCMCIA
22833 + * service (formerly SS_GetStatus in Card Services). Essentially just
22834 + * fills in bits in `status' according to internal driver state or
22835 + * the value of the voltage detect chipselect register.
22836 + *
22837 + * As a debugging note, during card startup, the PCMCIA core issues
22838 + * three set_socket() commands in a row the first with RESET deasserted,
22839 + * the second with RESET asserted, and the last with RESET deasserted
22840 + * again. Following the third set_socket(), a get_status() command will
22841 + * be issued. The kernel is looking for the SS_READY flag (see
22842 + * setup_socket(), reset_socket(), and unreset_socket() in cs.c).
22843 + *
22844 + * Returns: 0
22845 + */
22846 +static int
22847 +bcm47xx_pcmcia_get_status(unsigned int sock, unsigned int *status)
22848 +{
22849 +       struct pcmcia_state state;
22850 +
22851 +
22852 +       if ((pcmcia_low_level->socket_state(sock, &state)) < 0) {
22853 +               printk(KERN_ERR "Unable to get PCMCIA status from kernel.\n");
22854 +               return -1;
22855 +       }
22856 +
22857 +       pcmcia_socket[sock].k_state = state;
22858 +
22859 +       *status = state.detect ? SS_DETECT : 0;
22860 +
22861 +       *status |= state.ready ? SS_READY : 0;
22862 +
22863 +       /* The power status of individual sockets is not available
22864 +        * explicitly from the hardware, so we just remember the state
22865 +        * and regurgitate it upon request:
22866 +        */
22867 +       *status |= pcmcia_socket[sock].cs_state.Vcc ? SS_POWERON : 0;
22868 +
22869 +       if (pcmcia_socket[sock].cs_state.flags & SS_IOCARD)
22870 +               *status |= state.bvd1 ? SS_STSCHG : 0;
22871 +       else {
22872 +               if (state.bvd1 == 0)
22873 +                       *status |= SS_BATDEAD;
22874 +               else if (state.bvd2 == 0)
22875 +                       *status |= SS_BATWARN;
22876 +       }
22877 +
22878 +       *status |= state.vs_3v ? SS_3VCARD : 0;
22879 +
22880 +       *status |= state.vs_Xv ? SS_XVCARD : 0;
22881 +
22882 +       DEBUG(2, "\tstatus: %s%s%s%s%s%s%s%s\n",
22883 +             (*status&SS_DETECT)?"DETECT ":"",
22884 +             (*status&SS_READY)?"READY ":"",
22885 +             (*status&SS_BATDEAD)?"BATDEAD ":"",
22886 +             (*status&SS_BATWARN)?"BATWARN ":"",
22887 +             (*status&SS_POWERON)?"POWERON ":"",
22888 +             (*status&SS_STSCHG)?"STSCHG ":"",
22889 +             (*status&SS_3VCARD)?"3VCARD ":"",
22890 +             (*status&SS_XVCARD)?"XVCARD ":"");
22891 +
22892 +       return 0;
22893 +}
22894 +
22895 +
22896 +/*
22897 + * bcm47xx_pcmcia_get_socket()
22898 + *
22899 + * Implements the get_socket() operation for the in-kernel PCMCIA
22900 + * service (formerly SS_GetSocket in Card Services). Not a very
22901 + * exciting routine.
22902 + *
22903 + * Returns: 0
22904 + */
22905 +static int
22906 +bcm47xx_pcmcia_get_socket(unsigned int sock, socket_state_t *state)
22907 +{
22908 +       DEBUG(2, "%s() for sock %u\n", __FUNCTION__, sock);
22909 +
22910 +       /* This information was given to us in an earlier call to set_socket(),
22911 +        * so we're just regurgitating it here:
22912 +        */
22913 +       *state = pcmcia_socket[sock].cs_state;
22914 +       return 0;
22915 +}
22916 +
22917 +
22918 +/*
22919 + * bcm47xx_pcmcia_set_socket()
22920 + *
22921 + * Implements the set_socket() operation for the in-kernel PCMCIA
22922 + * service (formerly SS_SetSocket in Card Services). We more or
22923 + * less punt all of this work and let the kernel handle the details
22924 + * of power configuration, reset, &c. We also record the value of
22925 + * `state' in order to regurgitate it to the PCMCIA core later.
22926 + *
22927 + * Returns: 0
22928 + */
22929 +static int
22930 +bcm47xx_pcmcia_set_socket(unsigned int sock, socket_state_t *state)
22931 +{
22932 +       struct pcmcia_configure configure;
22933 +
22934 +       DEBUG(2, "\tmask:  %s%s%s%s%s%s\n\tflags: %s%s%s%s%s%s\n"
22935 +             "\tVcc %d  Vpp %d  irq %d\n",
22936 +             (state->csc_mask == 0) ? "<NONE>" : "",
22937 +             (state->csc_mask & SS_DETECT) ? "DETECT " : "",
22938 +             (state->csc_mask & SS_READY) ? "READY " : "",
22939 +             (state->csc_mask & SS_BATDEAD) ? "BATDEAD " : "",
22940 +             (state->csc_mask & SS_BATWARN) ? "BATWARN " : "",
22941 +             (state->csc_mask & SS_STSCHG) ? "STSCHG " : "",
22942 +             (state->flags == 0) ? "<NONE>" : "",
22943 +             (state->flags & SS_PWR_AUTO) ? "PWR_AUTO " : "",
22944 +             (state->flags & SS_IOCARD) ? "IOCARD " : "",
22945 +             (state->flags & SS_RESET) ? "RESET " : "",
22946 +             (state->flags & SS_SPKR_ENA) ? "SPKR_ENA " : "",
22947 +             (state->flags & SS_OUTPUT_ENA) ? "OUTPUT_ENA " : "",
22948 +             state->Vcc, state->Vpp, state->io_irq);
22949 +
22950 +       configure.sock = sock;
22951 +       configure.vcc = state->Vcc;
22952 +       configure.vpp = state->Vpp;
22953 +       configure.output = (state->flags & SS_OUTPUT_ENA) ? 1 : 0;
22954 +       configure.speaker = (state->flags & SS_SPKR_ENA) ? 1 : 0;
22955 +       configure.reset = (state->flags & SS_RESET) ? 1 : 0;
22956 +
22957 +       if (pcmcia_low_level->configure_socket(&configure) < 0) {
22958 +               printk(KERN_ERR "Unable to configure socket %u\n", sock);
22959 +               return -1;
22960 +       }
22961 +
22962 +       pcmcia_socket[sock].cs_state = *state;
22963 +       return 0;
22964 +}
22965 +
22966 +
22967 +/*
22968 + * bcm47xx_pcmcia_get_io_map()
22969 + *
22970 + * Implements the get_io_map() operation for the in-kernel PCMCIA
22971 + * service (formerly SS_GetIOMap in Card Services). Just returns an
22972 + * I/O map descriptor which was assigned earlier by a set_io_map().
22973 + *
22974 + * Returns: 0 on success, -1 if the map index was out of range
22975 + */
22976 +static int
22977 +bcm47xx_pcmcia_get_io_map(unsigned int sock, struct pccard_io_map *map)
22978 +{
22979 +       DEBUG(2, "bcm47xx_pcmcia_get_io_map: sock %d\n", sock);
22980 +
22981 +       if (map->map >= MAX_IO_WIN) {
22982 +               printk(KERN_ERR "%s(): map (%d) out of range\n",
22983 +                      __FUNCTION__, map->map);
22984 +               return -1;
22985 +       }
22986 +
22987 +       *map = pcmcia_socket[sock].io_map[map->map];
22988 +       return 0;
22989 +}
22990 +
22991 +
22992 +/*
22993 + * bcm47xx_pcmcia_set_io_map()
22994 + *
22995 + * Implements the set_io_map() operation for the in-kernel PCMCIA
22996 + * service (formerly SS_SetIOMap in Card Services). We configure
22997 + * the map speed as requested, but override the address ranges
22998 + * supplied by Card Services.
22999 + *
23000 + * Returns: 0 on success, -1 on error
23001 + */
23002 +int
23003 +bcm47xx_pcmcia_set_io_map(unsigned int sock, struct pccard_io_map *map)
23004 +{
23005 +       unsigned int speed;
23006 +       unsigned long start;
23007 +
23008 +       DEBUG(2, "\tmap %u  speed %u\n\tstart 0x%08lx  stop 0x%08lx\n"
23009 +             "\tflags: %s%s%s%s%s%s%s%s\n",
23010 +             map->map, map->speed, map->start, map->stop,
23011 +             (map->flags == 0) ? "<NONE>" : "",
23012 +             (map->flags & MAP_ACTIVE) ? "ACTIVE " : "",
23013 +             (map->flags & MAP_16BIT) ? "16BIT " : "",
23014 +             (map->flags & MAP_AUTOSZ) ? "AUTOSZ " : "",
23015 +             (map->flags & MAP_0WS) ? "0WS " : "",
23016 +             (map->flags & MAP_WRPROT) ? "WRPROT " : "",
23017 +             (map->flags & MAP_USE_WAIT) ? "USE_WAIT " : "",
23018 +             (map->flags & MAP_PREFETCH) ? "PREFETCH " : "");
23019 +
23020 +       if (map->map >= MAX_IO_WIN) {
23021 +               printk(KERN_ERR "%s(): map (%d) out of range\n",
23022 +                               __FUNCTION__, map->map);
23023 +               return -1;
23024 +       }
23025 +
23026 +       if (map->flags & MAP_ACTIVE) {
23027 +               speed = (map->speed > 0) ? map->speed : BCM47XX_PCMCIA_IO_SPEED;
23028 +               pcmcia_socket[sock].speed_io = speed;
23029 +       }
23030 +
23031 +       start = map->start;
23032 +
23033 +       if (map->stop == 1) {
23034 +               map->stop = PAGE_SIZE - 1;
23035 +       }
23036 +
23037 +       map->start = pcmcia_socket[sock].virt_io;
23038 +       map->stop = map->start + (map->stop - start);
23039 +       pcmcia_socket[sock].io_map[map->map] = *map;
23040 +       DEBUG(2, "set_io_map %d start %x stop %x\n",
23041 +             map->map, map->start, map->stop);
23042 +       return 0;
23043 +}
23044 +
23045 +
23046 +/*
23047 + * bcm47xx_pcmcia_get_mem_map()
23048 + *
23049 + * Implements the get_mem_map() operation for the in-kernel PCMCIA
23050 + * service (formerly SS_GetMemMap in Card Services). Just returns a
23051 + *  memory map descriptor which was assigned earlier by a
23052 + *  set_mem_map() request.
23053 + *
23054 + * Returns: 0 on success, -1 if the map index was out of range
23055 + */
23056 +static int
23057 +bcm47xx_pcmcia_get_mem_map(unsigned int sock, struct pccard_mem_map *map)
23058 +{
23059 +       DEBUG(2, "%s() for sock %u\n", __FUNCTION__, sock);
23060 +
23061 +       if (map->map >= MAX_WIN) {
23062 +               printk(KERN_ERR "%s(): map (%d) out of range\n",
23063 +                      __FUNCTION__, map->map);
23064 +               return -1;
23065 +       }
23066 +
23067 +       *map = pcmcia_socket[sock].mem_map[map->map];
23068 +       return 0;
23069 +}
23070 +
23071 +
23072 +/*
23073 + * bcm47xx_pcmcia_set_mem_map()
23074 + *
23075 + * Implements the set_mem_map() operation for the in-kernel PCMCIA
23076 + * service (formerly SS_SetMemMap in Card Services). We configure
23077 + * the map speed as requested, but override the address ranges
23078 + * supplied by Card Services.
23079 + *
23080 + * Returns: 0 on success, -1 on error
23081 + */
23082 +static int
23083 +bcm47xx_pcmcia_set_mem_map(unsigned int sock, struct pccard_mem_map *map)
23084 +{
23085 +       unsigned int speed;
23086 +       unsigned long start;
23087 +       u_long flags;
23088 +
23089 +       if (map->map >= MAX_WIN) {
23090 +               printk(KERN_ERR "%s(): map (%d) out of range\n",
23091 +                      __FUNCTION__, map->map);
23092 +               return -1;
23093 +       }
23094 +
23095 +       DEBUG(2, "\tmap %u  speed %u\n\tsys_start  %#lx\n"
23096 +             "\tsys_stop   %#lx\n\tcard_start %#x\n"
23097 +             "\tflags: %s%s%s%s%s%s%s%s\n",
23098 +             map->map, map->speed, map->sys_start, map->sys_stop,
23099 +             map->card_start, (map->flags == 0) ? "<NONE>" : "",
23100 +             (map->flags & MAP_ACTIVE) ? "ACTIVE " : "",
23101 +             (map->flags & MAP_16BIT) ? "16BIT " : "",
23102 +             (map->flags & MAP_AUTOSZ) ? "AUTOSZ " : "",
23103 +             (map->flags & MAP_0WS) ? "0WS " : "",
23104 +             (map->flags & MAP_WRPROT) ? "WRPROT " : "",
23105 +             (map->flags & MAP_ATTRIB) ? "ATTRIB " : "",
23106 +             (map->flags & MAP_USE_WAIT) ? "USE_WAIT " : "");
23107 +
23108 +       if (map->flags & MAP_ACTIVE) {
23109 +               /* When clients issue RequestMap, the access speed is not always
23110 +                * properly configured:
23111 +                */
23112 +               speed = (map->speed > 0) ? map->speed : BCM47XX_PCMCIA_MEM_SPEED;
23113 +
23114 +               /* TBD */
23115 +               if (map->flags & MAP_ATTRIB) {
23116 +                       pcmcia_socket[sock].speed_attr = speed;
23117 +               } else {
23118 +                       pcmcia_socket[sock].speed_mem = speed;
23119 +               }
23120 +       }
23121 +
23122 +       save_flags(flags);
23123 +       cli();
23124 +       start = map->sys_start;
23125 +
23126 +       if (map->sys_stop == 0)
23127 +               map->sys_stop = PAGE_SIZE - 1;
23128 +
23129 +       if (map->flags & MAP_ATTRIB) {
23130 +               map->sys_start = pcmcia_socket[sock].phys_attr +
23131 +                       map->card_start;
23132 +       } else {
23133 +               map->sys_start = pcmcia_socket[sock].phys_mem +
23134 +                       map->card_start;
23135 +       }
23136 +
23137 +       map->sys_stop = map->sys_start + (map->sys_stop - start);
23138 +       pcmcia_socket[sock].mem_map[map->map] = *map;
23139 +       restore_flags(flags);
23140 +       DEBUG(2, "set_mem_map %d start %x stop %x card_start %x\n",
23141 +                       map->map, map->sys_start, map->sys_stop,
23142 +                       map->card_start);
23143 +       return 0;
23144 +}
23145 +
23146 +
23147 +#if defined(CONFIG_PROC_FS)
23148 +
23149 +/*
23150 + * bcm47xx_pcmcia_proc_setup()
23151 + *
23152 + * Implements the proc_setup() operation for the in-kernel PCMCIA
23153 + * service (formerly SS_ProcSetup in Card Services).
23154 + *
23155 + * Returns: 0 on success, -1 on error
23156 + */
23157 +static void
23158 +bcm47xx_pcmcia_proc_setup(unsigned int sock, struct proc_dir_entry *base)
23159 +{
23160 +       struct proc_dir_entry *entry;
23161 +
23162 +       if ((entry = create_proc_entry("status", 0, base)) == NULL) {
23163 +               printk(KERN_ERR "Unable to install \"status\" procfs entry\n");
23164 +               return;
23165 +       }
23166 +
23167 +       entry->read_proc = bcm47xx_pcmcia_proc_status;
23168 +       entry->data = (void *)sock;
23169 +}
23170 +
23171 +
23172 +/*
23173 + * bcm47xx_pcmcia_proc_status()
23174 + *
23175 + * Implements the /proc/bus/pccard/??/status file.
23176 + *
23177 + * Returns: the number of characters added to the buffer
23178 + */
23179 +static int
23180 +bcm47xx_pcmcia_proc_status(char *buf, char **start, off_t pos,
23181 +                          int count, int *eof, void *data)
23182 +{
23183 +       char *p = buf;
23184 +       unsigned int sock = (unsigned int)data;
23185 +
23186 +       p += sprintf(p, "k_flags  : %s%s%s%s%s%s%s\n",
23187 +                    pcmcia_socket[sock].k_state.detect ? "detect " : "",
23188 +                    pcmcia_socket[sock].k_state.ready ? "ready " : "",
23189 +                    pcmcia_socket[sock].k_state.bvd1 ? "bvd1 " : "",
23190 +                    pcmcia_socket[sock].k_state.bvd2 ? "bvd2 " : "",
23191 +                    pcmcia_socket[sock].k_state.wrprot ? "wrprot " : "",
23192 +                    pcmcia_socket[sock].k_state.vs_3v ? "vs_3v " : "",
23193 +                    pcmcia_socket[sock].k_state.vs_Xv ? "vs_Xv " : "");
23194 +
23195 +       p += sprintf(p, "status   : %s%s%s%s%s%s%s%s%s\n",
23196 +                    pcmcia_socket[sock].k_state.detect ? "SS_DETECT " : "",
23197 +                    pcmcia_socket[sock].k_state.ready ? "SS_READY " : "",
23198 +                    pcmcia_socket[sock].cs_state.Vcc ? "SS_POWERON " : "",
23199 +                    pcmcia_socket[sock].cs_state.flags & SS_IOCARD ? "SS_IOCARD " : "",
23200 +                    (pcmcia_socket[sock].cs_state.flags & SS_IOCARD &&
23201 +                     pcmcia_socket[sock].k_state.bvd1) ? "SS_STSCHG " : "",
23202 +                    ((pcmcia_socket[sock].cs_state.flags & SS_IOCARD) == 0 &&
23203 +                     (pcmcia_socket[sock].k_state.bvd1 == 0)) ? "SS_BATDEAD " : "",
23204 +                    ((pcmcia_socket[sock].cs_state.flags & SS_IOCARD) == 0 &&
23205 +                     (pcmcia_socket[sock].k_state.bvd2 == 0)) ? "SS_BATWARN " : "",
23206 +                    pcmcia_socket[sock].k_state.vs_3v ? "SS_3VCARD " : "",
23207 +                    pcmcia_socket[sock].k_state.vs_Xv ? "SS_XVCARD " : "");
23208 +
23209 +       p += sprintf(p, "mask     : %s%s%s%s%s\n",
23210 +                    pcmcia_socket[sock].cs_state.csc_mask & SS_DETECT ? "SS_DETECT " : "",
23211 +                    pcmcia_socket[sock].cs_state.csc_mask & SS_READY ? "SS_READY " : "",
23212 +                    pcmcia_socket[sock].cs_state.csc_mask & SS_BATDEAD ? "SS_BATDEAD " : "",
23213 +                    pcmcia_socket[sock].cs_state.csc_mask & SS_BATWARN ? "SS_BATWARN " : "",
23214 +                    pcmcia_socket[sock].cs_state.csc_mask & SS_STSCHG ? "SS_STSCHG " : "");
23215 +
23216 +       p += sprintf(p, "cs_flags : %s%s%s%s%s\n",
23217 +                    pcmcia_socket[sock].cs_state.flags & SS_PWR_AUTO ?
23218 +                       "SS_PWR_AUTO " : "",
23219 +                    pcmcia_socket[sock].cs_state.flags & SS_IOCARD ?
23220 +                       "SS_IOCARD " : "",
23221 +                    pcmcia_socket[sock].cs_state.flags & SS_RESET ?
23222 +                       "SS_RESET " : "",
23223 +                    pcmcia_socket[sock].cs_state.flags & SS_SPKR_ENA ?
23224 +                       "SS_SPKR_ENA " : "",
23225 +                    pcmcia_socket[sock].cs_state.flags & SS_OUTPUT_ENA ?
23226 +                       "SS_OUTPUT_ENA " : "");
23227 +
23228 +       p += sprintf(p, "Vcc      : %d\n", pcmcia_socket[sock].cs_state.Vcc);
23229 +       p += sprintf(p, "Vpp      : %d\n", pcmcia_socket[sock].cs_state.Vpp);
23230 +       p += sprintf(p, "irq      : %d\n", pcmcia_socket[sock].cs_state.io_irq);
23231 +       p += sprintf(p, "I/O      : %u\n", pcmcia_socket[sock].speed_io);
23232 +       p += sprintf(p, "attribute: %u\n", pcmcia_socket[sock].speed_attr);
23233 +       p += sprintf(p, "common   : %u\n", pcmcia_socket[sock].speed_mem);
23234 +       return p-buf;
23235 +}
23236 +
23237 +
23238 +#endif  /* defined(CONFIG_PROC_FS) */
23239 diff -Nur linux-2.4.32/drivers/pcmcia/bcm4710_pcmcia.c linux-2.4.32-brcm/drivers/pcmcia/bcm4710_pcmcia.c
23240 --- linux-2.4.32/drivers/pcmcia/bcm4710_pcmcia.c        1970-01-01 01:00:00.000000000 +0100
23241 +++ linux-2.4.32-brcm/drivers/pcmcia/bcm4710_pcmcia.c   2005-12-16 23:39:11.368863250 +0100
23242 @@ -0,0 +1,266 @@
23243 +/*
23244 + * BCM4710 specific pcmcia routines.
23245 + *
23246 + * Copyright 2004, Broadcom Corporation
23247 + * All Rights Reserved.
23248 + *
23249 + * THIS SOFTWARE IS OFFERED "AS IS", AND BROADCOM GRANTS NO WARRANTIES OF ANY
23250 + * KIND, EXPRESS OR IMPLIED, BY STATUTE, COMMUNICATION OR OTHERWISE. BROADCOM
23251 + * SPECIFICALLY DISCLAIMS ANY IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS
23252 + * FOR A SPECIFIC PURPOSE OR NONINFRINGEMENT CONCERNING THIS SOFTWARE.
23253 + *
23254 + * $Id: bcm4710_pcmcia.c,v 1.1 2005/03/16 13:50:00 wbx Exp $
23255 + */
23256 +#include <linux/module.h>
23257 +#include <linux/init.h>
23258 +#include <linux/config.h>
23259 +#include <linux/delay.h>
23260 +#include <linux/ioport.h>
23261 +#include <linux/kernel.h>
23262 +#include <linux/tqueue.h>
23263 +#include <linux/timer.h>
23264 +#include <linux/mm.h>
23265 +#include <linux/proc_fs.h>
23266 +#include <linux/version.h>
23267 +#include <linux/types.h>
23268 +#include <linux/pci.h>
23269 +
23270 +#include <pcmcia/version.h>
23271 +#include <pcmcia/cs_types.h>
23272 +#include <pcmcia/cs.h>
23273 +#include <pcmcia/ss.h>
23274 +#include <pcmcia/bulkmem.h>
23275 +#include <pcmcia/cistpl.h>
23276 +#include <pcmcia/bus_ops.h>
23277 +#include "cs_internal.h"
23278 +
23279 +#include <asm/io.h>
23280 +#include <asm/irq.h>
23281 +#include <asm/system.h>
23282 +
23283 +
23284 +#include <typedefs.h>
23285 +#include <bcmdevs.h>
23286 +#include <bcm4710.h>
23287 +#include <sbconfig.h>
23288 +#include <sbextif.h>
23289 +
23290 +#include "bcm4710pcmcia.h"
23291 +
23292 +/* Use a static var for irq dev_id */
23293 +static int bcm47xx_pcmcia_dev_id;
23294 +
23295 +/* Do we think we have a card or not? */
23296 +static int bcm47xx_pcmcia_present = 0;
23297 +
23298 +
23299 +static void bcm4710_pcmcia_reset(void)
23300 +{
23301 +       extifregs_t *eir;
23302 +       unsigned long s;
23303 +       uint32 out0, out1, outen;
23304 +
23305 +
23306 +       eir = (extifregs_t *) ioremap_nocache(BCM4710_REG_EXTIF, sizeof(extifregs_t));
23307 +
23308 +       save_and_cli(s);
23309 +
23310 +       /* Use gpio7 to reset the pcmcia slot */
23311 +       outen = readl(&eir->gpio[0].outen);
23312 +       outen |= BCM47XX_PCMCIA_RESET;
23313 +       out0 = readl(&eir->gpio[0].out);
23314 +       out0 &= ~(BCM47XX_PCMCIA_RESET);
23315 +       out1 = out0 | BCM47XX_PCMCIA_RESET;
23316 +
23317 +       writel(out0, &eir->gpio[0].out);
23318 +       writel(outen, &eir->gpio[0].outen);
23319 +       mdelay(1);
23320 +       writel(out1, &eir->gpio[0].out);
23321 +       mdelay(1);
23322 +       writel(out0, &eir->gpio[0].out);
23323 +
23324 +       restore_flags(s);
23325 +}
23326 +
23327 +
23328 +static int bcm4710_pcmcia_init(struct pcmcia_init *init)
23329 +{
23330 +       struct pci_dev *pdev;
23331 +       extifregs_t *eir;
23332 +       uint32 outen, intp, intm, tmp;
23333 +       uint16 *attrsp;
23334 +       int rc = 0, i;
23335 +       extern unsigned long bcm4710_cpu_cycle;
23336 +
23337 +
23338 +       if (!(pdev = pci_find_device(VENDOR_BROADCOM, SB_EXTIF, NULL))) {
23339 +               printk(KERN_ERR "bcm4710_pcmcia: extif not found\n");
23340 +               return -ENODEV;
23341 +       }
23342 +       eir = (extifregs_t *) ioremap_nocache(pci_resource_start(pdev, 0), pci_resource_len(pdev, 0));
23343 +
23344 +       /* Initialize the pcmcia i/f: 16bit no swap */
23345 +       writel(CF_EM_PCMCIA | CF_DS | CF_EN, &eir->pcmcia_config);
23346 +
23347 +#ifdef notYet
23348 +
23349 +       /* Set the timing for memory accesses */
23350 +       tmp = (19 / bcm4710_cpu_cycle) << 24;           /* W3 = 10nS */
23351 +       tmp = tmp | ((29 / bcm4710_cpu_cycle) << 16);   /* W2 = 20nS */
23352 +       tmp = tmp | ((109 / bcm4710_cpu_cycle) << 8);   /* W1 = 100nS */
23353 +       tmp = tmp | (129 / bcm4710_cpu_cycle);          /* W0 = 120nS */
23354 +       writel(tmp, &eir->pcmcia_memwait);              /* 0x01020a0c for a 100Mhz clock */
23355 +
23356 +       /* Set the timing for I/O accesses */
23357 +       tmp = (19 / bcm4710_cpu_cycle) << 24;           /* W3 = 10nS */
23358 +       tmp = tmp | ((29 / bcm4710_cpu_cycle) << 16);   /* W2 = 20nS */
23359 +       tmp = tmp | ((109 / bcm4710_cpu_cycle) << 8);   /* W1 = 100nS */
23360 +       tmp = tmp | (129 / bcm4710_cpu_cycle);          /* W0 = 120nS */
23361 +       writel(tmp, &eir->pcmcia_iowait);               /* 0x01020a0c for a 100Mhz clock */
23362 +
23363 +       /* Set the timing for attribute accesses */
23364 +       tmp = (19 / bcm4710_cpu_cycle) << 24;           /* W3 = 10nS */
23365 +       tmp = tmp | ((29 / bcm4710_cpu_cycle) << 16);   /* W2 = 20nS */
23366 +       tmp = tmp | ((109 / bcm4710_cpu_cycle) << 8);   /* W1 = 100nS */
23367 +       tmp = tmp | (129 / bcm4710_cpu_cycle);          /* W0 = 120nS */
23368 +       writel(tmp, &eir->pcmcia_attrwait);             /* 0x01020a0c for a 100Mhz clock */
23369 +
23370 +#endif
23371 +       /* Make sure gpio0 and gpio5 are inputs */
23372 +       outen = readl(&eir->gpio[0].outen);
23373 +       outen &= ~(BCM47XX_PCMCIA_WP | BCM47XX_PCMCIA_STSCHG | BCM47XX_PCMCIA_RESET);
23374 +       writel(outen, &eir->gpio[0].outen);
23375 +
23376 +       /* Issue a reset to the pcmcia socket */
23377 +       bcm4710_pcmcia_reset();
23378 +
23379 +#ifdef DO_BCM47XX_PCMCIA_INTERRUPTS
23380 +       /* Setup gpio5 to be the STSCHG interrupt */
23381 +       intp = readl(&eir->gpiointpolarity);
23382 +       writel(intp | BCM47XX_PCMCIA_STSCHG, &eir->gpiointpolarity);    /* Active low */
23383 +       intm = readl(&eir->gpiointmask);
23384 +       writel(intm | BCM47XX_PCMCIA_STSCHG, &eir->gpiointmask);        /* Enable it */
23385 +#endif
23386 +
23387 +       DEBUG(2, "bcm4710_pcmcia after reset:\n");
23388 +       DEBUG(2, "\textstatus\t= 0x%08x:\n", readl(&eir->extstatus));
23389 +       DEBUG(2, "\tpcmcia_config\t= 0x%08x:\n", readl(&eir->pcmcia_config));
23390 +       DEBUG(2, "\tpcmcia_memwait\t= 0x%08x:\n", readl(&eir->pcmcia_memwait));
23391 +       DEBUG(2, "\tpcmcia_attrwait\t= 0x%08x:\n", readl(&eir->pcmcia_attrwait));
23392 +       DEBUG(2, "\tpcmcia_iowait\t= 0x%08x:\n", readl(&eir->pcmcia_iowait));
23393 +       DEBUG(2, "\tgpioin\t\t= 0x%08x:\n", readl(&eir->gpioin));
23394 +       DEBUG(2, "\tgpio_outen0\t= 0x%08x:\n", readl(&eir->gpio[0].outen));
23395 +       DEBUG(2, "\tgpio_out0\t= 0x%08x:\n", readl(&eir->gpio[0].out));
23396 +       DEBUG(2, "\tgpiointpolarity\t= 0x%08x:\n", readl(&eir->gpiointpolarity));
23397 +       DEBUG(2, "\tgpiointmask\t= 0x%08x:\n", readl(&eir->gpiointmask));
23398 +
23399 +#ifdef DO_BCM47XX_PCMCIA_INTERRUPTS
23400 +       /* Request pcmcia interrupt */
23401 +       rc =  request_irq(BCM47XX_PCMCIA_IRQ, init->handler, SA_INTERRUPT,
23402 +                         "PCMCIA Interrupt", &bcm47xx_pcmcia_dev_id);
23403 +#endif
23404 +
23405 +       attrsp = (uint16 *)ioremap_nocache(EXTIF_PCMCIA_CFGBASE(BCM4710_EXTIF), 0x1000);
23406 +       tmp = readw(&attrsp[0]);
23407 +       DEBUG(2, "\tattr[0] = 0x%04x\n", tmp);
23408 +       if ((tmp == 0x7fff) || (tmp == 0x7f00)) {
23409 +               bcm47xx_pcmcia_present = 0;
23410 +       } else {
23411 +               bcm47xx_pcmcia_present = 1;
23412 +       }
23413 +
23414 +       /* There's only one socket */
23415 +       return 1;
23416 +}
23417 +
23418 +static int bcm4710_pcmcia_shutdown(void)
23419 +{
23420 +       extifregs_t *eir;
23421 +       uint32 intm;
23422 +
23423 +       eir = (extifregs_t *) ioremap_nocache(BCM4710_REG_EXTIF, sizeof(extifregs_t));
23424 +
23425 +       /* Disable the pcmcia i/f */
23426 +       writel(0, &eir->pcmcia_config);
23427 +
23428 +       /* Reset gpio's */
23429 +       intm = readl(&eir->gpiointmask);
23430 +       writel(intm & ~BCM47XX_PCMCIA_STSCHG, &eir->gpiointmask);       /* Disable it */
23431 +
23432 +       free_irq(BCM47XX_PCMCIA_IRQ, &bcm47xx_pcmcia_dev_id);
23433 +
23434 +       return 0;
23435 +}
23436 +
23437 +static int
23438 +bcm4710_pcmcia_socket_state(unsigned sock, struct pcmcia_state *state)
23439 +{
23440 +       extifregs_t *eir;
23441 +
23442 +       eir = (extifregs_t *) ioremap_nocache(BCM4710_REG_EXTIF, sizeof(extifregs_t));
23443 +
23444 +
23445 +       if (sock != 0) {
23446 +               printk(KERN_ERR "bcm4710 socket_state bad sock %d\n", sock);
23447 +               return -1;
23448 +       }
23449 +
23450 +       if (bcm47xx_pcmcia_present) {
23451 +               state->detect = 1;
23452 +               state->ready = 1;
23453 +               state->bvd1 = 1;
23454 +               state->bvd2 = 1;
23455 +               state->wrprot = (readl(&eir->gpioin) & BCM47XX_PCMCIA_WP) == BCM47XX_PCMCIA_WP;
23456 +               state->vs_3v = 0;
23457 +               state->vs_Xv = 0;
23458 +       } else {
23459 +               state->detect = 0;
23460 +               state->ready = 0;
23461 +       }
23462 +
23463 +       return 1;
23464 +}
23465 +
23466 +
23467 +static int bcm4710_pcmcia_get_irq_info(struct pcmcia_irq_info *info)
23468 +{
23469 +       if (info->sock >= BCM47XX_PCMCIA_MAX_SOCK) return -1;
23470 +
23471 +       info->irq = BCM47XX_PCMCIA_IRQ;
23472 +
23473 +       return 0;
23474 +}
23475 +
23476 +
23477 +static int
23478 +bcm4710_pcmcia_configure_socket(const struct pcmcia_configure *configure)
23479 +{
23480 +       if (configure->sock >= BCM47XX_PCMCIA_MAX_SOCK) return -1;
23481 +
23482 +
23483 +       DEBUG(2, "Vcc %dV Vpp %dV output %d speaker %d reset %d\n", configure->vcc,
23484 +             configure->vpp, configure->output, configure->speaker, configure->reset);
23485 +
23486 +       if ((configure->vcc != 50) || (configure->vpp != 50)) {
23487 +               printk("%s: bad Vcc/Vpp (%d:%d)\n", __FUNCTION__, configure->vcc,
23488 +                      configure->vpp);
23489 +       }
23490 +
23491 +       if (configure->reset) {
23492 +               /* Issue a reset to the pcmcia socket */
23493 +               DEBUG(1, "%s: Reseting socket\n", __FUNCTION__);
23494 +               bcm4710_pcmcia_reset();
23495 +       }
23496 +
23497 +
23498 +       return 0;
23499 +}
23500 +
23501 +struct pcmcia_low_level bcm4710_pcmcia_ops = {
23502 +       bcm4710_pcmcia_init,
23503 +       bcm4710_pcmcia_shutdown,
23504 +       bcm4710_pcmcia_socket_state,
23505 +       bcm4710_pcmcia_get_irq_info,
23506 +       bcm4710_pcmcia_configure_socket
23507 +};
23508 +
23509 diff -Nur linux-2.4.32/drivers/pcmcia/bcm4710pcmcia.h linux-2.4.32-brcm/drivers/pcmcia/bcm4710pcmcia.h
23510 --- linux-2.4.32/drivers/pcmcia/bcm4710pcmcia.h 1970-01-01 01:00:00.000000000 +0100
23511 +++ linux-2.4.32-brcm/drivers/pcmcia/bcm4710pcmcia.h    2005-12-16 23:39:11.368863250 +0100
23512 @@ -0,0 +1,118 @@
23513 +/*
23514 + *
23515 + * bcm47xx pcmcia driver
23516 + *
23517 + * Copyright 2004, Broadcom Corporation
23518 + * All Rights Reserved.
23519 + *
23520 + * THIS SOFTWARE IS OFFERED "AS IS", AND BROADCOM GRANTS NO WARRANTIES OF ANY
23521 + * KIND, EXPRESS OR IMPLIED, BY STATUTE, COMMUNICATION OR OTHERWISE. BROADCOM
23522 + * SPECIFICALLY DISCLAIMS ANY IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS
23523 + * FOR A SPECIFIC PURPOSE OR NONINFRINGEMENT CONCERNING THIS SOFTWARE.
23524 + *
23525 + * Based on sa1100.h and include/asm-arm/arch-sa1100/pcmica.h
23526 + *     from www.handhelds.org,
23527 + * and au1000_generic.c from oss.sgi.com.
23528 + *
23529 + * $Id: bcm4710pcmcia.h,v 1.1 2005/03/16 13:50:00 wbx Exp $
23530 + */
23531 +
23532 +#if !defined(_BCM4710PCMCIA_H)
23533 +#define _BCM4710PCMCIA_H
23534 +
23535 +#include <pcmcia/cs_types.h>
23536 +#include <pcmcia/ss.h>
23537 +#include <pcmcia/bulkmem.h>
23538 +#include <pcmcia/cistpl.h>
23539 +#include "cs_internal.h"
23540 +
23541 +
23542 +/* The 47xx can only support one socket */
23543 +#define BCM47XX_PCMCIA_MAX_SOCK                1
23544 +
23545 +/* In the bcm947xx gpio's are used for some pcmcia functions */
23546 +#define        BCM47XX_PCMCIA_WP               0x01            /* Bit 0 is WP input */
23547 +#define        BCM47XX_PCMCIA_STSCHG           0x20            /* Bit 5 is STSCHG input/interrupt */
23548 +#define        BCM47XX_PCMCIA_RESET            0x80            /* Bit 7 is RESET */
23549 +
23550 +#define        BCM47XX_PCMCIA_IRQ              2
23551 +
23552 +/* The socket driver actually works nicely in interrupt-driven form,
23553 + * so the (relatively infrequent) polling is "just to be sure."
23554 + */
23555 +#define BCM47XX_PCMCIA_POLL_PERIOD    (2 * HZ)
23556 +
23557 +#define BCM47XX_PCMCIA_IO_SPEED       (255)
23558 +#define BCM47XX_PCMCIA_MEM_SPEED      (300)
23559 +
23560 +
23561 +struct pcmcia_state {
23562 +       unsigned detect: 1,
23563 +               ready: 1,
23564 +               bvd1: 1,
23565 +               bvd2: 1,
23566 +               wrprot: 1,
23567 +               vs_3v: 1,
23568 +               vs_Xv: 1;
23569 +};
23570 +
23571 +
23572 +struct pcmcia_configure {
23573 +       unsigned sock: 8,
23574 +               vcc: 8,
23575 +               vpp: 8,
23576 +               output: 1,
23577 +               speaker: 1,
23578 +               reset: 1;
23579 +};
23580 +
23581 +struct pcmcia_irq_info {
23582 +       unsigned int sock;
23583 +       unsigned int irq;
23584 +};
23585 +
23586 +/* This structure encapsulates per-socket state which we might need to
23587 + * use when responding to a Card Services query of some kind.
23588 + */
23589 +struct bcm47xx_pcmcia_socket {
23590 +  socket_state_t        cs_state;
23591 +  struct pcmcia_state   k_state;
23592 +  unsigned int          irq;
23593 +  void                  (*handler)(void *, unsigned int);
23594 +  void                  *handler_info;
23595 +  pccard_io_map         io_map[MAX_IO_WIN];
23596 +  pccard_mem_map        mem_map[MAX_WIN];
23597 +  ioaddr_t              virt_io, phys_attr, phys_mem;
23598 +  unsigned short        speed_io, speed_attr, speed_mem;
23599 +};
23600 +
23601 +struct pcmcia_init {
23602 +       void (*handler)(int irq, void *dev, struct pt_regs *regs);
23603 +};
23604 +
23605 +struct pcmcia_low_level {
23606 +       int (*init)(struct pcmcia_init *);
23607 +       int (*shutdown)(void);
23608 +       int (*socket_state)(unsigned sock, struct pcmcia_state *);
23609 +       int (*get_irq_info)(struct pcmcia_irq_info *);
23610 +       int (*configure_socket)(const struct pcmcia_configure *);
23611 +};
23612 +
23613 +extern struct pcmcia_low_level bcm47xx_pcmcia_ops;
23614 +
23615 +/* I/O pins replacing memory pins
23616 + * (PCMCIA System Architecture, 2nd ed., by Don Anderson, p.75)
23617 + *
23618 + * These signals change meaning when going from memory-only to
23619 + * memory-or-I/O interface:
23620 + */
23621 +#define iostschg bvd1
23622 +#define iospkr   bvd2
23623 +
23624 +
23625 +/*
23626 + * Declaration for implementation specific low_level operations.
23627 + */
23628 +extern struct pcmcia_low_level bcm4710_pcmcia_ops;
23629 +
23630 +#endif  /* !defined(_BCM4710PCMCIA_H) */
23631 diff -Nur linux-2.4.32/drivers/pcmcia/Makefile linux-2.4.32-brcm/drivers/pcmcia/Makefile
23632 --- linux-2.4.32/drivers/pcmcia/Makefile        2004-02-18 14:36:31.000000000 +0100
23633 +++ linux-2.4.32-brcm/drivers/pcmcia/Makefile   2005-12-16 23:39:11.364863000 +0100
23634 @@ -65,6 +65,10 @@
23635  au1000_ss-objs-$(CONFIG_PCMCIA_DB1X00)         += au1000_db1x00.o
23636  au1000_ss-objs-$(CONFIG_PCMCIA_XXS1500)        += au1000_xxs1500.o
23637
23638 +obj-$(CONFIG_PCMCIA_BCM4710)   += bcm4710_ss.o
23639 +bcm4710_ss-objs                                        := bcm4710_generic.o
23640 +bcm4710_ss-objs                                        += bcm4710_pcmcia.o
23641 +
23642  obj-$(CONFIG_PCMCIA_SA1100)    += sa1100_cs.o
23643  obj-$(CONFIG_PCMCIA_M8XX)      += m8xx_pcmcia.o
23644  obj-$(CONFIG_PCMCIA_SIBYTE)    += sibyte_generic.o
23645 @@ -102,5 +106,8 @@
23646  au1x00_ss.o: $(au1000_ss-objs-y)
23647         $(LD) -r -o $@ $(au1000_ss-objs-y)
23648
23649 +bcm4710_ss.o: $(bcm4710_ss-objs)
23650 +       $(LD) -r -o $@ $(bcm4710_ss-objs)
23651 +
23652  yenta_socket.o: $(yenta_socket-objs)
23653         $(LD) $(LD_RFLAG) -r -o $@ $(yenta_socket-objs)
23654 diff -Nur linux-2.4.32/include/asm-mips/bootinfo.h linux-2.4.32-brcm/include/asm-mips/bootinfo.h
23655 --- linux-2.4.32/include/asm-mips/bootinfo.h    2004-02-18 14:36:32.000000000 +0100
23656 +++ linux-2.4.32-brcm/include/asm-mips/bootinfo.h       2005-12-16 23:39:11.400865250 +0100
23657 @@ -37,6 +37,7 @@
23658  #define MACH_GROUP_HP_LJ       20 /* Hewlett Packard LaserJet               */
23659  #define MACH_GROUP_LASAT       21
23660  #define MACH_GROUP_TITAN       22 /* PMC-Sierra Titan                      */
23661 +#define MACH_GROUP_BRCM                   23 /* Broadcom */
23662
23663  /*
23664   * Valid machtype values for group unknown (low order halfword of mips_machtype)
23665 @@ -194,6 +195,15 @@
23666  #define MACH_TANBAC_TB0229     7       /* TANBAC TB0229 (VR4131DIMM) */
23667
23668  /*
23669 + * Valid machtypes for group Broadcom
23670 + */
23671 +#define MACH_BCM93725          0
23672 +#define MACH_BCM93725_VJ       1
23673 +#define MACH_BCM93730          2
23674 +#define MACH_BCM947XX          3
23675 +#define MACH_BCM933XX          4
23676 +
23677 +/*
23678   * Valid machtype for group TITAN
23679   */
23680  #define        MACH_TITAN_YOSEMITE     1       /* PMC-Sierra Yosemite */
23681 diff -Nur linux-2.4.32/include/asm-mips/cpu.h linux-2.4.32-brcm/include/asm-mips/cpu.h
23682 --- linux-2.4.32/include/asm-mips/cpu.h 2005-01-19 15:10:11.000000000 +0100
23683 +++ linux-2.4.32-brcm/include/asm-mips/cpu.h    2005-12-16 23:39:11.412866000 +0100
23684 @@ -22,6 +22,11 @@
23685     spec.
23686  */
23687
23688 +#define PRID_COPT_MASK         0xff000000
23689 +#define PRID_COMP_MASK         0x00ff0000
23690 +#define PRID_IMP_MASK          0x0000ff00
23691 +#define PRID_REV_MASK          0x000000ff
23692 +
23693  #define PRID_COMP_LEGACY       0x000000
23694  #define PRID_COMP_MIPS         0x010000
23695  #define PRID_COMP_BROADCOM     0x020000
23696 @@ -58,6 +63,7 @@
23697  #define PRID_IMP_RM7000                0x2700
23698  #define PRID_IMP_NEVADA                0x2800          /* RM5260 ??? */
23699  #define PRID_IMP_RM9000                0x3400
23700 +#define PRID_IMP_BCM4710       0x4000
23701  #define PRID_IMP_R5432         0x5400
23702  #define PRID_IMP_R5500         0x5500
23703  #define PRID_IMP_4KC           0x8000
23704 @@ -66,10 +72,16 @@
23705  #define PRID_IMP_4KEC          0x8400
23706  #define PRID_IMP_4KSC          0x8600
23707  #define PRID_IMP_25KF          0x8800
23708 +#define PRID_IMP_BCM3302       0x9000
23709 +#define PRID_IMP_BCM3303       0x9100
23710  #define PRID_IMP_24K           0x9300
23711
23712  #define PRID_IMP_UNKNOWN       0xff00
23713
23714 +#define       BCM330X(id) \
23715 +       (((id & (PRID_COMP_MASK | PRID_IMP_MASK)) == (PRID_COMP_BROADCOM | PRID_IMP_BCM3302)) \
23716 +       || ((id & (PRID_COMP_MASK | PRID_IMP_MASK)) == (PRID_COMP_BROADCOM | PRID_IMP_BCM3303)))
23717 +
23718  /*
23719   * These are the PRID's for when 23:16 == PRID_COMP_SIBYTE
23720   */
23721 @@ -174,7 +186,9 @@
23722  #define CPU_AU1550             57
23723  #define CPU_24K                        58
23724  #define CPU_AU1200             59
23725 -#define CPU_LAST               59
23726 +#define CPU_BCM4710            60
23727 +#define CPU_BCM3302            61
23728 +#define CPU_LAST               61
23729
23730  /*
23731   * ISA Level encodings
23732 diff -Nur linux-2.4.32/include/asm-mips/r4kcache.h linux-2.4.32-brcm/include/asm-mips/r4kcache.h
23733 --- linux-2.4.32/include/asm-mips/r4kcache.h    2004-02-18 14:36:32.000000000 +0100
23734 +++ linux-2.4.32-brcm/include/asm-mips/r4kcache.h       2005-12-16 23:39:11.416866250 +0100
23735 @@ -567,4 +567,17 @@
23736                         cache128_unroll32(addr|ws,Index_Writeback_Inv_SD);
23737  }
23738
23739 +extern inline void fill_icache_line(unsigned long addr)
23740 +{
23741 +       __asm__ __volatile__(
23742 +               ".set noreorder\n\t"
23743 +               ".set mips3\n\t"
23744 +               "cache %1, (%0)\n\t"
23745 +               ".set mips0\n\t"
23746 +               ".set reorder"
23747 +               :
23748 +               : "r" (addr),
23749 +               "i" (Fill));
23750 +}
23751 +
23752  #endif /* __ASM_R4KCACHE_H */
23753 diff -Nur linux-2.4.32/include/asm-mips/serial.h linux-2.4.32-brcm/include/asm-mips/serial.h
23754 --- linux-2.4.32/include/asm-mips/serial.h      2005-01-19 15:10:12.000000000 +0100
23755 +++ linux-2.4.32-brcm/include/asm-mips/serial.h 2005-12-16 23:39:11.428867000 +0100
23756 @@ -223,6 +223,13 @@
23757  #define TXX927_SERIAL_PORT_DEFNS
23758  #endif
23759
23760 +#ifdef CONFIG_BCM947XX
23761 +/* reserve 4 ports to be configured at runtime */
23762 +#define BCM947XX_SERIAL_PORT_DEFNS { 0, }, { 0, }, { 0, }, { 0, },
23763 +#else
23764 +#define BCM947XX_SERIAL_PORT_DEFNS
23765 +#endif
23766 +
23767  #ifdef CONFIG_HAVE_STD_PC_SERIAL_PORT
23768  #define STD_SERIAL_PORT_DEFNS                  \
23769         /* UART CLK   PORT IRQ     FLAGS        */                      \
23770 @@ -470,6 +477,7 @@
23771  #define SERIAL_PORT_DFNS                       \
23772         ATLAS_SERIAL_PORT_DEFNS                 \
23773         AU1000_SERIAL_PORT_DEFNS                \
23774 +       BCM947XX_SERIAL_PORT_DEFNS              \
23775         COBALT_SERIAL_PORT_DEFNS                \
23776         DDB5477_SERIAL_PORT_DEFNS               \
23777         EV96100_SERIAL_PORT_DEFNS               \
23778 diff -Nur linux-2.4.32/init/do_mounts.c linux-2.4.32-brcm/init/do_mounts.c
23779 --- linux-2.4.32/init/do_mounts.c       2003-11-28 19:26:21.000000000 +0100
23780 +++ linux-2.4.32-brcm/init/do_mounts.c  2005-12-16 23:39:11.504871750 +0100
23781 @@ -253,7 +253,13 @@
23782         { "ftlb", 0x2c08 },
23783         { "ftlc", 0x2c10 },
23784         { "ftld", 0x2c18 },
23785 +#if defined(CONFIG_MTD_BLOCK) || defined(CONFIG_MTD_BLOCK_RO)
23786         { "mtdblock", 0x1f00 },
23787 +       { "mtdblock0",0x1f00 },
23788 +       { "mtdblock1",0x1f01 },
23789 +       { "mtdblock2",0x1f02 },
23790 +       { "mtdblock3",0x1f03 },
23791 +#endif
23792         { "nb", 0x2b00 },
23793         { NULL, 0 }
23794  };