package/broadcom-57xx/src/mm.h

   1 /******************************************************************************/
   2 /*                                                                            */
   3 /* Broadcom BCM5700 Linux Network Driver, Copyright (c) 2000 - 2004 Broadcom  */
   4 /* Corporation.                                                               */
   5 /* All rights reserved.                                                       */
   6 /*                                                                            */
   7 /* This program is free software; you can redistribute it and/or modify       */
   8 /* it under the terms of the GNU General Public License as published by       */
   9 /* the Free Software Foundation, located in the file LICENSE.                 */
  10 /*                                                                            */
  11 /******************************************************************************/
  12
  13 /* $Id: mm.h,v 1.6 2006/09/26 05:22:21 michael Exp $ */
  14
  15 #ifndef MM_H
  16 #define MM_H
  17
  18 #include <linux/config.h>
  19
  20 #if defined(CONFIG_SMP) && !defined(__SMP__)
  21 #define __SMP__
  22 #endif
  23
  24 #if defined(CONFIG_MODVERSIONS) && defined(MODULE) && !defined(MODVERSIONS)
  25 #ifndef BCM_SMALL_DRV
  26 #define MODVERSIONS
  27 #endif
  28 #endif
  29
  30 #ifndef B57UM
  31 #define __NO_VERSION__
  32 #endif
  33 #include <linux/version.h>
  34
  35 #ifdef MODULE
  36
  37 #if defined(MODVERSIONS) && (LINUX_VERSION_CODE < 0x020500)
  38 #ifndef BCM_SMALL_DRV
  39 #include <linux/modversions.h>
  40 #endif
  41 #endif
  42
  43 #if (LINUX_VERSION_CODE < 0x020605)
  44 #include <linux/module.h>
  45 #else
  46 #include <linux/moduleparam.h>
  47 #endif
  48
  49 #else
  50
  51 #define MOD_INC_USE_COUNT
  52 #define MOD_DEC_USE_COUNT
  53 #define SET_MODULE_OWNER(dev)
  54 #define MODULE_DEVICE_TABLE(pci, pci_tbl)
  55 #endif
  56
  57
  58 #include <linux/kernel.h>
  59 #include <linux/sched.h>
  60 #include <linux/string.h>
  61 #include <linux/timer.h>
  62 #include <linux/errno.h>
  63 #include <linux/ioport.h>
  64 #include <linux/slab.h>
  65 #include <linux/interrupt.h>
  66 #include <linux/pci.h>
  67 #include <linux/init.h>
  68 #include <linux/netdevice.h>
  69 #include <linux/etherdevice.h>
  70 #include <linux/skbuff.h>
  71 #include <linux/reboot.h>
  72 #include <asm/processor.h>              /* Processor type for cache alignment. */
  73 #include <asm/bitops.h>
  74 #include <asm/io.h>
  75 #include <asm/unaligned.h>
  76 #include <linux/delay.h>
  77 #include <asm/byteorder.h>
  78 #include <linux/time.h>
  79 #include <asm/uaccess.h>
  80 #if (LINUX_VERSION_CODE >= 0x020400)
  81 #if (LINUX_VERSION_CODE < 0x020500)
  82 #include <linux/wrapper.h>
  83 #endif
  84 #include <linux/ethtool.h>
  85 #endif
  86 #ifdef CONFIG_PROC_FS
  87 #include <linux/smp_lock.h>
  88 #include <linux/proc_fs.h>
  89 #define BCM_PROC_FS 1
  90 #endif
  91 #ifdef NETIF_F_HW_VLAN_TX
  92 #include <linux/if_vlan.h>
  93 #define BCM_VLAN 1
  94 #endif
  95 #ifdef NETIF_F_TSO
  96 #define BCM_TSO 1
  97 #define INCLUDE_TCP_SEG_SUPPORT 1
  98 #include <net/ip.h>
  99 #include <net/tcp.h>
 100 #include <net/checksum.h>
 101 #endif
 102
 103 #ifndef LINUX_KERNEL_VERSION
 104 #define LINUX_KERNEL_VERSION    0
 105 #endif
 106
 107 #ifndef MAX_SKB_FRAGS
 108 #define MAX_SKB_FRAGS   0
 109 #endif
 110
 111 #if (LINUX_VERSION_CODE >= 0x020400)
 112 #ifndef ETHTOOL_GEEPROM
 113
 114 #define ETHTOOL_GEEPROM         0x0000000b /* Get EEPROM data */
 115 #define ETHTOOL_SEEPROM         0x0000000c /* Set EEPROM data */
 116
 117 /* for passing EEPROM chunks */
 118 struct ethtool_eeprom {
 119         u32     cmd;
 120         u32     magic;
 121         u32     offset; /* in bytes */
 122         u32     len; /* in bytes */
 123         u8      data[0];
 124 };
 125 #define BCM_EEDUMP_LEN(info_p, size) *((u32 *) &((info_p)->reserved1[24]))=size
 126
 127 #else
 128
 129 #define BCM_EEDUMP_LEN(info_p, size) (info_p)->eedump_len=size
 130
 131 #endif
 132 #endif
 133
 134 #define BCM_INT_COAL 1
 135 #define BCM_NIC_SEND_BD 1
 136 #define BCM_ASF 1
 137 #define BCM_WOL 1
 138 #define BCM_TASKLET 1
 139
 140 #if HAVE_NETIF_RECEIVE_SKB
 141 #define BCM_NAPI_RXPOLL 1
 142 #undef BCM_TASKLET
 143 #endif
 144
 145 #if defined(CONFIG_PPC64)
 146 #define BCM_DISCONNECT_AT_CACHELINE 1
 147 #endif
 148
 149 #ifdef BCM_SMALL_DRV
 150 #undef BCM_PROC_FS
 151 #undef ETHTOOL_GEEPROM
 152 #undef ETHTOOL_SEEPROM
 153 #undef ETHTOOL_GREGS
 154 #undef ETHTOOL_GPAUSEPARAM
 155 #undef ETHTOOL_GRXCSUM
 156 #undef ETHTOOL_TEST
 157 #undef BCM_INT_COAL
 158 #undef BCM_NIC_SEND_BD
 159 #undef BCM_WOL
 160 #undef BCM_TASKLET
 161 #undef BCM_TSO
 162 #endif
 163
 164 #ifdef __BIG_ENDIAN
 165 #define BIG_ENDIAN_HOST 1
 166 #endif
 167
 168 #define MM_SWAP_LE32(x) cpu_to_le32(x)
 169 #define MM_SWAP_BE32(x) cpu_to_be32(x)
 170
 171 #if (LINUX_VERSION_CODE < 0x020327)
 172 #define __raw_readl readl
 173 #define __raw_writel writel
 174 #endif
 175
 176 #define MM_MEMWRITEL(ptr, val) __raw_writel(val, ptr)
 177 #define MM_MEMREADL(ptr) __raw_readl(ptr)
 178
 179 typedef atomic_t MM_ATOMIC_T;
 180
 181 #define MM_ATOMIC_SET(ptr, val) atomic_set(ptr, val)
 182 #define MM_ATOMIC_READ(ptr) atomic_read(ptr)
 183 #define MM_ATOMIC_INC(ptr) atomic_inc(ptr)
 184 #define MM_ATOMIC_ADD(ptr, val) atomic_add(val, ptr)
 185 #define MM_ATOMIC_DEC(ptr) atomic_dec(ptr)
 186 #define MM_ATOMIC_SUB(ptr, val) atomic_sub(val, ptr)
 187
 188
 189 #ifndef mmiowb
 190 #define mmiowb()
 191 #endif
 192
 193
 194 #define MM_MB() mb()
 195 #define MM_WMB() wmb()
 196 #define MM_RMB() rmb()
 197 #define MM_MMIOWB() mmiowb()
 198
 199 #include "lm.h"
 200 #include "queue.h"
 201 #include "tigon3.h"
 202
 203 #if DBG
 204 #define STATIC
 205 #else
 206 #define STATIC static
 207 #endif
 208
 209 extern int MM_Packet_Desc_Size;
 210
 211 #define MM_PACKET_DESC_SIZE MM_Packet_Desc_Size
 212
 213 DECLARE_QUEUE_TYPE(UM_RX_PACKET_Q, MAX_RX_PACKET_DESC_COUNT+1);
 214
 215 #define MAX_MEM 16
 216 #define MAX_MEM2 4
 217
 218 #if (LINUX_VERSION_CODE < 0x020211)
 219 typedef u32 dma_addr_t;
 220 #endif
 221
 222 #if (LINUX_VERSION_CODE < 0x02032a)
 223 #define pci_map_single(dev, address, size, dir) virt_to_bus(address)
 224 #define pci_unmap_single(dev, dma_addr, size, dir)
 225 #endif
 226
 227 #if MAX_SKB_FRAGS
 228 #if (LINUX_VERSION_CODE >= 0x02040d)
 229
 230 typedef dma_addr_t dmaaddr_high_t;
 231
 232 #else
 233
 234 #if defined(CONFIG_HIGHMEM) && defined(CONFIG_X86) && !defined(CONFIG_X86_64)
 235
 236 #if defined(CONFIG_HIGHMEM64G)
 237 typedef unsigned long long dmaaddr_high_t;
 238 #else
 239 typedef dma_addr_t dmaaddr_high_t;
 240 #endif
 241
 242 #ifndef pci_map_page
 243 #define pci_map_page bcm_pci_map_page
 244 #endif
 245
 246 static inline dmaaddr_high_t
 247 bcm_pci_map_page(struct pci_dev *dev, struct page *page,
 248                     int offset, size_t size, int dir)
 249 {
 250         dmaaddr_high_t phys;
 251
 252         phys = (page-mem_map) * (dmaaddr_high_t) PAGE_SIZE + offset;
 253
 254         return phys;
 255 }
 256
 257 #ifndef pci_unmap_page
 258 #define pci_unmap_page(dev, map, size, dir)
 259 #endif
 260
 261 #else /* #if defined(CONFIG_HIGHMEM) && defined(CONFIG_X86) && ! defined(CONFIG_X86_64)*/
 262
 263 typedef dma_addr_t dmaaddr_high_t;
 264
 265 /* Warning - This may not work for all architectures if HIGHMEM is defined */
 266
 267 #ifndef pci_map_page
 268 #define pci_map_page(dev, page, offset, size, dir) \
 269         pci_map_single(dev, page_address(page) + (offset), size, dir)
 270 #endif
 271 #ifndef pci_unmap_page
 272 #define pci_unmap_page(dev, map, size, dir) \
 273         pci_unmap_single(dev, map, size, dir)
 274 #endif
 275
 276 #endif /* #if defined(CONFIG_HIGHMEM) && defined(CONFIG_X86) && ! defined(CONFIG_X86_64)*/
 277
 278 #endif /* #if (LINUX_VERSION_CODE >= 0x02040d)*/
 279 #endif /* #if MAX_SKB_FRAGS*/
 280
 281 #if defined(CONFIG_X86) && !defined(CONFIG_X86_64)
 282 #define NO_PCI_UNMAP 1
 283 #endif
 284
 285 #if (LINUX_VERSION_CODE < 0x020412)
 286 #if !defined(NO_PCI_UNMAP)
 287 #define DECLARE_PCI_UNMAP_ADDR(ADDR_NAME) dma_addr_t ADDR_NAME;
 288 #define DECLARE_PCI_UNMAP_LEN(LEN_NAME) __u32 LEN_NAME;
 289
 290 #define pci_unmap_addr(PTR, ADDR_NAME)  \
 291         ((PTR)->ADDR_NAME)
 292
 293 #define pci_unmap_len(PTR, LEN_NAME)    \
 294         ((PTR)->LEN_NAME)
 295
 296 #define pci_unmap_addr_set(PTR, ADDR_NAME, VAL) \
 297         (((PTR)->ADDR_NAME) = (VAL))
 298
 299 #define pci_unmap_len_set(PTR, LEN_NAME, VAL)   \
 300         (((PTR)->LEN_NAME) = (VAL))
 301 #else
 302 #define DECLARE_PCI_UNMAP_ADDR(ADDR_NAME)
 303 #define DECLARE_PCI_UNMAP_LEN(ADDR_NAME)
 304
 305 #define pci_unmap_addr(PTR, ADDR_NAME)  0
 306 #define pci_unmap_len(PTR, LEN_NAME)    0
 307 #define pci_unmap_addr_set(PTR, ADDR_NAME, VAL) do { } while (0)
 308 #define pci_unmap_len_set(PTR, LEN_NAME, VAL) do { } while (0)
 309 #endif
 310 #endif
 311
 312 #if (LINUX_VERSION_CODE < 0x02030e)
 313 #define net_device device
 314 #define netif_carrier_on(dev)
 315 #define netif_carrier_off(dev)
 316 #endif
 317
 318 #if (LINUX_VERSION_CODE < 0x02032b)
 319 #define tasklet_struct                  tq_struct
 320 #endif
 321
 322 typedef struct _UM_DEVICE_BLOCK {
 323         LM_DEVICE_BLOCK lm_dev;
 324         struct net_device *dev;
 325         struct pci_dev *pdev;
 326         struct net_device *next_module;
 327         char *name;
 328 #ifdef BCM_PROC_FS
 329         struct proc_dir_entry *pfs_entry;
 330         char pfs_name[32];
 331 #endif
 332         void *mem_list[MAX_MEM];
 333         dma_addr_t dma_list[MAX_MEM];
 334         int mem_size_list[MAX_MEM];
 335         int mem_list_num;
 336
 337         int index;
 338         int opened;
 339         int suspended;
 340         int using_dac;          /* dual address cycle */
 341         int delayed_link_ind; /* Delay link status during initial load */
 342         int adapter_just_inited; /* the first few seconds after init. */
 343         int timer_interval;
 344         int statstimer_interval;
 345         int adaptive_expiry;
 346         int crc_counter_expiry;
 347         int poll_tbi_interval;
 348         int poll_tbi_expiry;
 349         int asf_heartbeat;
 350         int tx_full;
 351         int tx_queued;
 352         int line_speed;         /* in Mbps, 0 if link is down */
 353         UM_RX_PACKET_Q rx_out_of_buf_q;
 354         int rx_out_of_buf;
 355         int rx_buf_repl_thresh;
 356         int rx_buf_repl_panic_thresh;
 357         int rx_buf_repl_isr_limit;
 358         int rx_buf_align;
 359         struct timer_list timer;
 360         struct timer_list statstimer;
 361         int do_global_lock;
 362         spinlock_t global_lock;
 363         spinlock_t undi_lock;
 364         spinlock_t phy_lock;
 365         unsigned long undi_flags;
 366         volatile unsigned long interrupt;
 367         atomic_t intr_sem;
 368         int tasklet_pending;
 369         volatile unsigned long tasklet_busy;
 370         struct tasklet_struct tasklet;
 371         struct net_device_stats stats;
 372         int intr_test;
 373         int intr_test_result;
 374 #ifdef NETIF_F_HW_VLAN_TX
 375         struct vlan_group *vlgrp;
 376 #endif
 377         int vlan_tag_mode;      /* Setting to allow ASF to work properly with */
 378                                 /* VLANs                                      */
 379         #define VLAN_TAG_MODE_AUTO_STRIP              0
 380         #define VLAN_TAG_MODE_NORMAL_STRIP            1
 381         #define VLAN_TAG_MODE_FORCED_STRIP            2
 382
 383         /* Auto mode - VLAN TAGs are always stripped if ASF is enabled,   */
 384         /*             If ASF is not enabled, it will be in normal mode.  */
 385         /* Normal mode - VLAN TAGs are stripped when VLANs are registered */
 386         /* Forced mode - VLAN TAGs are always stripped.                   */
 387
 388         int adaptive_coalesce;
 389         uint rx_last_cnt;
 390         uint tx_last_cnt;
 391         uint rx_curr_coalesce_frames;
 392         uint rx_curr_coalesce_frames_intr;
 393         uint rx_curr_coalesce_ticks;
 394         uint tx_curr_coalesce_frames;
 395 #if TIGON3_DEBUG
 396         unsigned long tx_zc_count;
 397         unsigned long tx_chksum_count;
 398         unsigned long tx_himem_count;
 399         unsigned long rx_good_chksum_count;
 400 #endif
 401         unsigned long rx_bad_chksum_count;
 402 #ifdef BCM_TSO
 403         unsigned long tso_pkt_count;
 404 #endif
 405         unsigned long rx_misc_errors;
 406         uint64_t phy_crc_count;
 407         unsigned int spurious_int;
 408
 409         void            *sbh;
 410         unsigned long   boardflags;
 411         void            *robo;
 412         int             qos;
 413 } UM_DEVICE_BLOCK, *PUM_DEVICE_BLOCK;
 414
 415 typedef struct _UM_PACKET {
 416         LM_PACKET lm_packet;
 417         struct sk_buff *skbuff;
 418 #if MAX_SKB_FRAGS
 419         DECLARE_PCI_UNMAP_ADDR(map[MAX_SKB_FRAGS + 1])
 420         DECLARE_PCI_UNMAP_LEN(map_len[MAX_SKB_FRAGS + 1])
 421 #else
 422         DECLARE_PCI_UNMAP_ADDR(map[1])
 423         DECLARE_PCI_UNMAP_LEN(map_len[1])
 424 #endif
 425 } UM_PACKET, *PUM_PACKET;
 426
 427 static inline void MM_SetAddr(LM_PHYSICAL_ADDRESS *paddr, dma_addr_t addr)
 428 {
 429 #if BITS_PER_LONG == 64
 430         paddr->High = ((unsigned long) addr) >> 32;
 431         paddr->Low = ((unsigned long) addr) & 0xffffffff;
 432 #else
 433         paddr->High = 0;
 434         paddr->Low = (unsigned long) addr;
 435 #endif
 436 }
 437
 438 static inline void MM_SetT3Addr(T3_64BIT_HOST_ADDR *paddr, dma_addr_t addr)
 439 {
 440 #if BITS_PER_LONG == 64
 441         paddr->High = ((unsigned long) addr) >> 32;
 442         paddr->Low = ((unsigned long) addr) & 0xffffffff;
 443 #else
 444         paddr->High = 0;
 445         paddr->Low = (unsigned long) addr;
 446 #endif
 447 }
 448
 449 #if MAX_SKB_FRAGS
 450 static inline void MM_SetT3AddrHigh(T3_64BIT_HOST_ADDR *paddr,
 451         dmaaddr_high_t addr)
 452 {
 453 #if defined(CONFIG_HIGHMEM64G) && defined(CONFIG_X86) && !defined(CONFIG_X86_64)
 454         paddr->High = (unsigned long) (addr >> 32);
 455         paddr->Low = (unsigned long) (addr & 0xffffffff);
 456 #else
 457         MM_SetT3Addr(paddr, (dma_addr_t) addr);
 458 #endif
 459 }
 460 #endif
 461
 462 static inline void MM_MapRxDma(PLM_DEVICE_BLOCK pDevice,
 463         struct _LM_PACKET *pPacket,
 464         T3_64BIT_HOST_ADDR *paddr)
 465 {
 466         dma_addr_t map;
 467         struct sk_buff *skb = ((struct _UM_PACKET *) pPacket)->skbuff;
 468
 469         map = pci_map_single(((struct _UM_DEVICE_BLOCK *)pDevice)->pdev,
 470                         skb->tail,
 471                         pPacket->u.Rx.RxBufferSize,
 472                         PCI_DMA_FROMDEVICE);
 473         pci_unmap_addr_set(((struct _UM_PACKET *) pPacket), map[0], map);
 474         MM_SetT3Addr(paddr, map);
 475 }
 476
 477 static inline void MM_MapTxDma(PLM_DEVICE_BLOCK pDevice,
 478         struct _LM_PACKET *pPacket,
 479         T3_64BIT_HOST_ADDR *paddr,
 480         LM_UINT32 *len,
 481         int frag)
 482 {
 483         dma_addr_t map;
 484         struct sk_buff *skb = ((struct _UM_PACKET *) pPacket)->skbuff;
 485         unsigned int length;
 486
 487         if (frag == 0) {
 488 #if MAX_SKB_FRAGS
 489                 if (skb_shinfo(skb)->nr_frags)
 490                         length = skb->len - skb->data_len;
 491                 else
 492 #endif
 493                         length = skb->len;
 494                 map = pci_map_single(((struct _UM_DEVICE_BLOCK *)pDevice)->pdev,
 495                         skb->data, length, PCI_DMA_TODEVICE);
 496                 MM_SetT3Addr(paddr, map);
 497                 pci_unmap_addr_set(((struct _UM_PACKET *)pPacket), map[0], map);
 498                 pci_unmap_len_set(((struct _UM_PACKET *) pPacket), map_len[0],
 499                         length);
 500                 *len = length;
 501         }
 502 #if MAX_SKB_FRAGS
 503         else {
 504                 skb_frag_t *sk_frag;
 505                 dmaaddr_high_t hi_map;
 506
 507                 sk_frag = &skb_shinfo(skb)->frags[frag - 1];
 508
 509                 hi_map = pci_map_page(
 510                                 ((struct _UM_DEVICE_BLOCK *)pDevice)->pdev,
 511                                 sk_frag->page,
 512                                 sk_frag->page_offset,
 513                                 sk_frag->size, PCI_DMA_TODEVICE);
 514
 515                 MM_SetT3AddrHigh(paddr, hi_map);
 516                 pci_unmap_addr_set(((struct _UM_PACKET *) pPacket), map[frag],
 517                         hi_map);
 518                 pci_unmap_len_set(((struct _UM_PACKET *) pPacket),
 519                         map_len[frag], sk_frag->size);
 520                 *len = sk_frag->size;
 521         }
 522 #endif
 523 }
 524
 525 #define BCM5700_PHY_LOCK(pUmDevice, flags) {                            \
 526         spinlock_t *lock;                                               \
 527         if ((pUmDevice)->do_global_lock) {                              \
 528                 lock = &(pUmDevice)->global_lock;                       \
 529         }                                                               \
 530         else {                                                          \
 531                 lock = &(pUmDevice)->phy_lock;                          \
 532         }                                                               \
 533         spin_lock_irqsave(lock, flags);                                 \
 534 }
 535
 536 #define BCM5700_PHY_UNLOCK(pUmDevice, flags) {                          \
 537         spinlock_t *lock;                                               \
 538         if ((pUmDevice)->do_global_lock) {                              \
 539                 lock = &(pUmDevice)->global_lock;                       \
 540         }                                                               \
 541         else {                                                          \
 542                 lock = &(pUmDevice)->phy_lock;                          \
 543         }                                                               \
 544         spin_unlock_irqrestore(lock, flags);                            \
 545 }
 546
 547
 548 #define MM_ACQUIRE_UNDI_LOCK(_pDevice) \
 549         if (!(((PUM_DEVICE_BLOCK)(_pDevice))->do_global_lock)) {        \
 550                 unsigned long flags;                                    \
 551                 spin_lock_irqsave(&((PUM_DEVICE_BLOCK)(_pDevice))->undi_lock, flags);   \
 552                 ((PUM_DEVICE_BLOCK)(_pDevice))->undi_flags = flags; \
 553         }
 554
 555 #define MM_RELEASE_UNDI_LOCK(_pDevice) \
 556         if (!(((PUM_DEVICE_BLOCK)(_pDevice))->do_global_lock)) {        \
 557                 unsigned long flags = ((PUM_DEVICE_BLOCK) (_pDevice))->undi_flags; \
 558                 spin_unlock_irqrestore(&((PUM_DEVICE_BLOCK)(_pDevice))->undi_lock, flags); \
 559         }
 560
 561 #define MM_ACQUIRE_PHY_LOCK_IN_IRQ(_pDevice) \
 562         if (!(((PUM_DEVICE_BLOCK)(_pDevice))->do_global_lock)) {        \
 563                 spin_lock(&((PUM_DEVICE_BLOCK)(_pDevice))->phy_lock);   \
 564         }
 565
 566 #define MM_RELEASE_PHY_LOCK_IN_IRQ(_pDevice) \
 567         if (!(((PUM_DEVICE_BLOCK)(_pDevice))->do_global_lock)) {        \
 568                 spin_unlock(&((PUM_DEVICE_BLOCK)(_pDevice))->phy_lock); \
 569         }
 570
 571 #define MM_UINT_PTR(_ptr)   ((unsigned long) (_ptr))
 572
 573 #define MM_GETSTATS64(_Ctr) \
 574         (uint64_t) (_Ctr).Low + ((uint64_t) (_Ctr).High << 32)
 575
 576 #define MM_GETSTATS32(_Ctr) \
 577         (uint32_t) (_Ctr).Low
 578
 579 #if BITS_PER_LONG == 64
 580 #define MM_GETSTATS(_Ctr) (unsigned long) MM_GETSTATS64(_Ctr)
 581 #else
 582 #define MM_GETSTATS(_Ctr) (unsigned long) MM_GETSTATS32(_Ctr)
 583 #endif
 584
 585 #if (LINUX_VERSION_CODE >= 0x020600)
 586 #define mm_copy_to_user( to, from, size ) \
 587         (in_atomic() ? (memcpy((to),(from),(size)), 0) : copy_to_user((to),(from),(size)))
 588 #define mm_copy_from_user( to, from, size ) \
 589         (in_atomic() ? (memcpy((to),(from),(size)), 0) : copy_from_user((to),(from),(size)))
 590 #else
 591 #define mm_copy_to_user( to, from, size )       \
 592                 copy_to_user((to),(from),(size) )
 593 #define mm_copy_from_user( to, from, size )     \
 594                 copy_from_user((to),(from),(size))
 595 #endif
 596
 597 #ifndef printf
 598 #define printf(fmt, args...) printk(KERN_WARNING fmt, ##args)
 599 #endif
 600
 601 #define DbgPrint(fmt, arg...) printk(KERN_DEBUG fmt, ##arg)
 602 #if defined(CONFIG_X86)
 603 #define DbgBreakPoint() __asm__("int $129")
 604 #else
 605 #define DbgBreakPoint()
 606 #endif
 607 #define MM_Wait(time) udelay(time)
 608
 609 #endif