drivers/ieee1394/ieee1394_types.h

   1
   2 #ifndef _IEEE1394_TYPES_H
   3 #define _IEEE1394_TYPES_H
   4
   5 #include <linux/kernel.h>
   6 #include <linux/types.h>
   7 #include <linux/version.h>
   8 #include <linux/list.h>
   9 #include <asm/byteorder.h>
  10
  11
  12 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,3,0)
  13
  14 #include <linux/wait.h>
  15 #define DECLARE_WAITQUEUE(name, task) struct wait_queue name = { task, NULL }
  16
  17 typedef struct wait_queue *wait_queue_head_t;
  18 typedef struct wait_queue wait_queue_t;
  19
  20 inline static void init_waitqueue_head(wait_queue_head_t *wh)
  21 {
  22         *wh = NULL;
  23 }
  24
  25 inline static void init_waitqueue_entry(wait_queue_t *wq, struct task_struct *p)
  26 {
  27         wq->task = p;
  28         wq->next = NULL;
  29 }
  30
  31 static __inline__ void list_add_tail(struct list_head *new, struct list_head *head)
  32 {
  33         __list_add(new, head->prev, head);
  34 }
  35
  36 #define __constant_cpu_to_be32(x) __constant_htonl((x))
  37
  38 #define set_current_state(state_value) \
  39  do { current->state = (state_value); } while (0)
  40
  41
  42 #include <asm/page.h>
  43 /* Pure 2^n version of get_order */
  44 extern __inline__ int get_order(unsigned long size)
  45 {
  46         int order;
  47         size = (size-1) >> (PAGE_SHIFT-1);
  48         order = -1;
  49         do {
  50                 size >>= 1;
  51                 order++;
  52         } while (size);
  53         return order;
  54 }
  55
  56
  57 #include <linux/pci.h>
  58 inline static int pci_enable_device(struct pci_dev *dev)
  59 {
  60         u16 cmd;
  61         pci_read_config_word(dev, PCI_COMMAND, &cmd);
  62         pci_write_config_word(dev, PCI_COMMAND, cmd | PCI_COMMAND_MEMORY);
  63         return 0;
  64 }
  65
  66 #define PCI_DMA_BIDIRECTIONAL   0
  67 #define PCI_DMA_TODEVICE        1
  68 #define PCI_DMA_FROMDEVICE      2
  69 #define PCI_DMA_NONE            3
  70 #define PCI_ROM_RESOURCE 6
  71 #define pci_resource_start(dev, bar) ((bar) == PCI_ROM_RESOURCE     \
  72                                       ? (dev)->rom_address          \
  73                                       : (dev)->base_address[(bar)])
  74 #define BUG() *(int *)0 = 0
  75
  76 #include <asm/io.h>
  77 typedef u32 dma_addr_t;
  78
  79 extern inline int pci_dma_supported(struct pci_dev *hwdev, dma_addr_t mask)
  80 {
  81         return 1;
  82 }
  83
  84 extern inline void *pci_alloc_consistent(struct pci_dev *hwdev, size_t size,
  85                                          dma_addr_t *dma_handle)
  86 {
  87         void *ret;
  88         ret = (void *)__get_free_pages(GFP_ATOMIC, get_order(size));
  89         if (ret) {
  90                 memset(ret, 0, size);
  91                 *dma_handle = virt_to_bus(ret);
  92         }
  93         return ret;
  94 }
  95
  96 extern inline void pci_free_consistent(struct pci_dev *hwdev, size_t size,
  97                                        void *vaddr, dma_addr_t dma_handle)
  98 {
  99         free_pages((unsigned long)vaddr, get_order(size));
 100 }
 101
 102 extern inline dma_addr_t pci_map_single(struct pci_dev *hwdev, void *ptr,
 103                                         size_t size, int direction)
 104 {
 105         if (direction == PCI_DMA_NONE)
 106                 BUG();
 107         return virt_to_bus(ptr);
 108 }
 109
 110 extern inline void pci_unmap_single(struct pci_dev *hwdev, dma_addr_t dma_addr,
 111                                     size_t size, int direction)
 112 {
 113         if (direction == PCI_DMA_NONE)
 114                 BUG();
 115 }
 116
 117 struct scatterlist {};
 118 extern inline int pci_map_sg(struct pci_dev *hwdev, struct scatterlist *sg,
 119                              int nents, int direction)
 120 {
 121         if (direction == PCI_DMA_NONE)
 122                 BUG();
 123         return nents;
 124 }
 125
 126 extern inline void pci_unmap_sg(struct pci_dev *hwdev, struct scatterlist *sg,
 127                                 int nents, int direction)
 128 {
 129         if (direction == PCI_DMA_NONE)
 130                 BUG();
 131 }
 132
 133 extern inline void pci_dma_sync_single(struct pci_dev *hwdev,
 134                                        dma_addr_t dma_handle,
 135                                        size_t size, int direction)
 136 {
 137         if (direction == PCI_DMA_NONE)
 138                 BUG();
 139 }
 140
 141 extern inline void pci_dma_sync_sg(struct pci_dev *hwdev,
 142                                    struct scatterlist *sg,
 143                                    int nelems, int direction)
 144 {
 145         if (direction == PCI_DMA_NONE)
 146                 BUG();
 147 }
 148
 149
 150 #ifndef _LINUX_DEVFS_FS_KERNEL_H
 151 typedef struct devfs_entry * devfs_handle_t;
 152 #define DEVFS_FL_NONE 0
 153
 154 static inline devfs_handle_t devfs_register (devfs_handle_t dir,
 155                                              const char *name,
 156                                              unsigned int flags,
 157                                              unsigned int major,
 158                                              unsigned int minor,
 159                                              umode_t mode,
 160                                              void *ops, void *info)
 161 {
 162     return NULL;
 163 }
 164 static inline void devfs_unregister (devfs_handle_t de)
 165 {
 166     return;
 167 }
 168 static inline int devfs_register_chrdev (unsigned int major, const char *name,
 169                                          struct file_operations *fops)
 170 {
 171     return register_chrdev (major, name, fops);
 172 }
 173 static inline int devfs_unregister_chrdev (unsigned int major,const char *name)
 174 {
 175     return unregister_chrdev (major, name);
 176 }
 177 #endif /* _LINUX_DEVFS_FS_KERNEL_H */
 178
 179
 180 #define V22_COMPAT_MOD_INC_USE_COUNT MOD_INC_USE_COUNT
 181 #define V22_COMPAT_MOD_DEC_USE_COUNT MOD_DEC_USE_COUNT
 182 #define OWNER_THIS_MODULE
 183
 184 #else /* Linux version < 2.3 */
 185
 186 #define V22_COMPAT_MOD_INC_USE_COUNT do {} while (0)
 187 #define V22_COMPAT_MOD_DEC_USE_COUNT do {} while (0)
 188 #define OWNER_THIS_MODULE owner: THIS_MODULE,
 189
 190 #endif /* Linux version < 2.3 */
 191
 192
 193
 194 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,3,18)
 195 #include <asm/spinlock.h>
 196 #else
 197 #include <linux/spinlock.h>
 198 #endif
 199
 200 #ifndef MIN
 201 #define MIN(a,b) ((a) < (b) ? (a) : (b))
 202 #endif
 203
 204 #ifndef MAX
 205 #define MAX(a,b) ((a) > (b) ? (a) : (b))
 206 #endif
 207
 208 typedef u32 quadlet_t;
 209 typedef u64 octlet_t;
 210 typedef u16 nodeid_t;
 211
 212 #define BUS_MASK  0xffc0
 213 #define NODE_MASK 0x003f
 214 #define LOCAL_BUS 0xffc0
 215 #define ALL_NODES 0x003f
 216
 217 #define HPSB_PRINT(level, fmt, args...) printk(level "ieee1394: " fmt "\n" , ## args)
 218
 219 #define HPSB_DEBUG(fmt, args...) HPSB_PRINT(KERN_DEBUG, fmt , ## args)
 220 #define HPSB_INFO(fmt, args...) HPSB_PRINT(KERN_INFO, fmt , ## args)
 221 #define HPSB_NOTICE(fmt, args...) HPSB_PRINT(KERN_NOTICE, fmt , ## args)
 222 #define HPSB_WARN(fmt, args...) HPSB_PRINT(KERN_WARNING, fmt , ## args)
 223 #define HPSB_ERR(fmt, args...) HPSB_PRINT(KERN_ERR, fmt , ## args)
 224
 225 #define HPSB_PANIC(fmt, args...) panic("ieee1394: " fmt "\n" , ## args)
 226
 227 #define HPSB_TRACE() HPSB_PRINT(KERN_INFO, "TRACE - %s, %s(), line %d", __FILE__, __FUNCTION__, __LINE__)
 228
 229
 230 #ifdef __BIG_ENDIAN
 231
 232 static __inline__ void *memcpy_le32(u32 *dest, const u32 *src, size_t count)
 233 {
 234         void *tmp = dest;
 235
 236         count /= 4;
 237
 238         while (count--) {
 239                 *dest++ = swab32p(src++);
 240         }
 241
 242         return tmp;
 243 }
 244
 245 #else
 246
 247 static __inline__ void *memcpy_le32(u32 *dest, const u32 *src, size_t count)
 248 {
 249         return memcpy(dest, src, count);
 250 }
 251
 252 #endif /* __BIG_ENDIAN */
 253
 254 #endif /* _IEEE1394_TYPES_H */