?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Expand PMF_FN_* macros.
[netbsd-mini2440.git] / sys / dev / pci / gcscaudio.c
blobe2f9b601ca605f5bdd4f9a8354bac01babe90c9f
1 /* $NetBSD: gcscaudio.c,v 1.3 2009/11/26 15:17:09 njoly Exp $ */
2
3 /*-
4 * Copyright (c) 2008 SHIMIZU Ryo <ryo@nerv.org>
5 * 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 *
16 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
17 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
18 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
19 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
20 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
21 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
22 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
23 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
24 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
25 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
26 * POSSIBILITY OF SUCH DAMAGE.
27 */
28
29 #include <sys/cdefs.h>
30 __KERNEL_RCSID(0, "$NetBSD: gcscaudio.c,v 1.3 2009/11/26 15:17:09 njoly Exp $");
31
32 #include <sys/param.h>
33 #include <sys/systm.h>
34 #include <sys/malloc.h>
35 #include <sys/device.h>
36 #include <sys/queue.h>
37
38 #include <uvm/uvm_extern.h>
39
40 #include <dev/pci/pcidevs.h>
41 #include <dev/pci/pcivar.h>
42
43 #include <sys/audioio.h>
44 #include <dev/audio_if.h>
45 #include <dev/mulaw.h>
46 #include <dev/auconv.h>
47 #include <dev/ic/ac97reg.h>
48 #include <dev/ic/ac97var.h>
49
50 #include <dev/pci/gcscaudioreg.h>
51
52
53 #define GCSCAUDIO_NPRDTABLE 256 /* including a JMP-PRD for loop */
54 #define GCSCAUDIO_PRD_SIZE_MAX 65532 /* limited by CS5536 Controller */
55 #define GCSCAUDIO_BUFSIZE_MAX (GCSCAUDIO_PRD_SIZE_MAX * (GCSCAUDIO_NPRDTABLE - 1))
56
57 struct gcscaudio_prd {
58 /* PRD table for play/rec */
59 struct gcscaudio_prdtables {
60 #define PRD_TABLE_FRONT 0
61 #define PRD_TABLE_SURR 1
62 #define PRD_TABLE_CENTER 2
63 #define PRD_TABLE_LFE 3
64 #define PRD_TABLE_REC 4
65 #define PRD_TABLE_MAX 5
66 struct acc_prd prdtbl[PRD_TABLE_MAX][GCSCAUDIO_NPRDTABLE];
67 } *p_prdtables;
68 bus_dmamap_t p_prdmap;
69 bus_dma_segment_t p_prdsegs[1];
70 int p_prdnseg;
71 };
72
73 struct gcscaudio_dma {
74 LIST_ENTRY(gcscaudio_dma) list;
75 bus_dmamap_t map;
76 void *addr;
77 size_t size;
78 bus_dma_segment_t segs[1];
79 int nseg;
80 };
81
82 struct gcscaudio_softc_ch {
83 void (*ch_intr)(void *);
84 void *ch_intr_arg;
85 struct audio_params ch_params;
86 };
87
88 struct gcscaudio_softc {
89 struct device sc_dev;
90 pci_chipset_tag_t sc_pc;
91 pcitag_t sc_pt;
92 void *sc_ih;
93 bus_space_tag_t sc_iot;
94 bus_space_handle_t sc_ioh;
95 bus_size_t sc_ios;
96 bus_dma_tag_t sc_dmat;
97
98 /* allocated DMA buffer list */
99 LIST_HEAD(, gcscaudio_dma) sc_dmalist;
100
101 #define GCSCAUDIO_MAXFORMATS 4
102 struct audio_format sc_formats[GCSCAUDIO_MAXFORMATS];
103 int sc_nformats;
104 struct audio_encoding_set *sc_encodings;
105
106 /* AC97 codec */
107 struct ac97_host_if host_if;
108 struct ac97_codec_if *codec_if;
109
110 /* input, output channels */
111 struct gcscaudio_softc_ch sc_play;
112 struct gcscaudio_softc_ch sc_rec;
113 struct gcscaudio_prd sc_prd;
114
115 /* multi channel splitter work; {4,6}ch stream to {2,4} DMA buffers */
116 void *sc_mch_split_buf;
117 void *sc_mch_split_start;
118 int sc_mch_split_off;
119 int sc_mch_split_size;
120 int sc_mch_split_blksize;
121 void (*sc_mch_splitter)(void *, void *, int, int);
122 bool sc_spdif;
123 };
124
125 /* for cfattach */
126 static int gcscaudio_match(device_t, cfdata_t, void *);
127 static void gcscaudio_attach(device_t, device_t, void *);
128
129 /* for audio_hw_if */
130 static int gcscaudio_open(void *, int);
131 static void gcscaudio_close(void *);
132 static int gcscaudio_query_encoding(void *, struct audio_encoding *);
133 static int gcscaudio_set_params(void *, int, int, audio_params_t *,
134 audio_params_t *, stream_filter_list_t *,
135 stream_filter_list_t *);
136 static int gcscaudio_round_blocksize(void *, int, int, const audio_params_t *);
137 static int gcscaudio_halt_output(void *);
138 static int gcscaudio_halt_input(void *);
139 static int gcscaudio_getdev(void *, struct audio_device *);
140 static int gcscaudio_set_port(void *, mixer_ctrl_t *);
141 static int gcscaudio_get_port(void *, mixer_ctrl_t *);
142 static int gcscaudio_query_devinfo(void *, mixer_devinfo_t *);
143 static void *gcscaudio_malloc(void *, int, size_t, struct malloc_type *, int);
144 static void gcscaudio_free(void *, void *, struct malloc_type *);
145 static size_t gcscaudio_round_buffersize(void *, int, size_t);
146 static paddr_t gcscaudio_mappage(void *, void *, off_t, int);
147 static int gcscaudio_get_props(void *);
148 static int gcscaudio_trigger_output(void *, void *, void *, int,
149 void (*)(void *), void *,
150 const audio_params_t *);
151 static int gcscaudio_trigger_input(void *, void *, void *, int,
152 void (*)(void *), void *,
153 const audio_params_t *);
154 static bool gcscaudio_resume(device_t, pmf_qual_t);
155 static int gcscaudio_intr(void *);
156
157 /* for codec_if */
158 static int gcscaudio_attach_codec(void *, struct ac97_codec_if *);
159 static int gcscaudio_write_codec(void *, uint8_t, uint16_t);
160 static int gcscaudio_read_codec(void *, uint8_t, uint16_t *);
161 static int gcscaudio_reset_codec(void *);
162 static void gcscaudio_spdif_event_codec(void *, bool);
163
164 /* misc */
165 static int gcscaudio_append_formats(struct gcscaudio_softc *,
166 const struct audio_format *);
167 static int gcscaudio_wait_ready_codec(struct gcscaudio_softc *sc, const char *);
168 static int gcscaudio_set_params_ch(struct gcscaudio_softc *,
169 struct gcscaudio_softc_ch *, int,
170 audio_params_t *, stream_filter_list_t *);
171 static int gcscaudio_allocate_dma(struct gcscaudio_softc *, size_t, void **,
172 bus_dma_segment_t *, int, int *,
173 int, bus_dmamap_t *);
174
175
176 CFATTACH_DECL(gcscaudio, sizeof (struct gcscaudio_softc),
177 gcscaudio_match, gcscaudio_attach, NULL, NULL);
178
179
180 static struct audio_device gcscaudio_device = {
181 "AMD Geode CS5536",
182 "",
183 "gcscaudio"
184 };
185
186 static const struct audio_hw_if gcscaudio_hw_if = {
187 .open = gcscaudio_open,
188 .close = gcscaudio_close,
189 .drain = NULL,
190 .query_encoding = gcscaudio_query_encoding,
191 .set_params = gcscaudio_set_params,
192 .round_blocksize = gcscaudio_round_blocksize,
193 .commit_settings = NULL,
194 .init_output = NULL,
195 .init_input = NULL,
196 .start_output = NULL,
197 .start_input = NULL,
198 .halt_output = gcscaudio_halt_output,
199 .halt_input = gcscaudio_halt_input,
200 .speaker_ctl = NULL,
201 .getdev = gcscaudio_getdev,
202 .setfd = NULL,
203 .set_port = gcscaudio_set_port,
204 .get_port = gcscaudio_get_port,
205 .query_devinfo = gcscaudio_query_devinfo,
206 .allocm = gcscaudio_malloc,
207 .freem = gcscaudio_free,
208 .round_buffersize = gcscaudio_round_buffersize,
209 .mappage = gcscaudio_mappage,
210 .get_props = gcscaudio_get_props,
211 .trigger_output = gcscaudio_trigger_output,
212 .trigger_input = gcscaudio_trigger_input,
213 .dev_ioctl = NULL,
214 .powerstate = NULL
215 };
216
217 static const struct audio_format gcscaudio_formats_2ch = {
218 NULL, AUMODE_PLAY | AUMODE_RECORD, AUDIO_ENCODING_SLINEAR_LE, 16, 16,
219 2, AUFMT_STEREO, 0, {8000, 48000}
220 };
221
222 static const struct audio_format gcscaudio_formats_4ch = {
223 NULL, AUMODE_PLAY, AUDIO_ENCODING_SLINEAR_LE, 16, 16,
224 4, AUFMT_SURROUND4, 0, {8000, 48000}
225 };
226
227 static const struct audio_format gcscaudio_formats_6ch = {
228 NULL, AUMODE_PLAY, AUDIO_ENCODING_SLINEAR_LE, 16, 16,
229 6, AUFMT_DOLBY_5_1, 0, {8000, 48000}
230 };
231
232 static int
233 gcscaudio_match(device_t parent, cfdata_t match, void *aux)
234 {
235 struct pci_attach_args *pa;
236
237 pa = (struct pci_attach_args *)aux;
238 if ((PCI_VENDOR(pa->pa_id) == PCI_VENDOR_AMD) &&
239 (PCI_PRODUCT(pa->pa_id) == PCI_PRODUCT_AMD_CS5536_AUDIO))
240 return 1;
241
242 return 0;
243 }
244
245 static int
246 gcscaudio_append_formats(struct gcscaudio_softc *sc,
247 const struct audio_format *format)
248 {
249 if (sc->sc_nformats >= GCSCAUDIO_MAXFORMATS) {
250 aprint_error_dev(&sc->sc_dev, "too many formats\n");
251 return EINVAL;
252 }
253 sc->sc_formats[sc->sc_nformats++] = *format;
254 return 0;
255 }
256
257 static void
258 gcscaudio_attach(device_t parent, device_t self, void *aux)
259 {
260 struct gcscaudio_softc *sc;
261 struct pci_attach_args *pa;
262 const char *intrstr;
263 pci_intr_handle_t ih;
264 int rc, i;
265
266 sc = device_private(self);
267
268 aprint_naive(": Audio controller\n");
269
270 pa = aux;
271 sc->sc_pc = pa->pa_pc;
272 sc->sc_pt = pa->pa_tag;
273 sc->sc_dmat = pa->pa_dmat;
274 LIST_INIT(&sc->sc_dmalist);
275 sc->sc_mch_split_buf = NULL;
276
277 aprint_normal(": AMD Geode CS5536 Audio\n");
278
279 if (pci_mapreg_map(pa, PCI_MAPREG_START, PCI_MAPREG_TYPE_IO, 0,
280 &sc->sc_iot, &sc->sc_ioh, NULL, &sc->sc_ios)) {
281 aprint_error_dev(&sc->sc_dev, "can't map i/o space\n");
282 return;
283 }
284
285 if (pci_intr_map(pa, &ih)) {
286 aprint_error_dev(&sc->sc_dev, "couldn't map interrupt\n");
287 goto attach_failure_unmap;
288 }
289 intrstr = pci_intr_string(sc->sc_pc, ih);
290
291 sc->sc_ih = pci_intr_establish(sc->sc_pc, ih, IPL_AUDIO,
292 gcscaudio_intr, sc);
293 if (sc->sc_ih == NULL) {
294 aprint_error_dev(&sc->sc_dev, "couldn't establish interrupt");
295 if (intrstr != NULL)
296 aprint_error(" at %s", intrstr);
297 aprint_error("\n");
298 goto attach_failure_unmap;
299 }
300
301 aprint_normal_dev(&sc->sc_dev, "interrupting at %s\n", intrstr);
302
303
304 if (gcscaudio_allocate_dma(sc, sizeof(*sc->sc_prd.p_prdtables),
305 (void **)&(sc->sc_prd.p_prdtables), sc->sc_prd.p_prdsegs, 1,
306 &(sc->sc_prd.p_prdnseg), M_WAITOK, &(sc->sc_prd.p_prdmap)) != 0)
307 goto attach_failure_intr;
308
309 sc->host_if.arg = sc;
310 sc->host_if.attach = gcscaudio_attach_codec;
311 sc->host_if.read = gcscaudio_read_codec;
312 sc->host_if.write = gcscaudio_write_codec;
313 sc->host_if.reset = gcscaudio_reset_codec;
314 sc->host_if.spdif_event = gcscaudio_spdif_event_codec;
315
316 if ((rc = ac97_attach(&sc->host_if, self)) != 0) {
317 aprint_error_dev(&sc->sc_dev,
318 "can't attach codec (error=%d)\n", rc);
319 goto attach_failure_intr;
320 }
321
322 if (!pmf_device_register(self, NULL, gcscaudio_resume))
323 aprint_error_dev(self, "couldn't establish power handler\n");
324
325
326 sc->sc_nformats = 0;
327 gcscaudio_append_formats(sc, &gcscaudio_formats_2ch);
328 if (AC97_IS_4CH(sc->codec_if))
329 gcscaudio_append_formats(sc, &gcscaudio_formats_4ch);
330 if (AC97_IS_6CH(sc->codec_if))
331 gcscaudio_append_formats(sc, &gcscaudio_formats_6ch);
332 if (AC97_IS_FIXED_RATE(sc->codec_if)) {
333 for (i = 0; i < sc->sc_nformats; i++) {
334 sc->sc_formats[i].frequency_type = 1;
335 sc->sc_formats[i].frequency[0] = 48000;
336 }
337 }
338
339 if ((rc = auconv_create_encodings(sc->sc_formats, sc->sc_nformats,
340 &sc->sc_encodings)) != 0) {
341 aprint_error_dev(self,
342 "auconv_create_encoding: error=%d\n", rc);
343 goto attach_failure_codec;
344 }
345
346 audio_attach_mi(&gcscaudio_hw_if, sc, &sc->sc_dev);
347 sc->codec_if->vtbl->unlock(sc->codec_if);
348 return;
349
350 attach_failure_codec:
351 sc->codec_if->vtbl->detach(sc->codec_if);
352 attach_failure_intr:
353 pci_intr_disestablish(sc->sc_pc, sc->sc_ih);
354 attach_failure_unmap:
355 bus_space_unmap(sc->sc_iot, sc->sc_ioh, sc->sc_ios);
356 return;
357 }
358
359 static int
360 gcscaudio_attach_codec(void *arg, struct ac97_codec_if *codec_if)
361 {
362 struct gcscaudio_softc *sc;
363
364 sc = (struct gcscaudio_softc *)arg;
365 sc->codec_if = codec_if;
366 return 0;
367 }
368
369 static int
370 gcscaudio_reset_codec(void *arg)
371 {
372 struct gcscaudio_softc *sc;
373 sc = (struct gcscaudio_softc *)arg;
374
375 bus_space_write_4(sc->sc_iot, sc->sc_ioh, ACC_CODEC_CNTL,
376 ACC_CODEC_CNTL_LNK_WRM_RST |
377 ACC_CODEC_CNTL_CMD_NEW);
378
379 if (gcscaudio_wait_ready_codec(sc, "reset timeout\n"))
380 return 1;
381
382 return 0;
383 }
384
385 static void
386 gcscaudio_spdif_event_codec(void *arg, bool flag)
387 {
388 struct gcscaudio_softc *sc;
389
390 sc = (struct gcscaudio_softc *)arg;
391 sc->sc_spdif = flag;
392 }
393
394 static int
395 gcscaudio_wait_ready_codec(struct gcscaudio_softc *sc, const char *timeout_msg)
396 {
397 int i;
398
399 #define GCSCAUDIO_WAIT_READY_CODEC_TIMEOUT 500
400 for (i = GCSCAUDIO_WAIT_READY_CODEC_TIMEOUT; (i >= 0) &&
401 (bus_space_read_4(sc->sc_iot, sc->sc_ioh, ACC_CODEC_CNTL) &
402 ACC_CODEC_CNTL_CMD_NEW); i--)
403 delay(1);
404
405 if (i < 0) {
406 aprint_error_dev(&sc->sc_dev, timeout_msg);
407 return 1;
408 }
409
410 return 0;
411 }
412
413 static int
414 gcscaudio_write_codec(void *arg, uint8_t reg, uint16_t val)
415 {
416 struct gcscaudio_softc *sc;
417
418 sc = (struct gcscaudio_softc *)arg;
419
420 bus_space_write_4(sc->sc_iot, sc->sc_ioh, ACC_CODEC_CNTL,
421 ACC_CODEC_CNTL_WRITE_CMD |
422 ACC_CODEC_CNTL_CMD_NEW |
423 ACC_CODEC_REG2ADDR(reg) |
424 (val & ACC_CODEC_CNTL_CMD_DATA_MASK));
425
426 if (gcscaudio_wait_ready_codec(sc, "codec write timeout\n"))
427 return 1;
428
429 #ifdef GCSCAUDIO_CODEC_DEBUG
430 aprint_error_dev(&sc->sc_dev, "codec write: reg=0x%02x, val=0x%04x\n",
431 reg, val);
432 #endif
433
434 return 0;
435 }
436
437 static int
438 gcscaudio_read_codec(void *arg, uint8_t reg, uint16_t *val)
439 {
440 struct gcscaudio_softc *sc;
441 uint32_t v;
442 int i;
443
444 sc = (struct gcscaudio_softc *)arg;
445 bus_space_write_4(sc->sc_iot, sc->sc_ioh, ACC_CODEC_CNTL,
446 ACC_CODEC_CNTL_READ_CMD | ACC_CODEC_CNTL_CMD_NEW |
447 ACC_CODEC_REG2ADDR(reg));
448
449 if (gcscaudio_wait_ready_codec(sc, "codec write timeout for reading"))
450 return 1;
451
452 #define GCSCAUDIO_READ_CODEC_TIMEOUT 50
453 for (i = GCSCAUDIO_READ_CODEC_TIMEOUT; i >= 0; i--) {
454 v = bus_space_read_4(sc->sc_iot, sc->sc_ioh, ACC_CODEC_STATUS);
455 if ((v & ACC_CODEC_STATUS_STS_NEW) &&
456 (ACC_CODEC_ADDR2REG(v) == reg))
457 break;
458
459 delay(10);
460 }
461
462 if (i < 0) {
463 aprint_error_dev(&sc->sc_dev, "codec read timeout\n");
464 return 1;
465 }
466
467 #ifdef GCSCAUDIO_CODEC_DEBUG
468 aprint_error_dev(&sc->sc_dev, "codec read: reg=0x%02x, val=0x%04x\n",
469 reg, v & ACC_CODEC_STATUS_STS_DATA_MASK);
470 #endif
471
472 *val = v;
473 return 0;
474 }
475
476 static int
477 gcscaudio_open(void *arg, int flags)
478 {
479 struct gcscaudio_softc *sc;
480
481 sc = (struct gcscaudio_softc *)arg;
482 sc->codec_if->vtbl->lock(sc->codec_if);
483 return 0;
484 }
485
486 static void
487 gcscaudio_close(void *arg)
488 {
489 struct gcscaudio_softc *sc;
490
491 sc = (struct gcscaudio_softc *)arg;
492 sc->codec_if->vtbl->unlock(sc->codec_if);
493 }
494
495 static int
496 gcscaudio_query_encoding(void *arg, struct audio_encoding *fp)
497 {
498 struct gcscaudio_softc *sc;
499
500 sc = (struct gcscaudio_softc *)arg;
501 return auconv_query_encoding(sc->sc_encodings, fp);
502 }
503
504 static int
505 gcscaudio_set_params_ch(struct gcscaudio_softc *sc,
506 struct gcscaudio_softc_ch *ch, int mode,
507 audio_params_t *p, stream_filter_list_t *fil)
508 {
509 int error, idx;
510
511 if ((p->sample_rate < 8000) || (p->sample_rate > 48000))
512 return EINVAL;
513
514 if (p->precision != 8 && p->precision != 16)
515 return EINVAL;
516
517 if ((idx = auconv_set_converter(sc->sc_formats, sc->sc_nformats,
518 mode, p, TRUE, fil)) < 0)
519 return EINVAL;
520
521 if (fil->req_size > 0)
522 p = &fil->filters[0].param;
523
524 if (mode == AUMODE_PLAY) {
525 if (!AC97_IS_FIXED_RATE(sc->codec_if)) {
526 /* setup rate of DAC/ADC */
527 if ((error = sc->codec_if->vtbl->set_rate(sc->codec_if,
528 AC97_REG_PCM_LR_ADC_RATE, &p->sample_rate)) != 0)
529 return error;
530
531 /* additional rate of DAC for Surround */
532 if ((p->channels >= 4) &&
533 (error = sc->codec_if->vtbl->set_rate(sc->codec_if,
534 AC97_REG_PCM_SURR_DAC_RATE, &p->sample_rate)) != 0)
535 return error;
536
537 /* additional rate of DAC for LowFrequencyEffect */
538 if ((p->channels == 6) &&
539 (error = sc->codec_if->vtbl->set_rate(sc->codec_if,
540 AC97_REG_PCM_LFE_DAC_RATE, &p->sample_rate)) != 0)
541 return error;
542 }
543 }
544
545 if (mode == AUMODE_RECORD) {
546 if (!AC97_IS_FIXED_RATE(sc->codec_if)) {
547 /* setup rate of DAC/ADC */
548 if ((error = sc->codec_if->vtbl->set_rate(sc->codec_if,
549 AC97_REG_PCM_FRONT_DAC_RATE, &p->sample_rate)) != 0)
550 return error;
551 }
552 }
553
554 ch->ch_params = *p;
555 return 0;
556 }
557
558 static int
559 gcscaudio_set_params(void *arg, int setmode, int usemode,
560 audio_params_t *play, audio_params_t *rec,
561 stream_filter_list_t *pfil, stream_filter_list_t *rfil)
562 {
563 struct gcscaudio_softc *sc;
564 int error;
565
566 sc = (struct gcscaudio_softc *)arg;
567
568 if (setmode & AUMODE_PLAY) {
569 if ((error = gcscaudio_set_params_ch(sc, &sc->sc_play,
570 AUMODE_PLAY, play, pfil)) != 0)
571 return error;
572 }
573 if (setmode & AUMODE_RECORD) {
574 if ((error = gcscaudio_set_params_ch(sc, &sc->sc_rec,
575 AUMODE_RECORD, rec, rfil)) != 0)
576 return error;
577 }
578
579 return 0;
580 }
581
582 static int
583 gcscaudio_round_blocksize(void *arg, int blk, int mode,
584 const audio_params_t *param)
585 {
586 blk &= -4;
587 if (blk > GCSCAUDIO_PRD_SIZE_MAX)
588 blk = GCSCAUDIO_PRD_SIZE_MAX;
589
590 return blk;
591 }
592
593 static int
594 gcscaudio_halt_output(void *arg)
595 {
596 struct gcscaudio_softc *sc;
597
598 sc = (struct gcscaudio_softc *)arg;
599 bus_space_write_4(sc->sc_iot, sc->sc_ioh, ACC_BM0_CMD,
600 ACC_BMx_CMD_BM_CTL_DISABLE);
601 bus_space_write_4(sc->sc_iot, sc->sc_ioh, ACC_BM4_CMD,
602 ACC_BMx_CMD_BM_CTL_DISABLE);
603 bus_space_write_4(sc->sc_iot, sc->sc_ioh, ACC_BM6_CMD,
604 ACC_BMx_CMD_BM_CTL_DISABLE);
605 bus_space_write_4(sc->sc_iot, sc->sc_ioh, ACC_BM7_CMD,
606 ACC_BMx_CMD_BM_CTL_DISABLE);
607 sc->sc_play.ch_intr = NULL;
608
609 /* channel splitter */
610 sc->sc_mch_splitter = NULL;
611 if (sc->sc_mch_split_buf)
612 gcscaudio_free(sc, sc->sc_mch_split_buf, M_DEVBUF);
613 sc->sc_mch_split_buf = NULL;
614
615 return 0;
616 }
617
618 static int
619 gcscaudio_halt_input(void *arg)
620 {
621 struct gcscaudio_softc *sc;
622
623 sc = (struct gcscaudio_softc *)arg;
624 bus_space_write_4(sc->sc_iot, sc->sc_ioh, ACC_BM1_CMD,
625 ACC_BMx_CMD_BM_CTL_DISABLE);
626 sc->sc_rec.ch_intr = NULL;
627 return 0;
628 }
629
630 static int
631 gcscaudio_getdev(void *addr, struct audio_device *retp)
632 {
633 *retp = gcscaudio_device;
634 return 0;
635 }
636
637 static int
638 gcscaudio_set_port(void *addr, mixer_ctrl_t *cp)
639 {
640 struct gcscaudio_softc *sc;
641
642 sc = addr;
643 return sc->codec_if->vtbl->mixer_set_port(sc->codec_if, cp);
644 }
645
646 static int
647 gcscaudio_get_port(void *addr, mixer_ctrl_t *cp)
648 {
649 struct gcscaudio_softc *sc;
650
651 sc = addr;
652 return sc->codec_if->vtbl->mixer_get_port(sc->codec_if, cp);
653 }
654
655 static int
656 gcscaudio_query_devinfo(void *addr, mixer_devinfo_t *dip)
657 {
658 struct gcscaudio_softc *sc;
659
660 sc = addr;
661 return sc->codec_if->vtbl->query_devinfo(sc->codec_if, dip);
662 }
663
664 static void *
665 gcscaudio_malloc(void *arg, int direction, size_t size,
666 struct malloc_type *pool, int flags)
667 {
668 struct gcscaudio_softc *sc;
669 struct gcscaudio_dma *p;
670 int error;
671
672 sc = (struct gcscaudio_softc *)arg;
673
674 p = malloc(sizeof(*p), pool, flags);
675 if (p == NULL)
676 return NULL;
677 p->size = size;
678
679 error = gcscaudio_allocate_dma(sc, size, &p->addr,
680 p->segs, sizeof(p->segs)/sizeof(p->segs[0]), &p->nseg,
681 BUS_DMA_NOWAIT, &p->map);
682
683 if (error) {
684 free(p, pool);
685 return NULL;
686 }
687
688 LIST_INSERT_HEAD(&sc->sc_dmalist, p, list);
689 return p->addr;
690 }
691
692 static void
693 gcscaudio_free(void *arg, void *ptr, struct malloc_type *pool)
694 {
695 struct gcscaudio_softc *sc;
696 struct gcscaudio_dma *p;
697
698 sc = (struct gcscaudio_softc *)arg;
699
700 LIST_FOREACH(p, &sc->sc_dmalist, list) {
701 if (p->addr == ptr) {
702 bus_dmamap_unload(sc->sc_dmat, p->map);
703 bus_dmamap_destroy(sc->sc_dmat, p->map);
704 bus_dmamem_unmap(sc->sc_dmat, p->addr, p->size);
705 bus_dmamem_free(sc->sc_dmat, p->segs, p->nseg);
706
707 LIST_REMOVE(p, list);
708 free(p, pool);
709 break;
710 }
711 }
712 }
713
714 static paddr_t
715 gcscaudio_mappage(void *arg, void *mem, off_t off, int prot)
716 {
717 struct gcscaudio_softc *sc;
718 struct gcscaudio_dma *p;
719
720 if (off < 0)
721 return -1;
722
723 sc = (struct gcscaudio_softc *)arg;
724 LIST_FOREACH(p, &sc->sc_dmalist, list) {
725 if (p->addr == mem) {
726 return bus_dmamem_mmap(sc->sc_dmat, p->segs, p->nseg,
727 off, prot, BUS_DMA_WAITOK);
728 }
729 }
730
731 return -1;
732 }
733
734 static size_t
735 gcscaudio_round_buffersize(void *addr, int direction, size_t size)
736 {
737 if (size > GCSCAUDIO_BUFSIZE_MAX)
738 size = GCSCAUDIO_BUFSIZE_MAX;
739
740 return size;
741 }
742
743 static int
744 gcscaudio_get_props(void *addr)
745 {
746 struct gcscaudio_softc *sc;
747 int props;
748
749 sc = (struct gcscaudio_softc *)addr;
750 props = AUDIO_PROP_INDEPENDENT | AUDIO_PROP_FULLDUPLEX;
751 /*
752 * Even if the codec is fixed-rate, set_param() succeeds for any sample
753 * rate because of aurateconv. Applications can't know what rate the
754 * device can process in the case of mmap().
755 */
756 if (!AC97_IS_FIXED_RATE(sc->codec_if))
757 props |= AUDIO_PROP_MMAP;
758 return props;
759 }
760
761 static int
762 build_prdtables(struct gcscaudio_softc *sc, int prdidx,
763 void *addr, size_t size, int blksize, int blklen, int blkoff)
764 {
765 struct gcscaudio_dma *p;
766 struct acc_prd *prdp;
767 bus_addr_t paddr;
768 int i;
769
770 /* get physical address of start */
771 paddr = (bus_addr_t)0;
772 LIST_FOREACH(p, &sc->sc_dmalist, list) {
773 if (p->addr == addr) {
774 paddr = p->map->dm_segs[0].ds_addr;
775 break;
776 }
777 }
778 if (!paddr) {
779 aprint_error_dev(&sc->sc_dev,
780 "bad addr %p\n", addr);
781 return EINVAL;
782 }
783
784 #define PRDADDR(prdidx,idx) \
785 (sc->sc_prd.p_prdmap->dm_segs[0].ds_addr) + sizeof(struct acc_prd) * \
786 (((prdidx) * GCSCAUDIO_NPRDTABLE) + (idx))
787
788 /*
789 * build PRD table
790 * prdtbl[] = <PRD0>, <PRD1>, <PRD2>, ..., <PRDn>, <jmp to PRD0>
791 */
792 prdp = sc->sc_prd.p_prdtables->prdtbl[prdidx];
793 for (i = 0; size > 0; size -= blksize, i++) {
794 prdp[i].address = paddr + blksize * i + blkoff;
795 prdp[i].ctrlsize =
796 (size < blklen ? size : blklen) | ACC_BMx_PRD_CTRL_EOP;
797 }
798 prdp[i].address = PRDADDR(prdidx, 0);
799 prdp[i].ctrlsize = ACC_BMx_PRD_CTRL_JMP;
800
801 bus_dmamap_sync(sc->sc_dmat, sc->sc_prd.p_prdmap, 0,
802 sizeof(struct acc_prd) * i, BUS_DMASYNC_PREWRITE);
803
804 return 0;
805 }
806
807 static void
808 split_buffer_4ch(void *dst, void *src, int size, int blksize)
809 {
810 int left, i;
811 uint16_t *s, *d;
812
813 /*
814 * src[blk0]: L,R,SL,SR,L,R,SL,SR,L,R,SL,SR,....
815 * src[blk1]: L,R,SL,SR,L,R,SL,SR,L,R,SL,SR,....
816 * src[blk2]: L,R,SL,SR,L,R,SL,SR,L,R,SL,SR,....
817 * :
818 *
819 * rearrange to
820 *
821 * src[blk0]: L,R,L,R,L,R,L,R,..
822 * src[blk1]: L,R,L,R,L,R,L,R,..
823 * src[blk2]: L,R,L,R,L,R,L,R,..
824 * :
825 * dst[blk0]: SL,SR,SL,SR,SL,SR,SL,SR,..
826 * dst[blk1]: SL,SR,SL,SR,SL,SR,SL,SR,..
827 * dst[blk2]: SL,SR,SL,SR,SL,SR,SL,SR,..
828 * :
829 */
830 for (left = size; left > 0; left -= blksize) {
831 s = (uint16_t *)src;
832 d = (uint16_t *)dst;
833 for (i = 0; i < blksize / sizeof(uint16_t) / 4; i++) {
834 /* L,R,SL,SR -> SL,SR */
835 s++;
836 s++;
837 *d++ = *s++;
838 *d++ = *s++;
839 }
840
841 s = (uint16_t *)src;
842 d = (uint16_t *)src;
843 for (i = 0; i < blksize / sizeof(uint16_t) / 2 / 2; i++) {
844 /* L,R,SL,SR -> L,R */
845 *d++ = *s++;
846 *d++ = *s++;
847 s++;
848 s++;
849 }
850
851 src = (char *)src + blksize;
852 dst = (char *)dst + blksize;
853 }
854 }
855
856 static void
857 split_buffer_6ch(void *dst, void *src, int size, int blksize)
858 {
859 int left, i;
860 uint16_t *s, *d, *dc, *dl;
861
862 /*
863 * by default, treat as WAV style 5.1ch order
864 * 5.1ch(WAV): L R C LFE SL SR
865 * 5.1ch(AAC): C L R SL SR LFE
866 * :
867 */
868
869 /*
870 * src[blk0]: L,R,C,LFE,SL,SR,L,R,C,LFE,SL,SR,...
871 * src[blk1]: L,R,C,LFE,SL,SR,L,R,C,LFE,SL,SR,...
872 * src[blk2]: L,R,C,LFE,SL,SR,L,R,C,LFE,SL,SR,...
873 * :
874 * src[N-1] : L,R,C,LFE,SL,SR,L,R,C,LFE,SL,SR,...
875 *
876 * rearrange to
877 *
878 * src[blk0]: L,R,L,R,..
879 * src[blk1]: L,R,L,R,..
880 * src[blk2]: L,R,L,R,..
881 * :
882 *
883 * dst[blk0]: SL,SR,SL,SR,..
884 * dst[blk1]: SL,SR,SL,SR,..
885 * dst[blk2]: SL,SR,SL,SR,..
886 * :
887 *
888 * dst[N/2+0]: C,C,C,..
889 * dst[N/2+1]: C,C,C,..
890 * :
891 *
892 * dst[N/2+N/4+0]: LFE,LFE,LFE,..
893 * dst[N/2+N/4+1]: LFE,LFE,LFE,..
894 * :
895 */
896
897 for (left = size; left > 0; left -= blksize) {
898 s = (uint16_t *)src;
899 d = (uint16_t *)dst;
900 dc = (uint16_t *)((char *)dst + blksize / 2);
901 dl = (uint16_t *)((char *)dst + blksize / 2 + blksize / 4);
902 for (i = 0; i < blksize / sizeof(uint16_t) / 6; i++) {
903 #ifdef GCSCAUDIO_5_1CH_AAC_ORDER
904 /*
905 * AAC: [C,L,R,SL,SR,LFE]
906 * => [SL,SR]
907 * => [C]
908 * => [LFE]
909 */
910 *dc++ = s[0]; /* C */
911 *dl++ = s[5]; /* LFE */
912 *d++ = s[3]; /* SL */
913 *d++ = s[4]; /* SR */
914 #else
915 /*
916 * WAV: [L,R,C,LFE,SL,SR]
917 * => [SL,SR]
918 * => [C]
919 * => [LFE]
920 */
921 *dc++ = s[2]; /* C */
922 *dl++ = s[3]; /* LFE */
923 *d++ = s[4]; /* SL */
924 *d++ = s[5]; /* SR */
925 #endif
926 s += 6;
927 }
928
929 s = (uint16_t *)src;
930 d = (uint16_t *)src;
931 for (i = 0; i < blksize / sizeof(uint16_t) / 2 / 2; i++) {
932 #ifdef GCSCAUDIO_5_1CH_AAC_ORDER
933 /* AAC: [C,L,R,SL,SR,LFE] => [L,R] */
934 *d++ = s[1];
935 *d++ = s[2];
936 #else
937 /* WAV: [L,R,C,LFE,SL,SR] => [L,R] */
938 *d++ = s[0];
939 *d++ = s[1];
940 #endif
941 s += 6;
942 }
943
944 src = (char *)src + blksize;
945 dst = (char *)dst + blksize;
946 }
947 }
948
949 static void
950 channel_splitter(struct gcscaudio_softc *sc)
951 {
952 int splitsize, left;
953 void *src, *dst;
954
955 if (sc->sc_mch_splitter == NULL)
956 return;
957
958 left = sc->sc_mch_split_size - sc->sc_mch_split_off;
959 splitsize = sc->sc_mch_split_blksize;
960 if (left < splitsize)
961 splitsize = left;
962
963 src = (char *)sc->sc_mch_split_start + sc->sc_mch_split_off;
964 dst = (char *)sc->sc_mch_split_buf + sc->sc_mch_split_off;
965
966 sc->sc_mch_splitter(dst, src, splitsize, sc->sc_mch_split_blksize);
967
968 sc->sc_mch_split_off += sc->sc_mch_split_blksize;
969 if (sc->sc_mch_split_off >= sc->sc_mch_split_size)
970 sc->sc_mch_split_off = 0;
971 }
972
973 static int
974 gcscaudio_trigger_output(void *addr, void *start, void *end, int blksize,
975 void (*intr)(void *), void *arg,
976 const audio_params_t *param)
977 {
978 struct gcscaudio_softc *sc;
979 size_t size;
980
981 sc = (struct gcscaudio_softc *)addr;
982 sc->sc_play.ch_intr = intr;
983 sc->sc_play.ch_intr_arg = arg;
984 size = (char *)end - (char *)start;
985
986 switch (sc->sc_play.ch_params.channels) {
987 case 2:
988 if (build_prdtables(sc, PRD_TABLE_FRONT, start, size, blksize,
989 blksize, 0))
990 return EINVAL;
991
992 if (!AC97_IS_4CH(sc->codec_if)) {
993 /*
994 * output 2ch PCM to FRONT.LR(BM0)
995 *
996 * 2ch: L,R,L,R,L,R,L,R,... => BM0: L,R,L,R,L,R,L,R,...
997 *
998 */
999 bus_space_write_4(sc->sc_iot, sc->sc_ioh, ACC_BM0_PRD,
1000 PRDADDR(PRD_TABLE_FRONT, 0));
1001
1002 /* start DMA transfer */
1003 bus_space_write_1(sc->sc_iot, sc->sc_ioh, ACC_BM0_CMD,
1004 ACC_BMx_CMD_WRITE |
1005 ACC_BMx_CMD_BYTE_ORD_EL |
1006 ACC_BMx_CMD_BM_CTL_ENABLE);
1007 } else {
1008 /*
1009 * output same PCM to FRONT.LR(BM0) and SURROUND.LR(BM6).
1010 * CENTER(BM4) and LFE(BM7) doesn't sound.
1011 *
1012 * 2ch: L,R,L,R,L,R,L,R,... => BM0: L,R,L,R,L,R,L,R,...
1013 * BM6: (same of BM0)
1014 * BM4: none
1015 * BM7: none
1016 */
1017 bus_space_write_4(sc->sc_iot, sc->sc_ioh, ACC_BM0_PRD,
1018 PRDADDR(PRD_TABLE_FRONT, 0));
1019 bus_space_write_4(sc->sc_iot, sc->sc_ioh, ACC_BM6_PRD,
1020 PRDADDR(PRD_TABLE_FRONT, 0));
1021
1022 /* start DMA transfer */
1023 bus_space_write_1(sc->sc_iot, sc->sc_ioh, ACC_BM0_CMD,
1024 ACC_BMx_CMD_WRITE |
1025 ACC_BMx_CMD_BYTE_ORD_EL |
1026 ACC_BMx_CMD_BM_CTL_ENABLE);
1027 bus_space_write_1(sc->sc_iot, sc->sc_ioh, ACC_BM6_CMD,
1028 ACC_BMx_CMD_WRITE |
1029 ACC_BMx_CMD_BYTE_ORD_EL |
1030 ACC_BMx_CMD_BM_CTL_ENABLE);
1031 }
1032 break;
1033 case 4:
1034 /*
1035 * output 4ch PCM split to FRONT.LR(BM0) and SURROUND.LR(BM6).
1036 * CENTER(BM4) and LFE(BM7) doesn't sound.
1037 *
1038 * rearrange ordered channel to continuous per channel
1039 *
1040 * 4ch: L,R,SL,SR,L,R,SL,SR,... => BM0: L,R,L,R,...
1041 * BM6: SL,SR,SL,SR,...
1042 * BM4: none
1043 * BM7: none
1044 */
1045 if (sc->sc_mch_split_buf)
1046 gcscaudio_free(sc, sc->sc_mch_split_buf, M_DEVBUF);
1047
1048 if ((sc->sc_mch_split_buf = gcscaudio_malloc(sc, AUMODE_PLAY,
1049 size, M_DEVBUF, M_WAITOK)) == NULL)
1050 return ENOMEM;
1051
1052 /*
1053 * 1st and 2nd blocks are split immediately.
1054 * Other blocks will be split synchronous with intr.
1055 */
1056 split_buffer_4ch(sc->sc_mch_split_buf, start, blksize * 2,
1057 blksize);
1058
1059 sc->sc_mch_split_start = start;
1060 sc->sc_mch_split_size = size;
1061 sc->sc_mch_split_blksize = blksize;
1062 sc->sc_mch_split_off = (blksize * 2) % size;
1063 sc->sc_mch_splitter = split_buffer_4ch; /* split function */
1064
1065 if (build_prdtables(sc, PRD_TABLE_FRONT, start, size, blksize,
1066 blksize / 2, 0))
1067 return EINVAL;
1068 if (build_prdtables(sc, PRD_TABLE_SURR, sc->sc_mch_split_buf,
1069 size, blksize, blksize / 2, 0))
1070 return EINVAL;
1071
1072 bus_space_write_4(sc->sc_iot, sc->sc_ioh, ACC_BM0_PRD,
1073 PRDADDR(PRD_TABLE_FRONT, 0));
1074 bus_space_write_4(sc->sc_iot, sc->sc_ioh, ACC_BM6_PRD,
1075 PRDADDR(PRD_TABLE_SURR, 0));
1076
1077 /* start DMA transfer */
1078 bus_space_write_1(sc->sc_iot, sc->sc_ioh, ACC_BM0_CMD,
1079 ACC_BMx_CMD_WRITE |
1080 ACC_BMx_CMD_BYTE_ORD_EL |
1081 ACC_BMx_CMD_BM_CTL_ENABLE);
1082 bus_space_write_1(sc->sc_iot, sc->sc_ioh, ACC_BM6_CMD,
1083 ACC_BMx_CMD_WRITE |
1084 ACC_BMx_CMD_BYTE_ORD_EL |
1085 ACC_BMx_CMD_BM_CTL_ENABLE);
1086 break;
1087 case 6:
1088 /*
1089 * output 6ch PCM split to
1090 * FRONT.LR(BM0), SURROUND.LR(BM6), CENTER(BM4) and LFE(BM7)
1091 *
1092 * rearrange ordered channel to continuous per channel
1093 *
1094 * 5.1ch: L,R,C,LFE,SL,SR,... => BM0: L,R,...
1095 * BM4: C,...
1096 * BM6: SL,SR,...
1097 * BM7: LFE,...
1098 *
1099 */
1100 if (sc->sc_mch_split_buf)
1101 gcscaudio_free(sc, sc->sc_mch_split_buf, M_DEVBUF);
1102
1103 if ((sc->sc_mch_split_buf = gcscaudio_malloc(sc, AUMODE_PLAY,
1104 size, M_DEVBUF, M_WAITOK)) == NULL)
1105 return ENOMEM;
1106
1107 /*
1108 * 1st and 2nd blocks are split immediately.
1109 * Other block will be split synchronous with intr.
1110 */
1111 split_buffer_6ch(sc->sc_mch_split_buf, start, blksize * 2,
1112 blksize);
1113
1114 sc->sc_mch_split_start = start;
1115 sc->sc_mch_split_size = size;
1116 sc->sc_mch_split_blksize = blksize;
1117 sc->sc_mch_split_off = (blksize * 2) % size;
1118 sc->sc_mch_splitter = split_buffer_6ch; /* split function */
1119
1120 if (build_prdtables(sc, PRD_TABLE_FRONT, start, size, blksize,
1121 blksize / 3, 0))
1122 return EINVAL;
1123 if (build_prdtables(sc, PRD_TABLE_CENTER, sc->sc_mch_split_buf,
1124 size, blksize, blksize / 3, blksize / 2))
1125 return EINVAL;
1126 if (build_prdtables(sc, PRD_TABLE_SURR, sc->sc_mch_split_buf,
1127 size, blksize, blksize / 3, 0))
1128 return EINVAL;
1129 if (build_prdtables(sc, PRD_TABLE_LFE, sc->sc_mch_split_buf,
1130 size, blksize, blksize / 3, blksize / 2 + blksize / 4))
1131 return EINVAL;
1132
1133 bus_space_write_4(sc->sc_iot, sc->sc_ioh, ACC_BM0_PRD,
1134 PRDADDR(PRD_TABLE_FRONT, 0));
1135 bus_space_write_4(sc->sc_iot, sc->sc_ioh, ACC_BM4_PRD,
1136 PRDADDR(PRD_TABLE_CENTER, 0));
1137 bus_space_write_4(sc->sc_iot, sc->sc_ioh, ACC_BM6_PRD,
1138 PRDADDR(PRD_TABLE_SURR, 0));
1139 bus_space_write_4(sc->sc_iot, sc->sc_ioh, ACC_BM7_PRD,
1140 PRDADDR(PRD_TABLE_LFE, 0));
1141
1142 /* start DMA transfer */
1143 bus_space_write_1(sc->sc_iot, sc->sc_ioh, ACC_BM0_CMD,
1144 ACC_BMx_CMD_WRITE | ACC_BMx_CMD_BYTE_ORD_EL |
1145 ACC_BMx_CMD_BM_CTL_ENABLE);
1146 bus_space_write_1(sc->sc_iot, sc->sc_ioh, ACC_BM4_CMD,
1147 ACC_BMx_CMD_WRITE | ACC_BMx_CMD_BYTE_ORD_EL |
1148 ACC_BMx_CMD_BM_CTL_ENABLE);
1149 bus_space_write_1(sc->sc_iot, sc->sc_ioh, ACC_BM6_CMD,
1150 ACC_BMx_CMD_WRITE | ACC_BMx_CMD_BYTE_ORD_EL |
1151 ACC_BMx_CMD_BM_CTL_ENABLE);
1152 bus_space_write_1(sc->sc_iot, sc->sc_ioh, ACC_BM7_CMD,
1153 ACC_BMx_CMD_WRITE | ACC_BMx_CMD_BYTE_ORD_EL |
1154 ACC_BMx_CMD_BM_CTL_ENABLE);
1155 break;
1156 }
1157
1158 return 0;
1159 }
1160
1161 static int
1162 gcscaudio_trigger_input(void *addr, void *start, void *end, int blksize,
1163 void (*intr)(void *), void *arg,
1164 const audio_params_t *param)
1165 {
1166 struct gcscaudio_softc *sc;
1167 size_t size;
1168
1169 sc = (struct gcscaudio_softc *)addr;
1170 sc->sc_rec.ch_intr = intr;
1171 sc->sc_rec.ch_intr_arg = arg;
1172 size = (char *)end - (char *)start;
1173
1174 if (build_prdtables(sc, PRD_TABLE_REC, start, size, blksize, blksize, 0))
1175 return EINVAL;
1176
1177 bus_space_write_4(sc->sc_iot, sc->sc_ioh, ACC_BM1_PRD,
1178 PRDADDR(PRD_TABLE_REC, 0));
1179
1180 /* start transfer */
1181 bus_space_write_1(sc->sc_iot, sc->sc_ioh, ACC_BM1_CMD,
1182 ACC_BMx_CMD_READ |
1183 ACC_BMx_CMD_BYTE_ORD_EL |
1184 ACC_BMx_CMD_BM_CTL_ENABLE);
1185
1186 return 0;
1187 }
1188
1189 static int
1190 gcscaudio_intr(void *arg)
1191 {
1192 struct gcscaudio_softc *sc;
1193 uint16_t intr;
1194 uint8_t bmstat;
1195 int nintr;
1196
1197 nintr = 0;
1198 sc = (struct gcscaudio_softc *)arg;
1199 intr = bus_space_read_2(sc->sc_iot, sc->sc_ioh, ACC_IRQ_STATUS);
1200 if (intr == 0)
1201 return 0;
1202
1203 /* Front output */
1204 if (intr & ACC_IRQ_STATUS_BM0_IRQ_STS) {
1205 bmstat = bus_space_read_1(sc->sc_iot, sc->sc_ioh, ACC_BM0_STATUS);
1206 if (bmstat & ACC_BMx_STATUS_BM_EOP_ERR)
1207 aprint_normal_dev(&sc->sc_dev, "BM0: Bus Master Error\n");
1208 if (!(bmstat & ACC_BMx_STATUS_EOP))
1209 aprint_normal_dev(&sc->sc_dev, "BM0: NO End of Page?\n");
1210
1211 if (sc->sc_play.ch_intr) {
1212 sc->sc_play.ch_intr(sc->sc_play.ch_intr_arg);
1213 channel_splitter(sc);
1214 }
1215 nintr++;
1216 }
1217
1218 /* Center output */
1219 if (intr & ACC_IRQ_STATUS_BM4_IRQ_STS) {
1220 bmstat = bus_space_read_1(sc->sc_iot, sc->sc_ioh, ACC_BM4_STATUS);
1221 if (bmstat & ACC_BMx_STATUS_BM_EOP_ERR)
1222 aprint_normal_dev(&sc->sc_dev, "BM4: Bus Master Error\n");
1223 if (!(bmstat & ACC_BMx_STATUS_EOP))
1224 aprint_normal_dev(&sc->sc_dev, "BM4: NO End of Page?\n");
1225
1226 nintr++;
1227 }
1228
1229 /* Surround output */
1230 if (intr & ACC_IRQ_STATUS_BM6_IRQ_STS) {
1231 bmstat = bus_space_read_1(sc->sc_iot, sc->sc_ioh, ACC_BM6_STATUS);
1232 if (bmstat & ACC_BMx_STATUS_BM_EOP_ERR)
1233 aprint_normal_dev(&sc->sc_dev, "BM6: Bus Master Error\n");
1234 if (!(bmstat & ACC_BMx_STATUS_EOP))
1235 aprint_normal_dev(&sc->sc_dev, "BM6: NO End of Page?\n");
1236
1237 nintr++;
1238 }
1239
1240 /* LowFrequencyEffect output */
1241 if (intr & ACC_IRQ_STATUS_BM7_IRQ_STS) {
1242 bmstat = bus_space_read_1(sc->sc_iot, sc->sc_ioh, ACC_BM7_STATUS);
1243 if (bmstat & ACC_BMx_STATUS_BM_EOP_ERR)
1244 aprint_normal_dev(&sc->sc_dev, "BM7: Bus Master Error\n");
1245 if (!(bmstat & ACC_BMx_STATUS_EOP))
1246 aprint_normal_dev(&sc->sc_dev, "BM7: NO End of Page?\n");
1247
1248 nintr++;
1249 }
1250
1251 /* record */
1252 if (intr & ACC_IRQ_STATUS_BM1_IRQ_STS) {
1253 bmstat = bus_space_read_1(sc->sc_iot, sc->sc_ioh, ACC_BM1_STATUS);
1254 if (bmstat & ACC_BMx_STATUS_BM_EOP_ERR)
1255 aprint_normal_dev(&sc->sc_dev, "BM1: Bus Master Error\n");
1256 if (!(bmstat & ACC_BMx_STATUS_EOP))
1257 aprint_normal_dev(&sc->sc_dev, "BM1: NO End of Page?\n");
1258
1259 if (sc->sc_rec.ch_intr) {
1260 sc->sc_rec.ch_intr(sc->sc_rec.ch_intr_arg);
1261 }
1262 nintr++;
1263 }
1264
1265 #ifdef GCSCAUDIO_DEBUG
1266 if (intr & ACC_IRQ_STATUS_IRQ_STS)
1267 aprint_normal_dev(&sc->sc_dev, "Codec GPIO IRQ Status\n");
1268 if (intr & ACC_IRQ_STATUS_WU_IRQ_STS)
1269 aprint_normal_dev(&sc->sc_dev, "Codec GPIO Wakeup IRQ Status\n");
1270 if (intr & ACC_IRQ_STATUS_BM2_IRQ_STS)
1271 aprint_normal_dev(&sc->sc_dev, "Audio Bus Master 2 IRQ Status\n");
1272 if (intr & ACC_IRQ_STATUS_BM3_IRQ_STS)
1273 aprint_normal_dev(&sc->sc_dev, "Audio Bus Master 3 IRQ Status\n");
1274 if (intr & ACC_IRQ_STATUS_BM5_IRQ_STS)
1275 aprint_normal_dev(&sc->sc_dev, "Audio Bus Master 5 IRQ Status\n");
1276 #endif
1277
1278 return nintr ? 1 : 0;
1279 }
1280
1281 static bool
1282 gcscaudio_resume(device_t dv, pmf_qual_t qual)
1283 {
1284 struct gcscaudio_softc *sc = device_private(dv);
1285
1286 gcscaudio_reset_codec(sc);
1287 DELAY(1000);
1288 (sc->codec_if->vtbl->restore_ports)(sc->codec_if);
1289
1290 return true;
1291 }
1292
1293 static int
1294 gcscaudio_allocate_dma(struct gcscaudio_softc *sc, size_t size, void **addrp,
1295 bus_dma_segment_t *seglist, int nseg, int *rsegp,
1296 int flags, bus_dmamap_t *mapp)
1297 {
1298 int error;
1299
1300 if ((error = bus_dmamem_alloc(sc->sc_dmat, size, PAGE_SIZE, 0, seglist,
1301 nseg, rsegp, flags)) != 0) {
1302 aprint_error_dev(&sc->sc_dev,
1303 "unable to allocate DMA buffer, error=%d\n", error);
1304 goto fail_alloc;
1305 }
1306
1307 if ((error = bus_dmamem_map(sc->sc_dmat, seglist, nseg, size, addrp,
1308 BUS_DMA_NOWAIT | BUS_DMA_COHERENT)) != 0) {
1309 aprint_error_dev(&sc->sc_dev,
1310 "unable to map DMA buffer, error=%d\n",
1311 error);
1312 goto fail_map;
1313 }
1314
1315 if ((error = bus_dmamap_create(sc->sc_dmat, size, nseg, size, 0,
1316 BUS_DMA_NOWAIT, mapp)) != 0) {
1317 aprint_error_dev(&sc->sc_dev,
1318 "unable to create DMA map, error=%d\n", error);
1319 goto fail_create;
1320 }
1321
1322 if ((error = bus_dmamap_load(sc->sc_dmat, *mapp, *addrp, size, NULL,
1323 BUS_DMA_NOWAIT)) != 0) {
1324 aprint_error_dev(&sc->sc_dev,
1325 "unable to load DMA map, error=%d\n", error);
1326 goto fail_load;
1327 }
1328
1329 return 0;
1330
1331 fail_load:
1332 bus_dmamap_destroy(sc->sc_dmat, *mapp);
1333 fail_create:
1334 bus_dmamem_unmap(sc->sc_dmat, *addrp, size);
1335 fail_map:
1336 bus_dmamem_free(sc->sc_dmat, seglist, nseg);
1337 fail_alloc:
1338 return error;
1339 }
NetBSD on the FriendlyARM MINI2440