1 /* $OpenBSD: awacs.c,v 1.42 2024/04/14 03:26:25 jsg Exp $ */
2 /* $NetBSD: awacs.c,v 1.4 2001/02/26 21:07:51 wiz Exp $ */
3
4 /*-
5 * Copyright (c) 2000 Tsubai Masanari. All rights reserved.
6 *
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
9 * are met:
10 * 1. Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 * 2. Redistributions in binary form must reproduce the above copyright
13 * notice, this list of conditions and the following disclaimer in the
14 * documentation and/or other materials provided with the distribution.
15 * 3. The name of the author may not be used to endorse or promote products
16 * derived from this software without specific prior written permission.
17 *
18 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
19 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
20 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
21 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
22 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
23 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
24 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
25 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
26 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
27 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
28 */
29
30 #include <sys/param.h>
31 #include <sys/audioio.h>
32 #include <sys/device.h>
33 #include <sys/malloc.h>
34 #include <sys/systm.h>
35
36 #include <dev/audio_if.h>
37
38 #include <machine/bus.h>
39 #include <machine/autoconf.h>
40 #include <macppc/dev/dbdma.h>
41
42 #ifdef AWACS_DEBUG
43 # define DPRINTF printf
44 #else
45 # define DPRINTF while (0) printf
46 #endif
47
48 #define AWACS_DMALIST_MAX 32
49 #define AWACS_DMASEG_MAX NBPG
50
51 struct awacs_dma {
52 bus_dmamap_t map;
53 caddr_t addr;
54 bus_dma_segment_t segs[AWACS_DMALIST_MAX];
55 int nsegs;
56 size_t size;
57 struct awacs_dma *next;
58 };
59
60
61 struct awacs_softc {
62 struct device sc_dev;
63
64 void (*sc_ointr)(void *); /* dma completion intr handler */
65 void *sc_oarg; /* arg for sc_ointr() */
66
67 void (*sc_iintr)(void *); /* dma completion intr handler */
68 void *sc_iarg; /* arg for sc_iintr() */
69
70 u_int sc_record_source; /* recording source mask */
71 u_int sc_output_mask; /* output source mask */
72
73 int sc_awacs_hardware;
74 int sc_awacs_headphone_mask;
75
76 char *sc_reg;
77 u_int sc_codecctl0;
78 u_int sc_codecctl1;
79 u_int sc_codecctl2;
80 u_int sc_codecctl4;
81 u_int sc_soundctl;
82
83 bus_dma_tag_t sc_dmat;
84 struct dbdma_regmap *sc_odma;
85 struct dbdma_regmap *sc_idma;
86 struct dbdma_command *sc_odmacmd, *sc_odmap;
87 struct dbdma_command *sc_idmacmd, *sc_idmap;
88 dbdma_t sc_odbdma, sc_idbdma;
89
90 struct awacs_dma *sc_dmas;
91 };
92
93 int awacs_match(struct device *, void *, void *);
94 void awacs_attach(struct device *, struct device *, void *);
95 int awacs_intr(void *);
96 int awacs_tx_intr(void *);
97 int awacs_rx_intr(void *);
98
99 int awacs_open(void *, int);
100 void awacs_close(void *);
101 int awacs_set_params(void *, int, int, struct audio_params *,
102 struct audio_params *);
103 int awacs_round_blocksize(void *, int);
104 int awacs_trigger_output(void *, void *, void *, int, void (*)(void *),
105 void *, struct audio_params *);
106 int awacs_trigger_input(void *, void *, void *, int, void (*)(void *),
107 void *, struct audio_params *);
108 int awacs_halt_output(void *);
109 int awacs_halt_input(void *);
110 int awacs_set_port(void *, mixer_ctrl_t *);
111 int awacs_get_port(void *, mixer_ctrl_t *);
112 int awacs_query_devinfo(void *, mixer_devinfo_t *);
113 size_t awacs_round_buffersize(void *, int, size_t);
114 void *awacs_allocm(void *, int, size_t, int, int);
115
116 static inline u_int awacs_read_reg(struct awacs_softc *, int);
117 static inline void awacs_write_reg(struct awacs_softc *, int, int);
118 void awacs_write_codec(struct awacs_softc *, int);
119 void awacs_set_speaker_volume(struct awacs_softc *, int, int);
120 void awacs_set_ext_volume(struct awacs_softc *, int, int);
121 void awacs_set_rate(struct awacs_softc *, struct audio_params *);
122
123 const struct cfattach awacs_ca = {
124 sizeof(struct awacs_softc), awacs_match, awacs_attach
125 };
126
127 struct cfdriver awacs_cd = {
128 NULL, "awacs", DV_DULL
129 };
130
131 const struct audio_hw_if awacs_hw_if = {
132 .open = awacs_open,
133 .close = awacs_close,
134 .set_params = awacs_set_params,
135 .round_blocksize = awacs_round_blocksize,
136 .halt_output = awacs_halt_output,
137 .halt_input = awacs_halt_input,
138 .set_port = awacs_set_port,
139 .get_port = awacs_get_port,
140 .query_devinfo = awacs_query_devinfo,
141 .allocm = awacs_allocm,
142 .round_buffersize = awacs_round_buffersize,
143 .trigger_output = awacs_trigger_output,
144 .trigger_input = awacs_trigger_input,
145 };
146
147 /* register offset */
148 #define AWACS_SOUND_CTRL 0x00
149 #define AWACS_CODEC_CTRL 0x10
150 #define AWACS_CODEC_STATUS 0x20
151 #define AWACS_CLIP_COUNT 0x30
152 #define AWACS_BYTE_SWAP 0x40
153
154 /* sound control */
155 #define AWACS_INPUT_SUBFRAME0 0x00000001
156 #define AWACS_INPUT_SUBFRAME1 0x00000002
157 #define AWACS_INPUT_SUBFRAME2 0x00000004
158 #define AWACS_INPUT_SUBFRAME3 0x00000008
159
160 #define AWACS_OUTPUT_SUBFRAME0 0x00000010
161 #define AWACS_OUTPUT_SUBFRAME1 0x00000020
162 #define AWACS_OUTPUT_SUBFRAME2 0x00000040
163 #define AWACS_OUTPUT_SUBFRAME3 0x00000080
164
165 #define AWACS_RATE_44100 0x00000000
166 #define AWACS_RATE_29400 0x00000100
167 #define AWACS_RATE_22050 0x00000200
168 #define AWACS_RATE_17640 0x00000300
169 #define AWACS_RATE_14700 0x00000400
170 #define AWACS_RATE_11025 0x00000500
171 #define AWACS_RATE_8820 0x00000600
172 #define AWACS_RATE_7350 0x00000700
173 #define AWACS_RATE_MASK 0x00000700
174
175 #define AWACS_CTL_CNTRLERR (1 << 11)
176 #define AWACS_CTL_PORTCHG (1 << 12)
177 #define AWACS_INT_CNTRLERR (1 << 13)
178 #define AWACS_INT_PORTCHG (1 << 14)
179
180 /* codec control */
181 #define AWACS_CODEC_ADDR0 0x00000000
182 #define AWACS_CODEC_ADDR1 0x00001000
183 #define AWACS_CODEC_ADDR2 0x00002000
184 #define AWACS_CODEC_ADDR4 0x00004000
185 #define AWACS_CODEC_EMSEL0 0x00000000
186 #define AWACS_CODEC_EMSEL1 0x00400000
187 #define AWACS_CODEC_EMSEL2 0x00800000
188 #define AWACS_CODEC_EMSEL4 0x00c00000
189 #define AWACS_CODEC_BUSY 0x01000000
190
191 /* cc0 */
192 #define AWACS_DEFAULT_CD_GAIN 0x000000bb
193 #define AWACS_INPUT_CD 0x00000200
194 #define AWACS_INPUT_LINE 0x00000400
195 #define AWACS_INPUT_MICROPHONE 0x00000800
196 #define AWACS_INPUT_MASK 0x00000e00
197
198 /* cc1 */
199 #define AWACS_MUTE_SPEAKER 0x00000080
200 #define AWACS_MUTE_HEADPHONE 0x00000200
201 /*
202 * iMacs that use this driver have a speaker amp power down feature,
203 * triggered by this bit in cc1.
204 */
205 #define AWACS_MUTE_SPEAKER_IMAC 0x00000800
206
207 const struct awacs_speed_tab {
208 int rate;
209 u_int32_t bits;
210 } awacs_speeds[] = {
211 { 7350, AWACS_RATE_7350 },
212 { 8820, AWACS_RATE_8820 },
213 { 11025, AWACS_RATE_11025 },
214 { 14700, AWACS_RATE_14700 },
215 { 17640, AWACS_RATE_17640 },
216 { 22050, AWACS_RATE_22050 },
217 { 29400, AWACS_RATE_29400 },
218 { 44100, AWACS_RATE_44100 },
219 };
220
221 /* add hardware as needed */
222 #define HW_IS_OTHER 0
223 /* iMac (Late 1999) */
224 #define HW_IS_IMAC1 1
225 /* iMac (Summer 2000) and iMac (Early 2001, Summer 2001) */
226 #define HW_IS_IMAC2 2
227
228 /* Codecs status headphones mask */
229
230 /* headphone connector on back */
231 #define AWACS_STATUS_HP_CONN 8
232
233 /* right connector on front */
234 #define AWACS_STATUS_HP_RCONN_IMAC 4
235 /* left connector on front */
236 #define AWACS_STATUS_HP_LCONN_IMAC 2
237 /* connector on the right side */
238 #define AWACS_STATUS_HP_SCONN_IMAC 1
239
240 int
awacs_match(struct device * parent,void * match,void * aux)241 awacs_match(struct device *parent, void *match, void *aux)
242 {
243 struct confargs *ca = aux;
244
245 if (strcmp(ca->ca_name, "awacs") != 0 &&
246 strcmp(ca->ca_name, "davbus") != 0)
247 return 0;
248
249 #ifdef DEBUG
250 printf("awacs: matched %s nreg %d nintr %d\n",
251 ca->ca_name, ca->ca_nreg, ca->ca_nintr);
252 #endif
253
254 if (ca->ca_nreg < 24 || ca->ca_nintr < 12)
255 return 0;
256
257 /* XXX for now
258 if (ca->ca_nintr > 12)
259 return 0;
260 */
261
262 return 1;
263 }
264
265 void
awacs_attach(struct device * parent,struct device * self,void * aux)266 awacs_attach(struct device *parent, struct device *self, void *aux)
267 {
268 struct awacs_softc *sc = (struct awacs_softc *)self;
269 struct confargs *ca = aux;
270 int cirq, oirq, iirq;
271 int cirq_type, oirq_type, iirq_type;
272
273 if (!strcmp(hw_prod, "PowerMac2,1"))
274 sc->sc_awacs_hardware = HW_IS_IMAC1;
275 else if (!strcmp(hw_prod, "PowerMac2,2") ||
276 !strcmp(hw_prod, "PowerMac4,1"))
277 sc->sc_awacs_hardware = HW_IS_IMAC2;
278 else
279 sc->sc_awacs_hardware = HW_IS_OTHER;
280 /* set headphone mask */
281 if (sc->sc_awacs_hardware == HW_IS_IMAC1 ||
282 sc->sc_awacs_hardware == HW_IS_IMAC2)
283 sc->sc_awacs_headphone_mask = AWACS_STATUS_HP_LCONN_IMAC |
284 AWACS_STATUS_HP_RCONN_IMAC | AWACS_STATUS_HP_SCONN_IMAC;
285 else
286 sc->sc_awacs_headphone_mask = AWACS_STATUS_HP_CONN;
287
288 ca->ca_reg[0] += ca->ca_baseaddr;
289 ca->ca_reg[2] += ca->ca_baseaddr;
290 ca->ca_reg[4] += ca->ca_baseaddr;
291
292 sc->sc_reg = mapiodev(ca->ca_reg[0], ca->ca_reg[1]);
293
294 sc->sc_dmat = ca->ca_dmat;
295 sc->sc_odma = mapiodev(ca->ca_reg[2], ca->ca_reg[3]); /* out */
296 sc->sc_idma = mapiodev(ca->ca_reg[4], ca->ca_reg[5]); /* in */
297 sc->sc_odbdma = dbdma_alloc(sc->sc_dmat, AWACS_DMALIST_MAX);
298 sc->sc_odmacmd = sc->sc_odbdma->d_addr;
299 sc->sc_idbdma = dbdma_alloc(sc->sc_dmat, AWACS_DMALIST_MAX);
300 sc->sc_idmacmd = sc->sc_idbdma->d_addr;
301
302 if (ca->ca_nintr == 24) {
303 cirq = ca->ca_intr[0];
304 oirq = ca->ca_intr[2];
305 iirq = ca->ca_intr[4];
306 cirq_type = ca->ca_intr[1] ? IST_LEVEL : IST_EDGE;
307 oirq_type = ca->ca_intr[3] ? IST_LEVEL : IST_EDGE;
308 iirq_type = ca->ca_intr[5] ? IST_LEVEL : IST_EDGE;
309 } else {
310 cirq = ca->ca_intr[0];
311 oirq = ca->ca_intr[1];
312 iirq = ca->ca_intr[2];
313 cirq_type = oirq_type = iirq_type = IST_LEVEL;
314 }
315 mac_intr_establish(parent, cirq, cirq_type, IPL_AUDIO | IPL_MPSAFE,
316 awacs_intr, sc, sc->sc_dev.dv_xname);
317 mac_intr_establish(parent, oirq, oirq_type, IPL_AUDIO | IPL_MPSAFE,
318 awacs_tx_intr, sc, sc->sc_dev.dv_xname);
319 mac_intr_establish(parent, iirq, iirq_type, IPL_AUDIO | IPL_MPSAFE,
320 awacs_rx_intr, sc, sc->sc_dev.dv_xname);
321
322 printf(": irq %d,%d,%d",
323 cirq, oirq, iirq);
324
325 sc->sc_soundctl = AWACS_INPUT_SUBFRAME0 | AWACS_OUTPUT_SUBFRAME0 |
326 AWACS_RATE_44100 | AWACS_INT_PORTCHG;
327 awacs_write_reg(sc, AWACS_SOUND_CTRL, sc->sc_soundctl);
328
329 sc->sc_codecctl0 = AWACS_CODEC_ADDR0 | AWACS_CODEC_EMSEL0;
330 sc->sc_codecctl1 = AWACS_CODEC_ADDR1 | AWACS_CODEC_EMSEL0;
331 sc->sc_codecctl2 = AWACS_CODEC_ADDR2 | AWACS_CODEC_EMSEL0;
332 sc->sc_codecctl4 = AWACS_CODEC_ADDR4 | AWACS_CODEC_EMSEL0;
333
334 /* don't set CD in on iMacs, or else the outputs will be very noisy */
335 if (sc->sc_awacs_hardware != HW_IS_IMAC1 &&
336 sc->sc_awacs_hardware != HW_IS_IMAC2)
337 sc->sc_codecctl0 |= AWACS_INPUT_CD | AWACS_DEFAULT_CD_GAIN;
338 awacs_write_codec(sc, sc->sc_codecctl0);
339
340 /* Set initial volume[s] */
341 awacs_set_speaker_volume(sc, 80, 80);
342 awacs_set_ext_volume(sc, 80, 80);
343
344 /* Set loopback (for CD?) */
345 /* sc->sc_codecctl1 |= 0x440; */
346 sc->sc_codecctl1 |= 0x40;
347 awacs_write_codec(sc, sc->sc_codecctl1);
348
349 /* check for headphone present */
350 if (awacs_read_reg(sc, AWACS_CODEC_STATUS) &
351 sc->sc_awacs_headphone_mask) {
352 /* default output to speakers */
353 printf(" headphones");
354 sc->sc_output_mask = 1 << 1;
355 /* front headphones on iMacs are wired to the speakers output */
356 if ((sc->sc_awacs_hardware != HW_IS_IMAC2 &&
357 sc->sc_awacs_hardware != HW_IS_IMAC1) ||
358 ((sc->sc_awacs_hardware == HW_IS_IMAC2 ||
359 sc->sc_awacs_hardware == HW_IS_IMAC1) &&
360 (awacs_read_reg(sc, AWACS_CODEC_STATUS) &
361 AWACS_STATUS_HP_SCONN_IMAC))) {
362 sc->sc_codecctl1 &= ~AWACS_MUTE_HEADPHONE;
363 sc->sc_codecctl1 |= AWACS_MUTE_SPEAKER;
364 }
365 if (sc->sc_awacs_hardware == HW_IS_IMAC1)
366 sc->sc_codecctl1 |= AWACS_MUTE_SPEAKER_IMAC;
367 else if (sc->sc_awacs_hardware == HW_IS_IMAC2)
368 sc->sc_codecctl1 &= ~AWACS_MUTE_SPEAKER_IMAC;
369 awacs_write_codec(sc, sc->sc_codecctl1);
370 } else {
371 /* default output to speakers */
372 printf(" speaker");
373 sc->sc_output_mask = 1 << 0;
374 sc->sc_codecctl1 &= ~AWACS_MUTE_SPEAKER;
375 sc->sc_codecctl1 |= AWACS_MUTE_HEADPHONE;
376 if (sc->sc_awacs_hardware == HW_IS_IMAC1)
377 sc->sc_codecctl1 &= ~AWACS_MUTE_SPEAKER_IMAC;
378 else if (sc->sc_awacs_hardware == HW_IS_IMAC2)
379 sc->sc_codecctl1 |= AWACS_MUTE_SPEAKER_IMAC;
380 awacs_write_codec(sc, sc->sc_codecctl1);
381 }
382
383 /* default input from CD */
384 sc->sc_record_source = 1 << 0;
385 sc->sc_codecctl0 &= ~AWACS_INPUT_MASK;
386 if (sc->sc_awacs_hardware != HW_IS_IMAC1 &&
387 sc->sc_awacs_hardware != HW_IS_IMAC2)
388 sc->sc_codecctl0 |= AWACS_INPUT_CD;
389 awacs_write_codec(sc, sc->sc_codecctl0);
390
391 /* Enable interrupts and looping mode. */
392 /* XXX ... */
393 awacs_halt_output(sc);
394 awacs_halt_input(sc);
395 printf("\n");
396
397 audio_attach_mi(&awacs_hw_if, sc, NULL, &sc->sc_dev);
398 }
399
400 u_int
awacs_read_reg(struct awacs_softc * sc,int reg)401 awacs_read_reg(struct awacs_softc *sc, int reg)
402 {
403 char *addr = sc->sc_reg;
404
405 return in32rb(addr + reg);
406 }
407
408 void
awacs_write_reg(struct awacs_softc * sc,int reg,int val)409 awacs_write_reg(struct awacs_softc *sc, int reg, int val)
410 {
411 char *addr = sc->sc_reg;
412
413 out32rb(addr + reg, val);
414 }
415
416 void
awacs_write_codec(struct awacs_softc * sc,int value)417 awacs_write_codec(struct awacs_softc *sc, int value)
418 {
419 awacs_write_reg(sc, AWACS_CODEC_CTRL, value);
420 while (awacs_read_reg(sc, AWACS_CODEC_CTRL) & AWACS_CODEC_BUSY);
421 }
422
423 int
awacs_intr(void * v)424 awacs_intr(void *v)
425 {
426 int reason;
427 struct awacs_softc *sc = v;
428
429 mtx_enter(&audio_lock);
430 reason = awacs_read_reg(sc, AWACS_SOUND_CTRL);
431 if (reason & AWACS_CTL_CNTRLERR) {
432 /* change outputs ?? */
433 }
434 if (reason & AWACS_CTL_PORTCHG) {
435 #ifdef DEBUG
436 printf("status = %x\n", awacs_read_reg(sc, AWACS_CODEC_STATUS));
437 #endif
438
439 if (awacs_read_reg(sc, AWACS_CODEC_STATUS) &
440 sc->sc_awacs_headphone_mask) {
441 /* default output to speakers */
442 sc->sc_output_mask = 1 << 1;
443 /*
444 * Front headphones on iMacs are wired to the
445 * speakers output.
446 */
447 if ((sc->sc_awacs_hardware != HW_IS_IMAC2 &&
448 sc->sc_awacs_hardware != HW_IS_IMAC1) ||
449 ((sc->sc_awacs_hardware == HW_IS_IMAC2 ||
450 sc->sc_awacs_hardware == HW_IS_IMAC1) &&
451 (awacs_read_reg(sc, AWACS_CODEC_STATUS) &
452 AWACS_STATUS_HP_SCONN_IMAC))) {
453 sc->sc_codecctl1 &= ~AWACS_MUTE_HEADPHONE;
454 sc->sc_codecctl1 |= AWACS_MUTE_SPEAKER;
455 }
456 if (sc->sc_awacs_hardware == HW_IS_IMAC1)
457 sc->sc_codecctl1 |= AWACS_MUTE_SPEAKER_IMAC;
458 else if (sc->sc_awacs_hardware == HW_IS_IMAC2)
459 sc->sc_codecctl1 &= ~AWACS_MUTE_SPEAKER_IMAC;
460 awacs_write_codec(sc, sc->sc_codecctl1);
461 } else {
462 /* default output to speakers */
463 sc->sc_output_mask = 1 << 0;
464 sc->sc_codecctl1 &= ~AWACS_MUTE_SPEAKER;
465 sc->sc_codecctl1 |= AWACS_MUTE_HEADPHONE;
466 if (sc->sc_awacs_hardware == HW_IS_IMAC1)
467 sc->sc_codecctl1 &= ~AWACS_MUTE_SPEAKER_IMAC;
468 else if (sc->sc_awacs_hardware == HW_IS_IMAC2)
469 sc->sc_codecctl1 |= AWACS_MUTE_SPEAKER_IMAC;
470 awacs_write_codec(sc, sc->sc_codecctl1);
471 }
472 }
473
474 awacs_write_reg(sc, AWACS_SOUND_CTRL, reason); /* clear interrupt */
475 mtx_leave(&audio_lock);
476 return 1;
477 }
478
479 int
awacs_tx_intr(void * v)480 awacs_tx_intr(void *v)
481 {
482 struct awacs_softc *sc = v;
483 struct dbdma_command *cmd = sc->sc_odmap;
484 u_int16_t c, status;
485
486 /* if not set we are not running */
487 if (!cmd)
488 return (0);
489 mtx_enter(&audio_lock);
490 c = in16rb(&cmd->d_command);
491 status = in16rb(&cmd->d_status);
492
493 if (c >> 12 == DBDMA_CMD_OUT_LAST)
494 sc->sc_odmap = sc->sc_odmacmd;
495 else
496 sc->sc_odmap++;
497
498 if (c & (DBDMA_INT_ALWAYS << 4)) {
499 cmd->d_status = 0;
500 if (status) /* status == 0x8400 */
501 if (sc->sc_ointr)
502 (*sc->sc_ointr)(sc->sc_oarg);
503 }
504 mtx_leave(&audio_lock);
505 return (1);
506 }
507 int
awacs_rx_intr(void * v)508 awacs_rx_intr(void *v)
509 {
510 struct awacs_softc *sc = v;
511 struct dbdma_command *cmd = sc->sc_idmap;
512 u_int16_t c, status;
513
514 /* if not set we are not running */
515 if (!cmd)
516 return (0);
517
518 mtx_enter(&audio_lock);
519 c = in16rb(&cmd->d_command);
520 status = in16rb(&cmd->d_status);
521
522 if (c >> 12 == DBDMA_CMD_IN_LAST)
523 sc->sc_idmap = sc->sc_idmacmd;
524 else
525 sc->sc_idmap++;
526
527 if (c & (DBDMA_INT_ALWAYS << 4)) {
528 cmd->d_status = 0;
529 if (status) /* status == 0x8400 */
530 if (sc->sc_iintr)
531 (*sc->sc_iintr)(sc->sc_iarg);
532 }
533 mtx_leave(&audio_lock);
534 return (1);
535 }
536
537 int
awacs_open(void * h,int flags)538 awacs_open(void *h, int flags)
539 {
540 return 0;
541 }
542
543 /*
544 * Close function is called at splaudio().
545 */
546 void
awacs_close(void * h)547 awacs_close(void *h)
548 {
549 struct awacs_softc *sc = h;
550
551 /* XXX: halt_xxx() already called by upper layer */
552 awacs_halt_output(sc);
553 awacs_halt_input(sc);
554
555 sc->sc_ointr = 0;
556 sc->sc_iintr = 0;
557 }
558
559 int
awacs_set_params(void * h,int setmode,int usemode,struct audio_params * play,struct audio_params * rec)560 awacs_set_params(void *h, int setmode, int usemode, struct audio_params *play,
561 struct audio_params *rec)
562 {
563 struct awacs_softc *sc = h;
564 struct audio_params *p;
565 int mode;
566
567 /*
568 * This device only has one clock, so make the sample rates match.
569 */
570 if (play->sample_rate != rec->sample_rate &&
571 usemode == (AUMODE_PLAY | AUMODE_RECORD)) {
572 if (setmode == AUMODE_PLAY) {
573 rec->sample_rate = play->sample_rate;
574 setmode |= AUMODE_RECORD;
575 } else if (setmode == AUMODE_RECORD) {
576 play->sample_rate = rec->sample_rate;
577 setmode |= AUMODE_PLAY;
578 } else
579 return EINVAL;
580 }
581
582 for (mode = AUMODE_RECORD; mode != -1;
583 mode = mode == AUMODE_RECORD ? AUMODE_PLAY : -1) {
584 if ((setmode & mode) == 0)
585 continue;
586
587 p = mode == AUMODE_PLAY ? play : rec;
588
589 if (p->sample_rate < 4000)
590 p->sample_rate = 4000;
591 if (p->sample_rate > 50000)
592 p->sample_rate = 50000;
593
594 awacs_write_reg(sc, AWACS_BYTE_SWAP, 0);
595
596 p->encoding = AUDIO_ENCODING_SLINEAR_BE;
597 p->precision = 16;
598 p->channels = 2;
599 p->bps = AUDIO_BPS(p->precision);
600 p->msb = 1;
601 }
602
603 /* Set the speed */
604 awacs_set_rate(sc, p);
605
606 return (0);
607 }
608
609 int
awacs_round_blocksize(void * h,int size)610 awacs_round_blocksize(void *h, int size)
611 {
612 if (size < PAGE_SIZE)
613 size = PAGE_SIZE;
614 return (size + PAGE_SIZE / 2) & ~(PGOFSET);
615 }
616
617 int
awacs_halt_output(void * h)618 awacs_halt_output(void *h)
619 {
620 struct awacs_softc *sc = h;
621
622 mtx_enter(&audio_lock);
623 dbdma_stop(sc->sc_odma);
624 dbdma_reset(sc->sc_odma);
625 dbdma_stop(sc->sc_odma);
626 sc->sc_odmap = NULL;
627 mtx_leave(&audio_lock);
628 return 0;
629 }
630
631 int
awacs_halt_input(void * h)632 awacs_halt_input(void *h)
633 {
634 struct awacs_softc *sc = h;
635
636 mtx_enter(&audio_lock);
637 dbdma_stop(sc->sc_idma);
638 dbdma_reset(sc->sc_idma);
639 mtx_leave(&audio_lock);
640 return 0;
641 }
642
643 enum {
644 AWACS_OUTPUT_SELECT,
645 AWACS_VOL_SPEAKER,
646 AWACS_VOL_HEADPHONE,
647 AWACS_OUTPUT_CLASS,
648 AWACS_MONITOR_CLASS,
649 AWACS_INPUT_SELECT,
650 AWACS_VOL_INPUT,
651 AWACS_INPUT_CLASS,
652 AWACS_RECORD_CLASS,
653 AWACS_ENUM_LAST
654 };
655
656 int
awacs_set_port(void * h,mixer_ctrl_t * mc)657 awacs_set_port(void *h, mixer_ctrl_t *mc)
658 {
659 struct awacs_softc *sc = h;
660 int l, r;
661
662 DPRINTF("awacs_set_port dev = %d, type = %d\n", mc->dev, mc->type);
663
664 l = mc->un.value.level[AUDIO_MIXER_LEVEL_LEFT];
665 r = mc->un.value.level[AUDIO_MIXER_LEVEL_RIGHT];
666
667 switch (mc->dev) {
668 case AWACS_OUTPUT_SELECT:
669 /* no change necessary? */
670 if (mc->un.mask == sc->sc_output_mask)
671 return 0;
672 sc->sc_codecctl1 |= AWACS_MUTE_SPEAKER | AWACS_MUTE_HEADPHONE;
673 if (mc->un.mask & 1 << 0)
674 sc->sc_codecctl1 &= ~AWACS_MUTE_SPEAKER;
675 if (mc->un.mask & 1 << 1)
676 sc->sc_codecctl1 &= ~AWACS_MUTE_HEADPHONE;
677
678 awacs_write_codec(sc, sc->sc_codecctl1);
679 sc->sc_output_mask = mc->un.mask;
680 return 0;
681
682 case AWACS_VOL_SPEAKER:
683 awacs_set_speaker_volume(sc, l, r);
684 return 0;
685
686 case AWACS_VOL_HEADPHONE:
687 awacs_set_ext_volume(sc, l, r);
688 return 0;
689
690 case AWACS_VOL_INPUT:
691 sc->sc_codecctl0 &= ~0xff;
692 sc->sc_codecctl0 |= (l & 0xf0) | (r >> 4);
693 awacs_write_codec(sc, sc->sc_codecctl0);
694 return 0;
695
696 case AWACS_INPUT_SELECT:
697 /* no change necessary? */
698 if (mc->un.mask == sc->sc_record_source)
699 return 0;
700 switch(mc->un.mask) {
701 case 1<<0: /* CD */
702 sc->sc_codecctl0 &= ~AWACS_INPUT_MASK;
703 sc->sc_codecctl0 |= AWACS_INPUT_CD;
704 awacs_write_codec(sc, sc->sc_codecctl0);
705 break;
706 case 1<<1: /* microphone */
707 sc->sc_codecctl0 &= ~AWACS_INPUT_MASK;
708 sc->sc_codecctl0 |= AWACS_INPUT_MICROPHONE;
709 awacs_write_codec(sc, sc->sc_codecctl0);
710 break;
711 case 1<<2: /* line in */
712 sc->sc_codecctl0 &= ~AWACS_INPUT_MASK;
713 sc->sc_codecctl0 |= AWACS_INPUT_LINE;
714 awacs_write_codec(sc, sc->sc_codecctl0);
715 break;
716 default: /* invalid argument */
717 return -1;
718 }
719 sc->sc_record_source = mc->un.mask;
720 return 0;
721 }
722
723 return ENXIO;
724 }
725
726 int
awacs_get_port(void * h,mixer_ctrl_t * mc)727 awacs_get_port(void *h, mixer_ctrl_t *mc)
728 {
729 struct awacs_softc *sc = h;
730 int vol, l, r;
731
732 DPRINTF("awacs_get_port dev = %d, type = %d\n", mc->dev, mc->type);
733
734 switch (mc->dev) {
735 case AWACS_OUTPUT_SELECT:
736 mc->un.mask = sc->sc_output_mask;
737 return 0;
738
739 case AWACS_VOL_SPEAKER:
740 vol = sc->sc_codecctl4;
741 l = (15 - ((vol & 0x3c0) >> 6)) * 16;
742 r = (15 - (vol & 0x0f)) * 16;
743 mc->un.mask = 1 << 0;
744 mc->un.value.num_channels = 2;
745 mc->un.value.level[AUDIO_MIXER_LEVEL_LEFT] = l;
746 mc->un.value.level[AUDIO_MIXER_LEVEL_RIGHT] = r;
747 return 0;
748
749 case AWACS_VOL_HEADPHONE:
750 vol = sc->sc_codecctl2;
751 l = (15 - ((vol & 0x3c0) >> 6)) * 16;
752 r = (15 - (vol & 0x0f)) * 16;
753 mc->un.mask = 1 << 1;
754 mc->un.value.num_channels = 2;
755 mc->un.value.level[AUDIO_MIXER_LEVEL_LEFT] = l;
756 mc->un.value.level[AUDIO_MIXER_LEVEL_RIGHT] = r;
757 return 0;
758
759 case AWACS_INPUT_SELECT:
760 mc->un.mask = sc->sc_record_source;
761 return 0;
762
763 case AWACS_VOL_INPUT:
764 vol = sc->sc_codecctl0 & 0xff;
765 l = (vol & 0xf0);
766 r = (vol & 0x0f) << 4;
767 mc->un.mask = sc->sc_record_source;
768 mc->un.value.num_channels = 2;
769 mc->un.value.level[AUDIO_MIXER_LEVEL_LEFT] = l;
770 mc->un.value.level[AUDIO_MIXER_LEVEL_RIGHT] = r;
771 return 0;
772
773 default:
774 return ENXIO;
775 }
776
777 return 0;
778 }
779
780 int
awacs_query_devinfo(void * h,mixer_devinfo_t * dip)781 awacs_query_devinfo(void *h, mixer_devinfo_t *dip)
782 {
783 DPRINTF("query_devinfo %d\n", dip->index);
784
785 switch (dip->index) {
786
787 case AWACS_OUTPUT_SELECT:
788 dip->mixer_class = AWACS_OUTPUT_CLASS;
789 strlcpy(dip->label.name, AudioNselect, sizeof dip->label.name);
790 dip->type = AUDIO_MIXER_SET;
791 dip->prev = dip->next = AUDIO_MIXER_LAST;
792 dip->un.s.num_mem = 2;
793 strlcpy(dip->un.s.member[0].label.name, AudioNspeaker,
794 sizeof dip->un.s.member[0].label.name);
795 dip->un.s.member[0].mask = 1 << 0;
796 strlcpy(dip->un.s.member[1].label.name, AudioNheadphone,
797 sizeof dip->un.s.member[0].label.name);
798 dip->un.s.member[1].mask = 1 << 1;
799 return 0;
800
801 case AWACS_VOL_SPEAKER:
802 dip->mixer_class = AWACS_OUTPUT_CLASS;
803 strlcpy(dip->label.name, AudioNspeaker,
804 sizeof dip->label.name);
805 dip->type = AUDIO_MIXER_VALUE;
806 dip->prev = dip->next = AUDIO_MIXER_LAST;
807 dip->un.v.num_channels = 2;
808 strlcpy(dip->un.v.units.name, AudioNvolume,
809 sizeof dip->un.v.units.name);
810 return 0;
811
812 case AWACS_VOL_HEADPHONE:
813 dip->mixer_class = AWACS_OUTPUT_CLASS;
814 strlcpy(dip->label.name, AudioNheadphone,
815 sizeof dip->label.name);
816 dip->type = AUDIO_MIXER_VALUE;
817 dip->prev = dip->next = AUDIO_MIXER_LAST;
818 dip->un.v.num_channels = 2;
819 strlcpy(dip->un.v.units.name, AudioNvolume,
820 sizeof dip->un.v.units.name);
821 return 0;
822
823 case AWACS_INPUT_SELECT:
824 dip->mixer_class = AWACS_RECORD_CLASS;
825 strlcpy(dip->label.name, AudioNsource, sizeof dip->label.name);
826 dip->type = AUDIO_MIXER_SET;
827 dip->prev = dip->next = AUDIO_MIXER_LAST;
828 dip->un.s.num_mem = 3;
829 strlcpy(dip->un.s.member[0].label.name, AudioNcd,
830 sizeof dip->un.s.member[0].label.name);
831 dip->un.s.member[0].mask = 1 << 0;
832 strlcpy(dip->un.s.member[1].label.name, AudioNmicrophone,
833 sizeof dip->un.s.member[1].label.name);
834 dip->un.s.member[1].mask = 1 << 1;
835 strlcpy(dip->un.s.member[2].label.name, AudioNline,
836 sizeof dip->un.s.member[2].label.name);
837 dip->un.s.member[2].mask = 1 << 2;
838 return 0;
839
840 case AWACS_VOL_INPUT:
841 dip->mixer_class = AWACS_RECORD_CLASS;
842 strlcpy(dip->label.name, AudioNmaster, sizeof dip->label.name);
843 dip->type = AUDIO_MIXER_VALUE;
844 dip->prev = dip->next = AUDIO_MIXER_LAST;
845 dip->un.v.num_channels = 2;
846 strlcpy(dip->un.v.units.name, AudioNvolume,
847 sizeof dip->un.v.units.name);
848 return 0;
849
850 case AWACS_MONITOR_CLASS:
851 dip->mixer_class = AWACS_MONITOR_CLASS;
852 strlcpy(dip->label.name, AudioCmonitor, sizeof dip->label.name);
853 dip->type = AUDIO_MIXER_CLASS;
854 dip->next = dip->prev = AUDIO_MIXER_LAST;
855 return 0;
856
857 case AWACS_OUTPUT_CLASS:
858 dip->mixer_class = AWACS_OUTPUT_CLASS;
859 strlcpy(dip->label.name, AudioCoutputs, sizeof dip->label.name);
860 dip->type = AUDIO_MIXER_CLASS;
861 dip->next = dip->prev = AUDIO_MIXER_LAST;
862 return 0;
863
864 case AWACS_RECORD_CLASS:
865 dip->mixer_class = AWACS_MONITOR_CLASS;
866 strlcpy(dip->label.name, AudioCrecord, sizeof dip->label.name);
867 dip->type = AUDIO_MIXER_CLASS;
868 dip->next = dip->prev = AUDIO_MIXER_LAST;
869 return 0;
870 }
871
872 return ENXIO;
873 }
874
875 size_t
awacs_round_buffersize(void * h,int dir,size_t size)876 awacs_round_buffersize(void *h, int dir, size_t size)
877 {
878 size = (size + PGOFSET) & ~(PGOFSET);
879 if (size > AWACS_DMALIST_MAX * AWACS_DMASEG_MAX)
880 size = AWACS_DMALIST_MAX * AWACS_DMASEG_MAX;
881 return (size);
882 }
883
884 void *
awacs_allocm(void * h,int dir,size_t size,int type,int flags)885 awacs_allocm(void *h, int dir, size_t size, int type, int flags)
886 {
887 struct awacs_softc *sc = h;
888 struct awacs_dma *p;
889 int error;
890
891 if (size > AWACS_DMALIST_MAX * AWACS_DMASEG_MAX)
892 return (NULL);
893
894 p = malloc(sizeof(*p), type, flags | M_ZERO);
895 if (!p)
896 return (NULL);
897
898 /* convert to the bus.h style, not used otherwise */
899 if (flags & M_NOWAIT)
900 flags = BUS_DMA_NOWAIT;
901
902 p->size = size;
903 if ((error = bus_dmamem_alloc(sc->sc_dmat, p->size, NBPG, 0, p->segs,
904 1, &p->nsegs, flags)) != 0) {
905 printf("%s: unable to allocate dma, error = %d\n",
906 sc->sc_dev.dv_xname, error);
907 free(p, type, sizeof *p);
908 return NULL;
909 }
910
911 if ((error = bus_dmamem_map(sc->sc_dmat, p->segs, p->nsegs, p->size,
912 &p->addr, flags | BUS_DMA_COHERENT)) != 0) {
913 printf("%s: unable to map dma, error = %d\n",
914 sc->sc_dev.dv_xname, error);
915 bus_dmamem_free(sc->sc_dmat, p->segs, p->nsegs);
916 free(p, type, sizeof *p);
917 return NULL;
918 }
919
920 if ((error = bus_dmamap_create(sc->sc_dmat, p->size, 1,
921 p->size, 0, flags, &p->map)) != 0) {
922 printf("%s: unable to create dma map, error = %d\n",
923 sc->sc_dev.dv_xname, error);
924 bus_dmamem_unmap(sc->sc_dmat, p->addr, size);
925 bus_dmamem_free(sc->sc_dmat, p->segs, p->nsegs);
926 free(p, type, sizeof *p);
927 return NULL;
928 }
929
930 if ((error = bus_dmamap_load(sc->sc_dmat, p->map, p->addr, p->size,
931 NULL, flags)) != 0) {
932 printf("%s: unable to load dma map, error = %d\n",
933 sc->sc_dev.dv_xname, error);
934 bus_dmamap_destroy(sc->sc_dmat, p->map);
935 bus_dmamem_unmap(sc->sc_dmat, p->addr, size);
936 bus_dmamem_free(sc->sc_dmat, p->segs, p->nsegs);
937 free(p, type, sizeof *p);
938 return NULL;
939 }
940
941 p->next = sc->sc_dmas;
942 sc->sc_dmas = p;
943
944 return p->addr;
945 }
946
947 int
awacs_trigger_output(void * h,void * start,void * end,int bsize,void (* intr)(void *),void * arg,struct audio_params * param)948 awacs_trigger_output(void *h, void *start, void *end, int bsize,
949 void (*intr)(void *), void *arg, struct audio_params *param)
950 {
951 struct awacs_softc *sc = h;
952 struct awacs_dma *p;
953 struct dbdma_command *cmd = sc->sc_odmacmd;
954 vaddr_t spa, pa, epa;
955 int c;
956
957 DPRINTF("trigger_output %p %p 0x%x\n", start, end, bsize);
958
959 for (p = sc->sc_dmas; p && p->addr != start; p = p->next)
960 ;
961 if (!p)
962 return -1;
963
964 sc->sc_ointr = intr;
965 sc->sc_oarg = arg;
966 sc->sc_odmap = sc->sc_odmacmd;
967
968 mtx_enter(&audio_lock);
969 spa = p->segs[0].ds_addr;
970 c = DBDMA_CMD_OUT_MORE;
971 for (pa = spa, epa = spa + (end - start);
972 pa < epa; pa += bsize, cmd++) {
973
974 if (pa + bsize == epa)
975 c = DBDMA_CMD_OUT_LAST;
976
977 DBDMA_BUILD(cmd, c, 0, bsize, pa, DBDMA_INT_ALWAYS,
978 DBDMA_WAIT_NEVER, DBDMA_BRANCH_NEVER);
979 }
980
981 DBDMA_BUILD(cmd, DBDMA_CMD_NOP, 0, 0, 0,
982 DBDMA_INT_NEVER, DBDMA_WAIT_NEVER, DBDMA_BRANCH_ALWAYS);
983 dbdma_st32(&cmd->d_cmddep, sc->sc_odbdma->d_paddr);
984
985 dbdma_start(sc->sc_odma, sc->sc_odbdma);
986
987 mtx_leave(&audio_lock);
988 return 0;
989 }
990
991 int
awacs_trigger_input(void * h,void * start,void * end,int bsize,void (* intr)(void *),void * arg,struct audio_params * param)992 awacs_trigger_input(void *h, void *start, void *end, int bsize,
993 void (*intr)(void *), void *arg, struct audio_params *param)
994 {
995 struct awacs_softc *sc = h;
996 struct awacs_dma *p;
997 struct dbdma_command *cmd = sc->sc_idmacmd;
998 vaddr_t spa, pa, epa;
999 int c;
1000
1001 DPRINTF("trigger_input %p %p 0x%x\n", start, end, bsize);
1002
1003 for (p = sc->sc_dmas; p && p->addr != start; p = p->next)
1004 ;
1005 if (!p)
1006 return -1;
1007
1008 sc->sc_iintr = intr;
1009 sc->sc_iarg = arg;
1010 sc->sc_idmap = sc->sc_idmacmd;
1011
1012 mtx_enter(&audio_lock);
1013 spa = p->segs[0].ds_addr;
1014 c = DBDMA_CMD_IN_MORE;
1015 for (pa = spa, epa = spa + (end - start);
1016 pa < epa; pa += bsize, cmd++) {
1017
1018 if (pa + bsize == epa)
1019 c = DBDMA_CMD_IN_LAST;
1020
1021 DBDMA_BUILD(cmd, c, 0, bsize, pa, DBDMA_INT_ALWAYS,
1022 DBDMA_WAIT_NEVER, DBDMA_BRANCH_NEVER);
1023 }
1024
1025 DBDMA_BUILD(cmd, DBDMA_CMD_NOP, 0, 0, 0,
1026 DBDMA_INT_NEVER, DBDMA_WAIT_NEVER, DBDMA_BRANCH_ALWAYS);
1027 dbdma_st32(&cmd->d_cmddep, sc->sc_idbdma->d_paddr);
1028
1029 dbdma_start(sc->sc_idma, sc->sc_idbdma);
1030
1031 mtx_leave(&audio_lock);
1032 return 0;
1033 }
1034
1035 void
awacs_set_speaker_volume(struct awacs_softc * sc,int left,int right)1036 awacs_set_speaker_volume(struct awacs_softc *sc, int left, int right)
1037 {
1038 int lval = 15 - (left & 0xff) / 16;
1039 int rval = 15 - (right & 0xff) / 16;
1040
1041 DPRINTF("speaker_volume %d %d\n", lval, rval);
1042
1043 sc->sc_codecctl4 &= ~0x3cf;
1044 sc->sc_codecctl4 |= (lval << 6) | rval;
1045 awacs_write_codec(sc, sc->sc_codecctl4);
1046 }
1047
1048 void
awacs_set_ext_volume(struct awacs_softc * sc,int left,int right)1049 awacs_set_ext_volume(struct awacs_softc *sc, int left, int right)
1050 {
1051 int lval = 15 - (left & 0xff) / 16;
1052 int rval = 15 - (right & 0xff) / 16;
1053
1054 DPRINTF("ext_volume %d %d\n", lval, rval);
1055
1056 sc->sc_codecctl2 &= ~0x3cf;
1057 sc->sc_codecctl2 |= (lval << 6) | rval;
1058 awacs_write_codec(sc, sc->sc_codecctl2);
1059 }
1060
1061 void
awacs_set_rate(struct awacs_softc * sc,struct audio_params * p)1062 awacs_set_rate(struct awacs_softc *sc, struct audio_params *p)
1063 {
1064 int selected = -1;
1065 size_t n, i;
1066
1067 n = sizeof(awacs_speeds)/sizeof(awacs_speeds[0]);
1068
1069 if (p->sample_rate < awacs_speeds[0].rate)
1070 selected = 0;
1071 if (p->sample_rate > awacs_speeds[n - 1].rate)
1072 selected = n - 1;
1073
1074 for (i = 1; selected == -1 && i < n; i++) {
1075 if (p->sample_rate == awacs_speeds[i].rate)
1076 selected = i;
1077 else if (p->sample_rate < awacs_speeds[i].rate) {
1078 u_int diff1, diff2;
1079
1080 diff1 = p->sample_rate - awacs_speeds[i - 1].rate;
1081 diff2 = awacs_speeds[i].rate - p->sample_rate;
1082 selected = (diff1 < diff2) ? i - 1 : i;
1083 }
1084 }
1085
1086 if (selected == -1)
1087 selected = 0;
1088
1089 sc->sc_soundctl &= ~AWACS_RATE_MASK;
1090 sc->sc_soundctl |= awacs_speeds[selected].bits;
1091 p->sample_rate = awacs_speeds[selected].rate;
1092 awacs_write_reg(sc, AWACS_SOUND_CTRL, sc->sc_soundctl);
1093 }
1094