Deleted Added
sdiff udiff text old ( 150832 ) new ( 152419 )
full compact
es137x.c (150832) es137x.c (152419)
1/*-
2 * Support the ENSONIQ AudioPCI board and Creative Labs SoundBlaster PCI
3 * boards based on the ES1370, ES1371 and ES1373 chips.
4 *
5 * Copyright (c) 1999 Russell Cattelan <cattelan@thebarn.com>
6 * Copyright (c) 1999 Cameron Grant <cg@freebsd.org>
7 * Copyright (c) 1998 by Joachim Kuebart. All rights reserved.
8 *

--- 45 unchanged lines hidden (view full) ---

54
55#include <dev/pci/pcireg.h>
56#include <dev/pci/pcivar.h>
57
58#include <sys/sysctl.h>
59
60#include "mixer_if.h"
61
1/*-
2 * Support the ENSONIQ AudioPCI board and Creative Labs SoundBlaster PCI
3 * boards based on the ES1370, ES1371 and ES1373 chips.
4 *
5 * Copyright (c) 1999 Russell Cattelan <cattelan@thebarn.com>
6 * Copyright (c) 1999 Cameron Grant <cg@freebsd.org>
7 * Copyright (c) 1998 by Joachim Kuebart. All rights reserved.
8 *

--- 45 unchanged lines hidden (view full) ---

54
55#include <dev/pci/pcireg.h>
56#include <dev/pci/pcivar.h>
57
58#include <sys/sysctl.h>
59
60#include "mixer_if.h"
61
62SND_DECLARE_FILE("$FreeBSD: head/sys/dev/sound/pci/es137x.c 150832 2005-10-02 15:56:36Z netchild $");
62SND_DECLARE_FILE("$FreeBSD: head/sys/dev/sound/pci/es137x.c 152419 2005-11-14 18:17:31Z ariff $");
63
64#define MEM_MAP_REG 0x14
65
66/* PCI IDs of supported chips */
67#define ES1370_PCI_ID 0x50001274
68#define ES1371_PCI_ID 0x13711274
69#define ES1371_PCI_ID2 0x13713274
70#define CT5880_PCI_ID 0x58801274

--- 11 unchanged lines hidden (view full) ---

82#define CT5880REV_CT5880_C 0x02
83#define CT5880REV_CT5880_D 0x03
84#define CT5880REV_CT5880_E 0x04
85
86#define CT4730REV_CT4730_A 0x00
87
88#define ES_DEFAULT_BUFSZ 4096
89
63
64#define MEM_MAP_REG 0x14
65
66/* PCI IDs of supported chips */
67#define ES1370_PCI_ID 0x50001274
68#define ES1371_PCI_ID 0x13711274
69#define ES1371_PCI_ID2 0x13713274
70#define CT5880_PCI_ID 0x58801274

--- 11 unchanged lines hidden (view full) ---

