?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Merge remote-tracking branch 'origin/master'
[unleashed/lotheac.git] / usr / src / uts / common / io / audio / drv / audiocmi / audiocmi.c
blob8aa989b03c188c7cffc43ac783b29fabcf5426e2
1 /*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License (the "License").
6 * You may not use this file except in compliance with the License.
7 *
8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 * or http://www.opensolaris.org/os/licensing.
10 * See the License for the specific language governing permissions
11 * and limitations under the License.
12 *
13 * When distributing Covered Code, include this CDDL HEADER in each
14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 * If applicable, add the following below this CDDL HEADER, with the
16 * fields enclosed by brackets "[]" replaced with your own identifying
17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 *
19 * CDDL HEADER END
20 */
21 /*
22 * Copyright (c) 2009, 2010, Oracle and/or its affiliates. All rights reserved.
23 */
24 /*
25 * Purpose: Driver for CMEDIA CM8738 PCI audio controller.
26 */
27 /*
28 * This file is part of Open Sound System
29 *
30 * Copyright (C) 4Front Technologies 1996-2008.
31 */
32
33 #include <sys/audio/audio_driver.h>
34 #include <sys/note.h>
35 #include <sys/pci.h>
36 #include <sys/sysmacros.h>
37 #include "audiocmi.h"
38
39 /*
40 * Note: The original 4Front driver had support SPDIF and dual dac
41 * options. Dual dac support is probably not terribly useful. SPDIF
42 * on the other hand might be quite useful, we just don't have a card
43 * that supports it at present. Some variants of the chip are also
44 * capable of jack retasking, but we're electing to punt on supporting
45 * that as well, for now (we don't have any cards that would benefit
46 * from this feature.)
47 *
48 * Note that surround support requires the use of the second DMA
49 * engine, and that the same second DMA engine is the only way one can
50 * capture from SPDIF. Rather than support a lot more complexity in
51 * the driver, we we will probably just punt on ever supporting
52 * capture of SPDIF. (SPDIF playback should be doable, however.)
53 *
54 * Adding back support for the advanced features would be an
55 * interesting project for someone with access to suitable hardware.
56 *
57 * Note that each variant (CMI 8338, 8738-033, -037, -055, and 8768)
58 * seems to have significant differences in some of the registers.
59 * While programming these parts for basic stereo is pretty much the
60 * same on all parts, doing anything more than that can be
61 * sigificantly different for each part.
62 */
63
64 static ddi_device_acc_attr_t acc_attr = {
65 DDI_DEVICE_ATTR_V0,
66 DDI_STRUCTURE_LE_ACC,
67 DDI_STRICTORDER_ACC
68 };
69
70 static ddi_device_acc_attr_t buf_attr = {
71 DDI_DEVICE_ATTR_V0,
72 DDI_NEVERSWAP_ACC,
73 DDI_STRICTORDER_ACC
74 };
75
76 static ddi_dma_attr_t dma_attr = {
77 DMA_ATTR_VERSION, /* dma_attr_version */
78 0x0, /* dma_attr_addr_lo */
79 0xffffffffU, /* dma_attr_addr_hi */
80 0x3ffff, /* dma_attr_count_max */
81 0x8, /* dma_attr_align */
82 0x7f, /* dma_attr_burstsizes */
83 0x1, /* dma_attr_minxfer */
84 0x3ffff, /* dma_attr_maxxfer */
85 0x3ffff, /* dma_attr_seg */
86 0x1, /* dma_attr_sgllen */
87 0x1, /* dma_attr_granular */
88 0 /* dma_attr_flags */
89 };
90
91
92 static int
93 cmpci_open(void *arg, int flag, uint_t *nframesp, caddr_t *bufp)
94 {
95 cmpci_port_t *port = arg;
96 cmpci_dev_t *dev = port->dev;
97
98 _NOTE(ARGUNUSED(flag));
99
100 mutex_enter(&dev->mutex);
101
102 *nframesp = port->nframes;
103 *bufp = port->kaddr;
104
105 port->count = 0;
106 mutex_exit(&dev->mutex);
107
108 return (0);
109 }
110
111 static void
112 cmpci_close(void *arg)
113 {
114 _NOTE(ARGUNUSED(arg));
115 }
116
117 static int
118 cmpci_start(void *arg)
119 {
120 cmpci_port_t *port = arg;
121 cmpci_dev_t *dev = port->dev;
122
123 mutex_enter(&dev->mutex);
124
125 port->offset = 0;
126
127 /* reset channel */
128 SET32(dev, REG_FUNCTRL0, port->fc0_rst_bit);
129 drv_usecwait(10);
130 CLR32(dev, REG_FUNCTRL0, port->fc0_rst_bit);
131 drv_usecwait(10);
132
133 /* Set 48k 16-bit stereo -- these are just with all bits set. */
134 SET32(dev, REG_FUNCTRL1, port->fc1_rate_mask);
135 SET32(dev, REG_CHFORMAT, port->chformat_mask);
136
137 if ((port->num == 1) && (dev->maxch > 2)) {
138 CLR32(dev, REG_LEGACY, LEGACY_NXCHG);
139
140 if (port->nchan > 2) {
141 SET32(dev, REG_MISC, MISC_XCHGDAC);
142 CLR32(dev, REG_MISC, MISC_N4SPK3D);
143 } else {
144 CLR32(dev, REG_MISC, MISC_XCHGDAC);
145 SET32(dev, REG_MISC, MISC_N4SPK3D);
146 }
147
148 switch (port->nchan) {
149 case 2:
150 if (dev->maxch >= 8) {
151 CLR8(dev, REG_MISC2, MISC2_CHB3D8C);
152 }
153 if (dev->maxch >= 6) {
154 CLR32(dev, REG_CHFORMAT, CHFORMAT_CHB3D5C);
155 CLR32(dev, REG_LEGACY, LEGACY_CHB3D6C);
156 }
157 if (dev->maxch >= 4) {
158 CLR32(dev, REG_CHFORMAT, CHFORMAT_CHB3D);
159 }
160 break;
161 case 4:
162 if (dev->maxch >= 8) {
163 CLR8(dev, REG_MISC2, MISC2_CHB3D8C);
164 }
165 if (dev->maxch >= 6) {
166 CLR32(dev, REG_CHFORMAT, CHFORMAT_CHB3D5C);
167 CLR32(dev, REG_LEGACY, LEGACY_CHB3D6C);
168 CLR32(dev, REG_MISC, MISC_ENCENTER);
169 CLR32(dev, REG_LEGACY, LEGACY_EXBASSEN);
170 }
171 SET32(dev, REG_CHFORMAT, CHFORMAT_CHB3D);
172 break;
173 case 6:
174 if (dev->maxch >= 8) {
175 CLR8(dev, REG_MISC2, MISC2_CHB3D8C);
176 }
177 SET32(dev, REG_CHFORMAT, CHFORMAT_CHB3D5C);
178 SET32(dev, REG_LEGACY, LEGACY_CHB3D6C);
179 CLR32(dev, REG_MISC, MISC_ENCENTER);
180 CLR32(dev, REG_LEGACY, LEGACY_EXBASSEN);
181 CLR32(dev, REG_CHFORMAT, CHFORMAT_CHB3D);
182 break;
183
184 case 8:
185 SET8(dev, REG_MISC2, MISC2_CHB3D8C);
186 CLR32(dev, REG_MISC, MISC_ENCENTER);
187 CLR32(dev, REG_LEGACY, LEGACY_EXBASSEN);
188 CLR32(dev, REG_CHFORMAT, CHFORMAT_CHB3D5C);
189 CLR32(dev, REG_LEGACY, LEGACY_CHB3D6C);
190 CLR32(dev, REG_CHFORMAT, CHFORMAT_CHB3D);
191 break;
192 }
193 }
194
195 PUT32(dev, port->reg_paddr, port->paddr);
196 PUT16(dev, port->reg_bufsz, (port->bufsz / 4) - 1);
197 PUT16(dev, port->reg_fragsz, (port->bufsz / 4) - 1);
198
199 /* Analog output */
200 if (port->capture) {
201 /* Analog capture */
202 SET32(dev, REG_FUNCTRL0, port->fc0_rec_bit);
203 } else {
204 CLR32(dev, REG_FUNCTRL0, port->fc0_rec_bit);
205 }
206
207 SET32(dev, REG_FUNCTRL0, port->fc0_en_bit);
208 mutex_exit(&dev->mutex);
209
210 return (0);
211 }
212
213 static void
214 cmpci_stop(void *arg)
215 {
216 cmpci_port_t *port = arg;
217 cmpci_dev_t *dev = port->dev;
218
219 mutex_enter(&dev->mutex);
220 CLR32(dev, REG_FUNCTRL0, port->fc0_en_bit);
221 mutex_exit(&dev->mutex);
222 }
223
224 static uint64_t
225 cmpci_count(void *arg)
226 {
227 cmpci_port_t *port = arg;
228 cmpci_dev_t *dev = port->dev;
229 uint64_t count;
230 uint32_t offset;
231
232 mutex_enter(&dev->mutex);
233
234 /* this gives us the offset in dwords */
235 offset = (port->bufsz / 4) - (GET16(dev, port->reg_bufsz) + 1);
236
237 /* check for wrap - note that the count is given in dwords */
238 if (offset < port->offset) {
239 count = ((port->bufsz / 4) - port->offset) + offset;
240 } else {
241 count = offset - port->offset;
242 }
243 port->count += count;
244 port->offset = offset;
245 count = port->count;
246
247 mutex_exit(&dev->mutex);
248
249 /*
250 * convert dwords to frames - unfortunately this requires a
251 * divide
252 */
253 return (count / (port->nchan / 2));
254 }
255
256 #define MASK(nbits) ((1 << (nbits)) - 1)
257 #define SCALE(val, nbits) \
258 ((uint8_t)((((val) * MASK(nbits)) / 100)) << (8 - (nbits)))
259
260 #define LEFT(dev, ctl) min(((dev->controls[ctl].value) >> 8), 100)
261 #define RIGHT(dev, ctl) min(((dev->controls[ctl].value) & 0xff), 100)
262 #define MONO(dev, ctl) min(dev->controls[ctl].value, 100)
263
264 static void
265 cmpci_setmixer(cmpci_dev_t *dev, uint8_t idx, uint8_t val)
266 {
267 PUT8(dev, REG_IDXADDR, idx);
268 PUT8(dev, REG_IDXDATA, val);
269 }
270
271 static uint8_t
272 cmpci_getmixer(cmpci_dev_t *dev, uint8_t idx)
273 {
274 PUT8(dev, REG_IDXADDR, idx);
275 return (GET8(dev, REG_IDXDATA));
276 }
277
278
279 static void
280 cmpci_configure_mixer(cmpci_dev_t *dev)
281 {
282 uint64_t left, right;
283 uint8_t outmix;
284 uint8_t inmix[2];
285 uint64_t recsrcs;
286 uint64_t monsrcs;
287
288 /* reset all mix values */
289 outmix = inmix[0] = inmix[1] = 0;
290
291 outmix = OUTMIX_MIC |
292 OUTMIX_CD_R | OUTMIX_CD_L | OUTMIX_LINE_R | OUTMIX_LINE_L;
293
294 inmix[0] = INMIX_LINE_L | INMIX_CD_L | INMIX_MIC;
295 inmix[1] = INMIX_LINE_R | INMIX_CD_R | INMIX_MIC;
296
297 recsrcs = dev->controls[CTL_RECSRCS].value;
298 monsrcs = dev->controls[CTL_MONSRCS].value;
299
300 /* program PCM volume */
301 left = MONO(dev, CTL_VOLUME);
302 if (left) {
303 /* left and right are the same */
304 cmpci_setmixer(dev, IDX_VOICE_LEFT, SCALE(left, 5));
305 cmpci_setmixer(dev, IDX_VOICE_RIGHT, SCALE(left, 5));
306 CLR8(dev, REG_MIX2, MIX2_WSMUTE);
307 } else {
308 cmpci_setmixer(dev, IDX_VOICE_LEFT, 0);
309 cmpci_setmixer(dev, IDX_VOICE_RIGHT, 0);
310 SET8(dev, REG_MIX2, MIX2_WSMUTE);
311 }
312
313 left = LEFT(dev, CTL_LINEOUT);
314 right = RIGHT(dev, CTL_LINEOUT);
315
316 /* lineout/master volume - no separate mute */
317 cmpci_setmixer(dev, IDX_MASTER_LEFT, SCALE(left, 5));
318 cmpci_setmixer(dev, IDX_MASTER_RIGHT, SCALE(right, 5));
319
320 /* speaker volume - mute in extension register, but we don't use */
321 left = MONO(dev, CTL_SPEAKER);
322 cmpci_setmixer(dev, IDX_SPEAKER, SCALE(left, 2));
323
324 /* mic gain */
325 left = MONO(dev, CTL_MIC);
326 if (left) {
327 cmpci_setmixer(dev, IDX_MIC, SCALE(left, 5));
328 /* set record mic gain */
329 uint8_t v = GET8(dev, REG_MIX3);
330 v &= ~(0x7 << 1);
331 v |= ((left * 7) / 100) << 1;
332 PUT8(dev, REG_MIX3, v);
333 cmpci_setmixer(dev, 0x3f, SCALE(100, 2));
334 cmpci_setmixer(dev, 0x40, SCALE(100, 2));
335 } else {
336 cmpci_setmixer(dev, IDX_MIC, 0);
337 outmix &= ~OUTMIX_MIC;
338 inmix[0] &= ~INMIX_MIC;
339 inmix[1] &= ~INMIX_MIC;
340 }
341
342 /* line in */
343 left = LEFT(dev, CTL_LINEOUT);
344 right = RIGHT(dev, CTL_LINEOUT);
345 if (left) {
346 cmpci_setmixer(dev, IDX_LINEIN_LEFT, SCALE(left, 5));
347 } else {
348 cmpci_setmixer(dev, IDX_LINEIN_LEFT, 0);
349 inmix[0] &= ~INMIX_LINE_L;
350 outmix &= ~OUTMIX_LINE_L;
351 }
352 if (right) {
353 cmpci_setmixer(dev, IDX_LINEIN_RIGHT, SCALE(left, 5));
354 } else {
355 cmpci_setmixer(dev, IDX_LINEIN_RIGHT, 0);
356 inmix[1] &= ~INMIX_LINE_R;
357 outmix &= ~OUTMIX_LINE_R;
358 }
359
360 /* cd */
361 left = LEFT(dev, CTL_CD);
362 right = RIGHT(dev, CTL_CD);
363 if (left) {
364 cmpci_setmixer(dev, IDX_CDDA_LEFT, SCALE(left, 5));
365 } else {
366 cmpci_setmixer(dev, IDX_CDDA_LEFT, 0);
367 inmix[0] &= ~INMIX_CD_L;
368 outmix &= ~OUTMIX_CD_L;
369 }
370 if (right) {
371 cmpci_setmixer(dev, IDX_CDDA_RIGHT, SCALE(left, 5));
372 } else {
373 cmpci_setmixer(dev, IDX_CDDA_RIGHT, 0);
374 inmix[1] &= ~INMIX_CD_R;
375 outmix &= ~OUTMIX_CD_R;
376 }
377
378 /* aux - trickier because it doesn't use regular sbpro mixer */
379 left = LEFT(dev, CTL_AUX);
380 right = RIGHT(dev, CTL_AUX);
381 PUT8(dev, REG_VAUX, (((left * 15) / 100) << 4) | ((right * 15) / 100));
382 /* maybe enable recording */
383 if ((left || right) && (recsrcs & (1 << SRC_LINE))) {
384 SET8(dev, REG_MIX3, MIX3_RAUXREN | MIX3_RAUXLEN);
385 } else {
386 CLR8(dev, REG_MIX3, MIX3_RAUXREN | MIX3_RAUXLEN);
387 }
388 /* maybe enable monitoring */
389 if ((left || right) && (monsrcs & (1 << SRC_AUX))) {
390 CLR8(dev, REG_MIX3, MIX3_VAUXRM | MIX3_VAUXLM);
391 } else {
392 SET8(dev, REG_MIX3, MIX3_VAUXRM | MIX3_VAUXLM);
393 }
394
395 /* now do the recsrcs */
396 if ((recsrcs & (1 << SRC_MIC)) == 0) {
397 inmix[0] &= ~INMIX_MIC;
398 inmix[1] &= ~INMIX_MIC;
399 }
400 if ((recsrcs & (1 << SRC_LINE)) == 0) {
401 inmix[0] &= ~INMIX_LINE_L;
402 inmix[1] &= ~INMIX_LINE_R;
403 }
404 if ((recsrcs & (1 << SRC_CD)) == 0) {
405 inmix[0] &= ~INMIX_CD_L;
406 inmix[1] &= ~INMIX_CD_R;
407 }
408 if (recsrcs & (1 << SRC_MIX)) {
409 SET8(dev, REG_MIX2, MIX2_WAVEIN_L | MIX2_WAVEIN_R);
410 } else {
411 CLR8(dev, REG_MIX2, MIX2_WAVEIN_L | MIX2_WAVEIN_R);
412 }
413 cmpci_setmixer(dev, IDX_INMIX_L, inmix[0]);
414 cmpci_setmixer(dev, IDX_INMIX_R, inmix[1]);
415
416 /* now the monsrcs */
417 if ((monsrcs & (1 << SRC_MIC)) == 0) {
418 outmix &= ~OUTMIX_MIC;
419 }
420 if ((monsrcs & (1 << SRC_LINE)) == 0) {
421 outmix &= ~(OUTMIX_LINE_L | OUTMIX_LINE_R);
422 }
423 if ((monsrcs & (1 << SRC_CD)) == 0) {
424 outmix &= ~(OUTMIX_CD_L | OUTMIX_CD_R);
425 }
426 cmpci_setmixer(dev, IDX_OUTMIX, outmix);
427
428 /* micboost */
429 if (dev->controls[CTL_MICBOOST].value != 0) {
430 CLR8(dev, REG_MIX3, MIX3_MICGAINZ);
431 cmpci_setmixer(dev, IDX_EXTENSION,
432 cmpci_getmixer(dev, IDX_EXTENSION) & ~0x1);
433 } else {
434 SET8(dev, REG_MIX3, MIX3_MICGAINZ);
435 cmpci_setmixer(dev, IDX_EXTENSION,
436 cmpci_getmixer(dev, IDX_EXTENSION) | 0x1);
437 }
438 }
439
440 static int
441 cmpci_set_ctrl(void *arg, uint64_t val)
442 {
443 cmpci_ctrl_t *cc = arg;
444 cmpci_dev_t *dev = cc->dev;
445
446 /*
447 * We don't bother to check for valid values - a bogus value
448 * will give incorrect volumes, but is otherwise harmless.
449 */
450 mutex_enter(&dev->mutex);
451 cc->value = val;
452 cmpci_configure_mixer(dev);
453 mutex_exit(&dev->mutex);
454
455 return (0);
456 }
457
458 static int
459 cmpci_get_ctrl(void *arg, uint64_t *val)
460 {
461 cmpci_ctrl_t *cc = arg;
462 cmpci_dev_t *dev = cc->dev;
463
464 mutex_enter(&dev->mutex);
465 *val = cc->value;
466 mutex_exit(&dev->mutex);
467 return (0);
468 }
469
470 #define PLAYCTL (AUDIO_CTRL_FLAG_RW | AUDIO_CTRL_FLAG_PLAY)
471 #define RECCTL (AUDIO_CTRL_FLAG_RW | AUDIO_CTRL_FLAG_REC)
472 #define MONCTL (AUDIO_CTRL_FLAG_RW | AUDIO_CTRL_FLAG_MONITOR)
473 #define PCMVOL (PLAYCTL | AUDIO_CTRL_FLAG_PCMVOL)
474 #define MAINVOL (PLAYCTL | AUDIO_CTRL_FLAG_MAINVOL)
475 #define RECVOL (RECCTL | AUDIO_CTRL_FLAG_RECVOL)
476
477 static void
478 cmpci_alloc_ctrl(cmpci_dev_t *dev, uint32_t num, uint64_t val)
479 {
480 audio_ctrl_desc_t desc;
481 cmpci_ctrl_t *cc;
482
483 cc = &dev->controls[num];
484 bzero(&desc, sizeof (desc));
485 cc->dev = dev;
486
487 switch (num) {
488 case CTL_VOLUME:
489 desc.acd_name = AUDIO_CTRL_ID_VOLUME;
490 desc.acd_type = AUDIO_CTRL_TYPE_MONO;
491 desc.acd_minvalue = 0;
492 desc.acd_maxvalue = 100;
493 desc.acd_flags = PCMVOL;
494 break;
495
496 case CTL_LINEOUT:
497 desc.acd_name = AUDIO_CTRL_ID_LINEOUT;
498 desc.acd_type = AUDIO_CTRL_TYPE_STEREO;
499 desc.acd_minvalue = 0;
500 desc.acd_maxvalue = 100;
501 desc.acd_flags = MAINVOL;
502 break;
503
504 case CTL_SPEAKER:
505 desc.acd_name = AUDIO_CTRL_ID_SPEAKER;
506 desc.acd_type = AUDIO_CTRL_TYPE_MONO;
507 desc.acd_minvalue = 0;
508 desc.acd_maxvalue = 100;
509 desc.acd_flags = MAINVOL;
510 break;
511
512 case CTL_MIC:
513 desc.acd_name = AUDIO_CTRL_ID_MIC;
514 desc.acd_type = AUDIO_CTRL_TYPE_MONO;
515 desc.acd_minvalue = 0;
516 desc.acd_maxvalue = 100;
517 desc.acd_flags = RECVOL;
518 break;
519
520 case CTL_LINEIN:
521 desc.acd_name = AUDIO_CTRL_ID_LINEIN;
522 desc.acd_type = AUDIO_CTRL_TYPE_STEREO;
523 desc.acd_minvalue = 0;
524 desc.acd_maxvalue = 100;
525 desc.acd_flags = RECVOL;
526 break;
527
528 case CTL_CD:
529 desc.acd_name = AUDIO_CTRL_ID_CD;
530 desc.acd_type = AUDIO_CTRL_TYPE_STEREO;
531 desc.acd_minvalue = 0;
532 desc.acd_maxvalue = 100;
533 desc.acd_flags = RECVOL;
534 break;
535
536 case CTL_AUX:
537 desc.acd_name = AUDIO_CTRL_ID_AUX1IN;
538 desc.acd_type = AUDIO_CTRL_TYPE_STEREO;
539 desc.acd_minvalue = 0;
540 desc.acd_maxvalue = 100;
541 desc.acd_flags = RECVOL;
542 break;
543
544 case CTL_RECSRCS:
545 desc.acd_name = AUDIO_CTRL_ID_RECSRC;
546 desc.acd_type = AUDIO_CTRL_TYPE_ENUM;
547 desc.acd_enum[SRC_MIC] = AUDIO_PORT_MIC;
548 desc.acd_enum[SRC_LINE] = AUDIO_PORT_LINEIN;
549 desc.acd_enum[SRC_CD] = AUDIO_PORT_CD;
550 desc.acd_enum[SRC_AUX] = AUDIO_PORT_AUX1IN;
551 desc.acd_enum[SRC_MIX] = AUDIO_PORT_STEREOMIX;
552 desc.acd_minvalue = (1 << (SRC_MIX + 1)) - 1;
553 desc.acd_maxvalue = desc.acd_minvalue;
554 desc.acd_flags = RECCTL | AUDIO_CTRL_FLAG_MULTI;
555 break;
556
557 case CTL_MONSRCS:
558 desc.acd_name = AUDIO_CTRL_ID_MONSRC;
559 desc.acd_type = AUDIO_CTRL_TYPE_ENUM;
560 desc.acd_enum[SRC_MIC] = AUDIO_PORT_MIC;
561 desc.acd_enum[SRC_LINE] = AUDIO_PORT_LINEIN;
562 desc.acd_enum[SRC_CD] = AUDIO_PORT_CD;
563 desc.acd_enum[SRC_AUX] = AUDIO_PORT_AUX1IN;
564 desc.acd_minvalue = ((1 << (SRC_AUX + 1)) - 1);
565 desc.acd_maxvalue = desc.acd_minvalue;
566 desc.acd_flags = MONCTL | AUDIO_CTRL_FLAG_MULTI;
567 break;
568
569 case CTL_MICBOOST:
570 desc.acd_name = AUDIO_CTRL_ID_MICBOOST;
571 desc.acd_type = AUDIO_CTRL_TYPE_BOOLEAN;
572 desc.acd_minvalue = 0;
573 desc.acd_maxvalue = 1;
574 desc.acd_flags = RECCTL;
575 break;
576 }
577
578 cc->value = val;
579 cc->ctrl = audio_dev_add_control(dev->adev, &desc,
580 cmpci_get_ctrl, cmpci_set_ctrl, cc);
581 }
582
583 static void
584 cmpci_add_controls(cmpci_dev_t *dev)
585 {
586 if (dev->softvol) {
587 audio_dev_add_soft_volume(dev->adev);
588 } else {
589 cmpci_alloc_ctrl(dev, CTL_VOLUME, 75);
590 }
591 cmpci_alloc_ctrl(dev, CTL_LINEOUT, 90 | (90 << 8));
592 cmpci_alloc_ctrl(dev, CTL_SPEAKER, 75);
593 cmpci_alloc_ctrl(dev, CTL_MIC, 32);
594 cmpci_alloc_ctrl(dev, CTL_LINEIN, 64 | (64 << 8));
595 cmpci_alloc_ctrl(dev, CTL_CD, 75 | (75 << 8));
596 cmpci_alloc_ctrl(dev, CTL_AUX, 75 | (75 << 8));
597 cmpci_alloc_ctrl(dev, CTL_RECSRCS, (1 << SRC_MIC));
598 cmpci_alloc_ctrl(dev, CTL_MONSRCS, 0);
599 cmpci_alloc_ctrl(dev, CTL_MICBOOST, 0);
600 }
601
602 static void
603 cmpci_del_controls(cmpci_dev_t *dev)
604 {
605 for (int i = 0; i < CTL_NUM; i++) {
606 if (dev->controls[i].ctrl) {
607 audio_dev_del_control(dev->controls[i].ctrl);
608 dev->controls[i].ctrl = NULL;
609 }
610 }
611 }
612
613 static void
614 cmpci_reset(cmpci_dev_t *dev)
615 {
616 /* Full reset */
617 SET32(dev, REG_MISC, MISC_RESET);
618 (void) GET32(dev, REG_MISC);
619 drv_usecwait(100);
620 CLR32(dev, REG_MISC, MISC_RESET);
621
622 /* reset all channels */
623 PUT32(dev, REG_FUNCTRL0, 0);
624
625 /* disable interrupts and such */
626 CLR32(dev, REG_FUNCTRL0, FUNCTRL0_CH0_EN | FUNCTRL0_CH1_EN);
627 CLR32(dev, REG_INTCTRL, INTCTRL_CH0_EN | INTCTRL_CH1_EN);
628
629 /* disable uart, joystick in Function Control Reg1 */
630 CLR32(dev, REG_FUNCTRL1, FUNCTRL1_UART_EN | FUNCTRL1_JYSTK_EN);
631
632 /*
633 * Set DAC and ADC rates to 48 kHz - note that both rates have
634 * all bits set in them, so we can do this with a simple "set".
635 */
636 SET32(dev, REG_FUNCTRL1,
637 FUNCTRL1_DAC_RATE_48K | FUNCTRL1_ADC_RATE_48K);
638
639 /* Set 16-bit stereo -- also these are just with all bits set. */
640 SET32(dev, REG_CHFORMAT, CHFORMAT_CH0_16ST | CHFORMAT_CH1_16ST);
641 }
642
643 static int
644 cmpci_format(void *unused)
645 {
646 _NOTE(ARGUNUSED(unused));
647 return (AUDIO_FORMAT_S16_LE);
648 }
649
650 static int
651 cmpci_channels(void *arg)
652 {
653 cmpci_port_t *port = arg;
654
655 return (port->nchan);
656 }
657
658 static void
659 cmpci_chinfo(void *arg, int chan, unsigned *offset, unsigned *incr)
660 {
661 cmpci_port_t *port = arg;
662 static const int map8ch[] = { 0, 1, 4, 5, 2, 3, 6, 7 };
663 static const int map4ch[] = { 0, 1, 2, 3 };
664
665 if (port->nchan <= 4) {
666 *offset = map4ch[chan];
667 } else {
668 *offset = map8ch[chan];
669 }
670 *incr = port->nchan;
671 }
672
673 static int
674 cmpci_rate(void *unused)
675 {
676 _NOTE(ARGUNUSED(unused));
677 return (48000);
678 }
679
680 static void
681 cmpci_sync(void *arg, unsigned nframes)
682 {
683 cmpci_port_t *port = arg;
684
685 _NOTE(ARGUNUSED(nframes));
686
687 (void) ddi_dma_sync(port->dmah, 0, 0, port->sync_dir);
688 }
689
690 audio_engine_ops_t cmpci_engine_ops = {
691 AUDIO_ENGINE_VERSION, /* version number */
692 cmpci_open,
693 cmpci_close,
694 cmpci_start,
695 cmpci_stop,
696 cmpci_count,
697 cmpci_format,
698 cmpci_channels,
699 cmpci_rate,
700 cmpci_sync,
701 NULL, /* qlen */
702 cmpci_chinfo,
703 NULL, /* playahead */
704 };
705
706 static int
707 cmpci_init(cmpci_dev_t *dev)
708 {
709 audio_dev_t *adev = dev->adev;
710 int playch;
711
712 playch = ddi_prop_get_int(DDI_DEV_T_ANY, dev->dip,
713 DDI_PROP_DONTPASS, "channels", dev->maxch);
714
715 if ((playch % 2) || (playch < 2) || (playch > dev->maxch)) {
716 audio_dev_warn(adev,
717 "Invalid channels property (%d), resetting to %d",
718 playch, dev->maxch);
719 playch = dev->maxch;
720 }
721
722 for (int i = 0; i < PORT_MAX; i++) {
723
724 cmpci_port_t *port;
725 unsigned dmaflags;
726 unsigned caps;
727 size_t rlen;
728 ddi_dma_cookie_t c;
729 unsigned ccnt;
730
731 port = &dev->port[i];
732 port->dev = dev;
733 port->num = i;
734
735 /*
736 * Channel 0 is recording channel, unless we are in
737 * dual DAC mode. The reason for this is simple --
738 * only channel "B" (which I presume to mean channel
739 * 1) supports multichannel configuration.
740 *
741 * However, if we're going to use SPDIF recording,
742 * then recording *must* occur on channel 1. Yes, the
743 * hardware is "strange".
744 */
745
746 switch (i) {
747 case 0:
748 caps = ENGINE_INPUT_CAP;
749 dmaflags = DDI_DMA_READ | DDI_DMA_CONSISTENT;
750 port->reg_paddr = REG_CH0_PADDR;
751 port->reg_bufsz = REG_CH0_BUFSZ;
752 port->reg_fragsz = REG_CH0_FRAGSZ;
753 port->fc0_rst_bit = FUNCTRL0_CH0_RST;
754 port->fc0_rec_bit = FUNCTRL0_CH0_REC;
755 port->fc0_en_bit = FUNCTRL0_CH0_EN;
756 port->sync_dir = DDI_DMA_SYNC_FORKERNEL;
757 port->capture = B_TRUE;
758 port->fc1_rate_mask = FUNCTRL1_ADC_RATE_48K;
759 port->chformat_mask = CHFORMAT_CH0_16ST;
760 port->nchan = 2;
761 break;
762
763 case 1:
764 caps = ENGINE_OUTPUT_CAP;
765 dmaflags = DDI_DMA_WRITE | DDI_DMA_CONSISTENT;
766 port->reg_paddr = REG_CH1_PADDR;
767 port->reg_bufsz = REG_CH1_BUFSZ;
768 port->reg_fragsz = REG_CH1_FRAGSZ;
769 port->fc0_rst_bit = FUNCTRL0_CH1_RST;
770 port->fc0_rec_bit = FUNCTRL0_CH1_REC;
771 port->fc0_en_bit = FUNCTRL0_CH1_EN;
772 port->sync_dir = DDI_DMA_SYNC_FORDEV;
773 port->capture = B_FALSE;
774 port->fc1_rate_mask = FUNCTRL1_DAC_RATE_48K;
775 port->chformat_mask = CHFORMAT_CH1_16ST;
776 port->nchan = playch;
777 break;
778 }
779
780 /*
781 * For efficiency, we'd like to have the fragments
782 * evenly divisble by 64 bytes. Since frames are
783 * already evenly divisble by 4 (16-bit stereo), this
784 * is adequate. For a typical configuration (175 Hz
785 * requested) this will translate to 166 Hz.
786 */
787 port->nframes = 2048;
788 port->bufsz = port->nframes * port->nchan * 2;
789
790 if (ddi_dma_alloc_handle(dev->dip, &dma_attr, DDI_DMA_DONTWAIT,
791 NULL, &port->dmah) != DDI_SUCCESS) {
792 audio_dev_warn(adev, "ch%d: dma hdl alloc failed", i);
793 return (DDI_FAILURE);
794 }
795 if (ddi_dma_mem_alloc(port->dmah, port->bufsz, &buf_attr,
796 DDI_DMA_CONSISTENT, DDI_DMA_DONTWAIT, NULL, &port->kaddr,
797 &rlen, &port->acch) != DDI_SUCCESS) {
798 audio_dev_warn(adev, "ch%d: dma mem allcoc failed", i);
799 return (DDI_FAILURE);
800 }
801 bzero(port->kaddr, rlen);
802
803 if (ddi_dma_addr_bind_handle(port->dmah, NULL, port->kaddr,
804 rlen, dmaflags, DDI_DMA_DONTWAIT, NULL, &c, &ccnt) !=
805 DDI_DMA_MAPPED) {
806 audio_dev_warn(adev, "ch%d: dma bind failed", i);
807 return (DDI_FAILURE);
808 }
809 port->paddr = c.dmac_address;
810
811 port->engine = audio_engine_alloc(&cmpci_engine_ops, caps);
812 if (port->engine == NULL) {
813 audio_dev_warn(adev, "ch%d: alloc engine failed", i);
814 return (DDI_FAILURE);
815 }
816 audio_engine_set_private(port->engine, port);
817 audio_dev_add_engine(adev, port->engine);
818 }
819
820 cmpci_add_controls(dev);
821
822 cmpci_reset(dev);
823 cmpci_configure_mixer(dev);
824
825 if (audio_dev_register(adev) != DDI_SUCCESS) {
826 audio_dev_warn(adev, "audio_dev_register failed");
827 return (DDI_FAILURE);
828 }
829
830 return (DDI_SUCCESS);
831 }
832
833 void
834 cmpci_destroy(cmpci_dev_t *dev)
835 {
836 mutex_destroy(&dev->mutex);
837
838 /* free up ports, including DMA resources for ports */
839 for (int i = 0; i < PORT_MAX; i++) {
840 cmpci_port_t *port = &dev->port[i];
841
842 if (port->paddr != 0)
843 (void) ddi_dma_unbind_handle(port->dmah);
844 if (port->acch != NULL)
845 ddi_dma_mem_free(&port->acch);
846 if (port->dmah != NULL)
847 ddi_dma_free_handle(&port->dmah);
848
849 if (port->engine != NULL) {
850 audio_dev_remove_engine(dev->adev, port->engine);
851 audio_engine_free(port->engine);
852 }
853 }
854
855 if (dev->acch != NULL) {
856 ddi_regs_map_free(&dev->acch);
857 }
858
859 cmpci_del_controls(dev);
860
861 if (dev->adev != NULL) {
862 audio_dev_free(dev->adev);
863 }
864
865 kmem_free(dev, sizeof (*dev));
866 }
867
868 int
869 cmpci_attach(dev_info_t *dip)
870 {
871 uint16_t vendor, device;
872 cmpci_dev_t *dev;
873 ddi_acc_handle_t pcih;
874 audio_dev_t *adev;
875 uint32_t val;
876
877 if (pci_config_setup(dip, &pcih) != DDI_SUCCESS) {
878 audio_dev_warn(NULL, "pci_config_setup failed");
879 return (DDI_FAILURE);
880 }
881
882 vendor = pci_config_get16(pcih, PCI_CONF_VENID);
883 device = pci_config_get16(pcih, PCI_CONF_DEVID);
884
885 if (vendor != CMEDIA_VENDOR_ID ||
886 ((device != CMEDIA_CM8738) && (device != CMEDIA_CM8338A) &&
887 (device != CMEDIA_CM8338B))) {
888 pci_config_teardown(&pcih);
889 audio_dev_warn(NULL, "device not recognized");
890 return (DDI_FAILURE);
891 }
892
893 /* enable IO and Master accesses */
894 pci_config_put16(pcih, PCI_CONF_COMM,
895 pci_config_get16(pcih, PCI_CONF_COMM) |
896 PCI_COMM_MAE | PCI_COMM_IO);
897
898 pci_config_teardown(&pcih);
899
900 dev = kmem_zalloc(sizeof (*dev), KM_SLEEP);
901 dev->dip = dip;
902 mutex_init(&dev->mutex, NULL, MUTEX_DRIVER, NULL);
903
904 ddi_set_driver_private(dip, dev);
905
906 if ((adev = audio_dev_alloc(dip, 0)) == NULL) {
907 goto err_exit;
908 }
909 dev->adev = adev;
910
911 if (ddi_regs_map_setup(dip, 1, &dev->regs, 0, 0, &acc_attr,
912 &dev->acch) != DDI_SUCCESS) {
913 audio_dev_warn(adev, "can't map registers");
914 goto err_exit;
915 }
916
917 /* setup some initial values */
918 dev->maxch = 2;
919 audio_dev_set_description(adev, "C-Media PCI Audio");
920 switch (device) {
921 case CMEDIA_CM8738:
922 /*
923 * Crazy 8738 detection scheme. Reviewing multiple
924 * different open sources gives multiple different
925 * answers here. Its unclear how accurate this is.
926 * The approach taken here is a bit conservative in
927 * assigning multiple channel support, but for users
928 * with newer 8768 cards should offer the best
929 * capability.
930 */
931 val = GET32(dev, REG_INTCTRL) & INTCTRL_MDL_MASK;
932 if (val == 0) {
933
934 if (GET32(dev, REG_CHFORMAT & CHFORMAT_VER_MASK)) {
935 audio_dev_set_version(adev, "CMI-8738-037");
936 dev->maxch = 4;
937 } else {
938 audio_dev_set_version(adev, "CMI-8738-033");
939 }
940 } else if ((val & INTCTRL_MDL_068) == INTCTRL_MDL_068) {
941 audio_dev_set_version(adev, "CMI-8768");
942 dev->maxch = 8;
943 dev->softvol = B_TRUE; /* No hardware PCM volume */
944 } else if ((val & INTCTRL_MDL_055) == INTCTRL_MDL_055) {
945 audio_dev_set_version(adev, "CMI-8738-055");
946 dev->maxch = 6;
947 } else if ((val & INTCTRL_MDL_039) == INTCTRL_MDL_039) {
948 audio_dev_set_version(adev, "CMI-8738-039");
949 dev->maxch = 4;
950 } else {
951 audio_dev_set_version(adev, "CMI-8738");
952 }
953 break;
954
955 case CMEDIA_CM8338A:
956 audio_dev_set_version(dev->adev, "CMI-8338");
957 break;
958
959 case CMEDIA_CM8338B:
960 audio_dev_set_version(dev->adev, "CMI-8338B");
961 break;
962 }
963
964 if (cmpci_init(dev) != DDI_SUCCESS) {
965 audio_dev_warn(dev->adev, "can't init device");
966 goto err_exit;
967 }
968
969 return (DDI_SUCCESS);
970
971 err_exit:
972 cmpci_destroy(dev);
973 return (DDI_FAILURE);
974 }
975
976 static int
977 cmpci_resume(cmpci_dev_t *dev)
978 {
979 mutex_enter(&dev->mutex);
980 cmpci_reset(dev);
981 /* wait one millisecond, to give reset a chance to get up */
982 drv_usecwait(1000);
983 mutex_exit(&dev->mutex);
984
985 audio_dev_resume(dev->adev);
986
987 return (DDI_SUCCESS);
988 }
989
990 static int
991 cmpci_detach(cmpci_dev_t *dev)
992 {
993 if (audio_dev_unregister(dev->adev) != DDI_SUCCESS)
994 return (DDI_FAILURE);
995
996 mutex_enter(&dev->mutex);
997
998 /* disable channels */
999 PUT32(dev, REG_FUNCTRL0, 0);
1000
1001 mutex_exit(&dev->mutex);
1002
1003 cmpci_destroy(dev);
1004
1005 return (DDI_SUCCESS);
1006 }
1007
1008 static int
1009 cmpci_quiesce(dev_info_t *dip)
1010 {
1011 cmpci_dev_t *dev;
1012
1013 if ((dev = ddi_get_driver_private(dip)) == NULL) {
1014 return (DDI_FAILURE);
1015 }
1016
1017 /* disable channels */
1018 PUT32(dev, REG_FUNCTRL0, 0);
1019
1020 return (DDI_SUCCESS);
1021 }
1022
1023 static int
1024 cmpci_ddi_attach(dev_info_t *dip, ddi_attach_cmd_t cmd)
1025 {
1026 cmpci_dev_t *dev;
1027
1028 switch (cmd) {
1029 case DDI_ATTACH:
1030 return (cmpci_attach(dip));
1031
1032 case DDI_RESUME:
1033 if ((dev = ddi_get_driver_private(dip)) == NULL) {
1034 return (DDI_FAILURE);
1035 }
1036 return (cmpci_resume(dev));
1037
1038 default:
1039 return (DDI_FAILURE);
1040 }
1041 }
1042
1043 static int
1044 cmpci_ddi_detach(dev_info_t *dip, ddi_detach_cmd_t cmd)
1045 {
1046 cmpci_dev_t *dev;
1047
1048 if ((dev = ddi_get_driver_private(dip)) == NULL) {
1049 return (DDI_FAILURE);
1050 }
1051
1052 switch (cmd) {
1053 case DDI_DETACH:
1054 return (cmpci_detach(dev));
1055
1056 case DDI_SUSPEND:
1057 audio_dev_suspend(dev->adev);
1058 return (DDI_SUCCESS);
1059
1060 default:
1061 return (DDI_FAILURE);
1062 }
1063 }
1064
1065 static struct dev_ops cmpci_dev_ops = {
1066 DEVO_REV, /* rev */
1067 0, /* refcnt */
1068 NULL, /* getinfo */
1069 nulldev, /* identify */
1070 nulldev, /* probe */
1071 cmpci_ddi_attach, /* attach */
1072 cmpci_ddi_detach, /* detach */
1073 nodev, /* reset */
1074 NULL, /* cb_ops */
1075 NULL, /* bus_ops */
1076 NULL, /* power */
1077 cmpci_quiesce, /* quiesce */
1078 };
1079
1080 static struct modldrv cmpci_modldrv = {
1081 &mod_driverops, /* drv_modops */
1082 "C-Media PCI Audio", /* linkinfo */
1083 &cmpci_dev_ops, /* dev_ops */
1084 };
1085
1086 static struct modlinkage modlinkage = {
1087 MODREV_1,
1088 { &cmpci_modldrv, NULL }
1089 };
1090
1091 int
1092 _init(void)
1093 {
1094 int rv;
1095
1096 audio_init_ops(&cmpci_dev_ops, "audiocmi");
1097 if ((rv = mod_install(&modlinkage)) != 0) {
1098 audio_fini_ops(&cmpci_dev_ops);
1099 }
1100 return (rv);
1101 }
1102
1103 int
1104 _fini(void)
1105 {
1106 int rv;
1107 if ((rv = mod_remove(&modlinkage)) == 0) {
1108 audio_fini_ops(&cmpci_dev_ops);
1109 }
1110 return (rv);
1111 }
1112
1113 int
1114 _info(struct modinfo *modinfop)
1115 {
1116 return (mod_info(&modlinkage, modinfop));
1117 }