Logo Search packages:      
Sourcecode: alsa-driver version File versions

compat_22.h

/*
 *  Missing Linux 2.2.x features
 */
#if LINUX_VERSION_CODE < KERNEL_VERSION(2,3,0)

#include <linux/list.h>
#include <linux/pagemap.h>
#include <linux/ioport.h>
#include <asm/byteorder.h>

#ifndef likely
#if __GNUC__ == 2 && __GNUC_MINOR__ < 96
#define __builtin_expect(x, expected_value) (x)
#endif
#define likely(x) __builtin_expect((x),1)
#define unlikely(x)     __builtin_expect((x),0)
#endif

#if defined(SND_NEED_USB_WRAPPER) && (defined(CONFIG_USB) || defined(CONFIG_USB_MODULE))
/* include linux/usb.h at first since it defines another compatibility layers, which
 * conflicts with ours...
 */
#define device compat_net_device
#include <linux/usb.h>
#undef device
#undef IORESOURCE_IO
#endif

#ifndef CONFIG_HAVE_DMA_ADDR_T
typedef unsigned long dma_addr_t;
#endif

/*
 */

#ifndef CONFIG_HAVE_MUTEX_MACROS
#define init_MUTEX(x) *(x) = MUTEX
#define DECLARE_MUTEX(x) struct semaphore x = MUTEX
typedef struct wait_queue wait_queue_t;
typedef struct wait_queue * wait_queue_head_t;
#define init_waitqueue_head(x) *(x) = NULL
#define init_waitqueue_entry(q,p) ((q)->task = (p))
#define set_current_state(xstate) do { current->state = xstate; } while (0)

/*
 * Insert a new entry before the specified head..
 */
static __inline__ void list_add_tail(struct list_head *new, struct list_head *head)
{
      __list_add(new, head->prev, head);
}

#endif /* !CONFIG_HAVE_MUTEX_MACROS */

/**
 * list_del_init - deletes entry from list and reinitialize it.
 * @entry: the element to delete from the list.
 */
static __inline__ void list_del_init(struct list_head *entry)
{
      __list_del(entry->prev, entry->next);
      INIT_LIST_HEAD(entry); 
}

/**
 * list_move_tail - delete from one list and add as another's tail
 * @list: the entry to move
 * @head: the head that will follow our entry
 */
static inline void list_move_tail(struct list_head *list,
                          struct list_head *head)
{
      __list_del(list->prev, list->next);
      list_add_tail(list, head);
}

/**
 * list_for_each_safe   -     iterate over a list safe against removal of list entry
 * @pos:    the &struct list_head to use as a loop counter.
 * @n:            another &struct list_head to use as temporary storage
 * @head:   the head for your list.
 */
#define list_for_each_safe(pos, n, head) \
      for (pos = (head)->next, n = pos->next; pos != (head); \
            pos = n, n = pos->next)

/**
 * list_for_each_entry  -     iterate over list of given type
 * @pos:    the type * to use as a loop counter.
 * @head:   the head for your list.
 * @member: the name of the list_struct within the struct.
 */
#define list_for_each_entry(pos, head, member)                    \
      for (pos = list_entry((head)->next, typeof(*pos), member);  \
           &pos->member != (head);                          \
           pos = list_entry(pos->member.next, typeof(*pos), member))

/**
 * list_for_each_entry_safe - iterate over list of given type safe against removal of list entry
 * @pos:    the type * to use as a loop counter.
 * @n:            another type * to use as temporary storage
 * @head:   the head for your list.
 * @member: the name of the list_struct within the struct.
 */
#define list_for_each_entry_safe(pos, n, head, member)                  \
      for (pos = list_entry((head)->next, typeof(*pos), member),  \
            n = list_entry(pos->member.next, typeof(*pos), member);     \
           &pos->member != (head);                          \
           pos = n, n = list_entry(n->member.next, typeof(*n), member))

/* rw_semaphore - replaced with mutex */
#define rw_semaphore semaphore
#define init_rwsem(x) init_MUTEX(x)
#define DECLARE_RWSEM(x) DECLARE_MUTEX(x)
#define down_read(x) down(x)
#define down_write(x) down(x)
#define up_read(x) up(x)
#define up_write(x) up(x)

