src/add-ons/kernel/drivers/audio/module_driver/audio_module_driver.c

   1 /*
   2  * BeOS audio_module_driver
   3  *
   4  * Copyright (c) 2003, Marcus Overhagen <marcus@overhagen.de>
   5  *
   6  * All rights reserved.
   7  * Redistribution only allowed under the terms of the MIT license.
   8  *
   9  */
  10
  11
  12 #include <KernelExport.h>
  13 #include <directories.h>
  14 #include <Drivers.h>
  15 #include <Errors.h>
  16 #include <OS.h>
  17
  18 #include <malloc.h>
  19 #include <fcntl.h>
  20 #include <image.h>
  21
  22 #include "audio_module.h"
  23
  24
  25 int32 api_version = B_CUR_DRIVER_API_VERSION;
  26
  27 #define DRIVER_NAME     "audio_module_driver"
  28
  29 #define MODULE_TEST_PATH "media/audio/ich"
  30
  31
  32 void republish_devices(void);
  33
  34 extern image_id load_kernel_addon(const char *path);
  35 extern status_t unload_kernel_addon(image_id imid);
  36
  37
  38 status_t
  39 init_hardware(void)
  40 {
  41         dprintf("audio_module_driver: init_hardware\n");
  42         return B_OK;
  43 }
  44
  45
  46 status_t
  47 init_driver(void)
  48 {
  49         audio_module_info *audio_module;
  50         image_id id;
  51         status_t rv;
  52         void (*print_hello_world)(void);
  53
  54         id = load_kernel_addon(kUserAddonsDirectory "/kernel/media/audio/ich");
  55         get_image_symbol(id, "print_hello_world", B_SYMBOL_TYPE_TEXT,
  56                 (void **) &print_hello_world);
  57         print_hello_world();
  58         unload_kernel_addon(id);
  59         if (rv != B_OK)
  60                 dprintf("unload_kernel_addon failed\n");
  61
  62 /*
  63         if (B_OK != get_module(MODULE_TEST_PATH, (module_info **)&audio_module)) {
  64                 dprintf("get_module failed\n");
  65                 return B_ERROR;
  66         }
  67
  68         dprintf("calling audio_module->print_hello()\n");
  69
  70         audio_module->print_hello();
  71
  72         dprintf("done\n");
  73
  74         if (B_OK != put_module(MODULE_TEST_PATH)) {
  75                 dprintf("put_module failed\n");
  76                 return B_ERROR;
  77         }
  78 */
  79         return B_OK;
  80 }
  81
  82
  83 void
  84 uninit_driver(void)
  85 {
  86         dprintf("audio_module_driver: uninit_driver\n");
  87 }
  88
  89
  90 static status_t
  91 audio_module_driver_open(const char *name, uint32 flags, void **cookie)
  92 {
  93         dprintf("audio_module_driver: open %s\n", name);
  94         return B_OK;
  95 }
  96
  97
  98 static status_t
  99 audio_module_driver_close(void *cookie)
 100 {
 101         dprintf("audio_module_driver: close\n");
 102         return B_OK;
 103 }
 104
 105
 106 static status_t
 107 audio_module_driver_free(void *cookie)
 108 {
 109         dprintf("audio_module_driver: free\n");
 110         return B_OK;
 111 }
 112
 113
 114 static status_t
 115 audio_module_driver_control(void *cookie, uint32 op, void *arg, size_t len)
 116 {
 117         dprintf("audio_module_driver: control\n");
 118         switch (op) {
 119                 default:
 120                         return B_ERROR;
 121         }
 122 }
 123
 124
 125 static status_t
 126 audio_module_driver_read(void *cookie, off_t position, void *buf,
 127         size_t *num_bytes)
 128 {
 129         *num_bytes = 0;
 130         return B_IO_ERROR;
 131 }
 132
 133
 134 static status_t
 135 audio_module_driver_write(void *cookie, off_t position, const void *buffer,
 136         size_t *num_bytes)
 137 {
 138         static int keep_open_fd = -1;
 139         if (*num_bytes >= 5 && 0 == memcmp("start", buffer, 5)
 140                 && keep_open_fd == -1) {
 141                 keep_open_fd = open("/dev/audio/audio_module_driver", O_RDWR);
 142                 return B_OK;
 143         }
 144         if (*num_bytes >= 4 && 0 == memcmp("stop", buffer, 4)
 145                 && keep_open_fd != -1) {
 146                 close(keep_open_fd);
 147                 keep_open_fd = -1;
 148                 return B_OK;
 149         }
 150         if (*num_bytes >= 6 && 0 == memcmp("rescan", buffer, 6)) {
 151                 republish_devices();
 152                 return B_OK;
 153         }
 154         *num_bytes = 0;
 155         return B_IO_ERROR;
 156 }
 157
 158
 159 static const char *ich_name[] = {
 160         "audio/" DRIVER_NAME,
 161         "audio/modules/foobar/1",
 162         "audio/modules/foobar/2",
 163         "audio/modules/snafu/1",
 164         "audio/modules/snafu/2",
 165         NULL
 166 };
 167
 168
 169 device_hooks audio_module_driver_hooks = {
 170         audio_module_driver_open,
 171         audio_module_driver_close,
 172         audio_module_driver_free,
 173         audio_module_driver_control,
 174         audio_module_driver_read,
 175         audio_module_driver_write,
 176         NULL,
 177         NULL,
 178         NULL,
 179         NULL
 180 };
 181
 182
 183 const char**
 184 publish_devices(void)
 185 {
 186         dprintf("audio_module_driver: publish_devices\n");
 187         return ich_name;
 188 }
 189
 190
 191 device_hooks*
 192 find_device(const char *name)
 193 {
 194         dprintf("audio_module_driver: find_device %s\n", name);
 195         return &audio_module_driver_hooks;
 196 }
 197
 198
 199 void republish_devices(void)
 200 {
 201         int fd = open("/dev", O_WRONLY);
 202         write(fd, DRIVER_NAME, strlen(DRIVER_NAME));
 203         close (fd);
 204 }