Open Sound System
The Hitchhiker's Guide to OSS 4.1 Internals

Do you have problems with sound/audio application development? Don't panic! Click here for help!


OS specific definitions for BeOS/Haiku


#ifndef _OS_H_
#define _OS_H_

This file is part of Open Sound System.

Copyright (C) 4Front Technologies 1996-2007.

This this source file is released under GPL v2 license (no other versions). See the COPYING file included in the main directory of this source distribution. Please contact for further info.

#define OS_VERSION "5"
#define __inline__ inline
#define __inline inline
#define EXTERN_C extern "C"

Debugging and misc settings

#undef  MEMDEBUG
/* very verbose */
/* XXX */
#define DEBUG_KDLCMD 1
//#define ENABLE_IMUX 1
//#define ENABLE_SOFTOSS 1

Disable support for per-application features such as /dev/dsp device selection based on command name. Requires working GET_PROCESS_NAME macro implementation.

/* no VDEV */

//XXX: try to avoid crashing

#include <OS.h>
#include <stdarg.h>
//#include <stdint.h>
#include <inttypes.h>
#include <sys/types.h>
#include <sys/param.h>
#include <oss_errno.h>
#include <sys/uio.h>
#include <fcntl.h>
#ifdef __HAIKU__
#include <poll.h>
//#include <sys/malloc.h>
#include <malloc.h>

#include <KernelExport.h>
#include <Drivers.h>
#include <PCI.h>

#ifndef ENOTSUP


//#define DEVICE_PREFIX "audio/oss/"
#define DEVICE_PREFIX ""
#define DEVICE_NAME_LEN (32+sizeof(DEVICE_PREFIX))



/* references to modules */
extern pci_module_info *gPCI;

#endif /* _KERNEL_MODE */

Some integer types

#if defined(amd64) || defined(sparc) // 64bit ? not yet
typedef uint64 oss_native_word;	/* Same as the address and status register size */
typedef uint32 oss_native_word;	/* Same as the address and status register size */

typedef int64 oss_int64_t;		/* Signed 64 bit integer */
typedef uint64 oss_uint64_t;	/* Unsigned 64 bit integer */
typedef unsigned long offset_t;

extern void oss_cmn_err (int level, char *format, ...);
#define CE_CONT		0
#define CE_NOTE		1
#define CE_WARN		2
#define CE_PANIC	3
#define cmn_err oss_cmn_err

//snooze(1000000); \

/* verbose debugging */
#define FENTRY() \
dprintf("oss>%s()\n", __FUNCTION__)
#define FENTRYA(f,a...) \
dprintf("oss>%s(" f ")\n", __FUNCTION__, a)
#define FEXIT() \
dprintf("oss<%s\n", __FUNCTION__)
#define FEXITR(e) \
dprintf("oss<%s returned 0x%08lx\n", __FUNCTION__, (uint32)e)
#define FENTRY() {}
#define FENTRYA(f,a...) {}
#define FEXIT() {}
#define FEXITR(e) {}

struct _dev_info_t
  //struct pci_dev *pcidev;
  struct pci_info pciinfo; //XXX: ptr or not ???
typedef struct _dev_info_t dev_info_t;

timeout wrappers

#undef timeout
#define timeout oss_timeout
#undef untimeout
#define untimeout oss_untimeout
typedef int timeout_id_t;
extern timeout_id_t oss_timeout (void (*func) (void *), void *arg,
				 unsigned long long ticks);
extern void oss_untimeout (timeout_id_t id);

#define uiomove oss_uiomove
typedef enum uio_rw
{ UIO_READ, UIO_WRITE } uio_rw_t;
struct uio
  char *ptr;
  int resid;
  int kernel_space;		/* Set if this uio points to a kernel space buffer */
  uio_rw_t rw;
typedef struct uio uio_t;
extern int oss_uiomove (void *address, size_t nbytes, enum uio_rw rwflag,
			uio_t * uio);
extern int oss_create_uio (uio_t * uiop, char *buf, size_t count, uio_rw_t rw,
			   int is_kernel);


/* Debugging version */
struct _oss_mutex_t
  spinlock lock;
  thread_id owner;
  char *file;
  int line;
  int busy_flags;
#define CNTX_INTR		1
#define CNTX_USER		2

typedef struct _oss_mutex_t oss_mutex_t;
extern void debug_mutex_init (oss_mutex_t * mutex, char *file, int line);
extern void debug_mutex_destroy (oss_mutex_t * mutex, char *file, int line);
extern void debug_mutex_enter (oss_mutex_t * mutex, char *file, int line, oss_native_word *flags);
extern void debug_mutex_exit (oss_mutex_t * mutex, char *file, int line, oss_native_word *flags);