#define virt_to_page(x) (&mem_map[MAP_NR(x)])
#define get_page(p) atomic_inc(&(p)->count)
#define SetPageReserved(p) set_bit(PG_reserved, &(p)->flags)
#define ClearPageReserved(p) clear_bit(PG_reserved, &(p)->flags)
#define vm_private_data vm_pte
#define NOPAGE_OOM 0
#define NOPAGE_SIGBUS (-1)
#define fops_get(x) (x)
#define fops_put(x) do { ; } while (0)

#define local_irq_save(flags) \
      do { __save_flags(flags); __cli(); } while (0)
#define local_irq_restore(flags) \
      do { __restore_flags(flags); } while (0)
#define local_irq_enable() __sti()

/* Some distributions use modified kill_fasync */
#ifdef CONFIG_OLD_KILL_FASYNC
#include <linux/fs.h>
static inline void snd_compat_kill_fasync(struct fasync_struct **fp, int sig, int band)
{
      kill_fasync(*(fp), sig);
}
#undef kill_fasync
#define kill_fasync(fp, sig, band) snd_compat_kill_fasync(fp, sig, band)
#endif

/* this is identical with tq_struct but the "routine" field is renamed to "func" */
struct tasklet_struct {
      struct tasklet_struct *next;  /* linked list of active bh's */
      unsigned long sync;           /* must be initialized to zero */
      void (*func)(void *);         /* function to call */
      void *data;             /* argument to function */
};

#define tasklet_schedule(t)   do { \
      queue_task((struct tq_struct *)(t), &tq_immediate);\
      mark_bh(IMMEDIATE_BH); \
} while (0)

#define tasklet_hi_schedule(t)      tasklet_schedule(t)

#define tasklet_init(t,f,d)   do { \
      (t)->next = NULL; \
      (t)->sync = 0; \
      (t)->func = (void (*)(void *))(f); \
      (t)->data = (void *)(d); \
} while (0)

#define tasklet_unlock_wait(t)      while (test_bit(0, &(t)->sync)) { }
#define tasklet_kill(t)       tasklet_unlock_wait(t) /* FIXME: world is not perfect... */

#define del_timer_sync(t) del_timer(t) /* FIXME: not quite correct on SMP */

#define rwlock_init(x) do { *(x) = RW_LOCK_UNLOCKED; } while(0)

#ifndef fastcall
#define fastcall
#endif

#ifndef __init
#define __init
#endif
#ifndef __initdata
#define __initdata
#endif
#ifndef __exit
#define __exit
#endif
#ifndef __exitdata
#define __exitdata
#endif
#ifndef __devinit
#define __devinit
#endif
#ifndef __devinitdata
#define __devinitdata
#endif
#ifndef __devexit
#define __devexit
#endif
#ifndef __devexitdata
#define __devexitdata
#endif

#ifdef MODULE
  #ifndef module_init
  #define module_init(x)      int init_module(void) { return x(); }
  #define module_exit(x)      void cleanup_module(void) { x(); }
  #endif
  #ifndef THIS_MODULE
  #define THIS_MODULE         (&__this_module)
  #endif
  int try_inc_mod_count(struct module *mod);
#else
  #define module_init(x)
  #define module_exit(x)
  #define THIS_MODULE NULL
  #define try_inc_mod_count(x) 1
#endif

