From 95747c9f610f765082ed9d8d874b9e94036f6548 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?J=C3=A9r=C3=B4me=20Duval?= Date: Sat, 15 Nov 2003 08:46:33 +0000 Subject: [PATCH] Added mpu401 module header git-svn-id: file:///srv/svn/repos/haiku/trunk/current@5372 a95241bf-73f2-0310-859d-f6bbb57e9c96 --- headers/os/drivers/midi_driver.h | 118 +++++++++++++++++++++++++++++++ 1 file changed, 118 insertions(+) create mode 100644 headers/os/drivers/midi_driver.h diff --git a/headers/os/drivers/midi_driver.h b/headers/os/drivers/midi_driver.h new file mode 100644 index 0000000000..147dce4915 --- /dev/null +++ b/headers/os/drivers/midi_driver.h @@ -0,0 +1,118 @@ +/* ++++++++++ + FILE: midi_driver.h + REVS: $Revision: 1.1 $ + NAME: herold + DATE: Tue Jun 4 15:23:29 PDT 1996 + + Interface to /dev/midi, the midi driver ++++++ */ +/* + Copyright 1999, Be Incorporated. All Rights Reserved. + This file may be used under the terms of the Be Sample Code License. +*/ + +#ifndef _MIDI_DRIVER_H +#define _MIDI_DRIVER_H + +#include +#include + +/* ----- + ioctl codes +----- */ + +/* the old opcodes are deprecated, and may or may not work + in newer drivers */ +enum { + B_MIDI_GET_READ_TIMEOUT = B_MIDI_DRIVER_BASE, + B_MIDI_SET_READ_TIMEOUT, + B_MIDI_TIMED_READ, + B_MIDI_TIMED_WRITE, + B_MIDI_WRITE_SYNC, + B_MIDI_WRITE_CLEAR, + B_MIDI_GET_READ_TIMEOUT_OLD = B_DEVICE_OP_CODES_END + 1, + B_MIDI_SET_READ_TIMEOUT_OLD +}; + +/* the default timeout when you open a midi driver */ +#define B_MIDI_DEFAULT_TIMEOUT 1000000000000000LL + +/* Usage: + To read, set "data" to a pointer to your buffer, and "size" to the + maximum size of this buffer. On return, "when" will contain the time + at which the data was received (first byte) and "size" will contain + the actual amount of data read. + Call ioctl(fd, B_MIDI_TIMED_READ, &midi_timed_data, sizeof(midi_timed_data)); + To write, set "when" to when you want the first byte to go out the + wire, set "data" to point to your data, and set "size" to the size + of your data. + Call ioctl(fd, B_MIDI_TIMED_WRITE, &midi_timed_data, sizeof(midi_timed_data)); +*/ +typedef struct { + bigtime_t when; + size_t size; + unsigned char * data; +} midi_timed_data; + + +/* The MIDI parser returns the number of bytes that a message contains, given the */ +/* initial byte. For some messages, this is not known until the second byte is seen. */ +/* For such messages, a state > 0 is returned as well as some count > 0. When state */ +/* is > 0, you should call (*parse) for the next byte as well, which might modify */ +/* the returned message size. Message size will always be returned with the current */ +/* byte being counted as byte 1. A return of 0 means that the byte initiates a new */ +/* message. SysX is handled by returning max_size until the end or next initial message */ +/* is seen. So your loop looks something like: */ +/* + uint32 state = 0; // Only set this to 0 the first time you call the parser. + // preserve the 'state' between invocations of your read() hook. + int todo = 0; + unsigned char * end = in_buf+buf_size + unsigned char * out_buf = in_buf; + while (true) { + uchar byte = read_midi(); + if (!todo || state) { + todo = (*parser->parse)(&state, byte, end-out_buf); + } + if (todo < 1) { + unput_midi(byte); + } else { + *(out_buf++) = byte; + todo--; + } + if (todo < 1 || out_buf >= end) { + received_midi_message(in_buf, out_buf-in_buf); + todo = 0; + } + } + */ + +#define B_MIDI_PARSER_MODULE_NAME "media/midiparser/v1" + +typedef struct _midi_parser_module_info { + module_info minfo; + int (*parse)(uint32 * state, uchar byte, size_t max_size); + int _reserved_; +} midi_parser_module_info; + +#define B_MPU_401_MODULE_NAME "generic/mpu401/v1" + +enum { + B_MPU_401_ENABLE_CARD_INT = 1, + B_MPU_401_DISABLE_CARD_INT +}; +typedef struct _generic_mpu401_module { + module_info minfo; + status_t (*create_device)(int port, void ** out_storage, uint32 workarounds, void (*interrupt_op)(int32 op, void * card), void * card); + status_t (*delete_device)(void * storage); + status_t (*open_hook)(void * storage, uint32 flags, void ** out_cookie); + status_t (*close_hook)(void * cookie); + status_t (*free_hook)(void * cookie); + status_t (*control_hook)(void * cookie, uint32 op, void * data, size_t len); + status_t (*read_hook)(void * cookie, off_t pos, void * data, size_t * len); + status_t (*write_hook)(void * cookie, off_t pos, const void * data, size_t * len); + bool (*interrupt_hook)(void * cookie); + int _reserved_; +} generic_mpu401_module; + +#endif