#define MUTEX_INIT(osdev, mutex, hier)			debug_mutex_init(&mutex, NULL, __FILE__, __LINE__)
#define MUTEX_CLEANUP(mutex)			debug_mutex_destroy(&mutex, __FILE__, __LINE__)
#define MUTEX_ENTER_IRQDISABLE(mutex, flags)	debug_mutex_enter(&mutex, __FILE__, __LINE__, &flags)
#define MUTEX_ENTER(mutex, flags)			debug_mutex_enter(&mutex, __FILE__, __LINE__, NULL)
#define MUTEX_EXIT_IRQRESTORE(mutex, flags)	debug_mutex_exit(&mutex, __FILE__, __LINE__, &flags)
#define MUTEX_EXIT(mutex, flags)			debug_mutex_exit(&mutex, __FILE__, __LINE__, NULL)
typedef spinlock oss_mutex_t;
#define MUTEX_INIT(osdev, mutex, hier)			{ mutex = 0; }
#define MUTEX_CLEANUP(mutex)			
#define MUTEX_ENTER_IRQDISABLE(mutex, flags)	\
{ \
	flags = (oss_native_word) disable_interrupts(); \
	acquire_spinlock(&(mutex)); \
#define MUTEX_ENTER(mutex, flags)			acquire_spinlock(&(mutex))
#define MUTEX_EXIT_IRQRESTORE(mutex, flags)	\
{ \
	release_spinlock(&(mutex)); \
	restore_interrupts((cpu_status)(flags)); \
#define MUTEX_EXIT(mutex, flags)			release_spinlock(&(mutex))

/* The soundcard.h could be in a nonstandard place so include it here. */
#include "soundcard.h"

typedef struct udi_usb_devc udi_usb_devc;
struct _oss_device_t
  int instance;
  void *devc;
  char *name;

  int cardnum;
  int dev_type;
  int instance;
  int available;
  dev_info_t *dip;
  int unloaded;
  void *osid;
  void *devc;
  char *name;
  char *hw_info;
  char nick[16];
  char modname[32];
  char handle[32];
  int num_audio_engines;
  int num_audioplay, num_audiorec, num_audioduplex;
  int num_mididevs;
  int num_mixerdevs;
  int num_loopdevs;
  int first_mixer;	/* This must be set to -1 by osdev_create() */
  volatile int refcount;	/* Nonzero means that the device is needed by some other (virtual) driver. */

/* Interrupts */

  long irq; //XXX:init =-1
  oss_tophalf_handler_t tophalf_handler;
  oss_bottomhalf_handler_t bottomhalf_handler;
  oss_mutex_t mutex;


/* XXX we'll deal with select() later */
/* BeOS doesn't support mmap. Haiku does, so FIXME someday */


#ifdef _KERNEL
struct oss_wait_queue
//  oss_mutex_t mutex;
  char name[32];
  sem_id sem;
  unsigned long flags;
//  struct selinfo poll_info;

/* Busy wait routine */
#define oss_udelay(d) spin((bigtime_t)d)

/* usec time base */
#undef HZ
/* XXX: might need to be lower to handle casts to long */
#define OSS_HZ 1000000

/* System wall timer access */
extern unsigned long oss_get_time (void);
#define GET_JIFFIES()	oss_get_time()

INB() and OUTB() should be obvious. NOTE! The order of paratemeters of OUTB() is different than on some other operating systems.

/* I/O Mapped devices */
#define INB(o, p)	gPCI->read_io_8(p)
#define INW(o, p)	gPCI->read_io_16(p)
#define INL(o, p)	gPCI->read_io_32(p)

#define OUTB(o, v, p)	gPCI->write_io_8(p,v)
#define OUTW(o, v, p)	gPCI->write_io_16(p,v)
#define OUTL(o, v, p)	gPCI->write_io_32(p,v)

/* Memory Mapped devices */
#define PCI_READB(osdev, addr)		*(volatile unsigned char *)(addr)
#define PCI_READW(osdev, addr)		*(volatile unsigned short *)(addr)
#define PCI_READL(osdev, addr)		*(volatile unsigned int *)(addr)

#define PCI_WRITEB(osdev, addr, data)	*(volatile unsigned char *)(addr)=data
#define PCI_WRITEW(osdev, addr, data)	*(volatile unsigned short *)(addr)=data
#define PCI_WRITEL(osdev, addr, data)	*(volatile unsigned int *)(addr)=data

typedef void *oss_dma_handle_t;

When a error (such as EINVAL) is returned by a function, the following macro is used. The driver assumes that a error is signalled by returning a negative value.

KERNEL_MALLOC() allocates requested number of memory and KERNEL_FREE is used to free it. These macros are never called from interrupt, in addition the nbytes will never be more than 4096 bytes. Generally the driver will allocate memory in blocks of 4k. If the kernel has just a page level memory allocation, 4K can be safely used as the size (the nbytes parameter can be ignored).

#define	KERNEL_MALLOC(nbytes)	calloc(1,nbytes)
#define	KERNEL_FREE(addr)	{if (addr)free(addr);addr=NULL;}

extern void *oss_contig_malloc (oss_device_t * osdev, int sz,
				oss_uint64_t memlimit,
				oss_native_word * phaddr);
extern void oss_contig_free (oss_device_t * osdev, void *p, int sz);
extern oss_native_word oss_virt_to_bus (void *addr);
#define CONTIG_MALLOC(osdev, sz, memlimit, phaddr, handle)	oss_contig_malloc(osdev, sz, memlimit, phaddr)
#define CONTIG_FREE(osdev, p, sz, handle)	oss_contig_free(osdev, p, sz)

PMALLOC is used to allocate memory that will get automatically freed when OSS unloads. Usable for per-instance structures allocated when OSS modules are being loaded.

extern void *oss_pmalloc (size_t sz);

//#define PMALLOC(osdev, sz) oss_pmalloc(sz)

Timer macros

These macros are obsolete and should not be used in any new code. Use the timeout mechanism (see the timeout(9F) Solaris man page).

#define DEFINE_TIMER(name, proc)	static timeout_id_t name = 0
#define REMOVE_TIMER(name, proc)	{if (name != 0) untimeout(name);}
#define INIT_TIMER(name,proc)
typedef void (*timeout_func_t) (void *);
#define ACTIVATE_TIMER(name, proc, time) \
	name=timeout((timeout_func_t)proc, (void*)&name, time)

struct fileinfo
  int mode;			/* Open mode */
  //int flags;
  int acc_flags;
#define ISSET_FILE_FLAG(fileinfo, flag)  (fileinfo->acc_flags & (flag) ? 1:0)

#define OSS_OS "BeOS"

typedef void (*softintr_func_t) (int);

struct oss_softintr
  int id;
  softintr_func_t func;
  volatile int armed, running;

struct _oss_poll_event_t
  short events, revents;
  struct thread *p;
  struct cdev *bsd_dev;
typedef struct _oss_poll_event_t oss_poll_event_t;
#ifndef POLLIN
/* events & revents - compatible with the B_SELECT_xxx definitions in Drivers.h */
#define POLLIN          0x0001          /* any readable data available */
#define POLLOUT         0x0002          /* file descriptor is writeable */
#define POLLRDBAND      0x0008          /* priority readable data */
#define POLLWRBAND      0x0010          /* priority data can be written */
#define POLLPRI         0x0020          /* high priority readable data */

extern int detect_trace;
#define DDB(x) if (detect_trace) x

extern caddr_t oss_map_pci_mem (oss_device_t * osdev, int nr, int phaddr,
				int size);
extern void oss_unmap_pci_mem (void *addr);
#define MAP_PCI_IOADDR(osdev, nr, io) (oss_native_word)io
#define MAP_PCI_MEM(osdev, ix, phaddr, size) 	oss_map_pci_mem(osdev, ix, phaddr, size)
#define UNMAP_PCI_MEM(osdev, ix, ph, virt, size)	oss_unmap_pci_mem(virt)
#define UNMAP_PCI_IOADDR(osdev, ix)	{}

#define GET_PROCESS_PID(f)  find_thread(NULL)
#define GET_PROCESS_UID()	getuid()

#define abs(x)                  ((x) >= 0 ? (x) : -(x))

Interface with the front-end driver

extern status_t init_osscore (void);
extern status_t uninit_osscore (void);
extern status_t oss_probe_pci (void);
extern status_t oss_load_drivers (void);
extern status_t oss_unload_all_drivers (void);

osscore module for use by low-level driver

#define OSS_CORE_MODULE_NAME "media/oss/oss_core/v1"
#define OSS_MODULES_PREFIX "media/oss/drivers/"
#define OSS_MODULES_SUFFIX "/v1"
typedef struct oss_drv_module_info {
  module_info minfo;
  int (*driver_probe)(void);
  int (*driver_attach)(oss_device_t *osdev);
  int (*driver_detach)(oss_device_t *osdev);
} oss_drv_module_info;

typedef struct oss_core_module_info {
  module_info minfo;
  status_t (*init_osscore) (void);
  status_t (*uninit_osscore) (void);
  const char **(*oss_publish_devices) (void);
  device_hooks *(*oss_get_driver_hooks) (void);
  status_t (*oss_probe_pci) (void);
  status_t (*oss_load_drivers) (void);
  status_t (*oss_unload_all_drivers) (void);
} oss_core_module_info;
extern oss_core_module_info *gOSSCore;

//XXX: not yet

struct oss_core_module {
  module_info minfo;
  void (*oss_foo)(void);
extern struct oss_core_info *gOSSCore;
  #define oss_foo gOSSCore->oss_foo
#endif /* ASMODULES */

Copyright (C) 4Front Technologies, 2007. All rights reserved.

Back to index OSS web site

Copyright (C) 4Front Technologies, 2007. All rights reserved.
Back to index OSS web site