1/* 2 * include/asm-sparc/audioio.h 3 * 4 * Sparc Audio Midlayer 5 * Copyright (C) 1996 Thomas K. Dyas (tdyas@noc.rutgers.edu) 6 */ 7 8#ifndef _AUDIOIO_H_ 9#define _AUDIOIO_H_ 10 11/* 12 * SunOS/Solaris /dev/audio interface 13 */ 14 15#if defined(__KERNEL__) || !defined(__GLIBC__) || (__GLIBC__ < 2) 16#include <linux/types.h> 17#include <linux/time.h> 18#include <linux/ioctl.h> 19#endif 20 21/* 22 * This structure contains state information for audio device IO streams. 23 */ 24typedef struct audio_prinfo { 25 /* 26 * The following values describe the audio data encoding. 27 */ 28 unsigned int sample_rate; /* samples per second */ 29 unsigned int channels; /* number of interleaved channels */ 30 unsigned int precision; /* bit-width of each sample */ 31 unsigned int encoding; /* data encoding method */ 32 33 /* 34 * The following values control audio device configuration 35 */ 36 unsigned int gain; /* gain level: 0 - 255 */ 37 unsigned int port; /* selected I/O port (see below) */ 38 unsigned int avail_ports; /* available I/O ports (see below) */ 39 unsigned int _xxx[2]; /* Reserved for future use */ 40 41 unsigned int buffer_size; /* I/O buffer size */ 42 43 /* 44 * The following values describe driver state 45 */ 46 unsigned int samples; /* number of samples converted */ 47 unsigned int eof; /* End Of File counter (play only) */ 48 49 unsigned char pause; /* non-zero for pause, zero to resume */ 50 unsigned char error; /* non-zero if overflow/underflow */ 51 unsigned char waiting; /* non-zero if a process wants access */ 52 unsigned char balance; /* stereo channel balance */ 53 54 unsigned short minordev; 55 56 /* 57 * The following values are read-only state flags 58 */ 59 unsigned char open; /* non-zero if open access permitted */ 60 unsigned char active; /* non-zero if I/O is active */ 61} audio_prinfo_t; 62 63 64/* 65 * This structure describes the current state of the audio device. 66 */ 67typedef struct audio_info { 68 /* 69 * Per-stream information 70 */ 71 audio_prinfo_t play; /* output status information */ 72 audio_prinfo_t record; /* input status information */ 73 74 /* 75 * Per-unit/channel information 76 */ 77 unsigned int monitor_gain; /* input to output mix: 0 - 255 */ 78 unsigned char output_muted; /* non-zero if output is muted */ 79 unsigned char _xxx[3]; /* Reserved for future use */ 80 unsigned int _yyy[3]; /* Reserved for future use */ 81} audio_info_t; 82 83 84/* 85 * Audio encoding types 86 */ 87#define AUDIO_ENCODING_NONE (0) /* no encoding assigned */ 88#define AUDIO_ENCODING_ULAW (1) /* u-law encoding */ 89#define AUDIO_ENCODING_ALAW (2) /* A-law encoding */ 90#define AUDIO_ENCODING_LINEAR (3) /* Linear PCM encoding */ 91#define AUDIO_ENCODING_FLOAT (4) /* IEEE float (-1. <-> +1.) */ 92#define AUDIO_ENCODING_DVI (104) /* DVI ADPCM */ 93#define AUDIO_ENCODING_LINEAR8 (105) /* 8 bit UNSIGNED */ 94#define AUDIO_ENCODING_LINEARLE (106) /* Linear PCM LE encoding */ 95 96/* 97 * These ranges apply to record, play, and monitor gain values 98 */ 99#define AUDIO_MIN_GAIN (0) /* minimum gain value */ 100#define AUDIO_MAX_GAIN (255) /* maximum gain value */ 101 102/* 103 * These values apply to the balance field to adjust channel gain values 104 */ 105#define AUDIO_LEFT_BALANCE (0) /* left channel only */ 106#define AUDIO_MID_BALANCE (32) /* equal left/right channel */ 107#define AUDIO_RIGHT_BALANCE (64) /* right channel only */ 108#define AUDIO_BALANCE_SHIFT (3) 109 110/* 111 * Generic minimum/maximum limits for number of channels, both modes 112 */ 113#define AUDIO_MIN_PLAY_CHANNELS (1) 114#define AUDIO_MAX_PLAY_CHANNELS (4) 115#define AUDIO_MIN_REC_CHANNELS (1) 116#define AUDIO_MAX_REC_CHANNELS (4) 117 118/* 119 * Generic minimum/maximum limits for sample precision 120 */ 121#define AUDIO_MIN_PLAY_PRECISION (8) 122#define AUDIO_MAX_PLAY_PRECISION (32) 123#define AUDIO_MIN_REC_PRECISION (8) 124#define AUDIO_MAX_REC_PRECISION (32) 125 126/* 127 * Define some convenient names for typical audio ports 128 */ 129/* 130 * output ports (several may be enabled simultaneously) 131 */ 132#define AUDIO_SPEAKER 0x01 /* output to built-in speaker */ 133#define AUDIO_HEADPHONE 0x02 /* output to headphone jack */ 134#define AUDIO_LINE_OUT 0x04 /* output to line out */ 135 136/* 137 * input ports (usually only one at a time) 138 */ 139#define AUDIO_MICROPHONE 0x01 /* input from microphone */ 140#define AUDIO_LINE_IN 0x02 /* input from line in */ 141#define AUDIO_CD 0x04 /* input from on-board CD inputs */ 142#define AUDIO_INTERNAL_CD_IN AUDIO_CD /* input from internal CDROM */ 143#define AUDIO_ANALOG_LOOPBACK 0x40 /* input from output */ 144 145 146/* 147 * This macro initializes an audio_info structure to 'harmless' values. 148 * Note that (~0) might not be a harmless value for a flag that was 149 * a signed int. 150 */ 151#define AUDIO_INITINFO(i) { \ 152 unsigned int *__x__; \ 153 for (__x__ = (unsigned int *)(i); \ 154 (char *) __x__ < (((char *)(i)) + sizeof (audio_info_t)); \ 155 *__x__++ = ~0); \ 156} 157 158/* 159 * These allow testing for what the user wants to set 160 */ 161#define AUD_INITVALUE (~0) 162#define Modify(X) ((unsigned int)(X) != AUD_INITVALUE) 163#define Modifys(X) ((X) != (unsigned short)AUD_INITVALUE) 164#define Modifyc(X) ((X) != (unsigned char)AUD_INITVALUE) 165 166/* 167 * Parameter for the AUDIO_GETDEV ioctl to determine current 168 * audio devices. 169 */ 170#define MAX_AUDIO_DEV_LEN (16) 171typedef struct audio_device { 172 char name[MAX_AUDIO_DEV_LEN]; 173 char version[MAX_AUDIO_DEV_LEN]; 174 char config[MAX_AUDIO_DEV_LEN]; 175} audio_device_t; 176 177 178/* 179 * Ioctl calls for the audio device. 180 */ 181 182/* 183 * AUDIO_GETINFO retrieves the current state of the audio device. 184 * 185 * AUDIO_SETINFO copies all fields of the audio_info structure whose 186 * values are not set to the initialized value (-1) to the device state. 187 * It performs an implicit AUDIO_GETINFO to return the new state of the 188 * device. Note that the record.samples and play.samples fields are set 189 * to the last value before the AUDIO_SETINFO took effect. This allows 190 * an application to reset the counters while atomically retrieving the 191 * last value. 192 * 193 * AUDIO_DRAIN suspends the calling process until the write buffers are 194 * empty. 195 * 196 * AUDIO_GETDEV returns a structure of type audio_device_t which contains 197 * three strings. The string "name" is a short identifying string (for 198 * example, the SBus Fcode name string), the string "version" identifies 199 * the current version of the device, and the "config" string identifies 200 * the specific configuration of the audio stream. All fields are 201 * device-dependent -- see the device specific manual pages for details. 202 * 203 * AUDIO_GETDEV_SUNOS returns a number which is an audio device defined 204 * herein (making it not too portable) 205 * 206 * AUDIO_FLUSH stops all playback and recording, clears all queued buffers, 207 * resets error counters, and restarts recording and playback as appropriate 208 * for the current sampling mode. 209 */ 210#define AUDIO_GETINFO _IOR('A', 1, audio_info_t) 211#define AUDIO_SETINFO _IOWR('A', 2, audio_info_t) 212#define AUDIO_DRAIN _IO('A', 3) 213#define AUDIO_GETDEV _IOR('A', 4, audio_device_t) 214#define AUDIO_GETDEV_SUNOS _IOR('A', 4, int) 215#define AUDIO_FLUSH _IO('A', 5) 216 217/* Define possible audio hardware configurations for 218 * old SunOS-style AUDIO_GETDEV ioctl */ 219#define AUDIO_DEV_UNKNOWN (0) /* not defined */ 220#define AUDIO_DEV_AMD (1) /* audioamd device */ 221#define AUDIO_DEV_SPEAKERBOX (2) /* dbri device with speakerbox */ 222#define AUDIO_DEV_CODEC (3) /* dbri device (internal speaker) */ 223#define AUDIO_DEV_CS4231 (5) /* cs4231 device */ 224 225/* 226 * The following ioctl sets the audio device into an internal loopback mode, 227 * if the hardware supports this. The argument is TRUE to set loopback, 228 * FALSE to reset to normal operation. If the hardware does not support 229 * internal loopback, the ioctl should fail with EINVAL. 230 * Causes ADC data to be digitally mixed in and sent to the DAC. 231 */ 232#define AUDIO_DIAG_LOOPBACK _IOW('A', 101, int) 233 234/* 235 * Linux kernel internal implementation. 236 */ 237 238#ifdef __KERNEL__ 239 240#include <linux/fs.h> 241#include <linux/tqueue.h> 242#include <linux/wait.h> 243 244#define SDF_OPEN_WRITE 0x00000001 245#define SDF_OPEN_READ 0x00000002 246 247struct sparcaudio_ringbuffer 248{ 249 __u8 *rb_start, *rb_end; /* start, end of this memory buffer */ 250 __u8 *rb_in, *rb_out; /* input, output pointers */ 251 252 int rb_fragsize; /* size of an audio frag */ 253 int rb_numfrags; /* number of frags */ 254 255 int rb_count, rb_hiwat, rb_lowat; /* bytes in use, hi/lo wat points */ 256 257 int rb_bufsize; /* total size of buffer */ 258}; 259 260struct sparcaudio_driver 261{ 262 const char * name; 263 struct sparcaudio_operations *ops; 264 void *private; 265 unsigned long flags; 266 struct strevent *sd_siglist; 267 /* duplex: 0=simplex, 1=duplex, 2=loop */ 268 int sd_sigflags, duplex; 269 270 /* Which audio device are we? */ 271 int index; 272 273 /* This device */ 274 struct sbus_dev *dev; 275 276 /* Processes blocked on open() sit here. */ 277 wait_queue_head_t open_wait; 278 279 /* Task queue for this driver's bottom half. */ 280 struct tq_struct tqueue; 281 282 /* Start of ring buffer support */ 283 __u8 *input_buffer, *output_buffer; 284 285 /* Support for a circular queue of output buffers. */ 286 __u8 **output_buffers; 287 size_t *output_sizes, output_size, output_buffer_size; 288 int num_output_buffers, output_front, output_rear, output_offset; 289 int output_count, output_active, playing_count, output_eof; 290 wait_queue_head_t output_write_wait, output_drain_wait; 291 char *output_notify; 292 293 /* Support for a circular queue of input buffers. */ 294 __u8 **input_buffers; 295 size_t *input_sizes, input_size, input_buffer_size; 296 int num_input_buffers, input_front, input_rear, input_offset; 297 int input_count, input_active, recording_count; 298 wait_queue_head_t input_read_wait; 299 300 /* Hack to make it look like we support variable size buffers. */ 301 int buffer_size; 302 303 int mixer_modify_counter; 304}; 305 306struct sparcaudio_operations 307{ 308 int (*open)(struct inode *, struct file *, struct sparcaudio_driver *); 309 void (*release)(struct inode *, struct file *, struct sparcaudio_driver *); 310 int (*ioctl)(struct inode *, struct file *, unsigned int, unsigned long, 311 struct sparcaudio_driver *); 312 313 /* Ask driver to begin playing a buffer. */ 314 void (*start_output)(struct sparcaudio_driver *, __u8 *, unsigned long); 315 316 /* Ask driver to stop playing a buffer. */ 317 void (*stop_output)(struct sparcaudio_driver *); 318 319 /* Ask driver to begin recording into a buffer. */ 320 void (*start_input)(struct sparcaudio_driver *, __u8 *, unsigned long); 321 322 /* Ask driver to stop recording. */ 323 void (*stop_input)(struct sparcaudio_driver *); 324 325 /* Return driver name/version to caller. (/dev/audio specific) */ 326 void (*sunaudio_getdev)(struct sparcaudio_driver *, audio_device_t *); 327 328 /* Get and set the output volume. (0-255) */ 329 int (*set_output_volume)(struct sparcaudio_driver *, int); 330 int (*get_output_volume)(struct sparcaudio_driver *); 331 332 /* Get and set the input volume. (0-255) */ 333 int (*set_input_volume)(struct sparcaudio_driver *, int); 334 int (*get_input_volume)(struct sparcaudio_driver *); 335 336 /* Get and set the monitor volume. (0-255) */ 337 int (*set_monitor_volume)(struct sparcaudio_driver *, int); 338 int (*get_monitor_volume)(struct sparcaudio_driver *); 339 340 /* Get and set the output balance. (0-64) */ 341 int (*set_output_balance)(struct sparcaudio_driver *, int); 342 int (*get_output_balance)(struct sparcaudio_driver *); 343 344 /* Get and set the input balance. (0-64) */ 345 int (*set_input_balance)(struct sparcaudio_driver *, int); 346 int (*get_input_balance)(struct sparcaudio_driver *); 347 348 /* Get and set the output channels. (1-4) */ 349 int (*set_output_channels)(struct sparcaudio_driver *, int); 350 int (*get_output_channels)(struct sparcaudio_driver *); 351 352 /* Get and set the input channels. (1-4) */ 353 int (*set_input_channels)(struct sparcaudio_driver *, int); 354 int (*get_input_channels)(struct sparcaudio_driver *); 355 356 /* Get and set the output precision. (8-32) */ 357 int (*set_output_precision)(struct sparcaudio_driver *, int); 358 int (*get_output_precision)(struct sparcaudio_driver *); 359 360 /* Get and set the input precision. (8-32) */ 361 int (*set_input_precision)(struct sparcaudio_driver *, int); 362 int (*get_input_precision)(struct sparcaudio_driver *); 363 364 /* Get and set the output port. () */ 365 int (*set_output_port)(struct sparcaudio_driver *, int); 366 int (*get_output_port)(struct sparcaudio_driver *); 367 368 /* Get and set the input port. () */ 369 int (*set_input_port)(struct sparcaudio_driver *, int); 370 int (*get_input_port)(struct sparcaudio_driver *); 371 372 /* Get and set the output encoding. () */ 373 int (*set_output_encoding)(struct sparcaudio_driver *, int); 374 int (*get_output_encoding)(struct sparcaudio_driver *); 375 376 /* Get and set the input encoding. () */ 377 int (*set_input_encoding)(struct sparcaudio_driver *, int); 378 int (*get_input_encoding)(struct sparcaudio_driver *); 379 380 /* Get and set the output rate. () */ 381 int (*set_output_rate)(struct sparcaudio_driver *, int); 382 int (*get_output_rate)(struct sparcaudio_driver *); 383 384 /* Get and set the input rate. () */ 385 int (*set_input_rate)(struct sparcaudio_driver *, int); 386 int (*get_input_rate)(struct sparcaudio_driver *); 387 388 /* Return driver number to caller. (SunOS /dev/audio specific) */ 389 int (*sunaudio_getdev_sunos)(struct sparcaudio_driver *); 390 391 /* Get available ports */ 392 int (*get_output_ports)(struct sparcaudio_driver *); 393 int (*get_input_ports)(struct sparcaudio_driver *); 394 395 /* Get and set output mute */ 396 int (*set_output_muted)(struct sparcaudio_driver *, int); 397 int (*get_output_muted)(struct sparcaudio_driver *); 398 399 /* Get and set output pause */ 400 int (*set_output_pause)(struct sparcaudio_driver *, int); 401 int (*get_output_pause)(struct sparcaudio_driver *); 402 403 /* Get and set input pause */ 404 int (*set_input_pause)(struct sparcaudio_driver *, int); 405 int (*get_input_pause)(struct sparcaudio_driver *); 406 407 /* Get and set output samples */ 408 int (*set_output_samples)(struct sparcaudio_driver *, int); 409 int (*get_output_samples)(struct sparcaudio_driver *); 410 411 /* Get and set input samples */ 412 int (*set_input_samples)(struct sparcaudio_driver *, int); 413 int (*get_input_samples)(struct sparcaudio_driver *); 414 415 /* Get and set output error */ 416 int (*set_output_error)(struct sparcaudio_driver *, int); 417 int (*get_output_error)(struct sparcaudio_driver *); 418 419 /* Get and set input error */ 420 int (*set_input_error)(struct sparcaudio_driver *, int); 421 int (*get_input_error)(struct sparcaudio_driver *); 422 423 /* Get supported encodings */ 424 int (*get_formats)(struct sparcaudio_driver *); 425}; 426 427extern int register_sparcaudio_driver(struct sparcaudio_driver *, int); 428extern int unregister_sparcaudio_driver(struct sparcaudio_driver *, int); 429extern void sparcaudio_output_done(struct sparcaudio_driver *, int); 430extern void sparcaudio_input_done(struct sparcaudio_driver *, int); 431 432#endif 433 434/* Device minor numbers */ 435 436#define SPARCAUDIO_MIXER_MINOR 0 437/* No sequencer (1) */ 438/* No midi (2) */ 439#define SPARCAUDIO_DSP_MINOR 3 440#define SPARCAUDIO_AUDIO_MINOR 4 441#define SPARCAUDIO_DSP16_MINOR 5 442#define SPARCAUDIO_STATUS_MINOR 6 443#define SPARCAUDIO_AUDIOCTL_MINOR 7 444/* No sequencer l2 (8) */ 445/* No sound processor (9) */ 446 447/* allocate 2^SPARCAUDIO_DEVICE_SHIFT minors per audio device */ 448#define SPARCAUDIO_DEVICE_SHIFT 4 449 450/* With the coming of dummy devices this should perhaps be as high as 5? */ 451#define SPARCAUDIO_MAX_DEVICES 3 452 453/* Streams crap for realaudio */ 454 455typedef 456struct strevent { 457 struct strevent *se_next; /* next event for this stream or NULL*/ 458 struct strevent *se_prev; /* previous event for this stream or last 459 * event if this is the first one*/ 460 pid_t se_pid; /* process to be signaled */ 461 short se_evs; /* events wanted */ 462} strevent_t; 463 464typedef 465struct stdata 466{ 467 struct stdata *sd_next ; /* all stdatas are linked together */ 468 struct stdata *sd_prev ; 469 struct strevent *sd_siglist; /* processes to be sent SIGPOLL */ 470 int sd_sigflags; /* logical OR of all siglist events */ 471} stdata_t; 472 473#define I_NREAD _IOR('S',01, int) 474#define I_NREAD_SOLARIS (('S'<<8)|1) 475 476#define I_FLUSH _IO('S',05) 477#define I_FLUSH_SOLARIS (('S'<<8)|5) 478#define FLUSHR 1 /* flush read queue */ 479#define FLUSHW 2 /* flush write queue */ 480#define FLUSHRW 3 /* flush both queues */ 481 482#define I_SETSIG _IO('S',011) 483#define I_SETSIG_SOLARIS (('S'<<8)|11) 484#define S_INPUT 0x01 485#define S_HIPRI 0x02 486#define S_OUTPUT 0x04 487#define S_MSG 0x08 488#define S_ERROR 0x0010 489#define S_HANGUP 0x0020 490#define S_RDNORM 0x0040 491#define S_WRNORM S_OUTPUT 492#define S_RDBAND 0x0080 493#define S_WRBAND 0x0100 494#define S_BANDURG 0x0200 495#define S_ALL 0x03FF 496 497#define I_GETSIG _IOR('S',012,int) 498#define I_GETSIG_SOLARIS (('S'<<8)|12) 499 500/* Conversion between Sun and OSS volume settings */ 501static __inline__ 502int OSS_LEFT(int value) 503{ 504 return ((value & 0xff) % 101); 505} 506 507static __inline__ 508int OSS_RIGHT(int value) 509{ 510 return (((value >> 8) & 0xff) % 101); 511} 512 513static __inline__ 514int O_TO_S(int value) 515{ 516 return value * 255 / 100; 517} 518 519static __inline__ 520int S_TO_O(int value) 521{ 522 return value * 100 / 255; 523} 524 525static __inline__ 526int OSS_TO_GAIN(int value) 527{ 528 int l = O_TO_S(OSS_LEFT(value)); 529 int r = O_TO_S(OSS_RIGHT(value)); 530 return ((l > r) ? l : r); 531} 532 533static __inline__ 534int OSS_TO_LGAIN(int value) 535{ 536 int l = O_TO_S(OSS_LEFT(value)); 537 int r = O_TO_S(OSS_RIGHT(value)); 538 return ((l < r) ? l : r); 539} 540 541static __inline__ 542int OSS_TO_BAL(int value) 543{ 544 if (!OSS_TO_GAIN(value)) 545 return AUDIO_MID_BALANCE; 546 if (!OSS_TO_LGAIN(value)) { 547 if (OSS_TO_GAIN(value) == OSS_TO_GAIN(OSS_RIGHT(value))) 548 return AUDIO_RIGHT_BALANCE; 549 else 550 return AUDIO_LEFT_BALANCE; 551 } 552 if (OSS_TO_GAIN(value) == OSS_TO_GAIN(OSS_RIGHT(value))) 553 return ((OSS_TO_GAIN(value) - OSS_TO_LGAIN(value)) >> AUDIO_BALANCE_SHIFT) 554 + AUDIO_MID_BALANCE; 555 else 556 return AUDIO_MID_BALANCE - ((OSS_TO_GAIN(value) - OSS_TO_LGAIN(value)) 557 >> AUDIO_BALANCE_SHIFT); 558} 559 560static __inline__ 561int BAL_TO_OSS(int value, unsigned char balance) 562{ 563 int l, r, adj; 564 if (balance > 63) balance = 63; 565 if (balance < AUDIO_MID_BALANCE) { 566 l = (int)value * 100 / 255 + ((value * 100 % 255) > 0); 567 adj = ((AUDIO_MID_BALANCE - balance) << AUDIO_BALANCE_SHIFT); 568 if (adj < value) 569 r = (int)(value - adj) 570 * 100 / 255; 571 else r = 0; 572 } else if (balance > AUDIO_MID_BALANCE) { 573 r = (int)value * 100 / 255 + ((value * 100 % 255) > 0); 574 adj = ((balance - AUDIO_MID_BALANCE) << AUDIO_BALANCE_SHIFT); 575 if (adj < value) 576 l = (int)(value - adj) 577 * 100 / 255; 578 else l = 0; 579 } else { 580 l = r = (int)value * 100 / 255 + ((value * 100 % 255) > 0); 581 } 582 583 return ((r << 8) + l); 584} 585 586#ifdef __KERNEL__ 587/* OSS mixer ioctl port handling */ 588static __inline__ 589int OSS_PORT_AUDIO(struct sparcaudio_driver *drv, unsigned int set) 590{ 591 int p; 592 if (drv->ops->get_output_port) { 593 p = drv->ops->get_output_port(drv); 594 if (p & set) 595 return 0x6464; 596 } 597 return 0; 598} 599 600static __inline__ 601int OSS_IPORT_AUDIO(struct sparcaudio_driver *drv, unsigned int set) 602{ 603 int p; 604 if (drv->ops->get_input_port) { 605 p = drv->ops->get_input_port(drv); 606 if (p & set) 607 return 0x6464; 608 } 609 return 0; 610} 611 612static __inline__ 613void OSS_TWIDDLE_PORT(struct sparcaudio_driver *drv, unsigned int ioctl, 614 unsigned int port, unsigned int set, unsigned int value) 615{ 616 if (ioctl == port) { 617 int p; 618 if (drv->ops->get_output_port && drv->ops->set_output_port) { 619 p = drv->ops->get_output_port(drv); 620 if ((value == 0) || ((p & set) && (OSS_LEFT(value) < 100))) 621 drv->ops->set_output_port(drv, p & ~(set)); 622 else 623 drv->ops->set_output_port(drv, p | set); 624 } 625 } 626} 627 628static __inline__ 629void OSS_TWIDDLE_IPORT(struct sparcaudio_driver *drv, unsigned int ioctl, 630 unsigned int port, unsigned int set, unsigned int value) 631{ 632 if (ioctl == port) { 633 int p; 634 if (drv->ops->get_input_port && drv->ops->set_input_port) { 635 p = drv->ops->get_input_port(drv); 636 if ((value == 0) || ((p & set) && (OSS_LEFT(value) < 100))) 637 drv->ops->set_input_port(drv, p & ~(set)); 638 else 639 drv->ops->set_input_port(drv, p | set); 640 } 641 } 642} 643#endif /* __KERNEL__ */ 644#endif /* _AUDIOIO_H_ */ 645