?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Port the SB128 code to AROS.
[AROS.git] / workbench / devs / AHI / Drivers / SB128 / misc.c
blob82c01c29bf4ca070d374423803bc6e570beabcd8
1 /*
2
3 The contents of this file are subject to the AROS Public License Version 1.1 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at
4 http://www.aros.org/license.html
5
6 Software distributed under the License is distributed on an "AS IS" basis, WITHOUT WARRANTY OF
7 ANY KIND, either express or implied. See the License for the specific language governing rights and
8 limitations under the License.
9
10 The Original Code is (C) Copyright 2004-2011 Ross Vumbaca.
11
12 The Initial Developer of the Original Code is Ross Vumbaca.
13
14 All Rights Reserved.
15
16 */
17
18 #include <exec/memory.h>
19
20 #ifdef __AROS__
21 #define DEBUG 1
22 #include <aros/debug.h>
23 #endif
24
25 #include <proto/exec.h>
26 #include <proto/dos.h>
27
28 #include "library.h"
29 #include "regs.h"
30 #include "interrupt.h"
31 #include "misc.h"
32
33 #include "pci_wrapper.h"
34
35 #ifdef __AROS__
36 #define DebugPrintF bug
37 INTGW(static, void, playbackinterrupt, PlaybackInterrupt);
38 INTGW(static, void, recordinterrupt, RecordInterrupt);
39 INTGW(static, ULONG, cardinterrupt, CardInterrupt);
40 #endif
41
42 /* Global in Card.c */
43 extern const UWORD InputBits[];
44
45 /* Public functions in main.c */
46 int card_init(struct SB128_DATA *card);
47 void card_cleanup(struct SB128_DATA *card);
48
49 #if !defined(__AROS__)
50 void AddResetHandler(struct SB128_DATA *card);
51 #endif
52
53 void micro_delay(unsigned int val)
54 {
55 struct Device* TimerBase = NULL;
56 struct timerequest* TimerIO = NULL;
57 struct MsgPort * replymp;
58
59 replymp = (struct MsgPort *) CreateMsgPort();
60 if (!replymp)
61 {
62 DebugPrintF("SB128: Couldn't create reply port\n");
63 return;
64 }
65
66 TimerIO = (struct TimeRequest *)CreateIORequest(replymp, sizeof(struct timerequest));
67
68 if (TimerIO == NULL)
69 {
70 DebugPrintF("SB128: Out of memory.\n");
71 return;
72 }
73
74 if (OpenDevice((CONST_STRPTR) "timer.device", UNIT_MICROHZ, (struct IORequest *)TimerIO, 0) != 0)
75 {
76 DebugPrintF("SB128: Unable to open 'timer.device'.\n");
77 return;
78 }
79 else
80 {
81 TimerBase = (struct Device *)TimerIO->tr_node.io_Device;
82 }
83
84 if (TimerIO)
85 {
86 TimerIO->tr_node.io_Command = TR_ADDREQUEST;
87 TimerIO->tr_time.tv_secs = 0;
88 TimerIO->tr_time.tv_micro = val;
89 DoIO((struct IORequest *)TimerIO);
90 DeleteIORequest((struct IORequest *)TimerIO);
91 TimerIO = NULL;
92 CloseDevice((struct IORequest *)TimerIO);
93 }
94
95 if (replymp)
96 {
97 DeleteMsgPort(replymp);
98 }
99 }
100
101 unsigned long src_ready(struct SB128_DATA *card)
102 {
103 struct PCIDevice *dev = (struct PCIDevice *) card->pci_dev;
104 unsigned int i;
105 unsigned long r;
106
107 /* Wait for the busy bit to become invalid, and then return the contents
108 of the SRC register. */
109 for (i = 0; i < 0x1000; i++)
110 {
111 if (!((r = pci_inl(SB128_SRC, card)) & SRC_BUSY))
112 return r;
113 //micro_delay(1);
114 }
115
116 DebugPrintF("SB128: SRC Ready timeout.\n");
117 return 0;
118 }
119
120 void src_write(struct SB128_DATA *card, unsigned short addr, unsigned short data)
121 {
122 struct PCIDevice *dev = (struct PCIDevice *) card->pci_dev;
123 unsigned long r;
124
125 // ObtainSemaphore(&card->sb128_semaphore);
126
127 /* Get copy of SRC register when it's not busy, add address and data, write back. */
128 r = src_ready(card) & (SRC_DISABLE | SRC_DIS_DAC2 | SRC_DIS_ADC);
129 r = r | (addr << SRC_ADDR_SHIFT);
130 r = r | data;
131 pci_outl(r | SRC_WE, SB128_SRC, card);
132 //micro_delay(1);
133
134 // ReleaseSemaphore(&card->sb128_semaphore);
135 }
136
137 unsigned short src_read(struct SB128_DATA *card, unsigned short addr)
138 {
139 struct PCIDevice *dev = (struct PCIDevice *) card->pci_dev;
140
141 //There may be ES137x bugs that require accomodating in this section.
142
143 unsigned long r;
144
145 // ObtainSemaphore(&card->sb128_semaphore);
146
147 /* Get copy of SRC register when it's not busy, add address, write back,
148 wait for ready, then read back value. */
149 r = src_ready(card) & (SRC_DISABLE | SRC_DIS_DAC2 | SRC_DIS_ADC);
150 r = r | (addr << SRC_ADDR_SHIFT);
151 pci_outl(r, SB128_SRC, card);
152
153 /* Give the chip a chance to set the busy bit. */
154 //micro_delay(1);
155
156 // ReleaseSemaphore(&card->sb128_semaphore);
157
158 return (src_ready(card) & 0xFFFF);
159 }
160
161 /* Translate AC97 commands to AK4531 commands, and write to the AK4531 codec */
162 void ak4531_ac97_write(struct SB128_DATA *card, unsigned short reg, unsigned short val)
163 {
164 char ak4531_L1 = 0;
165 char ak4531_R1 = 0;
166 char ak4531_L2 = 0;
167 char ak4531_R2 = 0;
168
169 char input_right = 0;
170 char input_left = 0;
171
172 short left_vol = 0;
173 short right_vol = 0;
174
175 float steps = 0;
176
177 if (reg == AC97_RECORD_SELECT)
178 {
179 /* Change input select settings */
180 input_right = val;
181 input_left = val >> 8;
182
183 /* Translate as appropriate */
184 switch (input_left) {
185
186 case 0:
187 /* Mic */
188 ak4531_L2 = 0x80;
189 break;
190
191 case 1:
192 /* CD */
193 ak4531_L1 = 0x04;
194 break;
195
196 case 2:
197 /* Video */
198 break;
199
200 case 3:
201 /* Aux */
202 ak4531_L2 = 0x10;
203 break;
204
205 case 4:
206 /* Line in */
207 ak4531_L1 = 0x10;
208 break;
209
210 case 5:
211 /* Stereo Mix (all) */
212 ak4531_L1 = 0x14;
213 ak4531_L2 = 0xF4;
214 break;
215
216 case 6:
217 /* Mono Mix */
218 break;
219
220 case 7:
221 /* Phone */
222 ak4531_L2 = 0x60;
223 break;
224
225 default:
226 /* Shouldn't happen */
227 DebugPrintF("SB128: Unsupported Record Input command\n");
228 }
229
230 switch (input_right) {
231
232 case 0:
233 /* Mic */
234 ak4531_R2 = 0x80;
235 break;
236
237 case 1:
238 /* CD */
239 ak4531_R1 = 0x02;
240 break;
241
242 case 2:
243 /* Video */
244 break;
245
246 case 3:
247 /* Aux */
248 ak4531_R2 = 0x08;
249 break;
250
251 case 4:
252 /* Line in */
253 ak4531_R1 = 0x08;
254 break;
255
256 case 5:
257 /* Stereo Mix (all) */
258 ak4531_R1 = 0x0A;
259 ak4531_R2 = 0xEC;
260 break;
261
262 case 6:
263 /* Mono Mix */
264 break;
265
266 case 7:
267 /* Phone */
268 ak4531_R2 = 0x60;
269 break;
270
271 default:
272 /* Shouldn't happen */
273 DebugPrintF("SB128: Unsupported Record Input command\n");
274 }
275
276 /* Write input values to AK4531 */
277
278 codec_write(card, AK4531_INPUT_MUX_L_1, ak4531_L1);
279 codec_write(card, AK4531_INPUT_MUX_R_1, ak4531_R1);
280 codec_write(card, AK4531_INPUT_MUX_L_2, ak4531_L2);
281 codec_write(card, AK4531_INPUT_MUX_R_2, ak4531_R2);
282 return;
283 }
284
285 if (reg == AC97_PHONE_VOL || AC97_MIC_VOL || AC97_LINEIN_VOL || AC97_CD_VOL || AC97_AUX_VOL || AC97_PCMOUT_VOL)
286 {
287 /* Adjust PCM (from card) Input gain */
288 if (val & AC97_MUTE)
289 {
290 /* Using a muted volume */
291 right_vol = (AK4531_MUTE | 0x6);
292 left_vol = (AK4531_MUTE | 0x6);
293 }
294 else
295 {
296 /* Strip bits */
297 right_vol = (val & 0x1F);
298 left_vol = (val >> 8);
299
300 /* Convert right volume */
301 if (right_vol < 0x8)
302 {
303 steps = 0x8 - right_vol;
304 steps = steps * 1.5;
305 steps = steps / 2;
306 right_vol = (int) (steps + 0.5);
307 right_vol = 0x6 - right_vol;
308 }
309 else if (right_vol > 0x8)
310 {
311 steps = right_vol - 0x8;
312 steps = steps * 1.5;
313 steps = steps / 2;
314 right_vol = (int) (steps + 0.5);
315 right_vol = 0x6 + right_vol;
316 }
317 else if (right_vol == 0x8)
318 {
319 /* No attentuation, no mute */
320 right_vol = 0x6;
321 }
322
323 /* Convert left volume */
324 if (left_vol < 0x8)
325 {
326 steps = 0x8 - left_vol;
327 steps = steps * 1.5;
328 steps = steps / 2;
329 left_vol = (int) (steps + 0.5);
330 left_vol = 0x6 - left_vol;
331 }
332 else if (left_vol > 0x8)
333 {
334 steps = left_vol - 0x8;
335 steps = steps * 1.5;
336 steps = steps / 2;
337 left_vol = (int) (steps + 0.5);
338 left_vol = 0x6 + left_vol;
339 }
340 else if (left_vol == 0x8)
341 {
342 /* No attentuation, no mute */
343 left_vol = 0x6;
344 }
345
346 }
347
348 /* Write adjusted volume to appropriate place */
349 /* Un-mute, and disable output, if an input muted */
350 switch (reg) {
351
352 case AC97_PHONE_VOL:
353 codec_write(card, AK4531_PHONE_VOL_L, right_vol);
354 codec_write(card, AK4531_PHONE_VOL_R, right_vol);
355 break;
356
357 case AC97_MIC_VOL:
358 codec_write(card, AK4531_MIC_VOL, right_vol);
359 break;
360
361 case AC97_LINEIN_VOL:
362 if ((left_vol & AK4531_MUTE) && (right_vol & AK4531_MUTE))
363 {
364 left_vol = 0x6;
365 right_vol = 0x6;
366 /* Disable on OUTPUT mux */
367 card->ak4531_output_1 = (card->ak4531_output_1 & ~(AK4531_OUTPUT_LINE));
368 codec_write(card, AK4531_OUTPUT_MUX_1, card->ak4531_output_1);
369 }
370 else
371 {
372 codec_write(card, AK4531_LINEIN_VOL_L, left_vol);
373 codec_write(card, AK4531_LINEIN_VOL_R, right_vol);
374 /* Re-enable on OUTPUT mux */
375 card->ak4531_output_1 = (card->ak4531_output_1 | AK4531_OUTPUT_LINE);
376 codec_write(card, AK4531_OUTPUT_MUX_1, card->ak4531_output_1);
377 }
378 break;
379
380 case AC97_CD_VOL:
381 if ((left_vol & AK4531_MUTE) && (right_vol & AK4531_MUTE))
382 {
383 left_vol = 0x6;
384 right_vol = 0x6;
385 /* Disable on OUTPUT mux */
386 card->ak4531_output_1 = (card->ak4531_output_1 & ~(AK4531_OUTPUT_CD));
387 codec_write(card, AK4531_OUTPUT_MUX_1, card->ak4531_output_1);
388 }
389 else
390 {
391 codec_write(card, AK4531_CD_VOL_L, left_vol);
392 codec_write(card, AK4531_CD_VOL_R, right_vol);
393 /* Re-enable on OUTPUT mux */
394 card->ak4531_output_1 = (card->ak4531_output_1 | AK4531_OUTPUT_CD);
395 codec_write(card, AK4531_OUTPUT_MUX_1, card->ak4531_output_1);
396 }
397 break;
398
399 case AC97_AUX_VOL:
400 if ((left_vol & AK4531_MUTE) && (right_vol & AK4531_MUTE))
401 {
402 left_vol = 0x6;
403 right_vol = 0x6;
404 /* Disable on OUTPUT mux */
405 card->ak4531_output_2 = (card->ak4531_output_2 & ~(AK4531_OUTPUT_AUX));
406 codec_write(card, AK4531_OUTPUT_MUX_2, card->ak4531_output_2);
407 }
408 else
409 {
410 codec_write(card, AK4531_AUX_VOL_L, left_vol);
411 codec_write(card, AK4531_AUX_VOL_R, right_vol);
412 /* Re-enable on OUTPUT mux */
413 card->ak4531_output_2 = (card->ak4531_output_2 | AK4531_OUTPUT_AUX);
414 codec_write(card, AK4531_OUTPUT_MUX_2, card->ak4531_output_2);
415 }
416 break;
417
418 case AC97_PCMOUT_VOL:
419 codec_write(card, AK4531_PCMOUT_VOL_L, left_vol);
420 codec_write(card, AK4531_PCMOUT_VOL_R, right_vol);
421 break;
422
423 default:
424 DebugPrintF("SB128: Invalid value for Volume Set\n");
425 }
426
427 return;
428
429 }
430
431 }
432
433 void codec_write(struct SB128_DATA *card, unsigned short reg, unsigned short val)
434 {
435 struct PCIDevice *dev = (struct PCIDevice *) card->pci_dev;
436 unsigned long i, r;
437
438 /* Take hold of the hardware semaphore */
439 //ObtainSemaphore(&card->sb128_semaphore);
440
441 if(card->es1370)
442 {
443 for (i = 0; i < 10; i++)
444 {
445 if (!(pci_inl(SB128_STATUS, card) & CODEC_CSTAT ))
446 goto es1370_ok1;
447 Delay(1);
448 }
449 DebugPrintF("SB128: Couldn't write to ak4531!\n");
450 return;
451
452 es1370_ok1:
453 pci_outw(((unsigned char)reg << ES1370_CODEC_ADD_SHIFT) | (unsigned char)val, ES1370_SB128_CODEC, card);
454 micro_delay(100);
455 }
456 else
457 {
458
459 /* Check for WIP. */
460 for (i = 0; i < 0x1000; i++)
461 {
462 if (!(pci_inl(SB128_CODEC, card) & CODEC_WIP ))
463 goto ok1;
464 }
465 DebugPrintF("SB128: Couldn't write to ac97! (1)\n");
466 //ReleaseSemaphore(&card->sb128_semaphore);
467 return;
468
469 ok1:
470 /* Get copy of SRC register when it's not busy. */
471 r = src_ready(card);
472 /* Enable "SRC State Data", an undocumented feature! */
473 pci_outl((r & (SRC_DISABLE | SRC_DIS_DAC2 | SRC_DIS_ADC)) | 0x00010000, SB128_SRC, card);
474
475 /* Wait for "state 0", to avoid "transition states". */
476 for (i = 0; i < 0x1000; i++)
477 {
478 if ((pci_inl(SB128_SRC, card) & 0x00870000) == 0x00)
479 break;
480 //micro_delay(1);
481 }
482
483 /* Now wait for an undocumented bit to be set (and the SRC to be NOT busy) */
484 for (i = 0; i < 0x1000; i++)
485 {
486 if ((pci_inl(SB128_SRC, card) & 0x00870000) == 0x00010000)
487 break;
488 //micro_delay(1);
489 }
490
491 /* Write out the value to the codec now. */
492 pci_outl((((reg << CODEC_ADD_SHIFT) & CODEC_ADD_MASK) | val), SB128_CODEC, card);
493
494 /* Delay to make sure the chip had time to set the WIP after
495 the codec write. */
496 //micro_delay(1);
497
498 /* Restore SRC register. */
499 src_ready(card);
500 pci_outl(r, SB128_SRC, card);
501
502 /* Check for WIP before returning. */
503 for (i = 0; i < 0x1000; i++)
504 {
505 if (!(pci_inl(SB128_CODEC, card) & CODEC_WIP))
506 {
507 //ReleaseSemaphore(&card->sb128_semaphore);
508 return;
509 }
510 }
511
512 DebugPrintF("SB128: Couldn't write to ac97! (2)\n");
513 }
514
515 //ReleaseSemaphore(&card->sb128_semaphore);
516 return;
517 }
518
519 unsigned short codec_read(struct SB128_DATA *card, unsigned short reg)
520 {
521 struct PCIDevice *dev = (struct PCIDevice *) card->pci_dev;
522 unsigned long i, r;
523 unsigned short val;
524
525 if(card->es1370)
526 return 0;
527
528 //ObtainSemaphore(&card->sb128_semaphore);
529
530 /* Check for WIP. */
531 for (i = 0; i < 0x1000; i++) {
532 if (!((pci_inl(SB128_CODEC, card)) & CODEC_WIP ))
533 goto ok1;
534 }
535 DebugPrintF("SB128: Couldn't read from ac97! (1)\n");
536 // ReleaseSemaphore(&card->sb128_semaphore);
537 return 0;
538
539 ok1:
540
541 /* Get copy of SRC register when it's not busy. */
542 r = src_ready(card);
543
544 /* Enable "SRC State Data", an undocumented feature! */
545 pci_outl((r & (SRC_DISABLE | SRC_DIS_DAC1 | SRC_DIS_DAC2 | SRC_DIS_ADC)) | 0x00010000, SB128_SRC, card);
546
547 /* Wait for "state 0", to avoid "transition states".
548 Seen in open code. */
549 for (i = 0; i < 0x1000; i++)
550 {
551 if ((pci_inl(SB128_SRC, card) & 0x00870000) == 0x00)
552 break;
553 //micro_delay(1);
554 }
555
556 /* Now wait for an undocumented bit to be set (and the SRC to be NOT busy) */
557 for (i = 0; i < 0x1000; i++)
558 {
559 if ((pci_inl(SB128_SRC, card) & 0x00870000) == 0x00010000)
560 break;
561 //micro_delay(1);
562 }
563
564 /* Write the read request to the chip now */
565 pci_outl((((reg << CODEC_ADD_SHIFT) & CODEC_ADD_MASK) | CODEC_READ), SB128_CODEC, card);
566
567 /* Give the chip time to respond to our read request. */
568 //micro_delay(1);
569
570 /* Restore SRC register. */
571 src_ready(card);
572 pci_outl(r, SB128_SRC, card);
573
574 /* Check for WIP. */
575 for (i = 0; i < 0x1000; i++) {
576 if (!((pci_inl(SB128_CODEC, card)) & CODEC_WIP))
577 goto ok2;
578 }
579 DebugPrintF("SB128: Couldn't read from ac97 (2)!\n");
580 // ReleaseSemaphore(&card->sb128_semaphore);
581 return 0;
582
583 ok2:
584
585 /* Wait for RDY. */
586 //micro_delay(1);
587 for (i = 0; i < 0x1000; i++) {
588 if (!((pci_inl(SB128_CODEC, card)) & CODEC_RDY))
589 goto ok3;
590 }
591 DebugPrintF("SB128: Couldn't read from ac97 (3)!\n");
592 // ReleaseSemaphore(&card->sb128_semaphore);
593 return 0;
594
595 ok3:
596 //micro_delay(5);
597 Delay(1); //A delay here is crucial, remove this if you use micro_delay()
598 val = pci_inl(SB128_CODEC, card);
599
600 // ReleaseSemaphore(&card->sb128_semaphore);
601
602 return val;
603 }
604
605 void rate_set_adc(struct SB128_DATA *card, unsigned long rate)
606 {
607 struct PCIDevice *dev = (struct PCIDevice *) card->pci_dev;
608
609 unsigned long n, truncm, freq;
610
611 //ObtainSemaphore(&card->sb128_semaphore);
612
613 if (rate > 48000)
614 rate = 48000;
615 if (rate < 4000)
616 rate = 4000;
617
618 if (card->es1370)
619 {
620 pci_outl(((pci_inl(SB128_CONTROL, card) & ~DAC2_DIV_MASK) | (DAC2_SRTODIV(rate) << DAC2_DIV_SHIFT)), SB128_CONTROL, card);
621 }
622 else
623 {
624
625 /* This is completely undocumented */
626 n = rate / 3000;
627 if ((1 << n) & ((1 << 15) | (1 << 13) | (1 << 11) | (1 << 9)))
628 n--;
629 truncm = (21 * n - 1) | 1;
630 freq = ((48000UL << 15) / rate) * n;
631
632 if (rate >= 24000)
633 {
634 if (truncm > 239)
635 truncm = 239;
636 src_write(card, SRC_ADC + SRC_TRUNC, (((239 - truncm) >> 1) << 9) | (n << 4));
637 }
638 else
639 {
640 if (truncm > 119)
641 truncm = 119;
642 src_write(card, SRC_ADC + SRC_TRUNC, 0x8000 | (((119 - truncm) >> 1) << 9) | (n << 4));
643 }
644 src_write(card, SRC_ADC + SRC_INT,
645 (src_read(card, SRC_ADC + SRC_INT) & 0x00FF) | ((freq >> 5) & 0xFC00));
646 src_write(card, SRC_ADC + SRC_VF, freq & 0x7FFF);
647 src_write(card, SRC_VOL_ADC, n << 8);
648 src_write(card, SRC_VOL_ADC + 1, n << 8);
649
650 }
651
652 //ReleaseSemaphore(&card->sb128_semaphore);
653
654 }
655
656 void rate_set_dac2(struct SB128_DATA *card, unsigned long rate)
657 {
658 struct PCIDevice *dev = (struct PCIDevice *) card->pci_dev;
659
660 unsigned long freq, r;
661
662 //ObtainSemaphore(&card->sb128_semaphore);
663
664 if (rate > 48000)
665 rate = 48000;
666 if (rate < 4000)
667 rate = 4000;
668
669 if(card->es1370)
670 {
671 pci_outl(((pci_inl(SB128_CONTROL, card) & ~DAC2_DIV_MASK) | (DAC2_SRTODIV(rate) << DAC2_DIV_SHIFT)), SB128_CONTROL, card);
672 }
673 else
674 {
675
676 freq = ((rate << 15 ) + 1500) / 3000;
677
678 /* Get copy of SRC register when it's not busy, clear, preserve the disable bits, write back. */
679 r = src_ready(card) & (SRC_DISABLE | SRC_DIS_DAC1 | SRC_DIS_DAC2 | SRC_DIS_ADC);
680 pci_outl(r, SB128_SRC, card);
681
682 /* This is completely undocumented */
683 src_write(card, SRC_DAC2 + SRC_INT,
684 (src_read(card, SRC_DAC2 + SRC_INT) & 0x00FF) | ((freq >> 5) & 0xFC00));
685 src_write(card, SRC_DAC2 + SRC_VF, freq & 0x7FFF);
686 r = (src_ready(card) & (SRC_DISABLE | SRC_DIS_DAC1 | SRC_DIS_ADC));
687 pci_outl(r, SB128_SRC, card);
688
689 }
690
691 //ReleaseSemaphore(&card->sb128_semaphore);
692
693 }
694
695 /******************************************************************************
696 ** DriverData allocation ******************************************************
697 ******************************************************************************/
698
699 /* This code used to be in _AHIsub_AllocAudio(), but since we're now
700 handling CAMD support too, it needs to be done at driver loading
701 time. */
702
703 struct SB128_DATA*
704 AllocDriverData( struct PCIDevice * dev,
705 struct DriverBase* AHIsubBase )
706 {
707 struct SB128Base* SB128Base = (struct SB128Base*) AHIsubBase;
708 struct SB128_DATA* card;
709 UWORD command_word;
710 int i;
711
712 bug("[SB128]: %s()\n", __PRETTY_FUNCTION__);
713
714 // FIXME: This should be non-cachable, DMA-able memory
715 card = AllocVec( sizeof( *card ), MEMF_PUBLIC | MEMF_CLEAR );
716
717 if( card == NULL )
718 {
719 Req( "Unable to allocate driver structure." );
720 return NULL;
721 }
722
723 card->ahisubbase = AHIsubBase;
724
725 card->interrupt.is_Node.ln_Type = IRQTYPE;
726 card->interrupt.is_Node.ln_Pri = 0;
727 card->interrupt.is_Node.ln_Name = (STRPTR) LibName;
728 #ifdef __AROS__
729 card->interrupt.is_Code = (void(*)(void))&cardinterrupt;
730 #else
731 card->interrupt.is_Code = (void(*)(void))CardInterrupt;
732 #endif
733 card->interrupt.is_Data = (APTR) card;
734
735 card->playback_interrupt.is_Node.ln_Type = IRQTYPE;
736 card->playback_interrupt.is_Node.ln_Pri = 0;
737 card->playback_interrupt.is_Node.ln_Name = (STRPTR) LibName;
738 #ifdef __AROS__
739 card->playback_interrupt.is_Code = (void(*)(void))&playbackinterrupt;
740 #else
741 card->playback_interrupt.is_Code = (void(*)(void))PlaybackInterrupt;
742 #endif
743 card->playback_interrupt.is_Data = (APTR) card;
744
745 card->record_interrupt.is_Node.ln_Type = IRQTYPE;
746 card->record_interrupt.is_Node.ln_Pri = 0;
747 card->record_interrupt.is_Node.ln_Name = (STRPTR) LibName;
748 #ifdef __AROS__
749 card->record_interrupt.is_Code = (void(*)(void))&recordinterrupt;
750 #else
751 card->record_interrupt.is_Code = (void(*)(void))RecordInterrupt;
752 #endif
753 card->record_interrupt.is_Data = (APTR) card;
754
755 card->pci_dev = dev;
756
757 command_word = inw_config( PCI_COMMAND , dev);
758 command_word |= PCI_COMMAND_IO | PCI_COMMAND_MEMORY | PCI_COMMAND_MASTER;
759 outw_config( PCI_COMMAND, command_word , dev);
760
761 card->pci_master_enabled = TRUE;
762
763 card->iobase = ahi_pci_get_base_address(0, dev);
764 card->length = ~( ahi_pci_get_base_size(0, dev) & PCI_BASE_ADDRESS_IO_MASK );
765 card->irq = ahi_pci_get_irq(dev);
766 card->chiprev = inb_config(PCI_REVISION_ID, dev);
767 card->model = inw_config(PCI_SUBSYSTEM_ID, dev);
768
769 bug("[CMI8738]: %s: iobase = 0x%p, len = %d\n", __PRETTY_FUNCTION__, card->iobase, card->length);
770
771 /* Initialise hardware access Semaphore */
772 InitSemaphore(&card->sb128_semaphore);
773
774
775 /* Initialize chip */
776 if( card_init( card ) < 0 )
777 {
778 DebugPrintF("SB128: Unable to initialize Card subsystem.");
779 return NULL;
780 }
781
782 ahi_pci_add_intserver(&card->interrupt, dev);
783 card->interrupt_added = TRUE;
784
785
786 card->card_initialized = TRUE;
787 card->input = 0;
788 card->output = 0;
789 card->monitor_volume = Linear2MixerGain( 0, &card->monitor_volume_bits );
790 card->input_gain = Linear2RecordGain( 0x10000, &card->input_gain_bits );
791 card->output_volume = Linear2MixerGain( 0x10000, &card->output_volume_bits );
792 SaveMixerState(card);
793
794 #if !defined(__AROS__)
795 AddResetHandler(card);
796 #endif
797
798 return card;
799 }
800
801
802 /******************************************************************************
803 ** DriverData deallocation ****************************************************
804 ******************************************************************************/
805
806 /* And this code used to be in _AHIsub_FreeAudio(). */
807
808 void
809 FreeDriverData( struct SB128_DATA* card,
810 struct DriverBase* AHIsubBase )
811 {
812 if( card != NULL )
813 {
814 if( card->pci_dev != NULL )
815 {
816 if( card->card_initialized )
817 {
818 card_cleanup( card );
819 }
820
821 if( card->pci_master_enabled )
822 {
823 UWORD cmd;
824
825 cmd = inw_config(PCI_COMMAND, (struct PCIDevice * ) card->pci_dev);
826 cmd &= ~( PCI_COMMAND_IO | PCI_COMMAND_MEMORY | PCI_COMMAND_MASTER );
827 outw_config(PCI_COMMAND, cmd, (struct PCIDevice * ) card->pci_dev );
828 }
829 }
830
831 if( card->interrupt_added )
832 {
833 ahi_pci_rem_intserver(&card->interrupt, card->pci_dev);
834 }
835
836 FreeVec( card );
837 }
838 }
839
840
841 int card_init(struct SB128_DATA *card)
842 {
843 struct PCIDevice *dev = (struct PCIDevice *) card->pci_dev;
844 unsigned short cod;
845 unsigned int i;
846
847 /* Check if the card is an original ES1370 - different code needed */
848 if (inw_config(2, dev) == 0x5000)
849 card->es1370 = TRUE;
850 else
851 card->es1370 = FALSE;
852
853 /* Different init sequence for the ES1370 */
854 if (card->es1370)
855 {
856 /* Enable CODEC access, set DAC sample rate to 44100 */
857 pci_outl(CTRL_CDC_EN | (DAC2_SRTODIV(44100) << DAC2_DIV_SHIFT), SB128_CONTROL, card);
858 pci_outl(0x00, SB128_SCON, card);
859 DebugPrintF("SB128: Did RATE init\n");
860
861 /* CODEC initialisation */
862 codec_write(card, AK4531_RESET, 0x03); /* Enable CODEC */
863 codec_write(card, AK4531_CLOCK_SEL, 0x00); /* CODEC ADC and DAC use PLL */
864 codec_write(card, AK4531_RECORD_SELECT, 0x00); /* CODEC ADC set to use mixer for input */
865 codec_write(card, AK4531_RECORD_GAIN_MIC, 0x00); /* Mic gain set to 0 dB */
866
867 /* Volume initialisation */
868 codec_write(card, AK4531_MASTER_VOL_L, 0x00); /* No attentuation */
869 codec_write(card, AK4531_MASTER_VOL_R, 0x00);
870 codec_write(card, AK4531_MASTER_VOL_MONO, 0x00);
871
872 /* Analogue mixer input gain registers */
873 codec_write(card, AK4531_PHONE_VOL_L, AK4531_MUTE | 0x06);
874 codec_write(card, AK4531_PHONE_VOL_R, AK4531_MUTE | 0x06);
875 codec_write(card, AK4531_MIC_VOL, AK4531_MUTE | 0x06);
876 codec_write(card, AK4531_LINEIN_VOL_L, AK4531_MUTE | 0x06);
877 codec_write(card, AK4531_LINEIN_VOL_R, AK4531_MUTE | 0x06);
878 codec_write(card, AK4531_CD_VOL_L, 0x06);
879 codec_write(card, AK4531_CD_VOL_R, 0x06);
880 codec_write(card, AK4531_AUX_VOL_L, 0x06);
881 codec_write(card, AK4531_AUX_VOL_R, 0x06);
882 codec_write(card, AK4531_PCMOUT_VOL_L, 0x06);
883 codec_write(card, AK4531_PCMOUT_VOL_R, 0x06);
884
885 /* Mixer registers */
886
887 /* Always on */
888 codec_write(card, AK4531_OUTPUT_MUX_1, 0x1F);
889 codec_write(card, AK4531_OUTPUT_MUX_2, 0x3F);
890
891 /* Store value of OUTPUT MUX registers */
892 card->ak4531_output_1 = 0x1F;
893 card->ak4531_output_2 = 0x3F;
894
895 /* Analogous to "Record Select", only TMIC and Phone enabled here */
896 codec_write(card, AK4531_INPUT_MUX_L_1, 0x00);
897 codec_write(card, AK4531_INPUT_MUX_R_1, 0x00);
898 codec_write(card, AK4531_INPUT_MUX_L_2, 0x80);
899 codec_write(card, AK4531_INPUT_MUX_R_2, 0x80);
900
901 DebugPrintF("SB128: Did VOLUME init\n");
902 }
903 else
904 {
905 /* Basic clear of everything */
906 pci_outl(0x00, SB128_CONTROL, card);
907 pci_outl(0x00, SB128_SCON, card);
908 pci_outl(0x00, SB128_LEGACY, card);
909
910 /* Magical CT5880 AC97 enable bit plus 20ms delay
911 (Gotta love the undocumented stuff) */
912 pci_outl(0x20000000, SB128_STATUS, card);
913 Delay(1);
914
915 /* Assert the AC97 reset, and wait 20ms */
916 pci_outl(CODEC_RESET, SB128_CONTROL, card);
917 Delay(1);
918 /* De-assert delay, and wait 20ms */
919 pci_outl(0x00, SB128_CONTROL, card);
920 Delay(1);
921
922 DebugPrintF("SB128: Did AC97 reset.\n");
923
924 /* Disable the Sample Rate Converter (SRC) */
925 src_ready(card);
926 pci_outl(SRC_DISABLE, SB128_SRC, card);
927 /* Clear the SRC RAM */
928 for (i = 0; i < 0x80; i++)
929 src_write(card, i, 0);
930
931 DebugPrintF("SB128: Did SRC wipe.\n");
932
933 /* Perform basic configuration of the SRC, not well documented! */
934 src_write(card, SRC_DAC1 + SRC_TRUNC, 0x100);
935 src_write(card, SRC_DAC1 + SRC_INT, 0x4000);
936 src_write(card, SRC_DAC2 + SRC_TRUNC, 0x100);
937 src_write(card, SRC_DAC2 + SRC_INT, 0x4000);
938 src_write(card, SRC_VOL_ADC, 0x1000);
939 src_write(card, SRC_VOL_ADC + 1, 0x1000);
940 src_write(card, SRC_VOL_DAC1, 0x1000);
941 src_write(card, SRC_VOL_DAC1 + 1, 0x1000);
942 src_write(card, SRC_VOL_DAC2, 0x1000);
943 src_write(card, SRC_VOL_DAC2 + 1, 0x1000);
944
945 DebugPrintF("SB128: Did SRC init.\n");
946
947 rate_set_adc(card, 44100);
948 rate_set_dac2(card, 44100);
949
950 /* Re-enable the SRC */
951 src_ready(card);
952 pci_outl(0, SB128_SRC, card);
953
954 card->currentPlayFreq = 9;
955 card->currentRecFreq = 9;
956
957 DebugPrintF("SB128: Did RATE init.\n");
958
959 /* Initialise registers of AC97 to default */
960 codec_write(card, AC97_RESET, 0x00);
961
962 /* Initialise volumes of AC97 */
963 codec_write(card, AC97_MASTER_VOL_STEREO, 0x0000 ); /* no attenuation */
964 codec_write(card, AC97_AUXOUT_VOL, 0x0000 ); /* volume of the rear output */
965 codec_write(card, AC97_MASTER_VOL_MONO, 0x0000 );
966 codec_write(card, AC97_MASTER_TONE, 0x0f0f ); /* bass/treble control (if present) */
967
968 codec_write(card, AC97_RECORD_SELECT, 0);
969 codec_write(card, AC97_RECORD_GAIN, 0x0000 ); /* 0 dB gain */
970
971 /* Analogue mixer input gain registers */
972 codec_write(card, AC97_PHONE_VOL, AC97_MUTE | 0x0008 );
973 codec_write(card, AC97_MIC_VOL, AC97_MUTE | 0x0008 );
974 codec_write(card, AC97_LINEIN_VOL, AC97_MUTE | 0x0808 );
975 codec_write(card, AC97_CD_VOL, 0x0808 );
976 codec_write(card, AC97_VIDEO_VOL, AC97_MUTE | 0x0808 );
977 codec_write(card, AC97_AUX_VOL, 0x0808 );
978 codec_write(card, AC97_PCMOUT_VOL, 0x0808 );
979
980 DebugPrintF("SB128: Did VOLUME init.\n");
981
982 cod = codec_read(card, AC97_RESET);
983 DebugPrintF("SB128: AC97 capabilities = %x\n", cod);
984
985 cod = codec_read(card, AC97_VENDOR_ID0);
986 DebugPrintF("SB128: AC97_VENDOR_ID0 = %x\n", cod);
987
988 cod = codec_read(card, AC97_VENDOR_ID1);
989 DebugPrintF("SB128: AC97_VENDOR_ID1 = %x\n", cod);
990 }
991
992 return 0;
993 }
994
995
996 void card_cleanup(struct SB128_DATA *card)
997 {
998 }
999
1000
1001
1002 /******************************************************************************
1003 ** Misc. **********************************************************************
1004 ******************************************************************************/
1005
1006 void
1007 SaveMixerState( struct SB128_DATA* card )
1008 {
1009 card->ac97_mic = codec_read( card, AC97_MIC_VOL );
1010 card->ac97_cd = codec_read( card, AC97_CD_VOL );
1011 card->ac97_aux = codec_read( card, AC97_AUX_VOL );
1012 card->ac97_linein = codec_read( card, AC97_LINEIN_VOL );
1013 card->ac97_phone = codec_read( card, AC97_PHONE_VOL );
1014 }
1015
1016
1017 void
1018 RestoreMixerState( struct SB128_DATA* card )
1019 {
1020 if(card->es1370)
1021 {
1022 /* Not possible to save the state, so restore all volumes to mid levels */
1023 ak4531_ac97_write(card, AC97_MIC_VOL, 0x0808);
1024 ak4531_ac97_write(card, AC97_CD_VOL, 0x0808);
1025 ak4531_ac97_write(card, AC97_AUX_VOL, 0x0808);
1026 ak4531_ac97_write(card, AC97_LINEIN_VOL, 0x0808);
1027 ak4531_ac97_write(card, AC97_PHONE_VOL, 0x0808);
1028 }
1029 else
1030 {
1031 codec_write(card, AC97_MIC_VOL, card->ac97_mic );
1032 codec_write(card, AC97_CD_VOL, card->ac97_cd );
1033 codec_write(card, AC97_AUX_VOL, card->ac97_aux );
1034 codec_write(card, AC97_LINEIN_VOL, card->ac97_linein );
1035 codec_write(card, AC97_PHONE_VOL, card->ac97_phone );
1036 }
1037 }
1038
1039 void
1040 UpdateMonitorMixer( struct SB128_DATA* card )
1041 {
1042 int i = InputBits[ card->input ];
1043 UWORD m = card->monitor_volume_bits & 0x801f;
1044 UWORD s = card->monitor_volume_bits;
1045 UWORD mm = AC97_MUTE | 0x0008;
1046 UWORD sm = AC97_MUTE | 0x0808;
1047
1048 if( i == AC97_RECMUX_STEREO_MIX )
1049 {
1050 /* Use the original mixer settings */
1051 RestoreMixerState( card );
1052 }
1053 else
1054 {
1055 if(card->es1370)
1056 {
1057 ak4531_ac97_write(card, AC97_MIC_VOL,
1058 i == AC97_RECMUX_MIC ? m : mm );
1059
1060 ak4531_ac97_write(card, AC97_CD_VOL,
1061 i == AC97_RECMUX_CD ? s : sm );
1062
1063 ak4531_ac97_write(card, AC97_AUX_VOL,
1064 i == AC97_RECMUX_AUX ? s : sm );
1065
1066 ak4531_ac97_write(card, AC97_LINEIN_VOL,
1067 i == AC97_RECMUX_LINE ? s : sm );
1068
1069 ak4531_ac97_write(card, AC97_PHONE_VOL,
1070 i == AC97_RECMUX_PHONE ? m : mm );
1071 }
1072 else
1073 {
1074 codec_write(card, AC97_MIC_VOL,
1075 i == AC97_RECMUX_MIC ? m : mm );
1076
1077 codec_write(card, AC97_CD_VOL,
1078 i == AC97_RECMUX_CD ? s : sm );
1079
1080 codec_write(card, AC97_AUX_VOL,
1081 i == AC97_RECMUX_AUX ? s : sm );
1082
1083 codec_write(card, AC97_LINEIN_VOL,
1084 i == AC97_RECMUX_LINE ? s : sm );
1085
1086 codec_write(card, AC97_PHONE_VOL,
1087 i == AC97_RECMUX_PHONE ? m : mm );
1088 }
1089 }
1090 }
1091
1092
1093 Fixed
1094 Linear2MixerGain( Fixed linear,
1095 UWORD* bits )
1096 {
1097 static const Fixed gain[ 33 ] =
1098 {
1099 260904, /* +12.0 dB */
1100 219523, /* +10.5 dB */
1101 184706, /* +9.0 dB */
1102 155410, /* +7.5 dB */
1103 130762, /* +6.0 dB */
1104 110022, /* +4.5 dB */
1105 92572, /* +3.0 dB */
1106 77890, /* +1.5 dB */
1107 65536, /* ±0.0 dB */
1108 55142, /* -1.5 dB */
1109 46396, /* -3.0 dB */
1110 39037, /* -4.5 dB */
1111 32846, /* -6.0 dB */
1112 27636, /* -7.5 dB */
1113 23253, /* -9.0 dB */
1114 19565, /* -10.5 dB */
1115 16462, /* -12.0 dB */
1116 13851, /* -13.5 dB */
1117 11654, /* -15.0 dB */
1118 9806, /* -16.5 dB */
1119 8250, /* -18.0 dB */
1120 6942, /* -19.5 dB */
1121 5841, /* -21.0 dB */
1122 4915, /* -22.5 dB */
1123 4135, /* -24.0 dB */
1124 3479, /* -25.5 dB */
1125 2927, /* -27.0 dB */
1126 2463, /* -28.5 dB */
1127 2072, /* -30.0 dB */
1128 1744, /* -31.5 dB */
1129 1467, /* -33.0 dB */
1130 1234, /* -34.5 dB */
1131 0 /* -oo dB */
1132 };
1133
1134 int v = 0;
1135 while( linear < gain[ v ] )
1136 {
1137 ++v;
1138 }
1139
1140 if( v == 32 )
1141 {
1142 *bits = 0x8000; /* Mute */
1143 }
1144 else
1145 {
1146 *bits = ( v << 8 ) | v;
1147 }
1148 return gain[ v ];
1149 }
1150
1151 Fixed
1152 Linear2RecordGain( Fixed linear,
1153 UWORD* bits )
1154 {
1155 static const Fixed gain[ 17 ] =
1156 {
1157 873937, /* +22.5 dB */
1158 735326, /* +21.0 dB */
1159 618700, /* +19.5 dB */
1160 520571, /* +18.0 dB */
1161 438006, /* +16.5 dB */
1162 368536, /* +15.0 dB */
1163 310084, /* +13.5 dB */
1164 260904, /* +12.0 dB */
1165 219523, /* +10.5 dB */
1166 184706, /* +9.0 dB */
1167 155410, /* +7.5 dB */
1168 130762, /* +6.0 dB */
1169 110022, /* +4.5 dB */
1170 92572, /* +3.0 dB */
1171 77890, /* +1.5 dB */
1172 65536, /* ±0.0 dB */
1173 0 /* -oo dB */
1174 };
1175
1176 int v = 0;
1177
1178 while( linear < gain[ v ] )
1179 {
1180 ++v;
1181 }
1182
1183 if( v == 16 )
1184 {
1185 *bits = 0x8000; /* Mute */
1186 }
1187 else
1188 {
1189 *bits = ( ( 15 - v ) << 8 ) | ( 15 - v );
1190 }
1191
1192 return gain[ v ];
1193 }
1194
1195
1196 ULONG
1197 SamplerateToLinearPitch( ULONG samplingrate )
1198 {
1199 samplingrate = (samplingrate << 8) / 375;
1200 return (samplingrate >> 1) + (samplingrate & 1);
1201 }
1202
1203
1204 void *pci_alloc_consistent(size_t size, APTR *NonAlignedAddress, unsigned int boundary)
1205 {
1206 void* address;
1207 unsigned long a;
1208
1209 bug("[CMI8738]: %s()\n", __PRETTY_FUNCTION__);
1210
1211 address = (void *) AllocVec(size + boundary, MEMF_PUBLIC | MEMF_CLEAR);
1212
1213 if (address != NULL)
1214 {
1215 a = (unsigned long) address;
1216 a = (a + boundary - 1) & ~(boundary - 1);
1217 address = (void *) a;
1218 }
1219
1220 if (NonAlignedAddress)
1221 {
1222 *NonAlignedAddress = address;
1223 }
1224
1225 return address;
1226 }
1227
1228
1229 void pci_free_consistent(void* addr)
1230 {
1231 bug("[CMI8738]: %s()\n", __PRETTY_FUNCTION__);
1232
1233 FreeVec(addr);
1234 }
1235
1236 static ULONG ResetHandler(struct ExceptionContext *ctx, struct ExecBase *pExecBase, struct SB128_DATA *card)
1237 {
1238 struct PCIDevice *dev = card->pci_dev;
1239
1240 //Stop SB128 interrupts and playback/recording
1241 unsigned long ctrl;
1242
1243 ctrl = pci_inl(SB128_CONTROL, card);
1244 ctrl &= ( ~(CTRL_DAC2_EN) & ~(CTRL_ADC_EN) );
1245
1246 /* Stop */
1247 pci_outl(ctrl, SB128_CONTROL, card);
1248
1249 /* Clear and mask interrupts */
1250 pci_outl((pci_inl(SB128_SCON, card) & SB128_IRQ_MASK), SB128_SCON, card);
1251
1252 return 0UL;
1253 }
1254
1255 #if !defined(__AROS__)
1256 void AddResetHandler(struct SB128_DATA *card)
1257 {
1258 static struct Interrupt interrupt;
1259
1260 interrupt.is_Code = (void (*)())ResetHandler;
1261 interrupt.is_Data = (APTR) card;
1262 interrupt.is_Node.ln_Pri = 0;
1263 interrupt.is_Node.ln_Type = NT_EXTINTERRUPT;
1264 interrupt.is_Node.ln_Name = "SB128 Reset Handler";
1265
1266 AddResetCallback( &interrupt );
1267 }
1268 #endif
Mirror of AROS' svn.