1 /* $Id: dmy.c,v 1.6 2000/12/13 05:06:26 davem Exp $
2 * drivers/sbus/audio/dummy.c
4 * Copyright 1998 Derrick J Brashear (shadow@andrew.cmu.edu)
6 * This is a dummy lowlevel driver. Consider it a distant cousin of
7 * /proc/audio; It pretends to be a piece of audio hardware, and writes
8 * to a file instead. (or will shortly)
11 #include <linux/module.h>
12 #include <linux/kernel.h>
13 #include <linux/sched.h>
14 #include <linux/errno.h>
15 #include <linux/interrupt.h>
16 #include <linux/malloc.h>
17 #include <linux/init.h>
18 #include <linux/soundcard.h>
19 #include <linux/delay.h>
20 #include <asm/openprom.h>
21 #include <asm/oplib.h>
22 #include <asm/system.h>
24 #include <asm/pgtable.h>
27 #include <asm/audioio.h>
31 static struct sparcaudio_driver drivers
[MAX_DRIVERS
];
32 static int num_drivers
;
34 static int dummy_play_gain(struct sparcaudio_driver
*drv
, int value
,
35 unsigned char balance
);
36 static int dummy_record_gain(struct sparcaudio_driver
*drv
, int value
,
37 unsigned char balance
);
38 static int dummy_output_muted(struct sparcaudio_driver
*drv
, int value
);
39 static int dummy_attach(struct sparcaudio_driver
*drv
);
42 dummy_set_output_encoding(struct sparcaudio_driver
*drv
, int value
)
44 struct dummy_chip
*dummy_chip
= (struct dummy_chip
*) drv
->private;
47 dummy_chip
->perchip_info
.play
.encoding
= value
;
54 dummy_set_input_encoding(struct sparcaudio_driver
*drv
, int value
)
56 struct dummy_chip
*dummy_chip
= (struct dummy_chip
*) drv
->private;
59 dummy_chip
->perchip_info
.record
.encoding
= value
;
65 static int dummy_get_output_encoding(struct sparcaudio_driver
*drv
)
67 struct dummy_chip
*dummy_chip
= (struct dummy_chip
*) drv
->private;
69 return dummy_chip
->perchip_info
.play
.encoding
;
72 static int dummy_get_input_encoding(struct sparcaudio_driver
*drv
)
74 struct dummy_chip
*dummy_chip
= (struct dummy_chip
*) drv
->private;
76 return dummy_chip
->perchip_info
.record
.encoding
;
80 dummy_set_output_rate(struct sparcaudio_driver
*drv
, int value
)
82 struct dummy_chip
*dummy_chip
= (struct dummy_chip
*) drv
->private;
85 dummy_chip
->perchip_info
.play
.sample_rate
= value
;
92 dummy_set_input_rate(struct sparcaudio_driver
*drv
, int value
)
94 struct dummy_chip
*dummy_chip
= (struct dummy_chip
*) drv
->private;
97 dummy_chip
->perchip_info
.record
.sample_rate
= value
;
103 static int dummy_get_output_rate(struct sparcaudio_driver
*drv
)
105 struct dummy_chip
*dummy_chip
= (struct dummy_chip
*) drv
->private;
107 return dummy_chip
->perchip_info
.play
.sample_rate
;
110 static int dummy_get_input_rate(struct sparcaudio_driver
*drv
)
112 struct dummy_chip
*dummy_chip
= (struct dummy_chip
*) drv
->private;
114 return dummy_chip
->perchip_info
.record
.sample_rate
;
117 /* Generically we support 4 channels. This does 2 */
119 dummy_set_output_channels(struct sparcaudio_driver
*drv
, int value
)
121 struct dummy_chip
*dummy_chip
= (struct dummy_chip
*) drv
->private;
131 dummy_chip
->perchip_info
.play
.channels
= value
;
135 /* Generically we support 4 channels. This does 2 */
137 dummy_set_input_channels(struct sparcaudio_driver
*drv
, int value
)
139 struct dummy_chip
*dummy_chip
= (struct dummy_chip
*) drv
->private;
149 dummy_chip
->perchip_info
.record
.channels
= value
;
153 static int dummy_get_input_channels(struct sparcaudio_driver
*drv
)
155 struct dummy_chip
*dummy_chip
= (struct dummy_chip
*) drv
->private;
157 return dummy_chip
->perchip_info
.record
.channels
;
160 static int dummy_get_output_channels(struct sparcaudio_driver
*drv
)
162 struct dummy_chip
*dummy_chip
= (struct dummy_chip
*) drv
->private;
164 return dummy_chip
->perchip_info
.play
.channels
;
167 static int dummy_get_output_precision(struct sparcaudio_driver
*drv
)
169 struct dummy_chip
*dummy_chip
= (struct dummy_chip
*) drv
->private;
171 return dummy_chip
->perchip_info
.play
.precision
;
174 static int dummy_get_input_precision(struct sparcaudio_driver
*drv
)
176 struct dummy_chip
*dummy_chip
= (struct dummy_chip
*) drv
->private;
178 return dummy_chip
->perchip_info
.record
.precision
;
181 static int dummy_set_output_precision(struct sparcaudio_driver
*drv
, int val
)
183 struct dummy_chip
*dummy_chip
= (struct dummy_chip
*) drv
->private;
185 dummy_chip
->perchip_info
.play
.precision
= val
;
186 return dummy_chip
->perchip_info
.play
.precision
;
189 static int dummy_set_input_precision(struct sparcaudio_driver
*drv
, int val
)
191 struct dummy_chip
*dummy_chip
= (struct dummy_chip
*) drv
->private;
193 dummy_chip
->perchip_info
.record
.precision
= val
;
194 return dummy_chip
->perchip_info
.record
.precision
;
197 /* Set output mute */
198 static int dummy_output_muted(struct sparcaudio_driver
*drv
, int value
)
200 struct dummy_chip
*dummy_chip
= (struct dummy_chip
*) drv
->private;
203 dummy_chip
->perchip_info
.output_muted
= 0;
205 dummy_chip
->perchip_info
.output_muted
= 1;
210 static int dummy_get_output_muted(struct sparcaudio_driver
*drv
)
212 struct dummy_chip
*dummy_chip
= (struct dummy_chip
*) drv
->private;
214 return dummy_chip
->perchip_info
.output_muted
;
217 static int dummy_get_formats(struct sparcaudio_driver
*drv
)
219 return (AFMT_MU_LAW
| AFMT_A_LAW
|
220 AFMT_U8
| AFMT_IMA_ADPCM
|
221 AFMT_S16_LE
| AFMT_S16_BE
);
224 static int dummy_get_output_ports(struct sparcaudio_driver
*drv
)
226 return (AUDIO_LINE_OUT
| AUDIO_SPEAKER
| AUDIO_HEADPHONE
);
229 static int dummy_get_input_ports(struct sparcaudio_driver
*drv
)
231 return (AUDIO_ANALOG_LOOPBACK
);
234 /* Set chip "output" port */
235 static int dummy_set_output_port(struct sparcaudio_driver
*drv
, int value
)
237 struct dummy_chip
*dummy_chip
= (struct dummy_chip
*) drv
->private;
239 dummy_chip
->perchip_info
.play
.port
= value
;
243 static int dummy_set_input_port(struct sparcaudio_driver
*drv
, int value
)
245 struct dummy_chip
*dummy_chip
= (struct dummy_chip
*) drv
->private;
247 dummy_chip
->perchip_info
.record
.port
= value
;
251 static int dummy_get_output_port(struct sparcaudio_driver
*drv
)
253 struct dummy_chip
*dummy_chip
= (struct dummy_chip
*) drv
->private;
255 return dummy_chip
->perchip_info
.play
.port
;
258 static int dummy_get_input_port(struct sparcaudio_driver
*drv
)
260 struct dummy_chip
*dummy_chip
= (struct dummy_chip
*) drv
->private;
262 return dummy_chip
->perchip_info
.record
.port
;
265 static int dummy_get_output_error(struct sparcaudio_driver
*drv
)
267 struct dummy_chip
*dummy_chip
= (struct dummy_chip
*) drv
->private;
269 return (int) dummy_chip
->perchip_info
.play
.error
;
272 static int dummy_get_input_error(struct sparcaudio_driver
*drv
)
274 struct dummy_chip
*dummy_chip
= (struct dummy_chip
*) drv
->private;
276 return (int) dummy_chip
->perchip_info
.record
.error
;
279 static int dummy_get_output_samples(struct sparcaudio_driver
*drv
)
281 struct dummy_chip
*dummy_chip
= (struct dummy_chip
*) drv
->private;
283 return dummy_chip
->perchip_info
.play
.samples
;
286 static int dummy_get_output_pause(struct sparcaudio_driver
*drv
)
288 struct dummy_chip
*dummy_chip
= (struct dummy_chip
*) drv
->private;
290 return (int) dummy_chip
->perchip_info
.play
.pause
;
293 static int dummy_set_output_volume(struct sparcaudio_driver
*drv
, int value
)
295 struct dummy_chip
*dummy_chip
= (struct dummy_chip
*) drv
->private;
297 dummy_play_gain(drv
, value
, dummy_chip
->perchip_info
.play
.balance
);
301 static int dummy_get_output_volume(struct sparcaudio_driver
*drv
)
303 struct dummy_chip
*dummy_chip
= (struct dummy_chip
*) drv
->private;
305 return dummy_chip
->perchip_info
.play
.gain
;
308 static int dummy_set_output_balance(struct sparcaudio_driver
*drv
, int value
)
310 struct dummy_chip
*dummy_chip
= (struct dummy_chip
*) drv
->private;
312 dummy_chip
->perchip_info
.play
.balance
= value
;
313 dummy_play_gain(drv
, dummy_chip
->perchip_info
.play
.gain
,
314 dummy_chip
->perchip_info
.play
.balance
);
318 static int dummy_get_output_balance(struct sparcaudio_driver
*drv
)
320 struct dummy_chip
*dummy_chip
= (struct dummy_chip
*) drv
->private;
322 return (int) dummy_chip
->perchip_info
.play
.balance
;
325 /* Set chip play gain */
326 static int dummy_play_gain(struct sparcaudio_driver
*drv
,
327 int value
, unsigned char balance
)
329 struct dummy_chip
*dummy_chip
= (struct dummy_chip
*) drv
->private;
330 int tmp
= 0, r
, l
, r_adj
, l_adj
;
333 if (balance
< AUDIO_MID_BALANCE
) {
335 ((AUDIO_MID_BALANCE
- balance
) << AUDIO_BALANCE_SHIFT
));
339 } else if (balance
> AUDIO_MID_BALANCE
) {
341 ((balance
- AUDIO_MID_BALANCE
) << AUDIO_BALANCE_SHIFT
));
346 (l
== 0) ? (l_adj
= DUMMY_MAX_DEV_ATEN
) : (l_adj
= DUMMY_MAX_ATEN
-
347 (l
* (DUMMY_MAX_ATEN
+ 1) /
348 (AUDIO_MAX_GAIN
+ 1)));
349 (r
== 0) ? (r_adj
= DUMMY_MAX_DEV_ATEN
) : (r_adj
= DUMMY_MAX_ATEN
-
350 (r
* (DUMMY_MAX_ATEN
+ 1) /
351 (AUDIO_MAX_GAIN
+ 1)));
352 if ((value
== 0) || (value
== AUDIO_MAX_GAIN
)) {
356 tmp
= ((DUMMY_MAX_ATEN
- l_adj
) * (AUDIO_MAX_GAIN
+ 1) /
357 (DUMMY_MAX_ATEN
+ 1));
358 } else if (value
== r
) {
359 tmp
= ((DUMMY_MAX_ATEN
- r_adj
) * (AUDIO_MAX_GAIN
+ 1) /
360 (DUMMY_MAX_ATEN
+ 1));
363 dummy_chip
->perchip_info
.play
.gain
= tmp
;
367 static int dummy_get_input_samples(struct sparcaudio_driver
*drv
)
369 struct dummy_chip
*dummy_chip
= (struct dummy_chip
*) drv
->private;
371 return dummy_chip
->perchip_info
.record
.samples
;
374 static int dummy_get_input_pause(struct sparcaudio_driver
*drv
)
376 struct dummy_chip
*dummy_chip
= (struct dummy_chip
*) drv
->private;
378 return (int) dummy_chip
->perchip_info
.record
.pause
;
381 static int dummy_set_monitor_volume(struct sparcaudio_driver
*drv
, int value
)
386 static int dummy_get_monitor_volume(struct sparcaudio_driver
*drv
)
391 static int dummy_set_input_volume(struct sparcaudio_driver
*drv
, int value
)
393 struct dummy_chip
*dummy_chip
= (struct dummy_chip
*) drv
->private;
395 dummy_record_gain(drv
, value
, dummy_chip
->perchip_info
.record
.balance
);
399 static int dummy_get_input_volume(struct sparcaudio_driver
*drv
)
401 struct dummy_chip
*dummy_chip
= (struct dummy_chip
*) drv
->private;
403 return dummy_chip
->perchip_info
.record
.gain
;
406 static int dummy_set_input_balance(struct sparcaudio_driver
*drv
, int value
)
408 struct dummy_chip
*dummy_chip
= (struct dummy_chip
*) drv
->private;
410 dummy_chip
->perchip_info
.record
.balance
= value
;
411 dummy_record_gain(drv
, dummy_chip
->perchip_info
.record
.gain
,
412 dummy_chip
->perchip_info
.play
.balance
);
416 static int dummy_get_input_balance(struct sparcaudio_driver
*drv
)
418 struct dummy_chip
*dummy_chip
= (struct dummy_chip
*) drv
->private;
420 return (int) dummy_chip
->perchip_info
.record
.balance
;
423 static int dummy_record_gain(struct sparcaudio_driver
*drv
,
424 int value
, unsigned char balance
)
426 struct dummy_chip
*dummy_chip
= (struct dummy_chip
*) drv
->private;
427 int tmp
= 0, r
, l
, r_adj
, l_adj
;
430 if (balance
< AUDIO_MID_BALANCE
) {
432 ((AUDIO_MID_BALANCE
- balance
) << AUDIO_BALANCE_SHIFT
));
436 } else if (balance
> AUDIO_MID_BALANCE
) {
438 ((balance
- AUDIO_MID_BALANCE
) << AUDIO_BALANCE_SHIFT
));
443 (l
== 0) ? (l_adj
= DUMMY_MAX_DEV_ATEN
) : (l_adj
= DUMMY_MAX_ATEN
-
444 (l
* (DUMMY_MAX_ATEN
+ 1) /
445 (AUDIO_MAX_GAIN
+ 1)));
446 (r
== 0) ? (r_adj
= DUMMY_MAX_DEV_ATEN
) : (r_adj
= DUMMY_MAX_ATEN
-
447 (r
* (DUMMY_MAX_ATEN
+ 1) /
448 (AUDIO_MAX_GAIN
+ 1)));
449 if ((value
== 0) || (value
== AUDIO_MAX_GAIN
)) {
453 tmp
= ((DUMMY_MAX_ATEN
- l_adj
) * (AUDIO_MAX_GAIN
+ 1) /
454 (DUMMY_MAX_ATEN
+ 1));
455 } else if (value
== r
) {
456 tmp
= ((DUMMY_MAX_ATEN
- r_adj
) * (AUDIO_MAX_GAIN
+ 1) /
457 (DUMMY_MAX_ATEN
+ 1));
460 dummy_chip
->perchip_info
.record
.gain
= tmp
;
464 /* Reset the audio chip to a sane state. */
465 static void dummy_chip_reset(struct sparcaudio_driver
*drv
)
467 dummy_set_output_encoding(drv
, AUDIO_ENCODING_ULAW
);
468 dummy_set_output_rate(drv
, DUMMY_RATE
);
469 dummy_set_output_channels(drv
, DUMMY_CHANNELS
);
470 dummy_set_output_precision(drv
, DUMMY_PRECISION
);
471 dummy_set_output_balance(drv
, AUDIO_MID_BALANCE
);
472 dummy_set_output_volume(drv
, DUMMY_DEFAULT_PLAYGAIN
);
473 dummy_set_output_port(drv
, AUDIO_SPEAKER
);
474 dummy_output_muted(drv
, 0);
475 dummy_set_input_encoding(drv
, AUDIO_ENCODING_ULAW
);
476 dummy_set_input_rate(drv
, DUMMY_RATE
);
477 dummy_set_input_channels(drv
, DUMMY_CHANNELS
);
478 dummy_set_input_precision(drv
, DUMMY_PRECISION
);
479 dummy_set_input_balance(drv
, AUDIO_MID_BALANCE
);
480 dummy_set_input_volume(drv
, DUMMY_DEFAULT_PLAYGAIN
);
481 dummy_set_input_port(drv
, AUDIO_SPEAKER
);
484 static int dummy_open(struct inode
* inode
, struct file
* file
, struct sparcaudio_driver
*drv
)
486 struct dummy_chip
*dummy_chip
= (struct dummy_chip
*) drv
->private;
488 /* Set the default audio parameters if not already in use. */
489 if (file
->f_mode
& FMODE_WRITE
) {
490 if (!(drv
->flags
& SDF_OPEN_WRITE
) &&
491 (dummy_chip
->perchip_info
.play
.active
== 0)) {
492 dummy_chip
->perchip_info
.play
.open
= 1;
493 dummy_chip
->perchip_info
.play
.samples
=
494 dummy_chip
->perchip_info
.play
.error
= 0;
498 if (file
->f_mode
& FMODE_READ
) {
499 if (!(drv
->flags
& SDF_OPEN_READ
) &&
500 (dummy_chip
->perchip_info
.record
.active
== 0)) {
501 dummy_chip
->perchip_info
.record
.open
= 1;
502 dummy_chip
->perchip_info
.record
.samples
=
503 dummy_chip
->perchip_info
.record
.error
= 0;
512 static void dummy_release(struct inode
* inode
, struct file
* file
, struct sparcaudio_driver
*drv
)
514 struct dummy_chip
*dummy_chip
= (struct dummy_chip
*) drv
->private;
516 if (file
->f_mode
& FMODE_WRITE
) {
517 dummy_chip
->perchip_info
.play
.active
=
518 dummy_chip
->perchip_info
.play
.open
= 0;
521 if (file
->f_mode
& FMODE_READ
) {
522 dummy_chip
->perchip_info
.record
.active
=
523 dummy_chip
->perchip_info
.record
.open
= 0;
529 static void dummy_output_done_task(void * arg
)
531 struct sparcaudio_driver
*drv
= (struct sparcaudio_driver
*) arg
;
532 struct dummy_chip
*dummy_chip
= (struct dummy_chip
*) drv
->private;
534 sparcaudio_output_done(drv
, 1);
535 if (dummy_chip
->perchip_info
.record
.active
)
536 sparcaudio_input_done(drv
, 1);
539 static void dummy_start_output(struct sparcaudio_driver
*drv
, __u8
* buffer
,
542 struct dummy_chip
*dummy_chip
= (struct dummy_chip
*) drv
->private;
544 if (dummy_chip
->perchip_info
.play
.pause
|| !count
)
547 dummy_chip
->perchip_info
.play
.active
= 1;
549 /* fake an "interrupt" to deal with this block */
550 INIT_LIST_HEAD(&dummy_chip
->tqueue
.list
);
551 dummy_chip
->tqueue
.sync
= 0;
552 dummy_chip
->tqueue
.routine
= dummy_output_done_task
;
553 dummy_chip
->tqueue
.data
= drv
;
555 queue_task(&dummy_chip
->tqueue
, &tq_immediate
);
556 mark_bh(IMMEDIATE_BH
);
559 static void dummy_start_input(struct sparcaudio_driver
*drv
, __u8
* buffer
,
562 struct dummy_chip
*dummy_chip
= (struct dummy_chip
*) drv
->private;
564 dummy_chip
->perchip_info
.record
.active
= 1;
567 static void dummy_stop_output(struct sparcaudio_driver
*drv
)
569 struct dummy_chip
*dummy_chip
= (struct dummy_chip
*) drv
->private;
571 dummy_chip
->perchip_info
.play
.active
= 0;
574 static void dummy_stop_input(struct sparcaudio_driver
*drv
)
576 struct dummy_chip
*dummy_chip
= (struct dummy_chip
*) drv
->private;
578 dummy_chip
->perchip_info
.record
.active
= 0;
581 static int dummy_set_output_pause(struct sparcaudio_driver
*drv
, int value
)
583 struct dummy_chip
*dummy_chip
= (struct dummy_chip
*) drv
->private;
585 dummy_chip
->perchip_info
.play
.pause
= value
;
588 sparcaudio_output_done(drv
, 0);
593 static int dummy_set_input_pause(struct sparcaudio_driver
*drv
, int value
)
595 struct dummy_chip
*dummy_chip
= (struct dummy_chip
*) drv
->private;
597 dummy_chip
->perchip_info
.record
.pause
= value
;
599 /* This should probably cause play pause. */
604 static int dummy_set_input_error(struct sparcaudio_driver
*drv
, int value
)
609 static int dummy_set_output_error(struct sparcaudio_driver
*drv
, int value
)
611 struct dummy_chip
*dummy_chip
= (struct dummy_chip
*) drv
->private;
614 i
= dummy_chip
->perchip_info
.play
.error
;
615 dummy_chip
->perchip_info
.play
.error
= value
;
619 static int dummy_set_output_samples(struct sparcaudio_driver
*drv
, int value
)
621 struct dummy_chip
*dummy_chip
= (struct dummy_chip
*) drv
->private;
624 i
= dummy_chip
->perchip_info
.play
.samples
;
625 dummy_chip
->perchip_info
.play
.samples
= value
;
629 static int dummy_set_input_samples(struct sparcaudio_driver
*drv
, int value
)
631 struct dummy_chip
*dummy_chip
= (struct dummy_chip
*) drv
->private;
634 i
= dummy_chip
->perchip_info
.play
.samples
;
635 dummy_chip
->perchip_info
.record
.samples
= value
;
639 /* In order to fake things which care out, play we're a 4231 */
640 static void dummy_audio_getdev(struct sparcaudio_driver
*drv
,
641 audio_device_t
* audinfo
)
643 strncpy(audinfo
->name
, "SUNW,cs4231", sizeof(audinfo
->name
) - 1);
644 strncpy(audinfo
->version
, "a", sizeof(audinfo
->version
) - 1);
645 strncpy(audinfo
->config
, "onboard1", sizeof(audinfo
->config
) - 1);
649 static int dummy_audio_getdev_sunos(struct sparcaudio_driver
*drv
)
654 static struct sparcaudio_operations dummy_ops
= {
663 dummy_set_output_volume
,
664 dummy_get_output_volume
,
665 dummy_set_input_volume
,
666 dummy_get_input_volume
,
667 dummy_set_monitor_volume
,
668 dummy_get_monitor_volume
,
669 dummy_set_output_balance
,
670 dummy_get_output_balance
,
671 dummy_set_input_balance
,
672 dummy_get_input_balance
,
673 dummy_set_output_channels
,
674 dummy_get_output_channels
,
675 dummy_set_input_channels
,
676 dummy_get_input_channels
,
677 dummy_set_output_precision
,
678 dummy_get_output_precision
,
679 dummy_set_input_precision
,
680 dummy_get_input_precision
,
681 dummy_set_output_port
,
682 dummy_get_output_port
,
683 dummy_set_input_port
,
684 dummy_get_input_port
,
685 dummy_set_output_encoding
,
686 dummy_get_output_encoding
,
687 dummy_set_input_encoding
,
688 dummy_get_input_encoding
,
689 dummy_set_output_rate
,
690 dummy_get_output_rate
,
691 dummy_set_input_rate
,
692 dummy_get_input_rate
,
693 dummy_audio_getdev_sunos
,
694 dummy_get_output_ports
,
695 dummy_get_input_ports
,
697 dummy_get_output_muted
,
698 dummy_set_output_pause
,
699 dummy_get_output_pause
,
700 dummy_set_input_pause
,
701 dummy_get_input_pause
,
702 dummy_set_output_samples
,
703 dummy_get_output_samples
,
704 dummy_set_input_samples
,
705 dummy_get_input_samples
,
706 dummy_set_output_error
,
707 dummy_get_output_error
,
708 dummy_set_input_error
,
709 dummy_get_input_error
,
713 /* Probe for the dummy chip and then attach the driver. */
715 int init_module(void)
717 int __init
dummy_init(void)
722 /* Add support here for specifying multiple dummies to attach at once. */
723 if (dummy_attach(&drivers
[num_drivers
]) == 0)
726 /* Only return success if we found some dummy chips. */
727 return (num_drivers
> 0) ? 0 : -EIO
;
730 /* Attach to an dummy chip given its PROM node. */
731 static int dummy_attach(struct sparcaudio_driver
*drv
)
733 struct dummy_chip
*dummy_chip
;
736 /* Allocate our private information structure. */
737 drv
->private = kmalloc(sizeof(struct dummy_chip
), GFP_KERNEL
);
738 if (drv
->private == NULL
)
741 /* Point at the information structure and initialize it. */
742 drv
->ops
= &dummy_ops
;
743 dummy_chip
= (struct dummy_chip
*) drv
->private;
745 /* Reset parameters. */
746 dummy_chip_reset(drv
);
748 /* Register ourselves with the midlevel audio driver. */
749 err
= register_sparcaudio_driver(drv
, 2);
752 printk(KERN_ERR
"dummy: unable to register\n");
757 dummy_chip
->perchip_info
.play
.active
=
758 dummy_chip
->perchip_info
.play
.pause
= 0;
760 dummy_chip
->perchip_info
.play
.avail_ports
= (AUDIO_HEADPHONE
|
764 /* Announce the hardware to the user. */
765 printk(KERN_INFO
"audio%d: dummy at 0x0 irq 0\n", drv
->index
);
772 /* Detach from an dummy chip given the device structure. */
773 static void dummy_detach(struct sparcaudio_driver
*drv
)
775 unregister_sparcaudio_driver(drv
, 2);
779 void cleanup_module(void)
783 for (i
= 0; i
< num_drivers
; i
++) {
784 dummy_detach(&drivers
[i
]);
791 * Overrides for Emacs so that we follow Linus's tabbing style.
792 * Emacs will notice this stuff at the end of the file and automatically
793 * adjust the settings for this buffer only. This must remain at the end
795 * ---------------------------------------------------------------------------
798 * c-brace-imaginary-offset: 0
800 * c-argdecl-indent: 4
802 * c-continued-statement-offset: 4
803 * c-continued-brace-offset: 0
804 * indent-tabs-mode: nil