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