#define MODULE_GENERIC_TABLE(gtype,name)        \
static const unsigned long __module_##gtype##_size \
  __attribute__ ((unused)) = sizeof(struct gtype##_id); \
static const struct gtype##_id * __module_##gtype##_table \
  __attribute__ ((unused)) = name
#define MODULE_DEVICE_TABLE(type,name)          \
  MODULE_GENERIC_TABLE(type##_device,name)

/**
 * list_for_each        -       iterate over a list
 * @pos:        the &struct list_head to use as a loop counter.
 * @head:       the head for your list.
 */
#define list_for_each(pos, head) \
      for (pos = (head)->next; pos != (head); pos = pos->next)

/**
 * list_for_each_prev   -     iterate over a list backwards
 * @pos:    the &struct list_head to use as a loop counter.
 * @head:   the head for your list.
 */
#define list_for_each_prev(pos, head) \
      for (pos = (head)->prev; pos != (head); pos = pos->prev)

#ifndef IORESOURCE_IO
struct resource {
      const char *name;
      unsigned long start, end;
      unsigned long flags;
      struct resource *parent, *sibling, *child;
};

#define IORESOURCE_IO           0x00000100      /* Resource type */
#define IORESOURCE_MEM        0x00000200
#define IORESOURCE_CACHEABLE  0x00004000
#endif

static inline void snd_wrapper_request_region(unsigned long from, unsigned long extent, const char *name)
{
      request_region(from, extent, name);
}

#undef request_region
#define request_region(start,size,name) snd_compat_request_region(start,size,name,0)
#define request_mem_region(start,size,name) snd_compat_request_region(start,size,name,1)
#define release_resource(res) snd_compat_release_resource(res)

struct resource *snd_compat_request_region(unsigned long start, unsigned long size, const char *name, int is_memory);
int snd_compat_release_resource(struct resource *resource);

/* these functions are used for ISA buffer allocation, too, so they stay
 * outside of CONFIG_PCI
 */
#define pci_alloc_consistent snd_pci_compat_alloc_consistent
#define pci_free_consistent snd_pci_compat_free_consistent
void *snd_pci_compat_alloc_consistent(struct pci_dev *, long, dma_addr_t *);
void snd_pci_compat_free_consistent(struct pci_dev *, long, void *, dma_addr_t);

#ifdef CONFIG_PCI

/* New-style probing supporting hot-pluggable devices */

#define PCI_PM_CTRL           4     /* PM control and status register */
#define PCI_PM_CTRL_STATE_MASK      0x0003      /* Current power state (D0 to D3) */

#define PCI_ANY_ID (~0)

#define pci_get_drvdata snd_pci_compat_get_driver_data
#define pci_set_drvdata snd_pci_compat_set_driver_data

#define pci_set_dma_mask snd_pci_compat_set_dma_mask

#undef pci_enable_device
#define pci_enable_device snd_pci_compat_enable_device
#define pci_disable_device snd_pci_compat_disable_device
#define pci_register_driver snd_pci_compat_register_driver
#define pci_unregister_driver snd_pci_compat_unregister_driver
#define pci_set_power_state snd_pci_compat_set_power_state
#define pci_match_device snd_pci_compat_match_device

#define pci_dma_supported snd_pci_compat_dma_supported

#define pci_dev_g(n) list_entry(n, struct pci_dev, global_list)
#define pci_dev_b(n) list_entry(n, struct pci_dev, bus_list)

#define pci_for_each_dev(dev) \
      for(dev = pci_devices; dev; dev = dev->next)

#undef pci_resource_start
#define pci_resource_start(dev,bar) \
      (((dev)->base_address[(bar)] & PCI_BASE_ADDRESS_SPACE) ? \
       ((dev)->base_address[(bar)] & PCI_BASE_ADDRESS_IO_MASK) : \
       ((dev)->base_address[(bar)] & PCI_BASE_ADDRESS_MEM_MASK))
#undef pci_resource_end
#define pci_resource_end(dev,bar) \
      (pci_resource_start(dev,bar) + snd_pci_compat_get_size((dev),(bar)))
#undef pci_resource_len
#define pci_resource_len(dev,bar) \
      ((pci_resource_start((dev),(bar)) == 0 && \
        pci_resource_end((dev),(bar)) ==        \
        pci_resource_start((dev),(bar))) ? 0 :  \
                                          \
      (pci_resource_end((dev),(bar)) -          \
       pci_resource_start((dev),(bar)) + 1))
#undef pci_resource_flags
#define pci_resource_flags(dev,bar) (snd_pci_compat_get_flags((dev),(bar)))

#define pci_request_region(dev,bar,name) snd_pci_compat_request_region(dev,bar,name)
#define pci_release_region(dev,bar) snd_pci_compat_release_region(dev,bar)
#define pci_request_regions(dev,name) snd_pci_compat_request_regions(dev,name)
#define pci_release_regions(dev) snd_pci_compat_release_regions(dev)

#define pci_save_state(dev) snd_pci_compat_save_state(dev)
#define pci_restore_state(dev) snd_pci_compat_restore_state(dev)

struct pci_device_id {
      unsigned int vendor, device;        /* Vendor and device ID or PCI_ANY_ID */
      unsigned int subvendor, subdevice;  /* Subsystem ID's or PCI_ANY_ID */
      unsigned int class, class_mask;           /* (class,subclass,prog-if) triplet */
      unsigned long driver_data;          /* Data private to the driver */
};

struct pci_driver {
      struct list_head node;
      struct pci_dev *dev;
      char *name;
      void *owner;
      const struct pci_device_id *id_table;     /* NULL if wants all devices */
      int (*probe)(struct pci_dev *dev, const struct pci_device_id *id); /* New device inserted */
      void (*remove)(struct pci_dev *dev);      /* Device removed (NULL if not a hot-plug capable driver) */
      int (*suspend)(struct pci_dev *dev, u32 stgate);      /* Device suspended */
      int (*resume)(struct pci_dev *dev); /* Device woken up */
};

/*
 *
 */
const struct pci_device_id * snd_pci_compat_match_device(const struct pci_device_id *ids, struct pci_dev *dev);
int snd_pci_compat_register_driver(struct pci_driver *drv);
void snd_pci_compat_unregister_driver(struct pci_driver *drv);
struct pci_driver *snd_pci_compat_get_pci_driver(struct pci_dev *dev);
unsigned long snd_pci_compat_get_size (struct pci_dev *dev, int n_base);
int snd_pci_compat_get_flags (struct pci_dev *dev, int n_base);
int snd_pci_compat_set_power_state(struct pci_dev *dev, int new_state);
int snd_pci_compat_enable_device(struct pci_dev *dev);
void snd_pci_compat_disable_device(struct pci_dev *dev);
int snd_pci_compat_find_capability(struct pci_dev *dev, int cap);
int snd_pci_compat_dma_supported(struct pci_dev *, dma_addr_t mask);
unsigned long snd_pci_compat_get_dma_mask(struct pci_dev *);
int snd_pci_compat_set_dma_mask(struct pci_dev *, unsigned long mask);
void * snd_pci_compat_get_driver_data (struct pci_dev *dev);
void snd_pci_compat_set_driver_data (struct pci_dev *dev, void *driver_data);
int snd_pci_compat_request_region(struct pci_dev *pdev, int bar, char *res_name);
void snd_pci_compat_release_region(struct pci_dev *pdev, int bar);
int snd_pci_compat_request_regions(struct pci_dev *pdev, char *res_name);
void snd_pci_compat_release_regions(struct pci_dev *pdev);
int snd_pci_compat_save_state(struct pci_dev *pdev);
int snd_pci_compat_restore_state(struct pci_dev *pdev);

#define pci_module_init snd_pci_compat_register_driver

#endif /* CONFIG_PCI */

/*
 * Power management requests
 */
enum
{
      PM_SUSPEND, /* enter D1-D3 */
      PM_RESUME,  /* enter D0 */

      /* enable wake-on */
      PM_SET_WAKEUP,

      /* bus resource management */
      PM_GET_RESOURCES,
      PM_SET_RESOURCES,

      /* base station management */
      PM_EJECT,
      PM_LOCK,
};

typedef int pm_request_t;

/*
 * Device types
 */
enum
{
      PM_UNKNOWN_DEV = 0, /* generic */
      PM_SYS_DEV,     /* system device (fan, KB controller, ...) */
      PM_PCI_DEV,     /* PCI device */
      PM_USB_DEV,     /* USB device */
      PM_SCSI_DEV,          /* SCSI device */
      PM_ISA_DEV,     /* ISA device */
};

typedef int pm_dev_t;

/*
 * System device hardware ID (PnP) values
 */
enum
{
      PM_SYS_UNKNOWN = 0x00000000, /* generic */
      PM_SYS_KBC =       0x41d00303, /* keyboard controller */
      PM_SYS_COM =       0x41d00500, /* serial port */
      PM_SYS_IRDA =      0x41d00510, /* IRDA controller */
      PM_SYS_FDC =       0x41d00700, /* floppy controller */
      PM_SYS_VGA =       0x41d00900, /* VGA controller */
      PM_SYS_PCMCIA =    0x41d00e00, /* PCMCIA controller */
};

#define __LINUX_PM_H    /* <linux/pm.h> in 2.2.18 is a bit stripped */

/*
 * Device identifier
 */
#define PM_PCI_ID(dev) ((dev)->bus->number << 16 | (dev)->devfn)

/*
 * Request handler callback
 */
struct pm_dev;

typedef int (*pm_callback)(struct pm_dev *dev, pm_request_t rqst, void *data);

/*
 * Dynamic device information
 */
struct pm_dev
{
      pm_dev_t     type;
      unsigned long      id;
      pm_callback  callback;
      void        *data;

      unsigned long      flags;
      int          state;
      int          prev_state;

      struct list_head entry;
};

#ifdef CONFIG_APM

int pm_init(void);
void pm_done(void);

#define CONFIG_PM

#define PM_IS_ACTIVE() 1

/*
 * Register a device with power management
 */
struct pm_dev *pm_register(pm_dev_t type,
                     unsigned long id,
                     pm_callback callback);

/*
 * Unregister a device with power management
 */
void pm_unregister(struct pm_dev *dev);

/*
 * Send a request to a single device
 */
int pm_send(struct pm_dev *dev, pm_request_t rqst, void *data);

#else /* CONFIG_APM */

#define PM_IS_ACTIVE() 0

extern inline struct pm_dev *pm_register(pm_dev_t type,
                               unsigned long id,
                               pm_callback callback)
{
      return 0;
}

extern inline void pm_unregister(struct pm_dev *dev) {}

extern inline int pm_send(struct pm_dev *dev, pm_request_t rqst, void *data)
{
      return 0;
}

#endif /* CONFIG_APM */

/*
 * ISA space access
 */
#define __ISA_IO_base phys_to_virt(0)
#define isa_readb(a) readb(phys_to_virt(a))
#define isa_readw(a) readw(phys_to_virt(a))
#define isa_readl(a) readl(phys_to_virt(a))
#define isa_writeb(b,a) writeb(b,phys_to_virt(a))
#define isa_writew(w,a) writew(w,phys_to_virt(a))
#define isa_writel(l,a) writel(l,phys_to_virt(a))
#define isa_memset_io(a,b,c)        memset_io(phys_to_virt(a),(b),(c))
#define isa_memcpy_fromio(a,b,c)    memcpy_fromio((a),phys_to_virt(b),(c))
#define isa_memcpy_toio(a,b,c)            memcpy_toio(phys_to_virt(a),(b),(c))

/* USB wrapper */
#if defined(SND_NEED_USB_WRAPPER) && (defined(CONFIG_USB) || defined(CONFIG_USB_MODULE))

#include <linux/usb.h>

struct usb_ctrlrequest {
      __u8 bRequestType;
      __u8 bRequest;
      __u16 wValue;
      __u16 wIndex;
      __u16 wLength;
} __attribute__ ((packed));

struct snd_compat_usb_device_id {
      __u16       match_flags;
      __u16       idVendor;
      __u16       idProduct;
      __u16       bcdDevice_lo, bcdDevice_hi;
      __u8        bDeviceClass;
      __u8        bDeviceSubClass;
      __u8        bDeviceProtocol;
      __u8        bInterfaceClass;
      __u8        bInterfaceSubClass;
      __u8        bInterfaceProtocol;
      unsigned long     driver_info;
};

struct usb_device;
struct usb_interface;

struct snd_compat_usb_driver {
      const char *name;
      void *(*probe)(struct usb_device *dev, unsigned intf, const struct snd_compat_usb_device_id *id);
      void (*disconnect)(struct usb_device *, void *);
      struct list_head driver_list;
      const struct snd_compat_usb_device_id *id_table;
};

int snd_compat_usb_register(struct snd_compat_usb_driver *);
void snd_compat_usb_deregister(struct snd_compat_usb_driver *);
void snd_compat_usb_driver_claim_interface(struct snd_compat_usb_driver *, struct usb_interface *iface, void *ptr);

#undef usb_driver
#undef usb_register
#undef usb_deregister
#undef usb_driver_claim_interface

#define usb_driver snd_compat_usb_driver
#define usb_device_id snd_compat_usb_device_id
#define usb_register(drv) snd_compat_usb_register(drv)
#define usb_deregister(drv) snd_compat_usb_deregister(drv)
#define usb_driver_claim_interface(drv,if,ptr) snd_compat_usb_driver_claim_interface(drv,if,ptr)

#define USB_DEVICE_ID_MATCH_VENDOR        0x0001
#define USB_DEVICE_ID_MATCH_PRODUCT       0x0002
#define USB_DEVICE_ID_MATCH_DEV_LO        0x0004
#define USB_DEVICE_ID_MATCH_DEV_HI        0x0008
#define USB_DEVICE_ID_MATCH_DEV_CLASS           0x0010
#define USB_DEVICE_ID_MATCH_DEV_SUBCLASS  0x0020
#define USB_DEVICE_ID_MATCH_DEV_PROTOCOL  0x0040
#define USB_DEVICE_ID_MATCH_INT_CLASS           0x0080
#define USB_DEVICE_ID_MATCH_INT_SUBCLASS  0x0100
#define USB_DEVICE_ID_MATCH_INT_PROTOCOL  0x0200

#define USB_DEVICE_ID_MATCH_DEVICE        (USB_DEVICE_ID_MATCH_VENDOR | USB_DEVICE_ID_MATCH_PRODUCT)
#define USB_DEVICE_ID_MATCH_DEV_RANGE           (USB_DEVICE_ID_MATCH_DEV_LO | USB_DEVICE_ID_MATCH_DEV_HI)
#define USB_DEVICE_ID_MATCH_DEVICE_AND_VERSION  (USB_DEVICE_ID_MATCH_DEVICE | USB_DEVICE_ID_MATCH_DEV_RANGE)
#define USB_DEVICE_ID_MATCH_DEV_INFO \
      (USB_DEVICE_ID_MATCH_DEV_CLASS | USB_DEVICE_ID_MATCH_DEV_SUBCLASS | USB_DEVICE_ID_MATCH_DEV_PROTOCOL)
#define USB_DEVICE_ID_MATCH_INT_INFO \
      (USB_DEVICE_ID_MATCH_INT_CLASS | USB_DEVICE_ID_MATCH_INT_SUBCLASS | USB_DEVICE_ID_MATCH_INT_PROTOCOL)

/* Some useful macros */
#define USB_DEVICE(vend,prod) \
      match_flags: USB_DEVICE_ID_MATCH_DEVICE, idVendor: (vend), idProduct: (prod)
#define USB_DEVICE_VER(vend,prod,lo,hi) \
      match_flags: USB_DEVICE_ID_MATCH_DEVICE_AND_VERSION, idVendor: (vend), idProduct: (prod), bcdDevice_lo: (lo), bcdDevice_hi: (hi)
#define USB_DEVICE_INFO(cl,sc,pr) \
      match_flags: USB_DEVICE_ID_MATCH_DEV_INFO, bDeviceClass: (cl), bDeviceSubClass: (sc), bDeviceProtocol: (pr)
#define USB_INTERFACE_INFO(cl,sc,pr) \
      match_flags: USB_DEVICE_ID_MATCH_INT_INFO, bInterfaceClass: (cl), bInterfaceSubClass: (sc), bInterfaceProtocol: (pr)

#endif /* USB */

#ifdef __SMP__
#define smp_mb()  mb()
#define smp_rmb() rmb()
#define smp_wmb() wmb()
#else
#define smp_mb()  barrier()
#define smp_rmb() barrier()
#define smp_wmb() barrier()
#endif
#define smp_mb__before_clear_bit()  smp_mb()
#define smp_mb__after_clear_bit()   smp_mb()
#define smp_mb__before_atomic_dec() smp_mb()
#define smp_mb__after_atomic_dec()  smp_mb()
#define smp_mb__before_atomic_inc() smp_mb()
#define smp_mb__after_atomic_inc()  smp_mb()

#define dump_stack() /*NOP*/

static inline int abs(int val)
{
      return (val < 0) ? -val : val;
}

#ifndef cpu_relax
#define cpu_relax()
#endif

#define might_sleep() do { } while (0)

#ifndef __constant_cpu_to_le32
#ifdef __LITTLE_ENDIAN
#define __constant_cpu_to_le32(x) (x)
#else
#define __constant_cpu_to_le32(x) \
      ((__u32)( \
            (((__u32)(x) & (__u32)0x000000ffUL) << 24) | \
            (((__u32)(x) & (__u32)0x0000ff00UL) <<  8) | \
            (((__u32)(x) & (__u32)0x00ff0000UL) >>  8) | \
            (((__u32)(x) & (__u32)0xff000000UL) >> 24) ))
#endif
#endif

#endif /* <2.3.0 */

Generated by  Doxygen 1.6.0   Back to index