82#define CT5880REV_CT5880_C 0x02
83#define CT5880REV_CT5880_D 0x03
84#define CT5880REV_CT5880_E 0x04
85
86#define CT4730REV_CT4730_A 0x00
87
88#define ES_DEFAULT_BUFSZ 4096
89
90/* 2 DAC for playback, 1 ADC for record */
91#define ES_DAC1 0
92#define ES_DAC2 1
93#define ES_ADC 2
94#define ES_NCHANS 3
95
96#define ES1370_DAC1_MINSPEED 5512
97#define ES1370_DAC1_MAXSPEED 44100
98
90/* device private data */
91struct es_info;
92
93struct es_chinfo {
94 struct es_info *parent;
95 struct pcm_channel *channel;
96 struct snd_dbuf *buffer;
99/* device private data */
100struct es_info;
101
102struct es_chinfo {
103 struct es_info *parent;
104 struct pcm_channel *channel;
105 struct snd_dbuf *buffer;
97 int dir, num;
106 struct pcmchan_caps caps;
107 int dir, num, index;
98 u_int32_t fmt, blksz, bufsz;
99};
100
108 u_int32_t fmt, blksz, bufsz;
109};
110
111/*
112 * 32bit Ensoniq Configuration (es->escfg).
113 * ----------------------------------------
114 *
115 * +-------+--------+------+------+---------+--------+---------+---------+
116 * len | 16 | 1 | 1 | 1 | 2 | 2 | 1 | 8 |
117 * +-------+--------+------+------+---------+--------+---------+---------+
118 * | fixed | single | | | | | is | general |
119 * | rate | pcm | DACx | DACy | numplay | numrec | es1370? | purpose |
120 * | | mixer | | | | | | |
121 * +-------+--------+------+------+---------+--------+---------+---------+
122 */
123#define ES_FIXED_RATE(cfgv) \
124 (((cfgv) & 0xffff0000) >> 16)
125#define ES_SET_FIXED_RATE(cfgv, nv) \
126 (((cfgv) & ~0xffff0000) | (((nv) & 0xffff) << 16))
127#define ES_SINGLE_PCM_MIX(cfgv) \
128 (((cfgv) & 0x8000) >> 15)
129#define ES_SET_SINGLE_PCM_MIX(cfgv, nv) \
130 (((cfgv) & ~0x8000) | (((nv) ? 1 : 0) << 15))
131#define ES_DAC_FIRST(cfgv) \
132 (((cfgv) & 0x4000) >> 14)
133#define ES_SET_DAC_FIRST(cfgv, nv) \
134 (((cfgv) & ~0x4000) | (((nv) & 0x1) << 14))
135#define ES_DAC_SECOND(cfgv) \
136 (((cfgv) & 0x2000) >> 13)
137#define ES_SET_DAC_SECOND(cfgv, nv) \
138 (((cfgv) & ~0x2000) | (((nv) & 0x1) << 13))
139#define ES_NUMPLAY(cfgv) \
140 (((cfgv) & 0x1800) >> 11)
141#define ES_SET_NUMPLAY(cfgv, nv) \
142 (((cfgv) & ~0x1800) | (((nv) & 0x3) << 11))
143#define ES_NUMREC(cfgv) \
144 (((cfgv) & 0x600) >> 9)
145#define ES_SET_NUMREC(cfgv, nv) \
146 (((cfgv) & ~0x600) | (((nv) & 0x3) << 9))
147#define ES_IS_ES1370(cfgv) \
148 (((cfgv) & 0x100) >> 8)
149#define ES_SET_IS_ES1370(cfgv, nv) \
150 (((cfgv) & ~0x100) | (((nv) ? 1 : 0) << 8))
151#define ES_GP(cfgv) \
152 ((cfgv) & 0xff)
153#define ES_SET_GP(cfgv, nv) \
154 (((cfgv) & ~0xff) | ((nv) & 0xff))
155
156#define ES_DAC1_ENABLED(cfgv) \
157 (ES_NUMPLAY(cfgv) > 1 || \
158 (ES_NUMPLAY(cfgv) == 1 && ES_DAC_FIRST(cfgv) == ES_DAC1))
159#define ES_DAC2_ENABLED(cfgv) \
160 (ES_NUMPLAY(cfgv) > 1 || \
161 (ES_NUMPLAY(cfgv) == 1 && ES_DAC_FIRST(cfgv) == ES_DAC2))
162
163/*
164 * DAC 1/2 configuration through kernel hint - hint.pcm.<unit>.dac="val"
165 *
166 * 0 = Enable both DACs - Default
167 * 1 = Enable single DAC (DAC1)
168 * 2 = Enable single DAC (DAC2)
169 * 3 = Enable both DACs, swap position (DAC2 comes first instead of DAC1)
170 */
171#define ES_DEFAULT_DAC_CFG 0
172
101struct es_info {
102 bus_space_tag_t st;
103 bus_space_handle_t sh;
104 bus_dma_tag_t parent_dmat;
105
106 struct resource *reg, *irq;
107 int regtype, regid, irqid;
108 void *ih;
109
110 device_t dev;
111 int num;
112 unsigned int bufsz;
173struct es_info {
174 bus_space_tag_t st;
175 bus_space_handle_t sh;
176 bus_dma_tag_t parent_dmat;
177
178 struct resource *reg, *irq;
179 int regtype, regid, irqid;
180 void *ih;
181
182 device_t dev;
183 int num;
184 unsigned int bufsz;
113 struct pcmchan_caps caps;
114
115 /* Contents of board's registers */
116 uint32_t ctrl;
117 uint32_t sctrl;
185
186 /* Contents of board's registers */
187 uint32_t ctrl;
188 uint32_t sctrl;
118 struct es_chinfo pch, rch;
189 uint32_t escfg;
190 struct es_chinfo ch[ES_NCHANS];
119 struct mtx *lock;
120};
121
122#define ES_LOCK(sc) snd_mtxlock((sc)->lock)
123#define ES_UNLOCK(sc) snd_mtxunlock((sc)->lock)
124#define ES_LOCK_ASSERT(sc) snd_mtxassert((sc)->lock)
125
126/* prototypes */

--- 18 unchanged lines hidden (view full) ---

145static const struct {
146 unsigned volidx:4;
147 unsigned left:4;
148 unsigned right:4;
149 unsigned stereo:1;
150 unsigned recmask:13;
151 unsigned avail:1;
152} mixtable[SOUND_MIXER_NRDEVICES] = {
191 struct mtx *lock;
192};
193
194#define ES_LOCK(sc) snd_mtxlock((sc)->lock)
195#define ES_UNLOCK(sc) snd_mtxunlock((sc)->lock)
196#define ES_LOCK_ASSERT(sc) snd_mtxassert((sc)->lock)
197
198/* prototypes */

--- 18 unchanged lines hidden (view full) ---

217static const struct {
218 unsigned volidx:4;
219 unsigned left:4;
220 unsigned right:4;
221 unsigned stereo:1;
222 unsigned recmask:13;
223 unsigned avail:1;
224} mixtable[SOUND_MIXER_NRDEVICES] = {
153 [SOUND_MIXER_VOLUME] = { 0, 0x0, 0x1, 1, 0x0000, 1 },
225 [SOUND_MIXER_VOLUME] = { 0, 0x0, 0x1, 1, 0x1f7f, 1 },
154 [SOUND_MIXER_PCM] = { 1, 0x2, 0x3, 1, 0x0400, 1 },
155 [SOUND_MIXER_SYNTH] = { 2, 0x4, 0x5, 1, 0x0060, 1 },
156 [SOUND_MIXER_CD] = { 3, 0x6, 0x7, 1, 0x0006, 1 },
157 [SOUND_MIXER_LINE] = { 4, 0x8, 0x9, 1, 0x0018, 1 },
158 [SOUND_MIXER_LINE1] = { 5, 0xa, 0xb, 1, 0x1800, 1 },
159 [SOUND_MIXER_LINE2] = { 6, 0xc, 0x0, 0, 0x0100, 1 },
160 [SOUND_MIXER_LINE3] = { 7, 0xd, 0x0, 0, 0x0200, 1 },
161 [SOUND_MIXER_MIC] = { 8, 0xe, 0x0, 0, 0x0001, 1 },

--- 33 unchanged lines hidden (view full) ---

195}
196
197/* -------------------------------------------------------------------- */
198/* The es1370 mixer interface */
199
200static int
201es1370_mixinit(struct snd_mixer *m)
202{
226 [SOUND_MIXER_PCM] = { 1, 0x2, 0x3, 1, 0x0400, 1 },
227 [SOUND_MIXER_SYNTH] = { 2, 0x4, 0x5, 1, 0x0060, 1 },
228 [SOUND_MIXER_CD] = { 3, 0x6, 0x7, 1, 0x0006, 1 },
229 [SOUND_MIXER_LINE] = { 4, 0x8, 0x9, 1, 0x0018, 1 },
230 [SOUND_MIXER_LINE1] = { 5, 0xa, 0xb, 1, 0x1800, 1 },
231 [SOUND_MIXER_LINE2] = { 6, 0xc, 0x0, 0, 0x0100, 1 },
232 [SOUND_MIXER_LINE3] = { 7, 0xd, 0x0, 0, 0x0200, 1 },
233 [SOUND_MIXER_MIC] = { 8, 0xe, 0x0, 0, 0x0001, 1 },

--- 33 unchanged lines hidden (view full) ---

267}
268
269/* -------------------------------------------------------------------- */
270/* The es1370 mixer interface */
271
272static int
273es1370_mixinit(struct snd_mixer *m)
274{
275 struct es_info *es;
203 int i;
204 u_int32_t v;
205
276 int i;
277 u_int32_t v;
278
279 es = mix_getdevinfo(m);
206 v = 0;
207 for (i = 0; i < SOUND_MIXER_NRDEVICES; i++)
208 if (mixtable[i].avail) v |= (1 << i);
280 v = 0;
281 for (i = 0; i < SOUND_MIXER_NRDEVICES; i++)
282 if (mixtable[i].avail) v |= (1 << i);
283 /*
284 * Each DAC1/2 for ES1370 can be controlled independently
285 * DAC1 = controlled by synth
286 * DAC2 = controlled by pcm
287 * This is indeed can confuse user if DAC1 become primary playback
288 * channel. Try to be smart and combine both if necessary.
289 */
290 if (ES_SINGLE_PCM_MIX(es->escfg))
291 v &= ~(1 << SOUND_MIXER_SYNTH);
209 mix_setdevs(m, v);
210 v = 0;
211 for (i = 0; i < SOUND_MIXER_NRDEVICES; i++)
212 if (mixtable[i].recmask) v |= (1 << i);
292 mix_setdevs(m, v);
293 v = 0;
294 for (i = 0; i < SOUND_MIXER_NRDEVICES; i++)
295 if (mixtable[i].recmask) v |= (1 << i);
296 if (ES_SINGLE_PCM_MIX(es->escfg)) /* ditto */
297 v &= ~(1 << SOUND_MIXER_SYNTH);
213 mix_setrecdevs(m, v);
214 return 0;
215}
216
217static int
218es1370_mixset(struct snd_mixer *m, unsigned dev, unsigned left, unsigned right)
219{
220 struct es_info *es;
298 mix_setrecdevs(m, v);
299 return 0;
300}
301
302static int
303es1370_mixset(struct snd_mixer *m, unsigned dev, unsigned left, unsigned right)
304{
305 struct es_info *es;
221 int l, r, rl, rr;
306 int l, r, rl, rr, set_dac1;
222
223 if (!mixtable[dev].avail) return -1;
224 l = left;
225 r = mixtable[dev].stereo? right : l;
226 if (mixtable[dev].left == 0xf) {
227 rl = (l < 2)? 0x80 : 7 - (l - 2) / 14;
228 } else {
229 rl = (l < 10)? 0x80 : 15 - (l - 10) / 6;
230 }
231 es = mix_getdevinfo(m);
232 ES_LOCK(es);
307
308 if (!mixtable[dev].avail) return -1;
309 l = left;
310 r = mixtable[dev].stereo? right : l;
311 if (mixtable[dev].left == 0xf) {
312 rl = (l < 2)? 0x80 : 7 - (l - 2) / 14;
313 } else {
314 rl = (l < 10)? 0x80 : 15 - (l - 10) / 6;
315 }
316 es = mix_getdevinfo(m);
317 ES_LOCK(es);
318 if (dev == SOUND_MIXER_PCM && (ES_SINGLE_PCM_MIX(es->escfg)) &&
319 ES_DAC1_ENABLED(es->escfg)) {
320 set_dac1 = 1;
321 } else {
322 set_dac1 = 0;
323 }
233 if (mixtable[dev].stereo) {
234 rr = (r < 10)? 0x80 : 15 - (r - 10) / 6;
235 es1370_wrcodec(es, mixtable[dev].right, rr);
324 if (mixtable[dev].stereo) {
325 rr = (r < 10)? 0x80 : 15 - (r - 10) / 6;
326 es1370_wrcodec(es, mixtable[dev].right, rr);
327 if (set_dac1 && mixtable[SOUND_MIXER_SYNTH].stereo)
328 es1370_wrcodec(es, mixtable[SOUND_MIXER_SYNTH].right, rr);
236 }
237 es1370_wrcodec(es, mixtable[dev].left, rl);
329 }
330 es1370_wrcodec(es, mixtable[dev].left, rl);
331 if (set_dac1)
332 es1370_wrcodec(es, mixtable[SOUND_MIXER_SYNTH].left, rl);
238 ES_UNLOCK(es);
239
240 return l | (r << 8);
241}
242
243static int
244es1370_mixsetrecsrc(struct snd_mixer *m, u_int32_t src)
245{
246 struct es_info *es;
247 int i, j = 0;
248
249 es = mix_getdevinfo(m);
250 if (src == 0) src = 1 << SOUND_MIXER_MIC;
251 src &= mix_getrecdevs(m);
252 for (i = 0; i < SOUND_MIXER_NRDEVICES; i++)
253 if ((src & (1 << i)) != 0) j |= mixtable[i].recmask;
254
255 ES_LOCK(es);
333 ES_UNLOCK(es);
334
335 return l | (r << 8);
336}
337
338static int
339es1370_mixsetrecsrc(struct snd_mixer *m, u_int32_t src)
340{
341 struct es_info *es;
342 int i, j = 0;
343
344 es = mix_getdevinfo(m);
345 if (src == 0) src = 1 << SOUND_MIXER_MIC;
346 src &= mix_getrecdevs(m);
347 for (i = 0; i < SOUND_MIXER_NRDEVICES; i++)
348 if ((src & (1 << i)) != 0) j |= mixtable[i].recmask;
349
350 ES_LOCK(es);
351 if ((src & (1 << SOUND_MIXER_PCM)) && ES_SINGLE_PCM_MIX(es->escfg) &&
352 ES_DAC1_ENABLED(es->escfg)) {
353 j |= mixtable[SOUND_MIXER_SYNTH].recmask;
354 }
256 es1370_wrcodec(es, CODEC_LIMIX1, j & 0x55);
257 es1370_wrcodec(es, CODEC_RIMIX1, j & 0xaa);
258 es1370_wrcodec(es, CODEC_LIMIX2, (j >> 8) & 0x17);
259 es1370_wrcodec(es, CODEC_RIMIX2, (j >> 8) & 0x0f);
260 es1370_wrcodec(es, CODEC_OMIX1, 0x7f);
261 es1370_wrcodec(es, CODEC_OMIX2, 0x3f);
262 ES_UNLOCK(es);
263

--- 32 unchanged lines hidden (view full) ---

296
297/* -------------------------------------------------------------------- */
298
299/* channel interface */
300static void *
301eschan_init(kobj_t obj, void *devinfo, struct snd_dbuf *b, struct pcm_channel *c, int dir)
302{
303 struct es_info *es = devinfo;
355 es1370_wrcodec(es, CODEC_LIMIX1, j & 0x55);
356 es1370_wrcodec(es, CODEC_RIMIX1, j & 0xaa);
357 es1370_wrcodec(es, CODEC_LIMIX2, (j >> 8) & 0x17);
358 es1370_wrcodec(es, CODEC_RIMIX2, (j >> 8) & 0x0f);
359 es1370_wrcodec(es, CODEC_OMIX1, 0x7f);
360 es1370_wrcodec(es, CODEC_OMIX2, 0x3f);
361 ES_UNLOCK(es);
362

--- 32 unchanged lines hidden (view full) ---

395
396/* -------------------------------------------------------------------- */
397
398/* channel interface */
399static void *
400eschan_init(kobj_t obj, void *devinfo, struct snd_dbuf *b, struct pcm_channel *c, int dir)
401{
402 struct es_info *es = devinfo;
304 struct es_chinfo *ch = (dir == PCMDIR_PLAY)? &es->pch : &es->rch;
403 struct es_chinfo *ch;
404 uint32_t index;
305
405
406 ES_LOCK(es);
407
408 if (dir == PCMDIR_PLAY) {
409 index = ES_GP(es->escfg);
410 es->escfg = ES_SET_GP(es->escfg, index + 1);
411 if (index == 0) {
412 index = ES_DAC_FIRST(es->escfg);
413 } else if (index == 1) {
414 index = ES_DAC_SECOND(es->escfg);
415 } else {
416 device_printf(es->dev, "Invalid ES_GP index: %d\n", index);
417 ES_UNLOCK(es);
418 return NULL;
419 }
420 if (!(index == ES_DAC1 || index == ES_DAC2)) {
421 device_printf(es->dev, "Unknown DAC: %d\n",
422 index + 1);
423 ES_UNLOCK(es);
424 return NULL;
425 }
426 if (es->ch[index].channel != NULL) {
427 device_printf(es->dev, "DAC%d already initialized!\n",
428 index + 1);
429 ES_UNLOCK(es);
430 return NULL;
431 }
432 } else
433 index = ES_ADC;
434
435 ch = &es->ch[index];
436 ch->index = index;
437 ch->num = es->num++;
438 ch->caps = es_caps;
439 if (ES_IS_ES1370(es->escfg)) {
440 if (ch->index == ES_DAC1) {
441 ch->caps.maxspeed = ES1370_DAC1_MAXSPEED;
442 ch->caps.minspeed = ES1370_DAC1_MINSPEED;
443 } else {
444 uint32_t fixed_rate = ES_FIXED_RATE(es->escfg);
445 if (!(fixed_rate < es_caps.minspeed ||
446 fixed_rate > es_caps.maxspeed)) {
447 ch->caps.maxspeed = fixed_rate;
448 ch->caps.minspeed = fixed_rate;
449 }
450 }
451 }
306 ch->parent = es;
307 ch->channel = c;
308 ch->buffer = b;
309 ch->bufsz = es->bufsz;
310 ch->blksz = ch->bufsz / 2;
452 ch->parent = es;
453 ch->channel = c;
454 ch->buffer = b;
455 ch->bufsz = es->bufsz;
456 ch->blksz = ch->bufsz / 2;
311 ch->num = ch->parent->num++;
312 ch->dir = dir;
457 ch->dir = dir;
458 ES_UNLOCK(es);
313 if (sndbuf_alloc(ch->buffer, es->parent_dmat, ch->bufsz) != 0)
314 return NULL;
315 ES_LOCK(es);
316 if (dir == PCMDIR_PLAY) {
459 if (sndbuf_alloc(ch->buffer, es->parent_dmat, ch->bufsz) != 0)
460 return NULL;
461 ES_LOCK(es);
462 if (dir == PCMDIR_PLAY) {
317 es_wr(es, ES1370_REG_MEMPAGE, ES1370_REG_DAC2_FRAMEADR >> 8, 1);
318 es_wr(es, ES1370_REG_DAC2_FRAMEADR & 0xff, sndbuf_getbufaddr(ch->buffer), 4);
319 es_wr(es, ES1370_REG_DAC2_FRAMECNT & 0xff, (ch->bufsz >> 2) - 1, 4);
463 if (ch->index == ES_DAC1) {
464 es_wr(es, ES1370_REG_MEMPAGE, ES1370_REG_DAC1_FRAMEADR >> 8, 1);
465 es_wr(es, ES1370_REG_DAC1_FRAMEADR & 0xff, sndbuf_getbufaddr(ch->buffer), 4);
466 es_wr(es, ES1370_REG_DAC1_FRAMECNT & 0xff, (ch->bufsz >> 2) - 1, 4);
467 } else {
468 es_wr(es, ES1370_REG_MEMPAGE, ES1370_REG_DAC2_FRAMEADR >> 8, 1);
469 es_wr(es, ES1370_REG_DAC2_FRAMEADR & 0xff, sndbuf_getbufaddr(ch->buffer), 4);
470 es_wr(es, ES1370_REG_DAC2_FRAMECNT & 0xff, (ch->bufsz >> 2) - 1, 4);
471 }
320 } else {
321 es_wr(es, ES1370_REG_MEMPAGE, ES1370_REG_ADC_FRAMEADR >> 8, 1);
322 es_wr(es, ES1370_REG_ADC_FRAMEADR & 0xff, sndbuf_getbufaddr(ch->buffer), 4);
323 es_wr(es, ES1370_REG_ADC_FRAMECNT & 0xff, (ch->bufsz >> 2) - 1, 4);
324 }
325 ES_UNLOCK(es);
326 return ch;
327}
328
329static int
330eschan_setformat(kobj_t obj, void *data, u_int32_t format)
331{
332 struct es_chinfo *ch = data;
333 struct es_info *es = ch->parent;
334
335 ES_LOCK(es);
336 if (ch->dir == PCMDIR_PLAY) {
472 } else {
473 es_wr(es, ES1370_REG_MEMPAGE, ES1370_REG_ADC_FRAMEADR >> 8, 1);
474 es_wr(es, ES1370_REG_ADC_FRAMEADR & 0xff, sndbuf_getbufaddr(ch->buffer), 4);
475 es_wr(es, ES1370_REG_ADC_FRAMECNT & 0xff, (ch->bufsz >> 2) - 1, 4);
476 }
477 ES_UNLOCK(es);
478 return ch;
479}
480
481static int
482eschan_setformat(kobj_t obj, void *data, u_int32_t format)
483{
484 struct es_chinfo *ch = data;
485 struct es_info *es = ch->parent;
486
487 ES_LOCK(es);
488 if (ch->dir == PCMDIR_PLAY) {
337 es->sctrl &= ~SCTRL_P2FMT;
338 if (format & AFMT_S16_LE) es->sctrl |= SCTRL_P2SEB;
339 if (format & AFMT_STEREO) es->sctrl |= SCTRL_P2SMB;
489 if (ch->index == ES_DAC1) {
490 es->sctrl &= ~SCTRL_P1FMT;
491 if (format & AFMT_S16_LE) es->sctrl |= SCTRL_P1SEB;
492 if (format & AFMT_STEREO) es->sctrl |= SCTRL_P1SMB;
493 } else {
494 es->sctrl &= ~SCTRL_P2FMT;
495 if (format & AFMT_S16_LE) es->sctrl |= SCTRL_P2SEB;
496 if (format & AFMT_STEREO) es->sctrl |= SCTRL_P2SMB;
497 }
340 } else {
341 es->sctrl &= ~SCTRL_R1FMT;
342 if (format & AFMT_S16_LE) es->sctrl |= SCTRL_R1SEB;
343 if (format & AFMT_STEREO) es->sctrl |= SCTRL_R1SMB;
344 }
345 es_wr(es, ES1370_REG_SERIAL_CONTROL, es->sctrl, 4);
346 ES_UNLOCK(es);
347 ch->fmt = format;
348 return 0;
349}
350
351static int
352eschan1370_setspeed(kobj_t obj, void *data, u_int32_t speed)
353{
354 struct es_chinfo *ch = data;
355 struct es_info *es = ch->parent;
356
498 } else {
499 es->sctrl &= ~SCTRL_R1FMT;
500 if (format & AFMT_S16_LE) es->sctrl |= SCTRL_R1SEB;
501 if (format & AFMT_STEREO) es->sctrl |= SCTRL_R1SMB;
502 }
503 es_wr(es, ES1370_REG_SERIAL_CONTROL, es->sctrl, 4);
504 ES_UNLOCK(es);
505 ch->fmt = format;
506 return 0;
507}
508
509static int
510eschan1370_setspeed(kobj_t obj, void *data, u_int32_t speed)
511{
512 struct es_chinfo *ch = data;
513 struct es_info *es = ch->parent;
514
357 /* XXX Fixed rate , do nothing. */
515 /* Fixed rate , do nothing. */
516 if (ch->caps.minspeed == ch->caps.maxspeed)
517 return ch->caps.maxspeed;
518 if (speed < ch->caps.minspeed)
519 speed = ch->caps.minspeed;
520 if (speed > ch->caps.maxspeed)
521 speed = ch->caps.maxspeed;
358 ES_LOCK(es);
522 ES_LOCK(es);
359 if (es->caps.minspeed == es->caps.maxspeed) {
360 speed = es->caps.maxspeed;
361 ES_UNLOCK(es);
362 return speed;
523 if (ch->index == ES_DAC1) {
524 /*
525 * DAC1 does not support continuous rate settings.
526 * Pick the nearest and use it since FEEDER_RATE will
527 * do the the proper conversion for us.
528 */
529 es->ctrl &= ~CTRL_WTSRSEL;
530 if (speed < 8268) {
531 speed = 5512;
532 es->ctrl |= 0 << CTRL_SH_WTSRSEL;
533 } else if (speed < 16537) {
534 speed = 11025;
535 es->ctrl |= 1 << CTRL_SH_WTSRSEL;
536 } else if (speed < 33075) {
537 speed = 22050;
538 es->ctrl |= 2 << CTRL_SH_WTSRSEL;
539 } else {
540 speed = 44100;
541 es->ctrl |= 3 << CTRL_SH_WTSRSEL;
542 }
543 } else {
544 es->ctrl &= ~CTRL_PCLKDIV;
545 es->ctrl |= DAC2_SRTODIV(speed) << CTRL_SH_PCLKDIV;
363 }
546 }
364 if (speed < es->caps.minspeed)
365 speed = es->caps.minspeed;
366 if (speed > es->caps.maxspeed)
367 speed = es->caps.maxspeed;
368 es->ctrl &= ~CTRL_PCLKDIV;
369 es->ctrl |= DAC2_SRTODIV(speed) << CTRL_SH_PCLKDIV;
370 es_wr(es, ES1370_REG_CONTROL, es->ctrl, 4);
371 ES_UNLOCK(es);
547 es_wr(es, ES1370_REG_CONTROL, es->ctrl, 4);
548 ES_UNLOCK(es);
372 /* rec/play speeds locked together - should indicate in flags */
373 return speed; /* XXX calc real speed */
549 return speed;
374}
375
376static int
377eschan1371_setspeed(kobj_t obj, void *data, u_int32_t speed)
378{
379 struct es_chinfo *ch = data;
380 struct es_info *es = ch->parent;
550}
551
552static int
553eschan1371_setspeed(kobj_t obj, void *data, u_int32_t speed)
554{
555 struct es_chinfo *ch = data;
556 struct es_info *es = ch->parent;
381 int i, delta;
557 uint32_t i;
558 int delta;
382
383 ES_LOCK(es);
384 if (ch->dir == PCMDIR_PLAY)
559
560 ES_LOCK(es);
561 if (ch->dir == PCMDIR_PLAY)
385 i = es1371_dac_rate(es, speed, 3 - ch->num); /* play */
562 i = es1371_dac_rate(es, speed, ch->index); /* play */
386 else
563 else
387 i = es1371_adc_rate(es, speed, 1); /* record */
564 i = es1371_adc_rate(es, speed, ch->index); /* record */
388 ES_UNLOCK(es);
389 delta = (speed > i) ? speed - i : i - speed;
390 if (delta < 2)
391 return speed;
392 return i;
393}
394
395static int

--- 19 unchanged lines hidden (view full) ---

415 return ch->blksz;
416}
417
418static int
419eschan_trigger(kobj_t obj, void *data, int go)
420{
421 struct es_chinfo *ch = data;
422 struct es_info *es = ch->parent;
565 ES_UNLOCK(es);
566 delta = (speed > i) ? speed - i : i - speed;
567 if (delta < 2)
568 return speed;
569 return i;
570}
571
572static int

--- 19 unchanged lines hidden (view full) ---

592 return ch->blksz;
593}
594
595static int
596eschan_trigger(kobj_t obj, void *data, int go)
597{
598 struct es_chinfo *ch = data;
599 struct es_info *es = ch->parent;
423 unsigned cnt;
600 uint32_t cnt, b = 0;
424
425 if (go == PCMTRIG_EMLDMAWR || go == PCMTRIG_EMLDMARD)
426 return 0;
427
428 cnt = (ch->blksz / sndbuf_getbps(ch->buffer)) - 1;
601
602 if (go == PCMTRIG_EMLDMAWR || go == PCMTRIG_EMLDMARD)
603 return 0;
604
605 cnt = (ch->blksz / sndbuf_getbps(ch->buffer)) - 1;
429
606 if (ch->fmt & AFMT_16BIT)
607 b |= 0x02;
608 if (ch->fmt & AFMT_STEREO)
609 b |= 0x01;
430 ES_LOCK(es);
431 if (ch->dir == PCMDIR_PLAY) {
432 if (go == PCMTRIG_START) {
610 ES_LOCK(es);
611 if (ch->dir == PCMDIR_PLAY) {
612 if (go == PCMTRIG_START) {
433 int b = (ch->fmt & AFMT_S16_LE)? 2 : 1;
434 es->ctrl |= CTRL_DAC2_EN;
435 es->sctrl &= ~(SCTRL_P2ENDINC | SCTRL_P2STINC | SCTRL_P2LOOPSEL | SCTRL_P2PAUSE | SCTRL_P2DACSEN);
436 es->sctrl |= SCTRL_P2INTEN | (b << SCTRL_SH_P2ENDINC);
437 es_wr(es, ES1370_REG_DAC2_SCOUNT, cnt, 4);
438 /* start at beginning of buffer */
439 es_wr(es, ES1370_REG_MEMPAGE, ES1370_REG_DAC2_FRAMECNT >> 8, 4);
440 es_wr(es, ES1370_REG_DAC2_FRAMECNT & 0xff, (ch->bufsz >> 2) - 1, 4);
441 } else es->ctrl &= ~CTRL_DAC2_EN;
613 if (ch->index == ES_DAC1) {
614 es->ctrl |= CTRL_DAC1_EN;
615 es->sctrl &= ~(SCTRL_P1LOOPSEL | SCTRL_P1PAUSE | SCTRL_P1SCTRLD);
616 es->sctrl |= SCTRL_P1INTEN | b;
617 es_wr(es, ES1370_REG_DAC1_SCOUNT, cnt, 4);
618 /* start at beginning of buffer */
619 es_wr(es, ES1370_REG_MEMPAGE, ES1370_REG_DAC1_FRAMECNT >> 8, 4);
620 es_wr(es, ES1370_REG_DAC1_FRAMECNT & 0xff, (ch->bufsz >> 2) - 1, 4);
621 } else {
622 es->ctrl |= CTRL_DAC2_EN;
623 es->sctrl &= ~(SCTRL_P2ENDINC | SCTRL_P2STINC | SCTRL_P2LOOPSEL | SCTRL_P2PAUSE | SCTRL_P2DACSEN);
624 es->sctrl |= SCTRL_P2INTEN | (b << 2) |
625 (((b & 2) ? : 1) << SCTRL_SH_P2ENDINC);
626 es_wr(es, ES1370_REG_DAC2_SCOUNT, cnt, 4);
627 /* start at beginning of buffer */
628 es_wr(es, ES1370_REG_MEMPAGE, ES1370_REG_DAC2_FRAMECNT >> 8, 4);
629 es_wr(es, ES1370_REG_DAC2_FRAMECNT & 0xff, (ch->bufsz >> 2) - 1, 4);
630 }
631 } else es->ctrl &= ~(ch->index == ES_DAC1 ? CTRL_DAC1_EN : CTRL_DAC2_EN);
442 } else {
443 if (go == PCMTRIG_START) {
444 es->ctrl |= CTRL_ADC_EN;
445 es->sctrl &= ~SCTRL_R1LOOPSEL;
632 } else {
633 if (go == PCMTRIG_START) {
634 es->ctrl |= CTRL_ADC_EN;
635 es->sctrl &= ~SCTRL_R1LOOPSEL;
446 es->sctrl |= SCTRL_R1INTEN;
636 es->sctrl |= SCTRL_R1INTEN | (b << 4);
447 es_wr(es, ES1370_REG_ADC_SCOUNT, cnt, 4);
448 /* start at beginning of buffer */
449 es_wr(es, ES1370_REG_MEMPAGE, ES1370_REG_ADC_FRAMECNT >> 8, 4);
450 es_wr(es, ES1370_REG_ADC_FRAMECNT & 0xff, (ch->bufsz >> 2) - 1, 4);
451 } else es->ctrl &= ~CTRL_ADC_EN;
452 }
453 es_wr(es, ES1370_REG_SERIAL_CONTROL, es->sctrl, 4);
454 es_wr(es, ES1370_REG_CONTROL, es->ctrl, 4);
455 ES_UNLOCK(es);
456 return 0;
457}
458
459static int
460eschan_getptr(kobj_t obj, void *data)
461{
462 struct es_chinfo *ch = data;
463 struct es_info *es = ch->parent;
464 u_int32_t reg, cnt;
465
637 es_wr(es, ES1370_REG_ADC_SCOUNT, cnt, 4);
638 /* start at beginning of buffer */
639 es_wr(es, ES1370_REG_MEMPAGE, ES1370_REG_ADC_FRAMECNT >> 8, 4);
640 es_wr(es, ES1370_REG_ADC_FRAMECNT & 0xff, (ch->bufsz >> 2) - 1, 4);
641 } else es->ctrl &= ~CTRL_ADC_EN;
642 }
643 es_wr(es, ES1370_REG_SERIAL_CONTROL, es->sctrl, 4);
644 es_wr(es, ES1370_REG_CONTROL, es->ctrl, 4);
645 ES_UNLOCK(es);
646 return 0;
647}
648
649static int
650eschan_getptr(kobj_t obj, void *data)
651{
652 struct es_chinfo *ch = data;
653 struct es_info *es = ch->parent;
654 u_int32_t reg, cnt;
655
466 if (ch->dir == PCMDIR_PLAY)
467 reg = ES1370_REG_DAC2_FRAMECNT;
468 else
656 if (ch->dir == PCMDIR_PLAY) {
657 if (ch->index == ES_DAC1)
658 reg = ES1370_REG_DAC1_FRAMECNT;
659 else
660 reg = ES1370_REG_DAC2_FRAMECNT;
661 } else
469 reg = ES1370_REG_ADC_FRAMECNT;
470 ES_LOCK(es);
471 es_wr(es, ES1370_REG_MEMPAGE, reg >> 8, 4);
472 cnt = es_rd(es, reg & 0x000000ff, 4) >> 16;
473 ES_UNLOCK(es);
474 /* cnt is longwords */
475 return cnt << 2;
476}
477
478static struct pcmchan_caps *
479eschan_getcaps(kobj_t obj, void *data)
480{
481 struct es_chinfo *ch = data;
662 reg = ES1370_REG_ADC_FRAMECNT;
663 ES_LOCK(es);
664 es_wr(es, ES1370_REG_MEMPAGE, reg >> 8, 4);
665 cnt = es_rd(es, reg & 0x000000ff, 4) >> 16;
666 ES_UNLOCK(es);
667 /* cnt is longwords */
668 return cnt << 2;
669}
670
671static struct pcmchan_caps *
672eschan_getcaps(kobj_t obj, void *data)
673{
674 struct es_chinfo *ch = data;
482 struct es_info *es = ch->parent;
483
675
484 return &es->caps;
676 return &ch->caps;
485}
486
487static kobj_method_t eschan1370_methods[] = {
488 KOBJMETHOD(channel_init, eschan_init),
489 KOBJMETHOD(channel_setformat, eschan_setformat),
490 KOBJMETHOD(channel_setspeed, eschan1370_setspeed),
491 KOBJMETHOD(channel_setblocksize, eschan_setblocksize),
492 KOBJMETHOD(channel_trigger, eschan_trigger),

--- 34 unchanged lines hidden (view full) ---

527 if (intsrc & STAT_ADC) sctrl &= ~SCTRL_R1INTEN;
528 if (intsrc & STAT_DAC1) sctrl &= ~SCTRL_P1INTEN;
529 if (intsrc & STAT_DAC2) sctrl &= ~SCTRL_P2INTEN;
530
531 es_wr(es, ES1370_REG_SERIAL_CONTROL, sctrl, 4);
532 es_wr(es, ES1370_REG_SERIAL_CONTROL, es->sctrl, 4);
533 ES_UNLOCK(es);
534
677}
678
679static kobj_method_t eschan1370_methods[] = {
680 KOBJMETHOD(channel_init, eschan_init),
681 KOBJMETHOD(channel_setformat, eschan_setformat),
682 KOBJMETHOD(channel_setspeed, eschan1370_setspeed),
683 KOBJMETHOD(channel_setblocksize, eschan_setblocksize),
684 KOBJMETHOD(channel_trigger, eschan_trigger),

--- 34 unchanged lines hidden (view full) ---

719 if (intsrc & STAT_ADC) sctrl &= ~SCTRL_R1INTEN;
720 if (intsrc & STAT_DAC1) sctrl &= ~SCTRL_P1INTEN;
721 if (intsrc & STAT_DAC2) sctrl &= ~SCTRL_P2INTEN;
722
723 es_wr(es, ES1370_REG_SERIAL_CONTROL, sctrl, 4);
724 es_wr(es, ES1370_REG_SERIAL_CONTROL, es->sctrl, 4);
725 ES_UNLOCK(es);
726
535 if (intsrc & STAT_ADC) chn_intr(es->rch.channel);
536 if (intsrc & STAT_DAC1)
537 ; /* nothing */
538 if (intsrc & STAT_DAC2) chn_intr(es->pch.channel);
727 if (intsrc & STAT_ADC) chn_intr(es->ch[ES_ADC].channel);
728 if (intsrc & STAT_DAC1) chn_intr(es->ch[ES_DAC1].channel);
729 if (intsrc & STAT_DAC2) chn_intr(es->ch[ES_DAC2].channel);
539}
540
541/* ES1370 specific */
542static int
543es1370_init(struct es_info *es)
544{
730}
731
732/* ES1370 specific */
733static int
734es1370_init(struct es_info *es)
735{
545 int r;
736 uint32_t fixed_rate;
737 int r, single_pcm;
546
738
547 /* XXX ES1370 default to fixed rate operation */
739 /* ES1370 default to fixed rate operation */
548 if (resource_int_value(device_get_name(es->dev),
549 device_get_unit(es->dev), "fixed_rate", &r) == 0) {
740 if (resource_int_value(device_get_name(es->dev),
741 device_get_unit(es->dev), "fixed_rate", &r) == 0) {
550 if (r != 0) {
551 if (r < es_caps.minspeed)
552 r = es_caps.minspeed;
553 if (r > es_caps.maxspeed)
554 r = es_caps.maxspeed;
742 fixed_rate = r;
743 if (fixed_rate) {
744 if (fixed_rate < es_caps.minspeed)
745 fixed_rate = es_caps.minspeed;
746 if (fixed_rate > es_caps.maxspeed)
747 fixed_rate = es_caps.maxspeed;
555 }
556 } else
748 }
749 } else
557 r = es_caps.maxspeed;
750 fixed_rate = es_caps.maxspeed;
751
752 if (resource_int_value(device_get_name(es->dev),
753 device_get_unit(es->dev), "single_pcm_mixer", &r) == 0)
754 single_pcm = (r) ? 1 : 0;
755 else
756 single_pcm = 1;
757
558 ES_LOCK(es);
758 ES_LOCK(es);
559 es->caps = es_caps;
560 if (r != 0) {
561 es->caps.minspeed = r;
562 es->caps.maxspeed = r;
759 if (ES_NUMPLAY(es->escfg) == 1)
760 single_pcm = 1;
761 /* This is ES1370 */
762 es->escfg = ES_SET_IS_ES1370(es->escfg, 1);
763 if (fixed_rate) {
764 es->escfg = ES_SET_FIXED_RATE(es->escfg, fixed_rate);
765 } else {
766 es->escfg = ES_SET_FIXED_RATE(es->escfg, 0);
767 fixed_rate = DSP_DEFAULT_SPEED;
563 }
768 }
564 es->ctrl = CTRL_CDC_EN | CTRL_SERR_DIS |
565 (DAC2_SRTODIV(es->caps.maxspeed) << CTRL_SH_PCLKDIV);
769 if (single_pcm) {
770 es->escfg = ES_SET_SINGLE_PCM_MIX(es->escfg, 1);
771 } else {
772 es->escfg = ES_SET_SINGLE_PCM_MIX(es->escfg, 0);
773 }
774 es->ctrl = CTRL_CDC_EN | CTRL_JYSTK_EN | CTRL_SERR_DIS |
775 (DAC2_SRTODIV(fixed_rate) << CTRL_SH_PCLKDIV);
776 es->ctrl |= 3 << CTRL_SH_WTSRSEL;
566 es_wr(es, ES1370_REG_CONTROL, es->ctrl, 4);
567
568 es->sctrl = 0;
569 es_wr(es, ES1370_REG_SERIAL_CONTROL, es->sctrl, 4);
570
571 es1370_wrcodec(es, CODEC_RES_PD, 3);/* No RST, PD */
572 es1370_wrcodec(es, CODEC_CSEL, 0); /* CODEC ADC and CODEC DAC use
573 * {LR,B}CLK2 and run off the LRCLK2

--- 8 unchanged lines hidden (view full) ---

582/* ES1371 specific */
583int
584es1371_init(struct es_info *es)
585{
586 uint32_t cssr, devid, revid;
587 int idx;
588
589 ES_LOCK(es);
777 es_wr(es, ES1370_REG_CONTROL, es->ctrl, 4);
778
779 es->sctrl = 0;
780 es_wr(es, ES1370_REG_SERIAL_CONTROL, es->sctrl, 4);
781
782 es1370_wrcodec(es, CODEC_RES_PD, 3);/* No RST, PD */
783 es1370_wrcodec(es, CODEC_CSEL, 0); /* CODEC ADC and CODEC DAC use
784 * {LR,B}CLK2 and run off the LRCLK2

--- 8 unchanged lines hidden (view full) ---

793/* ES1371 specific */
794int
795es1371_init(struct es_info *es)
796{
797 uint32_t cssr, devid, revid;
798 int idx;
799
800 ES_LOCK(es);
801 /* This is NOT ES1370 */
802 es->escfg = ES_SET_IS_ES1370(es->escfg, 0);
590 es->num = 0;
803 es->num = 0;
591 es->ctrl = 0;
804 es->ctrl = CTRL_JYSTK_EN;
592 es->sctrl = 0;
805 es->sctrl = 0;
593 es->caps = es_caps;
594 cssr = 0;
595 devid = pci_get_devid(es->dev);
596 revid = pci_get_revid(es->dev);
597 if (devid == CT4730_PCI_ID) {
598 /* XXX amplifier hack? */
599 es->ctrl |= (1 << 16);
600 }
601 /* initialize the chips */

--- 5 unchanged lines hidden (view full) ---

607 (devid == CT5880_PCI_ID && revid == CT5880REV_CT5880_C) ||
608 (devid == CT5880_PCI_ID && revid == CT5880REV_CT5880_D) ||
609 (devid == CT5880_PCI_ID && revid == CT5880REV_CT5880_E)) {
610 cssr = 1 << 29;
611 es_wr(es, ES1370_REG_STATUS, cssr, 4);
612 DELAY(20000);
613 }
614 /* AC'97 warm reset to start the bitclk */
806 cssr = 0;
807 devid = pci_get_devid(es->dev);
808 revid = pci_get_revid(es->dev);
809 if (devid == CT4730_PCI_ID) {
810 /* XXX amplifier hack? */
811 es->ctrl |= (1 << 16);
812 }
813 /* initialize the chips */

--- 5 unchanged lines hidden (view full) ---

819 (devid == CT5880_PCI_ID && revid == CT5880REV_CT5880_C) ||
820 (devid == CT5880_PCI_ID && revid == CT5880REV_CT5880_D) ||
821 (devid == CT5880_PCI_ID && revid == CT5880REV_CT5880_E)) {
822 cssr = 1 << 29;
823 es_wr(es, ES1370_REG_STATUS, cssr, 4);
824 DELAY(20000);
825 }
826 /* AC'97 warm reset to start the bitclk */
615 es_wr(es, ES1370_REG_CONTROL, es->ctrl | ES1371_SYNC_RES, 4);
616 DELAY(2000);
617 es_wr(es, ES1370_REG_CONTROL, es->ctrl, 4);
827 es_wr(es, ES1370_REG_CONTROL, es->ctrl, 4);
828 es_wr(es, ES1371_REG_LEGACY, ES1371_SYNC_RES, 4);
829 DELAY(2000);
830 es_wr(es, ES1370_REG_CONTROL, es->sctrl, 4);
618 es1371_wait_src_ready(es);
619 /* Init the sample rate converter */
620 es_wr(es, ES1371_REG_SMPRATE, ES1371_DIS_SRC, 4);
621 for (idx = 0; idx < 0x80; idx++)
622 es1371_src_write(es, idx, 0);
623 es1371_src_write(es, ES_SMPREG_DAC1 + ES_SMPREG_TRUNC_N, 16 << 4);
624 es1371_src_write(es, ES_SMPREG_DAC1 + ES_SMPREG_INT_REGS, 16 << 10);
625 es1371_src_write(es, ES_SMPREG_DAC2 + ES_SMPREG_TRUNC_N, 16 << 4);
626 es1371_src_write(es, ES_SMPREG_DAC2 + ES_SMPREG_INT_REGS, 16 << 10);
627 es1371_src_write(es, ES_SMPREG_VOL_ADC, 1 << 12);
628 es1371_src_write(es, ES_SMPREG_VOL_ADC + 1, 1 << 12);
629 es1371_src_write(es, ES_SMPREG_VOL_DAC1, 1 << 12);
630 es1371_src_write(es, ES_SMPREG_VOL_DAC1 + 1, 1 << 12);
631 es1371_src_write(es, ES_SMPREG_VOL_DAC2, 1 << 12);
632 es1371_src_write(es, ES_SMPREG_VOL_DAC2 + 1, 1 << 12);
831 es1371_wait_src_ready(es);
832 /* Init the sample rate converter */
833 es_wr(es, ES1371_REG_SMPRATE, ES1371_DIS_SRC, 4);
834 for (idx = 0; idx < 0x80; idx++)
835 es1371_src_write(es, idx, 0);
836 es1371_src_write(es, ES_SMPREG_DAC1 + ES_SMPREG_TRUNC_N, 16 << 4);
837 es1371_src_write(es, ES_SMPREG_DAC1 + ES_SMPREG_INT_REGS, 16 << 10);
838 es1371_src_write(es, ES_SMPREG_DAC2 + ES_SMPREG_TRUNC_N, 16 << 4);
839 es1371_src_write(es, ES_SMPREG_DAC2 + ES_SMPREG_INT_REGS, 16 << 10);
840 es1371_src_write(es, ES_SMPREG_VOL_ADC, 1 << 12);
841 es1371_src_write(es, ES_SMPREG_VOL_ADC + 1, 1 << 12);
842 es1371_src_write(es, ES_SMPREG_VOL_DAC1, 1 << 12);
843 es1371_src_write(es, ES_SMPREG_VOL_DAC1 + 1, 1 << 12);
844 es1371_src_write(es, ES_SMPREG_VOL_DAC2, 1 << 12);
845 es1371_src_write(es, ES_SMPREG_VOL_DAC2 + 1, 1 << 12);
633 es1371_adc_rate (es, 22050, 1);
634 es1371_dac_rate (es, 22050, 1);
635 es1371_dac_rate (es, 22050, 2);
846 es1371_adc_rate(es, 22050, ES_ADC);
847 es1371_dac_rate(es, 22050, ES_DAC1);
848 es1371_dac_rate(es, 22050, ES_DAC2);
636 /* WARNING:
637 * enabling the sample rate converter without properly programming
638 * its parameters causes the chip to lock up (the SRC busy bit will
639 * be stuck high, and I've found no way to rectify this other than
640 * power cycle)
641 */
642 es1371_wait_src_ready(es);
643 es_wr(es, ES1371_REG_SMPRATE, 0, 4);

--- 155 unchanged lines hidden (view full) ---

799es1371_dac_rate(struct es_info *es, u_int rate, int set)
800{
801 u_int freq, r, result, dac, dis;
802
803 ES_LOCK_ASSERT(es);
804
805 if (rate > 48000) rate = 48000;
806 if (rate < 4000) rate = 4000;
849 /* WARNING:
850 * enabling the sample rate converter without properly programming
851 * its parameters causes the chip to lock up (the SRC busy bit will
852 * be stuck high, and I've found no way to rectify this other than
853 * power cycle)
854 */
855 es1371_wait_src_ready(es);
856 es_wr(es, ES1371_REG_SMPRATE, 0, 4);

--- 155 unchanged lines hidden (view full) ---

1012es1371_dac_rate(struct es_info *es, u_int rate, int set)
1013{
1014 u_int freq, r, result, dac, dis;
1015
1016 ES_LOCK_ASSERT(es);
1017
1018 if (rate > 48000) rate = 48000;
1019 if (rate < 4000) rate = 4000;
807 freq = (rate << 15) / 3000;
1020 freq = ((rate << 15) + 1500) / 3000;
808 result = (freq * 3000) >> 15;
1021 result = (freq * 3000) >> 15;
809 if (set) {
810 dac = (set == 1)? ES_SMPREG_DAC1 : ES_SMPREG_DAC2;
811 dis = (set == 1)? ES1371_DIS_P2 : ES1371_DIS_P1;
812
813 r = (es1371_wait_src_ready(es) & (ES1371_DIS_SRC | ES1371_DIS_P1 | ES1371_DIS_P2 | ES1371_DIS_R1));
814 es_wr(es, ES1371_REG_SMPRATE, r, 4);
815 es1371_src_write(es, dac + ES_SMPREG_INT_REGS,
816 (es1371_src_read(es, dac + ES_SMPREG_INT_REGS) & 0x00ff) | ((freq >> 5) & 0xfc00));
817 es1371_src_write(es, dac + ES_SMPREG_VFREQ_FRAC, freq & 0x7fff);
818 r = (es1371_wait_src_ready(es) & (ES1371_DIS_SRC | dis | ES1371_DIS_R1));
819 es_wr(es, ES1371_REG_SMPRATE, r, 4);
820 }
1022
1023 dac = (set == ES_DAC1) ? ES_SMPREG_DAC1 : ES_SMPREG_DAC2;
1024 dis = (set == ES_DAC1) ? ES1371_DIS_P2 : ES1371_DIS_P1;
1025 r = (es1371_wait_src_ready(es) & (ES1371_DIS_SRC | ES1371_DIS_P1 | ES1371_DIS_P2 | ES1371_DIS_R1));
1026 es_wr(es, ES1371_REG_SMPRATE, r, 4);
1027 es1371_src_write(es, dac + ES_SMPREG_INT_REGS,
1028 (es1371_src_read(es, dac + ES_SMPREG_INT_REGS) & 0x00ff) | ((freq >> 5) & 0xfc00));
1029 es1371_src_write(es, dac + ES_SMPREG_VFREQ_FRAC, freq & 0x7fff);
1030 r = (es1371_wait_src_ready(es) & (ES1371_DIS_SRC | dis | ES1371_DIS_R1));
1031 es_wr(es, ES1371_REG_SMPRATE, r, 4);
821 return result;
822}
823
824static uint32_t
825es1371_wait_src_ready(struct es_info *es)
826{
827 uint32_t t, r;
828

--- 56 unchanged lines hidden (view full) ---

885 case ES1371_PCI_ID2:
886 device_set_desc(dev, "Strange AudioPCI ES1371-? (vid=3274)");
887 device_printf(dev, "unknown revision %d -- please report to cg@freebsd.org\n", pci_get_revid(dev));
888 return BUS_PROBE_DEFAULT;
889
890 case CT4730_PCI_ID:
891 switch(pci_get_revid(dev)) {
892 case CT4730REV_CT4730_A:
1032 return result;
1033}
1034
1035static uint32_t
1036es1371_wait_src_ready(struct es_info *es)
1037{
1038 uint32_t t, r;
1039

--- 56 unchanged lines hidden (view full) ---

1096 case ES1371_PCI_ID2:
1097 device_set_desc(dev, "Strange AudioPCI ES1371-? (vid=3274)");
1098 device_printf(dev, "unknown revision %d -- please report to cg@freebsd.org\n", pci_get_revid(dev));
1099 return BUS_PROBE_DEFAULT;
1100
1101 case CT4730_PCI_ID:
1102 switch(pci_get_revid(dev)) {
1103 case CT4730REV_CT4730_A:
893 device_set_desc(dev, "Creative SB AudioPCI CT4730");
1104 device_set_desc(dev, "Creative SB AudioPCI CT4730/EV1938");
894 return BUS_PROBE_DEFAULT;
895 default:
896 device_set_desc(dev, "Creative SB AudioPCI CT4730-?");
897 device_printf(dev, "unknown revision %d -- please report to cg@freebsd.org\n", pci_get_revid(dev));
898 return BUS_PROBE_DEFAULT;
899 }
900
901 case CT5880_PCI_ID:

--- 93 unchanged lines hidden (view full) ---

995 struct es_info *es;
996 device_t dev;
997 uint32_t val;
998 int err;
999
1000 dev = oidp->oid_arg1;
1001 es = pcm_getdevinfo(dev);
1002 ES_LOCK(es);
1105 return BUS_PROBE_DEFAULT;
1106 default:
1107 device_set_desc(dev, "Creative SB AudioPCI CT4730-?");
1108 device_printf(dev, "unknown revision %d -- please report to cg@freebsd.org\n", pci_get_revid(dev));
1109 return BUS_PROBE_DEFAULT;
1110 }
1111
1112 case CT5880_PCI_ID:

--- 93 unchanged lines hidden (view full) ---

1206 struct es_info *es;
1207 device_t dev;
1208 uint32_t val;
1209 int err;
1210
1211 dev = oidp->oid_arg1;
1212 es = pcm_getdevinfo(dev);
1213 ES_LOCK(es);
1003 if (es->caps.minspeed == es->caps.maxspeed)
1004 val = es->caps.maxspeed;
1005 else
1214 val = ES_FIXED_RATE(es->escfg);
1215 if (val < es_caps.minspeed)
1006 val = 0;
1007 ES_UNLOCK(es);
1008 err = sysctl_handle_int(oidp, &val, sizeof(val), req);
1009
1010 if (err || req->newptr == NULL)
1011 return (err);
1012 if (val != 0 && (val < es_caps.minspeed || val > es_caps.maxspeed))
1013 return (EINVAL);
1014
1015 ES_LOCK(es);
1216 val = 0;
1217 ES_UNLOCK(es);
1218 err = sysctl_handle_int(oidp, &val, sizeof(val), req);
1219
1220 if (err || req->newptr == NULL)
1221 return (err);
1222 if (val != 0 && (val < es_caps.minspeed || val > es_caps.maxspeed))
1223 return (EINVAL);
1224
1225 ES_LOCK(es);
1226 if (es->ctrl & (CTRL_DAC2_EN|CTRL_ADC_EN)) {
1227 ES_UNLOCK(es);
1228 return (EBUSY);
1229 }
1016 if (val) {
1230 if (val) {
1017 es->caps.minspeed = val;
1018 es->caps.maxspeed = val;
1019 es->ctrl &= ~CTRL_PCLKDIV;
1020 es->ctrl |= DAC2_SRTODIV(val) << CTRL_SH_PCLKDIV;
1021 es_wr(es, ES1370_REG_CONTROL, es->ctrl, 4);
1231 if (val != ES_FIXED_RATE(es->escfg)) {
1232 es->escfg = ES_SET_FIXED_RATE(es->escfg, val);
1233 es->ch[ES_DAC2].caps.maxspeed = val;
1234 es->ch[ES_DAC2].caps.minspeed = val;
1235 es->ch[ES_ADC].caps.maxspeed = val;
1236 es->ch[ES_ADC].caps.minspeed = val;
1237 es->ctrl &= ~CTRL_PCLKDIV;
1238 es->ctrl |= DAC2_SRTODIV(val) << CTRL_SH_PCLKDIV;
1239 es_wr(es, ES1370_REG_CONTROL, es->ctrl, 4);
1240 }
1022 } else {
1241 } else {
1023 es->caps.minspeed = es_caps.minspeed;
1024 es->caps.maxspeed = es_caps.maxspeed;
1242 es->escfg = ES_SET_FIXED_RATE(es->escfg, 0);
1243 es->ch[ES_DAC2].caps = es_caps;
1244 es->ch[ES_ADC].caps = es_caps;
1025 }
1026 ES_UNLOCK(es);
1027
1028 return (0);
1029}
1245 }
1246 ES_UNLOCK(es);
1247
1248 return (0);
1249}
1250
1251static int
1252sysctl_es137x_single_pcm_mixer(SYSCTL_HANDLER_ARGS)
1253{
1254 struct es_info *es;
1255 struct snddev_info *d;
1256 struct snd_mixer *m;
1257 struct cdev *i_dev;
1258 device_t dev;
1259 uint32_t val, set;
1260 int recsrc, level, err;
1261
1262 dev = oidp->oid_arg1;
1263 d = device_get_softc(dev);
1264 if (d == NULL || d->mixer_dev == NULL || d->mixer_dev->si_drv1 == NULL)
1265 return (EINVAL);
1266 es = d->devinfo;
1267 if (es == NULL)
1268 return (EINVAL);
1269 ES_LOCK(es);
1270 set = ES_SINGLE_PCM_MIX(es->escfg);
1271 val = set;
1272 ES_UNLOCK(es);
1273 err = sysctl_handle_int(oidp, &val, sizeof(val), req);
1274
1275 if (err || req->newptr == NULL)
1276 return (err);
1277 if (!(val == 0 || val == 1))
1278 return (EINVAL);
1279 if (val == set)
1280 return (0);
1281 i_dev = d->mixer_dev;
1282 if (mixer_ioctl(i_dev, 0, (caddr_t)&recsrc, 0, NULL) != EBADF)
1283 return (EBUSY);
1284 err = mixer_ioctl(i_dev, MIXER_READ(SOUND_MIXER_PCM),
1285 (caddr_t)&level, -1, NULL);
1286 if (!err)
1287 err = mixer_ioctl(i_dev, MIXER_READ(SOUND_MIXER_RECSRC),
1288 (caddr_t)&recsrc, -1, NULL);
1289 if (err)
1290 return (err);
1291 if (level < 0)
1292 return (EINVAL);
1293
1294 ES_LOCK(es);
1295 if (es->ctrl & (CTRL_ADC_EN | CTRL_DAC1_EN | CTRL_DAC2_EN)) {
1296 ES_UNLOCK(es);
1297 return (EBUSY);
1298 }
1299 if (val) {
1300 es->escfg = ES_SET_SINGLE_PCM_MIX(es->escfg, 1);
1301 } else {
1302 es->escfg = ES_SET_SINGLE_PCM_MIX(es->escfg, 0);
1303 }
1304 ES_UNLOCK(es);
1305 m = i_dev->si_drv1;
1306 if (!val) {
1307 mix_setdevs(m, mix_getdevs(d->mixer_dev->si_drv1) |
1308 (1 << SOUND_MIXER_SYNTH));
1309 mix_setrecdevs(m, mix_getrecdevs(d->mixer_dev->si_drv1) |
1310 (1 << SOUND_MIXER_SYNTH));
1311 err = mixer_ioctl(i_dev, MIXER_WRITE(SOUND_MIXER_SYNTH),
1312 (caddr_t)&level, -1, NULL);
1313 } else {
1314 err = mixer_ioctl(i_dev, MIXER_WRITE(SOUND_MIXER_SYNTH),
1315 (caddr_t)&level, -1, NULL);
1316 mix_setdevs(m, mix_getdevs(d->mixer_dev->si_drv1) &
1317 ~(1 << SOUND_MIXER_SYNTH));
1318 mix_setrecdevs(m, mix_getrecdevs(d->mixer_dev->si_drv1) &
1319 ~(1 << SOUND_MIXER_SYNTH));
1320 }
1321 if (!err) {
1322 level = recsrc;
1323 if (recsrc & (1 << SOUND_MIXER_PCM))
1324 recsrc |= 1 << SOUND_MIXER_SYNTH;
1325 else if (recsrc & (1 << SOUND_MIXER_SYNTH))
1326 recsrc |= 1 << SOUND_MIXER_PCM;
1327 if (level != recsrc)
1328 err = mixer_ioctl(i_dev, MIXER_WRITE(SOUND_MIXER_RECSRC),
1329 (caddr_t)&recsrc, -1, NULL);
1330 }
1331 return (err);
1332}
1030#endif /* SND_DYNSYSCTL */
1031
1032static void
1033es_init_sysctls(device_t dev)
1034{
1035#ifdef SND_DYNSYSCTL
1036 struct es_info *es;
1037 int r, devid, revid;

--- 8 unchanged lines hidden (view full) ---

1046 (devid == CT5880_PCI_ID && revid == CT5880REV_CT5880_E)) {
1047 SYSCTL_ADD_PROC(snd_sysctl_tree(dev),
1048 SYSCTL_CHILDREN(snd_sysctl_tree_top(dev)),
1049 OID_AUTO, "spdif_enabled",
1050 CTLTYPE_INT | CTLFLAG_RW, dev, sizeof(dev),
1051 sysctl_es137x_spdif_enable, "I",
1052 "Enable S/PDIF output on primary playback channel");
1053 } else if (devid == ES1370_PCI_ID) {
1333#endif /* SND_DYNSYSCTL */
1334
1335static void
1336es_init_sysctls(device_t dev)
1337{
1338#ifdef SND_DYNSYSCTL
1339 struct es_info *es;
1340 int r, devid, revid;

--- 8 unchanged lines hidden (view full) ---

1349 (devid == CT5880_PCI_ID && revid == CT5880REV_CT5880_E)) {
1350 SYSCTL_ADD_PROC(snd_sysctl_tree(dev),
1351 SYSCTL_CHILDREN(snd_sysctl_tree_top(dev)),
1352 OID_AUTO, "spdif_enabled",
1353 CTLTYPE_INT | CTLFLAG_RW, dev, sizeof(dev),
1354 sysctl_es137x_spdif_enable, "I",
1355 "Enable S/PDIF output on primary playback channel");
1356 } else if (devid == ES1370_PCI_ID) {
1054 SYSCTL_ADD_PROC(snd_sysctl_tree(dev),
1055 SYSCTL_CHILDREN(snd_sysctl_tree_top(dev)),
1056 OID_AUTO, "fixed_rate",
1057 CTLTYPE_INT | CTLFLAG_RW, dev, sizeof(dev),
1058 sysctl_es137x_fixed_rate, "I",
1059 "Enable fixed rate playback/recording");
1357 /*
1358 * Enable fixed rate sysctl if both DAC2 / ADC enabled.
1359 */
1360 if (es->ch[ES_DAC2].channel != NULL && es->ch[ES_ADC].channel != NULL) {
1361 SYSCTL_ADD_PROC(snd_sysctl_tree(dev),
1362 SYSCTL_CHILDREN(snd_sysctl_tree_top(dev)),
1363 OID_AUTO, "fixed_rate",
1364 CTLTYPE_INT | CTLFLAG_RW, dev, sizeof(dev),
1365 sysctl_es137x_fixed_rate, "I",
1366 "Enable fixed rate playback/recording");
1367 }
1368 /*
1369 * Enable single pcm mixer sysctl if both DAC1/2 enabled.
1370 */
1371 if (es->ch[ES_DAC1].channel != NULL && es->ch[ES_DAC2].channel != NULL) {
1372 SYSCTL_ADD_PROC(snd_sysctl_tree(dev),
1373 SYSCTL_CHILDREN(snd_sysctl_tree_top(dev)),
1374 OID_AUTO, "single_pcm_mixer",
1375 CTLTYPE_INT | CTLFLAG_RW, dev, sizeof(dev),
1376 sysctl_es137x_single_pcm_mixer, "I",
1377 "Single PCM mixer controller for both DAC1/DAC2");
1378 }
1060 }
1061 if (resource_int_value(device_get_name(dev),
1062 device_get_unit(dev), "latency_timer", &r) == 0 &&
1063 !(r < 0 || r > 255))
1064 pci_write_config(dev, PCIR_LATTIMER, r, 1);
1065 SYSCTL_ADD_PROC(snd_sysctl_tree(dev),
1066 SYSCTL_CHILDREN(snd_sysctl_tree_top(dev)),
1067 OID_AUTO, "latency_timer",
1068 CTLTYPE_INT | CTLFLAG_RW, dev, sizeof(dev),
1069 sysctl_es137x_latency_timer, "I",
1070 "PCI Latency Timer configuration");
1071#endif /* SND_DYNSYSCTL */
1072}
1073
1074static int
1075es_pci_attach(device_t dev)
1076{
1077 u_int32_t data;
1078 struct es_info *es = NULL;
1379 }
1380 if (resource_int_value(device_get_name(dev),
1381 device_get_unit(dev), "latency_timer", &r) == 0 &&
1382 !(r < 0 || r > 255))
1383 pci_write_config(dev, PCIR_LATTIMER, r, 1);
1384 SYSCTL_ADD_PROC(snd_sysctl_tree(dev),
1385 SYSCTL_CHILDREN(snd_sysctl_tree_top(dev)),
1386 OID_AUTO, "latency_timer",
1387 CTLTYPE_INT | CTLFLAG_RW, dev, sizeof(dev),
1388 sysctl_es137x_latency_timer, "I",
1389 "PCI Latency Timer configuration");
1390#endif /* SND_DYNSYSCTL */
1391}
1392
1393static int
1394es_pci_attach(device_t dev)
1395{
1396 u_int32_t data;
1397 struct es_info *es = NULL;
1079 int mapped;
1398 int mapped, i, numplay, dac_cfg;
1080 char status[SND_STATUSLEN];
1081 struct ac97_info *codec = NULL;
1082 kobj_class_t ct = NULL;
1083 uint32_t devid;
1084
1085 if ((es = malloc(sizeof *es, M_DEVBUF, M_NOWAIT | M_ZERO)) == NULL) {
1086 device_printf(dev, "cannot allocate softc\n");
1087 return ENXIO;
1088 }
1089 es->lock = snd_mtxcreate(device_get_nameunit(dev), "sound softc");
1090 es->dev = dev;
1399 char status[SND_STATUSLEN];
1400 struct ac97_info *codec = NULL;
1401 kobj_class_t ct = NULL;
1402 uint32_t devid;
1403
1404 if ((es = malloc(sizeof *es, M_DEVBUF, M_NOWAIT | M_ZERO)) == NULL) {
1405 device_printf(dev, "cannot allocate softc\n");
1406 return ENXIO;
1407 }
1408 es->lock = snd_mtxcreate(device_get_nameunit(dev), "sound softc");
1409 es->dev = dev;
1410 es->escfg = 0;
1091 mapped = 0;
1092
1093 pci_enable_busmaster(dev);
1094 data = pci_read_config(dev, PCIR_COMMAND, 2);
1095 data |= (PCIM_CMD_PORTEN|PCIM_CMD_MEMEN);
1096 pci_write_config(dev, PCIR_COMMAND, data, 2);
1097 data = pci_read_config(dev, PCIR_COMMAND, 2);
1098 if (mapped == 0 && (data & PCIM_CMD_MEMEN)) {

--- 16 unchanged lines hidden (view full) ---

1115 device_printf(dev, "unable to map register space\n");
1116 goto bad;
1117 }
1118
1119 es->st = rman_get_bustag(es->reg);
1120 es->sh = rman_get_bushandle(es->reg);
1121 es->bufsz = pcm_getbuffersize(dev, 4096, ES_DEFAULT_BUFSZ, 65536);
1122
1411 mapped = 0;
1412
1413 pci_enable_busmaster(dev);
1414 data = pci_read_config(dev, PCIR_COMMAND, 2);
1415 data |= (PCIM_CMD_PORTEN|PCIM_CMD_MEMEN);
1416 pci_write_config(dev, PCIR_COMMAND, data, 2);
1417 data = pci_read_config(dev, PCIR_COMMAND, 2);
1418 if (mapped == 0 && (data & PCIM_CMD_MEMEN)) {

--- 16 unchanged lines hidden (view full) ---

1435 device_printf(dev, "unable to map register space\n");
1436 goto bad;
1437 }
1438
1439 es->st = rman_get_bustag(es->reg);
1440 es->sh = rman_get_bushandle(es->reg);
1441 es->bufsz = pcm_getbuffersize(dev, 4096, ES_DEFAULT_BUFSZ, 65536);
1442
1443 if (resource_int_value(device_get_name(dev),
1444 device_get_unit(dev), "dac", &dac_cfg) == 0) {
1445 if (dac_cfg < 0 || dac_cfg > 3)
1446 dac_cfg = ES_DEFAULT_DAC_CFG;
1447 } else
1448 dac_cfg = ES_DEFAULT_DAC_CFG;
1449
1450 switch (dac_cfg) {
1451 case 0: /* Enable all DAC: DAC1, DAC2 */
1452 numplay = 2;
1453 es->escfg = ES_SET_DAC_FIRST(es->escfg, ES_DAC1);
1454 es->escfg = ES_SET_DAC_SECOND(es->escfg, ES_DAC2);
1455 break;
1456 case 1: /* Only DAC1 */
1457 numplay = 1;
1458 es->escfg = ES_SET_DAC_FIRST(es->escfg, ES_DAC1);
1459 break;
1460 case 3: /* Enable all DAC / swap position: DAC2, DAC1 */
1461 numplay = 2;
1462 es->escfg = ES_SET_DAC_FIRST(es->escfg, ES_DAC2);
1463 es->escfg = ES_SET_DAC_SECOND(es->escfg, ES_DAC1);
1464 break;
1465 case 2: /* Only DAC2 */
1466 default:
1467 numplay = 1;
1468 es->escfg = ES_SET_DAC_FIRST(es->escfg, ES_DAC2);
1469 break;
1470 }
1471 es->escfg = ES_SET_NUMPLAY(es->escfg, numplay);
1472 es->escfg = ES_SET_NUMREC(es->escfg, 1);
1473
1123 devid = pci_get_devid(dev);
1124 switch (devid) {
1125 case ES1371_PCI_ID:
1126 case ES1371_PCI_ID2:
1127 case CT5880_PCI_ID:
1128 case CT4730_PCI_ID:
1129 es1371_init(es);
1130 codec = AC97_CREATE(dev, es, es1371_ac97);
1131 if (codec == NULL)
1132 goto bad;
1133 /* our init routine does everything for us */
1134 /* set to NULL; flag mixer_init not to run the ac97_init */
1135 /* ac97_mixer.init = NULL; */
1136 if (mixer_init(dev, ac97_getmixerclass(), codec))
1137 goto bad;
1138 ct = &eschan1371_class;
1139 break;
1140 case ES1370_PCI_ID:
1141 es1370_init(es);
1474 devid = pci_get_devid(dev);
1475 switch (devid) {
1476 case ES1371_PCI_ID:
1477 case ES1371_PCI_ID2:
1478 case CT5880_PCI_ID:
1479 case CT4730_PCI_ID:
1480 es1371_init(es);
1481 codec = AC97_CREATE(dev, es, es1371_ac97);
1482 if (codec == NULL)
1483 goto bad;
1484 /* our init routine does everything for us */
1485 /* set to NULL; flag mixer_init not to run the ac97_init */
1486 /* ac97_mixer.init = NULL; */
1487 if (mixer_init(dev, ac97_getmixerclass(), codec))
1488 goto bad;
1489 ct = &eschan1371_class;
1490 break;
1491 case ES1370_PCI_ID:
1492 es1370_init(es);
1493 /*
1494 * Disable fixed rate operation if DAC2 disabled.
1495 * This is a special case for es1370 only, where the
1496 * speed of both ADC and DAC2 locked together.
1497 */
1498 if (!ES_DAC2_ENABLED(es->escfg)) {
1499 es->escfg = ES_SET_FIXED_RATE(es->escfg, 0);
1500 }
1142 if (mixer_init(dev, &es1370_mixer_class, es))
1143 goto bad;
1144 ct = &eschan1370_class;
1145 break;
1146 default:
1147 goto bad;
1148 /* NOTREACHED */
1149 }

--- 16 unchanged lines hidden (view full) ---

1166 device_printf(dev, "unable to create dma tag\n");
1167 goto bad;
1168 }
1169
1170 snprintf(status, SND_STATUSLEN, "at %s 0x%lx irq %ld %s",
1171 (es->regtype == SYS_RES_IOPORT)? "io" : "memory",
1172 rman_get_start(es->reg), rman_get_start(es->irq),PCM_KLDSTRING(snd_es137x));
1173
1501 if (mixer_init(dev, &es1370_mixer_class, es))
1502 goto bad;
1503 ct = &eschan1370_class;
1504 break;
1505 default:
1506 goto bad;
1507 /* NOTREACHED */
1508 }

--- 16 unchanged lines hidden (view full) ---

1525 device_printf(dev, "unable to create dma tag\n");
1526 goto bad;
1527 }
1528
1529 snprintf(status, SND_STATUSLEN, "at %s 0x%lx irq %ld %s",
1530 (es->regtype == SYS_RES_IOPORT)? "io" : "memory",
1531 rman_get_start(es->reg), rman_get_start(es->irq),PCM_KLDSTRING(snd_es137x));
1532
1174 if (pcm_register(dev, es, 1, 1))
1533 if (pcm_register(dev, es, numplay, 1))
1175 goto bad;
1534 goto bad;
1535 for (i = 0; i < numplay; i++)
1536 pcm_addchan(dev, PCMDIR_PLAY, ct, es);
1176 pcm_addchan(dev, PCMDIR_REC, ct, es);
1537 pcm_addchan(dev, PCMDIR_REC, ct, es);
1177 pcm_addchan(dev, PCMDIR_PLAY, ct, es);
1178 es_init_sysctls(dev);
1179 pcm_setstatus(dev, status);
1538 es_init_sysctls(dev);
1539 pcm_setstatus(dev, status);
1180
1540 es->escfg = ES_SET_GP(es->escfg, 0);
1541 if (numplay == 1) {
1542 device_printf(dev, "<Playback: DAC%d / Record: ADC>\n",
1543 ES_DAC_FIRST(es->escfg) + 1);
1544 } else if (numplay == 2) {
1545 device_printf(dev, "<Playback: DAC%d,DAC%d / Record: ADC>\n",
1546 ES_DAC_FIRST(es->escfg) + 1,
1547 ES_DAC_SECOND(es->escfg) + 1);
1548 }
1181 return 0;
1182
1183 bad:
1184 if (es->parent_dmat) bus_dma_tag_destroy(es->parent_dmat);
1185 if (es->ih) bus_teardown_intr(dev, es->irq, es->ih);
1186 if (es->irq) bus_release_resource(dev, SYS_RES_IRQ, es->irqid, es->irq);
1187 if (codec) ac97_destroy(codec);
1188 if (es->reg) bus_release_resource(dev, es->regtype, es->regid, es->reg);

--- 43 unchanged lines hidden --- 		1549 return 0;
1550
1551 bad:
1552 if (es->parent_dmat) bus_dma_tag_destroy(es->parent_dmat);
1553 if (es->ih) bus_teardown_intr(dev, es->irq, es->ih);
1554 if (es->irq) bus_release_resource(dev, SYS_RES_IRQ, es->irqid, es->irq);
1555 if (codec) ac97_destroy(codec);
1556 if (es->reg) bus_release_resource(dev, es->regtype, es->regid, es->reg);

--- 43 unchanged lines hidden ---