Alex Dewar | dbddf42 | 2019-08-25 10:49:16 +0100 | [diff] [blame] | 1 | // SPDX-License-Identifier: GPL-2.0 |
Jeff Dike | cb8fa61 | 2007-10-16 01:27:34 -0700 | [diff] [blame] | 2 | /* |
| 3 | * Copyright (C) 2002 Steve Schmidtke |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 4 | */ |
| 5 | |
Al Viro | 37185b3 | 2012-10-08 03:27:32 +0100 | [diff] [blame] | 6 | #include <linux/fs.h> |
| 7 | #include <linux/module.h> |
| 8 | #include <linux/slab.h> |
| 9 | #include <linux/sound.h> |
| 10 | #include <linux/soundcard.h> |
| 11 | #include <linux/mutex.h> |
Linus Torvalds | 7c0f6ba | 2016-12-24 11:46:01 -0800 | [diff] [blame] | 12 | #include <linux/uaccess.h> |
Al Viro | 37185b3 | 2012-10-08 03:27:32 +0100 | [diff] [blame] | 13 | #include <init.h> |
| 14 | #include <os.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 15 | |
| 16 | struct hostaudio_state { |
Jeff Dike | d471c0f | 2007-02-10 01:44:00 -0800 | [diff] [blame] | 17 | int fd; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 18 | }; |
| 19 | |
| 20 | struct hostmixer_state { |
Jeff Dike | d471c0f | 2007-02-10 01:44:00 -0800 | [diff] [blame] | 21 | int fd; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 22 | }; |
| 23 | |
| 24 | #define HOSTAUDIO_DEV_DSP "/dev/sound/dsp" |
| 25 | #define HOSTAUDIO_DEV_MIXER "/dev/sound/mixer" |
| 26 | |
Jeff Dike | cb8fa61 | 2007-10-16 01:27:34 -0700 | [diff] [blame] | 27 | /* |
| 28 | * Changed either at boot time or module load time. At boot, this is |
Jeff Dike | b612e47 | 2007-02-10 01:43:59 -0800 | [diff] [blame] | 29 | * single-threaded; at module load, multiple modules would each have |
| 30 | * their own copy of these variables. |
| 31 | */ |
| 32 | static char *dsp = HOSTAUDIO_DEV_DSP; |
| 33 | static char *mixer = HOSTAUDIO_DEV_MIXER; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 34 | |
| 35 | #define DSP_HELP \ |
| 36 | " This is used to specify the host dsp device to the hostaudio driver.\n" \ |
| 37 | " The default is \"" HOSTAUDIO_DEV_DSP "\".\n\n" |
| 38 | |
| 39 | #define MIXER_HELP \ |
| 40 | " This is used to specify the host mixer device to the hostaudio driver.\n"\ |
| 41 | " The default is \"" HOSTAUDIO_DEV_MIXER "\".\n\n" |
| 42 | |
FUJITA Tomonori | e3c6cf6 | 2010-10-15 14:34:13 -0700 | [diff] [blame] | 43 | module_param(dsp, charp, 0644); |
| 44 | MODULE_PARM_DESC(dsp, DSP_HELP); |
| 45 | module_param(mixer, charp, 0644); |
| 46 | MODULE_PARM_DESC(mixer, MIXER_HELP); |
| 47 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 48 | #ifndef MODULE |
| 49 | static int set_dsp(char *name, int *add) |
| 50 | { |
| 51 | dsp = name; |
Jeff Dike | cb8fa61 | 2007-10-16 01:27:34 -0700 | [diff] [blame] | 52 | return 0; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 53 | } |
| 54 | |
| 55 | __uml_setup("dsp=", set_dsp, "dsp=<dsp device>\n" DSP_HELP); |
| 56 | |
| 57 | static int set_mixer(char *name, int *add) |
| 58 | { |
| 59 | mixer = name; |
Jeff Dike | cb8fa61 | 2007-10-16 01:27:34 -0700 | [diff] [blame] | 60 | return 0; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 61 | } |
| 62 | |
| 63 | __uml_setup("mixer=", set_mixer, "mixer=<mixer device>\n" MIXER_HELP); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 64 | #endif |
| 65 | |
Arnd Bergmann | 9a181c5 | 2010-09-11 18:38:03 +0200 | [diff] [blame] | 66 | static DEFINE_MUTEX(hostaudio_mutex); |
| 67 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 68 | /* /dev/dsp file operations */ |
| 69 | |
Al Viro | 4d338e1 | 2006-03-31 02:30:15 -0800 | [diff] [blame] | 70 | static ssize_t hostaudio_read(struct file *file, char __user *buffer, |
| 71 | size_t count, loff_t *ppos) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 72 | { |
Jeff Dike | d471c0f | 2007-02-10 01:44:00 -0800 | [diff] [blame] | 73 | struct hostaudio_state *state = file->private_data; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 74 | void *kbuf; |
| 75 | int err; |
| 76 | |
| 77 | #ifdef DEBUG |
Jeff Dike | cb8fa61 | 2007-10-16 01:27:34 -0700 | [diff] [blame] | 78 | printk(KERN_DEBUG "hostaudio: read called, count = %d\n", count); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 79 | #endif |
| 80 | |
| 81 | kbuf = kmalloc(count, GFP_KERNEL); |
Jeff Dike | cb8fa61 | 2007-10-16 01:27:34 -0700 | [diff] [blame] | 82 | if (kbuf == NULL) |
| 83 | return -ENOMEM; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 84 | |
Jeff Dike | a6ea4cc | 2007-05-06 14:51:43 -0700 | [diff] [blame] | 85 | err = os_read_file(state->fd, kbuf, count); |
Jeff Dike | cb8fa61 | 2007-10-16 01:27:34 -0700 | [diff] [blame] | 86 | if (err < 0) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 87 | goto out; |
| 88 | |
Jeff Dike | cb8fa61 | 2007-10-16 01:27:34 -0700 | [diff] [blame] | 89 | if (copy_to_user(buffer, kbuf, err)) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 90 | err = -EFAULT; |
| 91 | |
Jeff Dike | d471c0f | 2007-02-10 01:44:00 -0800 | [diff] [blame] | 92 | out: |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 93 | kfree(kbuf); |
Jeff Dike | cb8fa61 | 2007-10-16 01:27:34 -0700 | [diff] [blame] | 94 | return err; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 95 | } |
| 96 | |
Al Viro | 4d338e1 | 2006-03-31 02:30:15 -0800 | [diff] [blame] | 97 | static ssize_t hostaudio_write(struct file *file, const char __user *buffer, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 98 | size_t count, loff_t *ppos) |
| 99 | { |
Jeff Dike | d471c0f | 2007-02-10 01:44:00 -0800 | [diff] [blame] | 100 | struct hostaudio_state *state = file->private_data; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 101 | void *kbuf; |
| 102 | int err; |
| 103 | |
| 104 | #ifdef DEBUG |
Jeff Dike | cb8fa61 | 2007-10-16 01:27:34 -0700 | [diff] [blame] | 105 | printk(KERN_DEBUG "hostaudio: write called, count = %d\n", count); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 106 | #endif |
| 107 | |
Al Viro | 1ceb362 | 2016-01-02 14:50:51 -0500 | [diff] [blame] | 108 | kbuf = memdup_user(buffer, count); |
| 109 | if (IS_ERR(kbuf)) |
| 110 | return PTR_ERR(kbuf); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 111 | |
Jeff Dike | a6ea4cc | 2007-05-06 14:51:43 -0700 | [diff] [blame] | 112 | err = os_write_file(state->fd, kbuf, count); |
Jeff Dike | cb8fa61 | 2007-10-16 01:27:34 -0700 | [diff] [blame] | 113 | if (err < 0) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 114 | goto out; |
| 115 | *ppos += err; |
| 116 | |
| 117 | out: |
| 118 | kfree(kbuf); |
Jeff Dike | cb8fa61 | 2007-10-16 01:27:34 -0700 | [diff] [blame] | 119 | return err; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 120 | } |
| 121 | |
Al Viro | 76d2d4a | 2017-07-02 22:59:49 -0400 | [diff] [blame] | 122 | static __poll_t hostaudio_poll(struct file *file, |
| 123 | struct poll_table_struct *wait) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 124 | { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 125 | #ifdef DEBUG |
Jeff Dike | cb8fa61 | 2007-10-16 01:27:34 -0700 | [diff] [blame] | 126 | printk(KERN_DEBUG "hostaudio: poll called (unimplemented)\n"); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 127 | #endif |
| 128 | |
Yang Li | ea8e896 | 2021-03-10 16:49:08 +0800 | [diff] [blame] | 129 | return 0; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 130 | } |
| 131 | |
John Kacur | d6c89d9 | 2010-05-07 17:34:28 +0200 | [diff] [blame] | 132 | static long hostaudio_ioctl(struct file *file, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 133 | unsigned int cmd, unsigned long arg) |
| 134 | { |
Jeff Dike | d471c0f | 2007-02-10 01:44:00 -0800 | [diff] [blame] | 135 | struct hostaudio_state *state = file->private_data; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 136 | unsigned long data = 0; |
| 137 | int err; |
| 138 | |
| 139 | #ifdef DEBUG |
Jeff Dike | cb8fa61 | 2007-10-16 01:27:34 -0700 | [diff] [blame] | 140 | printk(KERN_DEBUG "hostaudio: ioctl called, cmd = %u\n", cmd); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 141 | #endif |
| 142 | switch(cmd){ |
| 143 | case SNDCTL_DSP_SPEED: |
| 144 | case SNDCTL_DSP_STEREO: |
| 145 | case SNDCTL_DSP_GETBLKSIZE: |
| 146 | case SNDCTL_DSP_CHANNELS: |
| 147 | case SNDCTL_DSP_SUBDIVIDE: |
| 148 | case SNDCTL_DSP_SETFRAGMENT: |
Jeff Dike | cb8fa61 | 2007-10-16 01:27:34 -0700 | [diff] [blame] | 149 | if (get_user(data, (int __user *) arg)) |
Johann Felix Soden | 484f1e2 | 2008-05-12 14:01:51 -0700 | [diff] [blame] | 150 | return -EFAULT; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 151 | break; |
| 152 | default: |
| 153 | break; |
| 154 | } |
| 155 | |
| 156 | err = os_ioctl_generic(state->fd, cmd, (unsigned long) &data); |
| 157 | |
| 158 | switch(cmd){ |
| 159 | case SNDCTL_DSP_SPEED: |
| 160 | case SNDCTL_DSP_STEREO: |
| 161 | case SNDCTL_DSP_GETBLKSIZE: |
| 162 | case SNDCTL_DSP_CHANNELS: |
| 163 | case SNDCTL_DSP_SUBDIVIDE: |
| 164 | case SNDCTL_DSP_SETFRAGMENT: |
Jeff Dike | cb8fa61 | 2007-10-16 01:27:34 -0700 | [diff] [blame] | 165 | if (put_user(data, (int __user *) arg)) |
| 166 | return -EFAULT; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 167 | break; |
| 168 | default: |
| 169 | break; |
| 170 | } |
| 171 | |
Jeff Dike | cb8fa61 | 2007-10-16 01:27:34 -0700 | [diff] [blame] | 172 | return err; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 173 | } |
| 174 | |
| 175 | static int hostaudio_open(struct inode *inode, struct file *file) |
| 176 | { |
Jeff Dike | d471c0f | 2007-02-10 01:44:00 -0800 | [diff] [blame] | 177 | struct hostaudio_state *state; |
| 178 | int r = 0, w = 0; |
| 179 | int ret; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 180 | |
| 181 | #ifdef DEBUG |
Dan Streetman | b51d23e4 | 2015-06-17 06:18:52 +0930 | [diff] [blame] | 182 | kernel_param_lock(THIS_MODULE); |
Jeff Dike | cb8fa61 | 2007-10-16 01:27:34 -0700 | [diff] [blame] | 183 | printk(KERN_DEBUG "hostaudio: open called (host: %s)\n", dsp); |
Dan Streetman | b51d23e4 | 2015-06-17 06:18:52 +0930 | [diff] [blame] | 184 | kernel_param_unlock(THIS_MODULE); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 185 | #endif |
| 186 | |
Jeff Dike | d471c0f | 2007-02-10 01:44:00 -0800 | [diff] [blame] | 187 | state = kmalloc(sizeof(struct hostaudio_state), GFP_KERNEL); |
Jeff Dike | cb8fa61 | 2007-10-16 01:27:34 -0700 | [diff] [blame] | 188 | if (state == NULL) |
| 189 | return -ENOMEM; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 190 | |
Jeff Dike | cb8fa61 | 2007-10-16 01:27:34 -0700 | [diff] [blame] | 191 | if (file->f_mode & FMODE_READ) |
| 192 | r = 1; |
| 193 | if (file->f_mode & FMODE_WRITE) |
| 194 | w = 1; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 195 | |
Dan Streetman | b51d23e4 | 2015-06-17 06:18:52 +0930 | [diff] [blame] | 196 | kernel_param_lock(THIS_MODULE); |
Arnd Bergmann | 9a181c5 | 2010-09-11 18:38:03 +0200 | [diff] [blame] | 197 | mutex_lock(&hostaudio_mutex); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 198 | ret = os_open_file(dsp, of_set_rw(OPENFLAGS(), r, w), 0); |
Arnd Bergmann | 9a181c5 | 2010-09-11 18:38:03 +0200 | [diff] [blame] | 199 | mutex_unlock(&hostaudio_mutex); |
Dan Streetman | b51d23e4 | 2015-06-17 06:18:52 +0930 | [diff] [blame] | 200 | kernel_param_unlock(THIS_MODULE); |
Arnd Bergmann | 90dc763 | 2010-07-11 12:16:36 +0200 | [diff] [blame] | 201 | |
Jeff Dike | cb8fa61 | 2007-10-16 01:27:34 -0700 | [diff] [blame] | 202 | if (ret < 0) { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 203 | kfree(state); |
Jeff Dike | cb8fa61 | 2007-10-16 01:27:34 -0700 | [diff] [blame] | 204 | return ret; |
Jeff Dike | d471c0f | 2007-02-10 01:44:00 -0800 | [diff] [blame] | 205 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 206 | state->fd = ret; |
Jeff Dike | d471c0f | 2007-02-10 01:44:00 -0800 | [diff] [blame] | 207 | file->private_data = state; |
Jeff Dike | cb8fa61 | 2007-10-16 01:27:34 -0700 | [diff] [blame] | 208 | return 0; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 209 | } |
| 210 | |
| 211 | static int hostaudio_release(struct inode *inode, struct file *file) |
| 212 | { |
Jeff Dike | d471c0f | 2007-02-10 01:44:00 -0800 | [diff] [blame] | 213 | struct hostaudio_state *state = file->private_data; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 214 | |
| 215 | #ifdef DEBUG |
Jeff Dike | cb8fa61 | 2007-10-16 01:27:34 -0700 | [diff] [blame] | 216 | printk(KERN_DEBUG "hostaudio: release called\n"); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 217 | #endif |
Jeff Dike | d471c0f | 2007-02-10 01:44:00 -0800 | [diff] [blame] | 218 | os_close_file(state->fd); |
| 219 | kfree(state); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 220 | |
Jeff Dike | cb8fa61 | 2007-10-16 01:27:34 -0700 | [diff] [blame] | 221 | return 0; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 222 | } |
| 223 | |
| 224 | /* /dev/mixer file operations */ |
| 225 | |
John Kacur | d6c89d9 | 2010-05-07 17:34:28 +0200 | [diff] [blame] | 226 | static long hostmixer_ioctl_mixdev(struct file *file, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 227 | unsigned int cmd, unsigned long arg) |
| 228 | { |
Jeff Dike | d471c0f | 2007-02-10 01:44:00 -0800 | [diff] [blame] | 229 | struct hostmixer_state *state = file->private_data; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 230 | |
| 231 | #ifdef DEBUG |
Jeff Dike | cb8fa61 | 2007-10-16 01:27:34 -0700 | [diff] [blame] | 232 | printk(KERN_DEBUG "hostmixer: ioctl called\n"); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 233 | #endif |
| 234 | |
Jeff Dike | cb8fa61 | 2007-10-16 01:27:34 -0700 | [diff] [blame] | 235 | return os_ioctl_generic(state->fd, cmd, arg); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 236 | } |
| 237 | |
| 238 | static int hostmixer_open_mixdev(struct inode *inode, struct file *file) |
| 239 | { |
Jeff Dike | d471c0f | 2007-02-10 01:44:00 -0800 | [diff] [blame] | 240 | struct hostmixer_state *state; |
| 241 | int r = 0, w = 0; |
| 242 | int ret; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 243 | |
| 244 | #ifdef DEBUG |
Jeff Dike | cb8fa61 | 2007-10-16 01:27:34 -0700 | [diff] [blame] | 245 | printk(KERN_DEBUG "hostmixer: open called (host: %s)\n", mixer); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 246 | #endif |
| 247 | |
Jeff Dike | d471c0f | 2007-02-10 01:44:00 -0800 | [diff] [blame] | 248 | state = kmalloc(sizeof(struct hostmixer_state), GFP_KERNEL); |
Jeff Dike | cb8fa61 | 2007-10-16 01:27:34 -0700 | [diff] [blame] | 249 | if (state == NULL) |
| 250 | return -ENOMEM; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 251 | |
Jeff Dike | cb8fa61 | 2007-10-16 01:27:34 -0700 | [diff] [blame] | 252 | if (file->f_mode & FMODE_READ) |
| 253 | r = 1; |
| 254 | if (file->f_mode & FMODE_WRITE) |
| 255 | w = 1; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 256 | |
Dan Streetman | b51d23e4 | 2015-06-17 06:18:52 +0930 | [diff] [blame] | 257 | kernel_param_lock(THIS_MODULE); |
Arnd Bergmann | 9a181c5 | 2010-09-11 18:38:03 +0200 | [diff] [blame] | 258 | mutex_lock(&hostaudio_mutex); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 259 | ret = os_open_file(mixer, of_set_rw(OPENFLAGS(), r, w), 0); |
Arnd Bergmann | 9a181c5 | 2010-09-11 18:38:03 +0200 | [diff] [blame] | 260 | mutex_unlock(&hostaudio_mutex); |
Dan Streetman | b51d23e4 | 2015-06-17 06:18:52 +0930 | [diff] [blame] | 261 | kernel_param_unlock(THIS_MODULE); |
Jeff Dike | cb8fa61 | 2007-10-16 01:27:34 -0700 | [diff] [blame] | 262 | |
| 263 | if (ret < 0) { |
Dan Streetman | b51d23e4 | 2015-06-17 06:18:52 +0930 | [diff] [blame] | 264 | kernel_param_lock(THIS_MODULE); |
Jeff Dike | cb8fa61 | 2007-10-16 01:27:34 -0700 | [diff] [blame] | 265 | printk(KERN_ERR "hostaudio_open_mixdev failed to open '%s', " |
| 266 | "err = %d\n", dsp, -ret); |
Dan Streetman | b51d23e4 | 2015-06-17 06:18:52 +0930 | [diff] [blame] | 267 | kernel_param_unlock(THIS_MODULE); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 268 | kfree(state); |
Jeff Dike | cb8fa61 | 2007-10-16 01:27:34 -0700 | [diff] [blame] | 269 | return ret; |
Jeff Dike | d471c0f | 2007-02-10 01:44:00 -0800 | [diff] [blame] | 270 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 271 | |
Jeff Dike | d471c0f | 2007-02-10 01:44:00 -0800 | [diff] [blame] | 272 | file->private_data = state; |
Jeff Dike | cb8fa61 | 2007-10-16 01:27:34 -0700 | [diff] [blame] | 273 | return 0; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 274 | } |
| 275 | |
| 276 | static int hostmixer_release(struct inode *inode, struct file *file) |
| 277 | { |
Jeff Dike | d471c0f | 2007-02-10 01:44:00 -0800 | [diff] [blame] | 278 | struct hostmixer_state *state = file->private_data; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 279 | |
| 280 | #ifdef DEBUG |
Jeff Dike | cb8fa61 | 2007-10-16 01:27:34 -0700 | [diff] [blame] | 281 | printk(KERN_DEBUG "hostmixer: release called\n"); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 282 | #endif |
| 283 | |
Jeff Dike | d471c0f | 2007-02-10 01:44:00 -0800 | [diff] [blame] | 284 | os_close_file(state->fd); |
| 285 | kfree(state); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 286 | |
Jeff Dike | cb8fa61 | 2007-10-16 01:27:34 -0700 | [diff] [blame] | 287 | return 0; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 288 | } |
| 289 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 290 | /* kernel module operations */ |
| 291 | |
Jeff Dike | 5e7672e | 2006-09-27 01:50:33 -0700 | [diff] [blame] | 292 | static const struct file_operations hostaudio_fops = { |
Jeff Dike | d471c0f | 2007-02-10 01:44:00 -0800 | [diff] [blame] | 293 | .owner = THIS_MODULE, |
| 294 | .llseek = no_llseek, |
| 295 | .read = hostaudio_read, |
| 296 | .write = hostaudio_write, |
| 297 | .poll = hostaudio_poll, |
John Kacur | d6c89d9 | 2010-05-07 17:34:28 +0200 | [diff] [blame] | 298 | .unlocked_ioctl = hostaudio_ioctl, |
Arnd Bergmann | 2022ca0 | 2018-09-06 22:54:38 +0200 | [diff] [blame] | 299 | .compat_ioctl = compat_ptr_ioctl, |
Jeff Dike | d471c0f | 2007-02-10 01:44:00 -0800 | [diff] [blame] | 300 | .mmap = NULL, |
| 301 | .open = hostaudio_open, |
| 302 | .release = hostaudio_release, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 303 | }; |
| 304 | |
Jeff Dike | 5e7672e | 2006-09-27 01:50:33 -0700 | [diff] [blame] | 305 | static const struct file_operations hostmixer_fops = { |
Jeff Dike | d471c0f | 2007-02-10 01:44:00 -0800 | [diff] [blame] | 306 | .owner = THIS_MODULE, |
| 307 | .llseek = no_llseek, |
John Kacur | d6c89d9 | 2010-05-07 17:34:28 +0200 | [diff] [blame] | 308 | .unlocked_ioctl = hostmixer_ioctl_mixdev, |
Jeff Dike | d471c0f | 2007-02-10 01:44:00 -0800 | [diff] [blame] | 309 | .open = hostmixer_open_mixdev, |
| 310 | .release = hostmixer_release, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 311 | }; |
| 312 | |
| 313 | struct { |
| 314 | int dev_audio; |
| 315 | int dev_mixer; |
| 316 | } module_data; |
| 317 | |
| 318 | MODULE_AUTHOR("Steve Schmidtke"); |
| 319 | MODULE_DESCRIPTION("UML Audio Relay"); |
| 320 | MODULE_LICENSE("GPL"); |
| 321 | |
| 322 | static int __init hostaudio_init_module(void) |
| 323 | { |
Dan Streetman | b51d23e4 | 2015-06-17 06:18:52 +0930 | [diff] [blame] | 324 | kernel_param_lock(THIS_MODULE); |
Jeff Dike | d471c0f | 2007-02-10 01:44:00 -0800 | [diff] [blame] | 325 | printk(KERN_INFO "UML Audio Relay (host dsp = %s, host mixer = %s)\n", |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 326 | dsp, mixer); |
Dan Streetman | b51d23e4 | 2015-06-17 06:18:52 +0930 | [diff] [blame] | 327 | kernel_param_unlock(THIS_MODULE); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 328 | |
| 329 | module_data.dev_audio = register_sound_dsp(&hostaudio_fops, -1); |
Jeff Dike | cb8fa61 | 2007-10-16 01:27:34 -0700 | [diff] [blame] | 330 | if (module_data.dev_audio < 0) { |
Jeff Dike | d471c0f | 2007-02-10 01:44:00 -0800 | [diff] [blame] | 331 | printk(KERN_ERR "hostaudio: couldn't register DSP device!\n"); |
| 332 | return -ENODEV; |
| 333 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 334 | |
| 335 | module_data.dev_mixer = register_sound_mixer(&hostmixer_fops, -1); |
Jeff Dike | cb8fa61 | 2007-10-16 01:27:34 -0700 | [diff] [blame] | 336 | if (module_data.dev_mixer < 0) { |
Jeff Dike | d471c0f | 2007-02-10 01:44:00 -0800 | [diff] [blame] | 337 | printk(KERN_ERR "hostmixer: couldn't register mixer " |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 338 | "device!\n"); |
Jeff Dike | d471c0f | 2007-02-10 01:44:00 -0800 | [diff] [blame] | 339 | unregister_sound_dsp(module_data.dev_audio); |
| 340 | return -ENODEV; |
| 341 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 342 | |
Jeff Dike | d471c0f | 2007-02-10 01:44:00 -0800 | [diff] [blame] | 343 | return 0; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 344 | } |
| 345 | |
| 346 | static void __exit hostaudio_cleanup_module (void) |
| 347 | { |
Jeff Dike | d471c0f | 2007-02-10 01:44:00 -0800 | [diff] [blame] | 348 | unregister_sound_mixer(module_data.dev_mixer); |
| 349 | unregister_sound_dsp(module_data.dev_audio); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 350 | } |
| 351 | |
| 352 | module_init(hostaudio_init_module); |
| 353 | module_exit(hostaudio_cleanup_module); |