kernel/linux/arch/mips/brcm-boards/bcm963xx/setup.c

   1 /*
   2 <:copyright-gpl
   3  Copyright 2002 Broadcom Corp. All Rights Reserved.
   4
   5  This program is free software; you can distribute it and/or modify it
   6  under the terms of the GNU General Public License (Version 2) as
   7  published by the Free Software Foundation.
   8
   9  This program is distributed in the hope it will be useful, but WITHOUT
  10  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11  FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  12  for more details.
  13
  14  You should have received a copy of the GNU General Public License along
  15  with this program; if not, write to the Free Software Foundation, Inc.,
  16  59 Temple Place - Suite 330, Boston MA 02111-1307, USA.
  17 :>
  18 */
  19 /*
  20  * Generic setup routines for Broadcom 963xx MIPS boards
  21  */
  22
  23 #include <linux/config.h>
  24 #include <linux/init.h>
  25 #include <linux/interrupt.h>
  26 #include <linux/kernel.h>
  27 #include <linux/kdev_t.h>
  28 #include <linux/types.h>
  29 #include <linux/console.h>
  30 #include <linux/sched.h>
  31 #include <linux/mm.h>
  32 #include <linux/slab.h>
  33 #include <linux/module.h>
  34 #include <linux/delay.h>
  35
  36 #include <asm/addrspace.h>
  37 #include <asm/bcache.h>
  38 #include <asm/irq.h>
  39 #include <asm/time.h>
  40 #include <asm/reboot.h>
  41 #include <asm/gdb-stub.h>
  42
  43 extern void brcm_timer_setup(struct irqaction *irq);
  44 extern unsigned long getMemorySize(void);
  45
  46 #include <bcm_map_part.h>
  47
  48 #if defined(CONFIG_PCI)
  49 #include <linux/pci.h>
  50 #include <bcmpci.h>
  51 #endif
  52
  53 /* This function should be in a board specific directory.  For now,
  54  * assume that all boards that include this file use a Broadcom chip
  55  * with a soft reset bit in the PLL control register.
  56  */
  57 static void brcm_machine_restart(char *command)
  58 {
  59     PERF->pll_control |= SOFT_RESET;
  60 }
  61
  62 static void brcm_machine_halt(void)
  63 {
  64     printk("System halted\n");
  65     while (1);
  66 }
  67
  68 #if defined(CONFIG_PCI)
  69
  70 static void mpi_SetLocalPciConfigReg(uint32 reg, uint32 value)
  71 {
  72     /* write index then value */
  73     MPI->pcicfgcntrl = PCI_CFG_REG_WRITE_EN + reg;;
  74     MPI->pcicfgdata = value;
  75 }
  76
  77 static uint32 mpi_GetLocalPciConfigReg(uint32 reg)
  78 {
  79     /* write index then get value */
  80     MPI->pcicfgcntrl = PCI_CFG_REG_WRITE_EN + reg;;
  81     return MPI->pcicfgdata;
  82 }
  83
  84 /*
  85  * mpi_ResetPcCard: Set/Reset the PcCard
  86  */
  87 static void mpi_ResetPcCard(int cardtype, BOOL bReset)
  88 {
  89     if (cardtype == MPI_CARDTYPE_NONE) {
  90         return;
  91     }
  92
  93     if (cardtype == MPI_CARDTYPE_CARDBUS) {
  94         bReset = ! bReset;
  95     }
  96
  97     if (bReset) {
  98         MPI->pcmcia_cntl1 = (MPI->pcmcia_cntl1 & ~PCCARD_CARD_RESET);
  99     } else {
 100         MPI->pcmcia_cntl1 = (MPI->pcmcia_cntl1 | PCCARD_CARD_RESET);
 101     }
 102 }
 103
 104 /*
 105  * mpi_ConfigCs: Configure an MPI/EBI chip select
 106  */
 107 static void mpi_ConfigCs(uint32 cs, uint32 base, uint32 size, uint32 flags)
 108 {
 109     MPI->cs[cs].base = ((base & 0x1FFFFFFF) | size);
 110     MPI->cs[cs].config = flags;
 111 }
 112
 113 /*
 114  * mpi_InitPcmciaSpace
 115  */
 116 static void mpi_InitPcmciaSpace(void)
 117 {
 118     // ChipSelect 4 controls PCMCIA Memory accesses
 119     mpi_ConfigCs(PCMCIA_COMMON_BASE, pcmciaMem, EBI_SIZE_1M, (EBI_WORD_WIDE|EBI_ENABLE));
 120     // ChipSelect 5 controls PCMCIA Attribute accesses
 121     mpi_ConfigCs(PCMCIA_ATTRIBUTE_BASE, pcmciaAttr, EBI_SIZE_1M, (EBI_WORD_WIDE|EBI_ENABLE));
 122     // ChipSelect 6 controls PCMCIA I/O accesses
 123     mpi_ConfigCs(PCMCIA_IO_BASE, pcmciaIo, EBI_SIZE_64K, (EBI_WORD_WIDE|EBI_ENABLE));
 124
 125     MPI->pcmcia_cntl2 = ((PCMCIA_ATTR_ACTIVE << RW_ACTIVE_CNT_BIT) |
 126                          (PCMCIA_ATTR_INACTIVE << INACTIVE_CNT_BIT) |
 127                          (PCMCIA_ATTR_CE_SETUP << CE_SETUP_CNT_BIT) |
 128                          (PCMCIA_ATTR_CE_HOLD << CE_HOLD_CNT_BIT));
 129
 130     MPI->pcmcia_cntl2 |= (PCMCIA_HALFWORD_EN | PCMCIA_BYTESWAP_DIS);
 131 }
 132
 133 /*
 134  * cardtype_vcc_detect: PC Card's card detect and voltage sense connection
 135  *
 136  *   CD1#/      CD2#/     VS1#/     VS2#/    Card       Initial Vcc
 137  *  CCD1#      CCD2#     CVS1      CVS2      Type
 138  *
 139  *   GND        GND       open      open     16-bit     5 vdc
 140  *
 141  *   GND        GND       GND       open     16-bit     3.3 vdc
 142  *
 143  *   GND        GND       open      GND      16-bit     x.x vdc
 144  *
 145  *   GND        GND       GND       GND      16-bit     3.3 & x.x vdc
 146  *
 147  *====================================================================
 148  *
 149  *   CVS1       GND       CCD1#     open     CardBus    3.3 vdc
 150  *
 151  *   GND        CVS2      open      CCD2#    CardBus    x.x vdc
 152  *
 153  *   GND        CVS1      CCD2#     open     CardBus    y.y vdc
 154  *
 155  *   GND        CVS2      GND       CCD2#    CardBus    3.3 & x.x vdc
 156  *
 157  *   CVS2       GND       open      CCD1#    CardBus    x.x & y.y vdc
 158  *
 159  *   GND        CVS1      CCD2#     open     CardBus    3.3, x.x & y.y vdc
 160  *
 161  */
 162 static int cardtype_vcc_detect(void)
 163 {
 164     uint32 data32;
 165     int cardtype;
 166
 167     cardtype = MPI_CARDTYPE_NONE;
 168     MPI->pcmcia_cntl1 = (CARDBUS_ENABLE|PCMCIA_GPIO_ENABLE); // Turn on the output enables and drive
 169                                         // the CVS pins to 0.
 170     data32 = MPI->pcmcia_cntl1;
 171     switch (data32 & (CD2_IN|CD1_IN))  // Test CD1# and CD2#, see if card is plugged in.
 172     {
 173     case (CD2_IN|CD1_IN):  // No Card is in the slot.
 174         printk("MPI: No Card is in the PCMCIA slot\n");
 175         break;
 176
 177     case CD2_IN:  // Partial insertion, No CD2#.
 178         printk("MPI: Card in the PCMCIA slot partial insertion, no CD2 signal\n");
 179         break;
 180
 181     case CD1_IN:  // Partial insertion, No CD1#.
 182         printk("MPI: Card in the PCMCIA slot partial insertion, no CD1 signal\n");
 183         break;
 184
 185     case 0x00000000:
 186         MPI->pcmcia_cntl1 = (CARDBUS_ENABLE|PCMCIA_GPIO_ENABLE|VS2_OEN|VS1_OEN);
 187                                         // Turn off the CVS output enables and
 188                                         // float the CVS pins.
 189         mdelay(1);
 190         data32 = MPI->pcmcia_cntl1;
 191         // Read the Register.
 192         switch (data32 & (VS2_IN|VS1_IN))  // See what is on the CVS pins.
 193         {
 194         case 0x00000000: // CVS1 and CVS2 are tied to ground, only 1 option.
 195             printk("MPI: Detected 3.3 & x.x 16-bit PCMCIA card\n");
 196             cardtype = MPI_CARDTYPE_PCMCIA;
 197             break;
 198
 199         case VS1_IN: // CVS1 is open or tied to CCD1/CCD2 and CVS2 is tied to ground.
 200                          // 2 valid voltage options.
 201         switch (data32 & (CD2_IN|CD1_IN))  // Test the values of CCD1 and CCD2.
 202         {
 203             case (CD2_IN|CD1_IN):  // CCD1 and CCD2 are tied to 1 of the CVS pins.
 204                               // This is not a valid combination.
 205                 printk("MPI: Unknown card plugged into slot\n");
 206                 break;
 207
 208             case CD2_IN:  // CCD2 is tied to either CVS1 or CVS2.
 209                 MPI->pcmcia_cntl1 = (CARDBUS_ENABLE|PCMCIA_GPIO_ENABLE|VS2_OEN); // Drive CVS1 to a 0.
 210                 mdelay(1);
 211                 data32 = MPI->pcmcia_cntl1;
 212                 if (data32 & CD2_IN) { // CCD2 is tied to CVS2, not valid.
 213                     printk("MPI: Unknown card plugged into slot\n");
 214                 } else {                   // CCD2 is tied to CVS1.
 215                     printk("MPI: Detected 3.3, x.x and y.y Cardbus card\n");
 216                     cardtype = MPI_CARDTYPE_CARDBUS;
 217                 }
 218                 break;
 219
 220             case CD1_IN: // CCD1 is tied to either CVS1 or CVS2.
 221                              // This is not a valid combination.
 222                 printk("MPI: Unknown card plugged into slot\n");
 223                 break;
 224
 225             case 0x00000000:  // CCD1 and CCD2 are tied to ground.
 226                 printk("MPI: Detected x.x vdc 16-bit PCMCIA card\n");
 227                 cardtype = MPI_CARDTYPE_PCMCIA;
 228                 break;
 229             }
 230             break;
 231
 232         case VS2_IN: // CVS2 is open or tied to CCD1/CCD2 and CVS1 is tied to ground.
 233                          // 2 valid voltage options.
 234             switch (data32 & (CD2_IN|CD1_IN))  // Test the values of CCD1 and CCD2.
 235             {
 236             case (CD2_IN|CD1_IN):  // CCD1 and CCD2 are tied to 1 of the CVS pins.
 237                               // This is not a valid combination.
 238                 printk("MPI: Unknown card plugged into slot\n");
 239                 break;
 240
 241             case CD2_IN:  // CCD2 is tied to either CVS1 or CVS2.
 242                 MPI->pcmcia_cntl1 = (CARDBUS_ENABLE|PCMCIA_GPIO_ENABLE|VS1_OEN);// Drive CVS2 to a 0.
 243                 mdelay(1);
 244                 data32 = MPI->pcmcia_cntl1;
 245                 if (data32 & CD2_IN) { // CCD2 is tied to CVS1, not valid.
 246                     printk("MPI: Unknown card plugged into slot\n");
 247                 } else {// CCD2 is tied to CVS2.
 248                     printk("MPI: Detected 3.3 and x.x Cardbus card\n");
 249                     cardtype = MPI_CARDTYPE_CARDBUS;
 250                 }
 251                 break;
 252
 253             case CD1_IN: // CCD1 is tied to either CVS1 or CVS2.
 254                              // This is not a valid combination.
 255                 printk("MPI: Unknown card plugged into slot\n");
 256                 break;
 257
 258             case 0x00000000:  // CCD1 and CCD2 are tied to ground.
 259                 cardtype = MPI_CARDTYPE_PCMCIA;
 260                 printk("MPI: Detected 3.3 vdc 16-bit PCMCIA card\n");
 261                 break;
 262             }
 263             break;
 264
 265         case (VS2_IN|VS1_IN):  // CVS1 and CVS2 are open or tied to CCD1/CCD2.
 266                           // 5 valid voltage options.
 267
 268             switch (data32 & (CD2_IN|CD1_IN))  // Test the values of CCD1 and CCD2.
 269             {
 270             case (CD2_IN|CD1_IN):  // CCD1 and CCD2 are tied to 1 of the CVS pins.
 271                               // This is not a valid combination.
 272                 printk("MPI: Unknown card plugged into slot\n");
 273                 break;
 274
 275             case CD2_IN:  // CCD2 is tied to either CVS1 or CVS2.
 276                               // CCD1 is tied to ground.
 277                 MPI->pcmcia_cntl1 = (CARDBUS_ENABLE|PCMCIA_GPIO_ENABLE|VS1_OEN);// Drive CVS2 to a 0.
 278                 mdelay(1);
 279                 data32 = MPI->pcmcia_cntl1;
 280                 if (data32 & CD2_IN) {  // CCD2 is tied to CVS1.
 281                     printk("MPI: Detected y.y vdc Cardbus card\n");
 282                 } else {                    // CCD2 is tied to CVS2.
 283                     printk("MPI: Detected x.x vdc Cardbus card\n");
 284                 }
 285                 cardtype = MPI_CARDTYPE_CARDBUS;
 286                 break;
 287
 288             case CD1_IN: // CCD1 is tied to either CVS1 or CVS2.
 289                              // CCD2 is tied to ground.
 290
 291                 MPI->pcmcia_cntl1 = (CARDBUS_ENABLE|PCMCIA_GPIO_ENABLE|VS1_OEN);// Drive CVS2 to a 0.
 292                 mdelay(1);
 293                 data32 = MPI->pcmcia_cntl1;
 294                 if (data32 & CD1_IN) {// CCD1 is tied to CVS1.
 295                     printk("MPI: Detected 3.3 vdc Cardbus card\n");
 296                 } else {                    // CCD1 is tied to CVS2.
 297                     printk("MPI: Detected x.x and y.y Cardbus card\n");
 298                 }
 299                 cardtype = MPI_CARDTYPE_CARDBUS;
 300                 break;
 301
 302             case 0x00000000:  // CCD1 and CCD2 are tied to ground.
 303                 cardtype = MPI_CARDTYPE_PCMCIA;
 304                 printk("MPI: Detected 5 vdc 16-bit PCMCIA card\n");
 305                 break;
 306             }
 307             break;
 308
 309         default:
 310             printk("MPI: Unknown card plugged into slot\n");
 311             break;
 312
 313         }
 314     }
 315     return cardtype;
 316 }
 317
 318 /*
 319  * mpi_DetectPcCard: Detect the plugged in PC-Card
 320  * Return: < 0 => Unknown card detected
 321  *         0 => No card detected
 322  *         1 => 16-bit card detected
 323  *         2 => 32-bit CardBus card detected
 324  */
 325 static int mpi_DetectPcCard(void)
 326 {
 327     int cardtype;
 328
 329     cardtype = cardtype_vcc_detect();
 330     switch(cardtype) {
 331         case MPI_CARDTYPE_PCMCIA:
 332             MPI->pcmcia_cntl1 &= ~(CARDBUS_ENABLE|PCMCIA_ENABLE|PCMCIA_GPIO_ENABLE); // disable enable bits
 333             MPI->pcmcia_cntl1 |= (PCMCIA_ENABLE | PCMCIA_GPIO_ENABLE);
 334             mpi_InitPcmciaSpace();
 335             mpi_ResetPcCard(cardtype, FALSE);
 336             // Hold card in reset for 10ms
 337             mdelay(10);
 338             mpi_ResetPcCard(cardtype, TRUE);
 339             // Let card come out of reset
 340             mdelay(100);
 341             break;
 342         case MPI_CARDTYPE_CARDBUS:
 343             // 8 => CardBus Enable
 344             // 1 => PCI Slot Number
 345             // C => Float VS1 & VS2
 346             MPI->pcmcia_cntl1 = (MPI->pcmcia_cntl1 & 0xFFFF0000) |
 347                                 CARDBUS_ENABLE |
 348                                 (CARDBUS_SLOT << 8)|
 349                                 VS2_OEN |
 350                                 VS1_OEN | PCMCIA_GPIO_ENABLE;
 351             /* access to this memory window will be to/from CardBus */
 352             MPI->l2pmremap1 |= CARDBUS_MEM;
 353
 354             // Need to reset the Cardbus Card. There's no CardManager to do this,
 355             // and we need to be ready for PCI configuration.
 356             mpi_ResetPcCard(cardtype, FALSE);
 357             // Hold card in reset for 10ms
 358             mdelay(10);
 359             mpi_ResetPcCard(cardtype, TRUE);
 360             // Let card come out of reset
 361             mdelay(100);
 362             break;
 363         default:
 364             break;
 365     }
 366     return cardtype;
 367 }
 368
 369 static int mpi_init(void)
 370 {
 371     unsigned long data;
 372     unsigned int chipid;
 373     unsigned int chiprev;
 374     unsigned int sdramsize;
 375     unsigned int modesel;
 376
 377     chipid  = (PERF->RevID & 0xFFFF0000) >> 16;
 378     chiprev = (PERF->RevID & 0xFF);
 379     sdramsize = getMemorySize();
 380
 381 #if defined(CONFIG_BCM96348)
 382     /*
 383      * Init the pci interface
 384      */
 385     data = GPIO->GPIOMode; // GPIO mode register
 386     data |= GROUP2_PCI | GROUP1_MII_PCCARD; // PCI internal arbiter + Cardbus
 387     GPIO->GPIOMode = data; // PCI internal arbiter
 388 #endif
 389     /*
 390      * CardBus support is defaulted to Slot 0
 391      * because there is no external IDSEL for CardBus.  To disable
 392      * the CardBus and allow a standard PCI card in Slot 0
 393      * set the cbus_idsel field to 0x1f.
 394     */
 395     /*
 396     uData = MPI->pcmcia_cntl1;
 397     uData |= CARDBUS_IDSEL;
 398     MPI->pcmcia_cntl1 = uData;
 399     */
 400
 401     // UBUS to PCI address range
 402     // Memory Window 1. Used for devices in slot 0. Potentially can be CardBus
 403     MPI->l2pmrange1 = ~(BCM_PCI_MEM_SIZE_16MB-1);
 404     // UBUS to PCI Memory base address. This is akin to the ChipSelect base
 405     // register.
 406     MPI->l2pmbase1 = BCM_CB_MEM_BASE & BCM_PCI_ADDR_MASK;
 407     // UBUS to PCI Remap Address. Replaces the masked address bits in the
 408     // range register with this setting.
 409     // Also, enable direct I/O and direct Memory accesses
 410     MPI->l2pmremap1 = (BCM_PCI_MEM_BASE | MEM_WINDOW_EN);
 411
 412     // Memory Window 2. Used for devices in other slots
 413     MPI->l2pmrange2 = ~(BCM_PCI_MEM_SIZE_16MB-1);
 414     // UBUS to PCI Memory base address.
 415     MPI->l2pmbase2 = BCM_PCI_MEM_BASE & BCM_PCI_ADDR_MASK;
 416     // UBUS to PCI Remap Address
 417     MPI->l2pmremap2 = (BCM_PCI_MEM_BASE | MEM_WINDOW_EN);
 418
 419     // Setup PCI I/O Window range. Give 64K to PCI I/O
 420     MPI->l2piorange = ~(BCM_PCI_IO_SIZE_64KB-1);
 421     // UBUS to PCI I/O base address
 422     MPI->l2piobase = BCM_PCI_IO_BASE & BCM_PCI_ADDR_MASK;
 423     // UBUS to PCI I/O Window remap
 424     MPI->l2pioremap = (BCM_PCI_IO_BASE | MEM_WINDOW_EN);
 425
 426     // enable PCI related GPIO pins and data swap between system and PCI bus
 427     MPI->locbuscntrl = (EN_PCI_GPIO | DIR_U2P_NOSWAP);
 428
 429     /* Enable BusMaster and Memory access mode */
 430     data = mpi_GetLocalPciConfigReg(PCI_COMMAND);
 431     data |= (PCI_COMMAND_MEMORY | PCI_COMMAND_MASTER);
 432     mpi_SetLocalPciConfigReg(PCI_COMMAND, data);
 433
 434     /* Configure two 16 MByte PCI to System memory regions. */
 435     /* These memory regions are used when PCI device is a bus master */
 436     /* Accesses to the SDRAM from PCI bus will be "byte swapped" for this region */
 437     mpi_SetLocalPciConfigReg(PCI_BASE_ADDRESS_3, BCM_HOST_MEM_SPACE1);
 438
 439 #if defined(CONFIG_BCM96348)
 440     MPI->sp0remap = 0x0;
 441 #else
 442     MPI->sp0remap = MEM_WINDOW_EN;
 443 #endif
 444
 445     /* Accesses to the SDRAM from PCI bus will be "byte swapped" for this region */
 446     mpi_SetLocalPciConfigReg(PCI_BASE_ADDRESS_4, BCM_HOST_MEM_SPACE2);
 447
 448 #if defined(CONFIG_BCM96348)
 449     MPI->sp1remap = 0x0;
 450 #else
 451     MPI->sp1remap = MEM_WINDOW_EN;
 452 #endif
 453
 454     modesel = MPI->pcimodesel;
 455     modesel &= ~PCI_INT_BUS_RD_PREFETCH;
 456 #if defined(CONFIG_BCM96348)
 457     modesel |= 0x80;
 458 #else
 459     modesel |= 0x100;
 460 #endif
 461     MPI->pcimodesel = modesel;
 462
 463     if (!((chipid == 0x6348) && ((chiprev & 0xF0) == 0xa0))) {
 464         MPI->sp0range = ~(sdramsize-1);
 465         MPI->sp1range = ~(sdramsize-1);
 466     }
 467     /*
 468      * Change PCI Cfg Reg. offset 0x40 to PCI memory read retry count infinity
 469      * by set 0 in bit 8~15.  This resolve read Bcm4306 srom return 0xffff in
 470      * first read.
 471      */
 472     data = mpi_GetLocalPciConfigReg(BRCM_PCI_CONFIG_TIMER);
 473     data &= ~BRCM_PCI_CONFIG_TIMER_RETRY_MASK;
 474     data |= 0x00000080;
 475     mpi_SetLocalPciConfigReg(BRCM_PCI_CONFIG_TIMER, data);
 476
 477     /* enable pci interrupt */
 478     MPI->locintstat |= (EXT_PCI_INT << 16);
 479
 480 #if !defined(CONFIG_BCM_VDSL)
 481     mpi_DetectPcCard();
 482 #endif
 483
 484     ioport_resource.start = BCM_PCI_IO_BASE;
 485     ioport_resource.end = BCM_PCI_IO_BASE + BCM_PCI_IO_SIZE_64KB;
 486
 487     return 0;
 488 }
 489 #endif
 490
 491 static int __init bcm63xx_hw_init(void)
 492 {
 493 #if defined(CONFIG_BCM96338)
 494    /*
 495     *  atm and sdioh share the same reset bit
 496     *  issue reset needed such that sdioh can work properly after power cycle
 497     */
 498    PERF->BlockSoftReset &= ~BSR_SAR;
 499    mdelay(10);
 500    PERF->BlockSoftReset |= BSR_SAR;
 501    mdelay(10);
 502 #endif
 503
 504 #if defined(CONFIG_PCI)
 505     /* MPI initialization */
 506     mpi_init();
 507 #endif
 508
 509 #if defined(CONFIG_USB)
 510 #if defined(CONFIG_BCM96348)
 511     PERF->blkEnables |= USBH_CLK_EN;
 512     mdelay(100);
 513     *USBH = USBH_BYTE_SWAP;
 514 #else
 515     USBH->SwapControl = EHCI_ENDIAN_SWAP | OHCI_ENDIAN_SWAP;
 516     USBH->TestPortControl = 0x001c0020;
 517 #endif
 518 #endif
 519
 520     return 0;
 521 }
 522
 523 arch_initcall(bcm63xx_hw_init);
 524
 525 static int __init brcm63xx_setup(void)
 526 {
 527     extern int panic_timeout;
 528
 529     _machine_restart = brcm_machine_restart;
 530     _machine_halt = brcm_machine_halt;
 531     _machine_power_off = brcm_machine_halt;
 532
 533     board_timer_setup = brcm_timer_setup;
 534
 535     panic_timeout = 1;
 536
 537     return 0;
 538 }
 539
 540 early_initcall(brcm63xx_setup);
 541
 542 /***************************************************************************
 543  * C++ New and delete operator functions
 544  ***************************************************************************/
 545
 546 /* void *operator new(unsigned int sz) */
 547 void *_Znwj(unsigned int sz)
 548 {
 549     return( kmalloc(sz, GFP_KERNEL) );
 550 }
 551
 552 /* void *operator new[](unsigned int sz)*/
 553 void *_Znaj(unsigned int sz)
 554 {
 555     return( kmalloc(sz, GFP_KERNEL) );
 556 }
 557
 558 /* placement new operator */
 559 /* void *operator new (unsigned int size, void *ptr) */
 560 void *ZnwjPv(unsigned int size, void *ptr)
 561 {
 562     return ptr;
 563 }
 564
 565 /* void operator delete(void *m) */
 566 void _ZdlPv(void *m)
 567 {
 568     kfree(m);
 569 }
 570
 571 /* void operator delete[](void *m) */
 572 void _ZdaPv(void *m)
 573 {
 574     kfree(m);
 575 }
 576
 577 EXPORT_SYMBOL(_Znwj);
 578 EXPORT_SYMBOL(_Znaj);
 579 EXPORT_SYMBOL(ZnwjPv);
 580 EXPORT_SYMBOL(_ZdlPv);
 581 EXPORT_SYMBOL(_ZdaPv);
 582