2 * drivers/misc/goldfish_audio.c
4 * Copyright (C) 2007 Google, Inc.
5 * Copyright (C) 2012 Intel, Inc.
7 * This software is licensed under the terms of the GNU General Public
8 * License version 2, as published by the Free Software Foundation, and
9 * may be copied, distributed, and modified under those terms.
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
18 #include <linux/module.h>
19 #include <linux/miscdevice.h>
21 #include <linux/platform_device.h>
22 #include <linux/types.h>
23 #include <linux/pci.h>
24 #include <linux/interrupt.h>
26 #include <linux/sched.h>
27 #include <linux/dma-mapping.h>
28 #include <linux/uaccess.h>
29 #include <linux/slab.h>
30 #include <linux/goldfish.h>
32 MODULE_AUTHOR("Google, Inc.");
33 MODULE_DESCRIPTION("Android QEMU Audio Driver");
34 MODULE_LICENSE("GPL");
35 MODULE_VERSION("1.0");
37 struct goldfish_audio
{
38 char __iomem
*reg_base
;
40 /* lock protects access to buffer_status and to device registers */
42 wait_queue_head_t wait
;
44 char *buffer_virt
; /* combined buffer virtual address */
45 unsigned long buffer_phys
; /* combined buffer physical address */
47 char *write_buffer1
; /* write buffer 1 virtual address */
48 char *write_buffer2
; /* write buffer 2 virtual address */
49 char *read_buffer
; /* read buffer virtual address */
51 int read_supported
; /* true if we have audio input support */
55 * We will allocate two read buffers and two write buffers.
56 * Having two read buffers facilitate stereo -> mono conversion.
57 * Having two write buffers facilitate interleaved IO.
59 #define READ_BUFFER_SIZE 16384
60 #define WRITE_BUFFER_SIZE 16384
61 #define COMBINED_BUFFER_SIZE ((2 * READ_BUFFER_SIZE) + \
62 (2 * WRITE_BUFFER_SIZE))
64 #define AUDIO_READ(data, addr) (readl(data->reg_base + addr))
65 #define AUDIO_WRITE(data, addr, x) (writel(x, data->reg_base + addr))
66 #define AUDIO_WRITE64(data, addr, addr2, x) \
67 (gf_write_dma_addr((x), data->reg_base + addr, data->reg_base + addr2))
70 * temporary variable used between goldfish_audio_probe() and
71 * goldfish_audio_open()
73 static struct goldfish_audio
*audio_data
;
76 /* audio status register */
77 AUDIO_INT_STATUS
= 0x00,
78 /* set this to enable IRQ */
79 AUDIO_INT_ENABLE
= 0x04,
80 /* set these to specify buffer addresses */
81 AUDIO_SET_WRITE_BUFFER_1
= 0x08,
82 AUDIO_SET_WRITE_BUFFER_2
= 0x0C,
83 /* set number of bytes in buffer to write */
84 AUDIO_WRITE_BUFFER_1
= 0x10,
85 AUDIO_WRITE_BUFFER_2
= 0x14,
86 AUDIO_SET_WRITE_BUFFER_1_HIGH
= 0x28,
87 AUDIO_SET_WRITE_BUFFER_2_HIGH
= 0x30,
89 /* true if audio input is supported */
90 AUDIO_READ_SUPPORTED
= 0x18,
91 /* buffer to use for audio input */
92 AUDIO_SET_READ_BUFFER
= 0x1C,
93 AUDIO_SET_READ_BUFFER_HIGH
= 0x34,
95 /* driver writes number of bytes to read */
96 AUDIO_START_READ
= 0x20,
98 /* number of bytes available in read buffer */
99 AUDIO_READ_BUFFER_AVAILABLE
= 0x24,
101 /* AUDIO_INT_STATUS bits */
103 /* this bit set when it is safe to write more bytes to the buffer */
104 AUDIO_INT_WRITE_BUFFER_1_EMPTY
= 1U << 0,
105 AUDIO_INT_WRITE_BUFFER_2_EMPTY
= 1U << 1,
106 AUDIO_INT_READ_BUFFER_FULL
= 1U << 2,
108 AUDIO_INT_MASK
= AUDIO_INT_WRITE_BUFFER_1_EMPTY
|
109 AUDIO_INT_WRITE_BUFFER_2_EMPTY
|
110 AUDIO_INT_READ_BUFFER_FULL
,
113 static atomic_t open_count
= ATOMIC_INIT(0);
115 static ssize_t
goldfish_audio_read(struct file
*fp
, char __user
*buf
,
116 size_t count
, loff_t
*pos
)
118 struct goldfish_audio
*data
= fp
->private_data
;
122 if (!data
->read_supported
)
126 length
= (count
> READ_BUFFER_SIZE
? READ_BUFFER_SIZE
: count
);
127 AUDIO_WRITE(data
, AUDIO_START_READ
, length
);
129 wait_event_interruptible(data
->wait
, data
->buffer_status
&
130 AUDIO_INT_READ_BUFFER_FULL
);
132 length
= AUDIO_READ(data
, AUDIO_READ_BUFFER_AVAILABLE
);
134 /* copy data to user space */
135 if (copy_to_user(buf
, data
->read_buffer
, length
))
145 static ssize_t
goldfish_audio_write(struct file
*fp
, const char __user
*buf
,
146 size_t count
, loff_t
*pos
)
148 struct goldfish_audio
*data
= fp
->private_data
;
149 unsigned long irq_flags
;
154 ssize_t copy
= count
;
156 if (copy
> WRITE_BUFFER_SIZE
)
157 copy
= WRITE_BUFFER_SIZE
;
158 wait_event_interruptible(data
->wait
, data
->buffer_status
&
159 (AUDIO_INT_WRITE_BUFFER_1_EMPTY
|
160 AUDIO_INT_WRITE_BUFFER_2_EMPTY
));
162 if ((data
->buffer_status
& AUDIO_INT_WRITE_BUFFER_1_EMPTY
) != 0)
163 kbuf
= data
->write_buffer1
;
165 kbuf
= data
->write_buffer2
;
167 /* copy from user space to the appropriate buffer */
168 if (copy_from_user(kbuf
, buf
, copy
)) {
173 spin_lock_irqsave(&data
->lock
, irq_flags
);
175 * clear the buffer empty flag, and signal the emulator
176 * to start writing the buffer
178 if (kbuf
== data
->write_buffer1
) {
179 data
->buffer_status
&= ~AUDIO_INT_WRITE_BUFFER_1_EMPTY
;
180 AUDIO_WRITE(data
, AUDIO_WRITE_BUFFER_1
, copy
);
182 data
->buffer_status
&= ~AUDIO_INT_WRITE_BUFFER_2_EMPTY
;
183 AUDIO_WRITE(data
, AUDIO_WRITE_BUFFER_2
, copy
);
185 spin_unlock_irqrestore(&data
->lock
, irq_flags
);
194 static int goldfish_audio_open(struct inode
*ip
, struct file
*fp
)
199 if (atomic_inc_return(&open_count
) == 1) {
200 fp
->private_data
= audio_data
;
201 audio_data
->buffer_status
= (AUDIO_INT_WRITE_BUFFER_1_EMPTY
|
202 AUDIO_INT_WRITE_BUFFER_2_EMPTY
);
203 AUDIO_WRITE(audio_data
, AUDIO_INT_ENABLE
, AUDIO_INT_MASK
);
207 atomic_dec(&open_count
);
211 static int goldfish_audio_release(struct inode
*ip
, struct file
*fp
)
213 atomic_dec(&open_count
);
214 /* FIXME: surely this is wrong for the multi-opened case */
215 AUDIO_WRITE(audio_data
, AUDIO_INT_ENABLE
, 0);
219 static long goldfish_audio_ioctl(struct file
*fp
, unsigned int cmd
,
222 /* temporary workaround, until we switch to the ALSA API */
229 static irqreturn_t
goldfish_audio_interrupt(int irq
, void *dev_id
)
231 unsigned long irq_flags
;
232 struct goldfish_audio
*data
= dev_id
;
235 spin_lock_irqsave(&data
->lock
, irq_flags
);
237 /* read buffer status flags */
238 status
= AUDIO_READ(data
, AUDIO_INT_STATUS
);
239 status
&= AUDIO_INT_MASK
;
241 * if buffers are newly empty, wake up blocked
242 * goldfish_audio_write() call
245 data
->buffer_status
= status
;
246 wake_up(&data
->wait
);
249 spin_unlock_irqrestore(&data
->lock
, irq_flags
);
250 return status
? IRQ_HANDLED
: IRQ_NONE
;
253 /* file operations for /dev/eac */
254 static const struct file_operations goldfish_audio_fops
= {
255 .owner
= THIS_MODULE
,
256 .read
= goldfish_audio_read
,
257 .write
= goldfish_audio_write
,
258 .open
= goldfish_audio_open
,
259 .release
= goldfish_audio_release
,
260 .unlocked_ioctl
= goldfish_audio_ioctl
,
263 static struct miscdevice goldfish_audio_device
= {
264 .minor
= MISC_DYNAMIC_MINOR
,
266 .fops
= &goldfish_audio_fops
,
269 static int goldfish_audio_probe(struct platform_device
*pdev
)
273 struct goldfish_audio
*data
;
276 data
= devm_kzalloc(&pdev
->dev
, sizeof(*data
), GFP_KERNEL
);
279 spin_lock_init(&data
->lock
);
280 init_waitqueue_head(&data
->wait
);
281 platform_set_drvdata(pdev
, data
);
283 r
= platform_get_resource(pdev
, IORESOURCE_MEM
, 0);
285 dev_err(&pdev
->dev
, "platform_get_resource failed\n");
288 data
->reg_base
= devm_ioremap(&pdev
->dev
, r
->start
, PAGE_SIZE
);
292 data
->irq
= platform_get_irq(pdev
, 0);
294 dev_err(&pdev
->dev
, "platform_get_irq failed\n");
297 data
->buffer_virt
= dmam_alloc_coherent(&pdev
->dev
,
298 COMBINED_BUFFER_SIZE
, &buf_addr
, GFP_KERNEL
);
299 if (!data
->buffer_virt
) {
300 dev_err(&pdev
->dev
, "allocate buffer failed\n");
303 data
->buffer_phys
= buf_addr
;
304 data
->write_buffer1
= data
->buffer_virt
;
305 data
->write_buffer2
= data
->buffer_virt
+ WRITE_BUFFER_SIZE
;
306 data
->read_buffer
= data
->buffer_virt
+ 2 * WRITE_BUFFER_SIZE
;
308 ret
= devm_request_irq(&pdev
->dev
, data
->irq
, goldfish_audio_interrupt
,
309 IRQF_SHARED
, pdev
->name
, data
);
311 dev_err(&pdev
->dev
, "request_irq failed\n");
315 ret
= misc_register(&goldfish_audio_device
);
318 "misc_register returned %d in goldfish_audio_init\n",
323 AUDIO_WRITE64(data
, AUDIO_SET_WRITE_BUFFER_1
,
324 AUDIO_SET_WRITE_BUFFER_1_HIGH
, buf_addr
);
325 buf_addr
+= WRITE_BUFFER_SIZE
;
327 AUDIO_WRITE64(data
, AUDIO_SET_WRITE_BUFFER_2
,
328 AUDIO_SET_WRITE_BUFFER_2_HIGH
, buf_addr
);
330 buf_addr
+= WRITE_BUFFER_SIZE
;
332 data
->read_supported
= AUDIO_READ(data
, AUDIO_READ_SUPPORTED
);
333 if (data
->read_supported
)
334 AUDIO_WRITE64(data
, AUDIO_SET_READ_BUFFER
,
335 AUDIO_SET_READ_BUFFER_HIGH
, buf_addr
);
341 static int goldfish_audio_remove(struct platform_device
*pdev
)
343 misc_deregister(&goldfish_audio_device
);
348 static const struct of_device_id goldfish_audio_of_match
[] = {
349 { .compatible
= "google,goldfish-audio", },
352 MODULE_DEVICE_TABLE(of
, goldfish_audio_of_match
);
354 static struct platform_driver goldfish_audio_driver
= {
355 .probe
= goldfish_audio_probe
,
356 .remove
= goldfish_audio_remove
,
358 .name
= "goldfish_audio",
359 .of_match_table
= goldfish_audio_of_match
,
363 module_platform_driver(goldfish_audio_driver
);