?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
- Added device-specific settings for AD1981HD and AD1884 codecs.
[AROS.git] / workbench / devs / AHI / Drivers / HDAudio / misc.c
blob67f3d75aa9a0b96a673a52ca3e6410470f596c0f
1 /*
2 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
3 http://www.aros.org/license.html
4
5 Software distributed under the License is distributed on an "AS IS" basis, WITHOUT WARRANTY OF
6 ANY KIND, either express or implied. See the License for the specific language governing rights and
7 limitations under the License.
8
9 (C) Copyright xxxx-2009 Davy Wentzler.
10 (C) Copyright 2009-2010 Stephen Jones.
11 (C) Copyright 2010-2018 The AROS Dev Team.
12
13 The Initial Developer of the Original Code is Davy Wentzler.
14
15 All Rights Reserved.
16 */
17
18 #include <config.h>
19
20 #include <exec/memory.h>
21 #include <proto/expansion.h>
22
23 #include <proto/dos.h>
24 #ifdef __AROS__
25 #include <aros/debug.h>
26 #endif
27 #include <math.h>
28
29 #include "library.h"
30 #include "regs.h"
31 #include "interrupt.h"
32 #include "misc.h"
33 #include "pci_wrapper.h"
34
35
36 /* Public functions in main.c */
37 static void perform_controller_specific_settings(struct HDAudioChip *card);
38 int card_init(struct HDAudioChip *card);
39 void card_cleanup(struct HDAudioChip *card);
40 static BOOL allocate_corb(struct HDAudioChip *card);
41 static BOOL allocate_rirb(struct HDAudioChip *card);
42 static BOOL allocate_pos_buffer(struct HDAudioChip *card);
43 static BOOL alloc_streams(struct HDAudioChip *card);
44 static BOOL perform_codec_specific_settings(struct HDAudioChip *card);
45 static void determine_frequencies(struct HDAudioChip *card);
46 static void set_frequency_info(struct Freq *freq, UWORD bitnr);
47 static BOOL reset_chip(struct HDAudioChip *card);
48 static void codec_discovery(struct HDAudioChip *card);
49 static ULONG get_response(struct HDAudioChip *card);
50 static BOOL perform_realtek_specific_settings(struct HDAudioChip *card, UWORD device);
51 static BOOL perform_via_specific_settings(struct HDAudioChip *card, UWORD device);
52 static BOOL perform_idt_specific_settings(struct HDAudioChip *card, UWORD device);
53 static BOOL perform_ad_specific_settings(struct HDAudioChip *card,
54 UWORD device);
55 static void set_gpio(UBYTE mask, struct HDAudioChip *card);
56 static BOOL interrogate_unknown_chip(struct HDAudioChip *card);
57 static UBYTE find_widget(struct HDAudioChip *card, UBYTE type, UBYTE pin_type);
58 static BOOL power_up_all_nodes(struct HDAudioChip *card);
59
60 struct Device *TimerBase = NULL;
61 struct timerequest *TimerIO = NULL;
62 struct MsgPort *replymp = NULL;
63 static BOOL forceQuery = FALSE;
64 static BOOL dumpAll = FALSE;
65 static int force_speaker_nid = 0;
66 //void AddResetHandler(struct HDAudioChip *card);
67
68
69 #ifdef __AROS__
70 #define DebugPrintF bug
71 INTGW(static, void, playbackinterrupt, PlaybackInterrupt);
72 INTGW(static, void, recordinterrupt, RecordInterrupt);
73 INTGW(static, ULONG, cardinterrupt, CardInterrupt);
74 #endif
75
76 void micro_delay(unsigned int val)
77 {
78 replymp = (struct MsgPort *) CreateMsgPort();
79 if (!replymp)
80 {
81 D(bug("[HDAudio] Could not create the reply port!\n"));
82 return;
83 }
84
85 TimerIO = (struct timerequest *) CreateIORequest(replymp, sizeof(struct timerequest));
86
87 if (TimerIO == NULL)
88 {
89 D(bug("[HDAudio] Out of memory.\n"));
90 return;
91 }
92
93 if (OpenDevice((CONST_STRPTR) "timer.device", UNIT_MICROHZ, (struct IORequest *) TimerIO, 0) != 0)
94 {
95 D(bug("[HDAudio] Unable to open 'timer.device'.\n"));
96 return;
97 }
98 else
99 {
100 TimerBase = (struct Device *) TimerIO->tr_node.io_Device;
101 }
102
103 TimerIO->tr_node.io_Command = TR_ADDREQUEST; /* Add a request. */
104 TimerIO->tr_time.tv_secs = 0; /* 0 seconds. */
105 TimerIO->tr_time.tv_micro = val; /* 'val' micro seconds. */
106 DoIO((struct IORequest *) TimerIO);
107 CloseDevice((struct IORequest *) TimerIO);
108 DeleteIORequest((struct IORequest *) TimerIO);
109 TimerIO = NULL;
110
111 if (replymp)
112 {
113 DeleteMsgPort(replymp);
114 }
115 }
116
117
118 /******************************************************************************
119 ** DriverData allocation ******************************************************
120 ******************************************************************************/
121
122 struct HDAudioChip* AllocDriverData(APTR dev, struct DriverBase* AHIsubBase)
123 {
124 struct HDAudioChip* card;
125 UWORD command_word;
126 BOOL success = TRUE;
127
128 card = (struct HDAudioChip *) AllocVec(sizeof(struct HDAudioChip), MEMF_PUBLIC | MEMF_CLEAR);
129
130 if (card == NULL)
131 {
132 Req("Unable to allocate driver structure.");
133 return NULL;
134 }
135
136 card->ahisubbase = AHIsubBase;
137
138 card->interrupt.is_Node.ln_Type = IRQTYPE;
139 card->interrupt.is_Node.ln_Pri = 0;
140 card->interrupt.is_Node.ln_Name = (char *) LibName;
141 #ifdef __AROS__
142 card->interrupt.is_Code = (void(*)(void)) &cardinterrupt;
143 #else
144 card->interrupt.is_Code = (void(*)(void)) CardInterrupt;
145 #endif
146 card->interrupt.is_Data = (APTR) card;
147
148 card->playback_interrupt.is_Node.ln_Type = IRQTYPE;
149 card->playback_interrupt.is_Node.ln_Pri = 0;
150 card->playback_interrupt.is_Node.ln_Name = (char *) LibName;
151 #ifdef __AROS__
152 card->playback_interrupt.is_Code = (APTR)&playbackinterrupt;
153 #else
154 card->playback_interrupt.is_Code = PlaybackInterrupt;
155 #endif
156 card->playback_interrupt.is_Data = (APTR) card;
157
158 card->record_interrupt.is_Node.ln_Type = IRQTYPE;
159 card->record_interrupt.is_Node.ln_Pri = 0;
160 card->record_interrupt.is_Node.ln_Name = (char *) LibName;
161 #ifdef __AROS__
162 card->record_interrupt.is_Code = (APTR)&recordinterrupt;
163 #else
164 card->record_interrupt.is_Code = RecordInterrupt;
165 #endif
166 card->record_interrupt.is_Data = (APTR) card;
167
168 command_word = inw_config(PCI_COMMAND, dev);
169 command_word |= PCI_COMMAND_IO | PCI_COMMAND_MEMORY | PCI_COMMAND_MASTER;
170 outw_config(PCI_COMMAND, command_word, dev);
171
172 card->pci_dev = dev;
173 card->pci_master_enabled = TRUE;
174
175 card->iobase = ahi_pci_get_base_address(0, dev);
176 card->length = ahi_pci_get_base_size(0, dev);
177 card->chiprev = inb_config(PCI_REVISION_ID, dev);
178 card->model = inb_config(PCI_SUBSYSTEM_ID, dev);
179
180 perform_controller_specific_settings(card);
181
182 ahi_pci_add_intserver(&card->interrupt, dev);
183
184 /* Initialize chip */
185 if (card_init(card) < 0)
186 {
187 D(bug("[HDAudio] Unable to initialize Card subsystem.\n"));
188
189 success = FALSE;
190 }
191
192 card->interrupt_added = TRUE;
193
194 card->card_initialized = TRUE;
195 card->input = 0;
196 card->output = 0;
197 card->monitor_volume = (unsigned long) (0x10000 * pow (10.0, -6.0 / 20.0)); // -6 dB
198 card->input_gain = 0x10000; // 0dB
199 card->output_volume = 0x10000; // 0dB
200
201 if (success)
202 {
203 set_monitor_volumes(card, -6.0); // -6dB monitor volume
204 }
205
206 if (!success)
207 {
208 FreeDriverData(card, AHIsubBase);
209 card = NULL;
210 }
211
212 return card;
213 }
214
215
216 /******************************************************************************
217 ** DriverData deallocation ****************************************************
218 ******************************************************************************/
219
220 void FreeDriverData(struct HDAudioChip* card, struct DriverBase* AHIsubBase)
221 {
222 if (card != NULL)
223 {
224 if (card->pci_dev != NULL)
225 {
226 if (card->card_initialized)
227 {
228 card_cleanup(card);
229 }
230
231 if (card->pci_master_enabled)
232 {
233 UWORD cmd;
234
235 cmd = inw_config(PCI_COMMAND, card->pci_dev);
236 cmd &= ~(PCI_COMMAND_IO | PCI_COMMAND_MEMORY | PCI_COMMAND_MASTER);
237 outw_config(PCI_COMMAND, cmd, card->pci_dev);
238 }
239 }
240
241 if (card->interrupt_added)
242 {
243 ahi_pci_rem_intserver(&card->interrupt, card->pci_dev);
244 }
245
246 FreeVec(card);
247 }
248 }
249
250 #define CNT_VEN_ID_ATI_SB 0x437B1002
251 #define CNT_VEN_ID_ATI_SB2 0x43831002
252 #define CNT_VEN_ID_ATI_HUDSON 0x780D1022
253 #define CNT_VEN_ID_NVIDIA 0x10DE
254
255 static const UWORD intel_no_snoop_list[] =
256 {
257 0x2668,
258 0x27d8,
259 0x269a,
260 0x284b,
261 0x293e,
262 0x293f,
263 0x3a3e,
264 0x3a6e,
265 0
266 };
267
268 /* This is the controller specific portion, for fixes to southbridge */
269 static void perform_controller_specific_settings(struct HDAudioChip *card)
270 {
271 ULONG data, subsystem;
272 ULONG mask = (1 << 16) - 1;
273 UWORD i, vendor_id, product_id;
274 BOOL snoop = TRUE;
275
276 /* Get vendor/product/subsystem IDs */
277 data = inl_config(0x0, card->pci_dev);
278 vendor_id = inw_config(0x0, card->pci_dev);
279 product_id = inw_config(0x2, card->pci_dev);
280 D(bug("DEBUG: Controller Vendor ID: %x\n", data));
281 subsystem = inl_config(0x2C, card->pci_dev);
282
283 /* Check for Intel controllers that need snoop */
284 if (vendor_id == 0x8086)
285 {
286 D(bug("[HDAudio] Intel controller detected, checking if snooping needed\n"));
287 for (i = 0; intel_no_snoop_list[i] != 0; i++)
288 {
289 if (intel_no_snoop_list[i] == product_id)
290 {
291 snoop = FALSE;
292 }
293 }
294
295 if (snoop)
296 {
297 D(bug("[HDAudio] Enabling snooping\n"));
298 data = inw_config(0x78, card->pci_dev);
299 data &= ~0x800;
300 outw_config(0x78, data, card->pci_dev);
301 }
302 }
303
304 /* Check for ATI Southbridge or AMD Hudson controller */
305 if (data == CNT_VEN_ID_ATI_SB || data == CNT_VEN_ID_ATI_SB2 || data == CNT_VEN_ID_ATI_HUDSON)
306 {
307 D(bug("[HDAudio] ATI SB/AMD Hudson controller detected, setting snoop to on.\n"));
308 data = inb_config(0x42, card->pci_dev);
309 data &= ~0x07;
310 data |= 0x02;
311 outb_config(0x42, data, card->pci_dev);
312 }
313
314 /* Check for NVidia MCP controller */
315 if ((data & mask) == CNT_VEN_ID_NVIDIA )
316 {
317 D(bug("[HDAudio] NVidia MCP controller detected, setting snoop to on.\n"));
318 data = inb_config(0x4E, card->pci_dev);
319 data |= 0x0F;
320 outb_config(0x4E, data, card->pci_dev);
321
322 data = inb_config(0x4D, card->pci_dev);
323 data |= 0x01;
324 outb_config(0x4D, data, card->pci_dev);
325
326 data = inb_config(0x4C, card->pci_dev);
327 data |= 0x01;
328 outb_config(0x4C, data, card->pci_dev);
329 }
330
331 /* Check for HP Compaq nc6320 laptop */
332 if (subsystem == 0x30aa103c)
333 {
334 D(bug("[HDAudio] HP Compaq nc6320 laptop detected, correcting IRQ\n"));
335 data = inb_config(0x3C, card->pci_dev);
336 if (data == 10)
337 outb_config(0x3C, 11, card->pci_dev);
338 }
339 }
340
341 int card_init(struct HDAudioChip *card)
342 {
343 int i;
344
345 if (reset_chip(card) == FALSE)
346 {
347 D(bug("[HDAudio] Reset chip failed\n"));
348 return -1;
349 }
350
351 // 4.3 Codec discovery: 15 codecs can be connected, bits that are on indicate a codec
352 card->codecbits = pci_inw(HD_STATESTS, card);
353
354 if (card->codecbits == 0)
355 {
356 D(bug("[HDAudio] No codecs found!\n"));
357 return -1;
358 }
359
360 if (alloc_streams(card) == FALSE)
361 {
362 D(bug("[HDAudio] Allocating streams failed!\n"));
363 return -1;
364 }
365
366 if (allocate_corb(card) == FALSE)
367 {
368 D(bug("[HDAudio] Allocating CORB failed!\n"));
369 return -1;
370 }
371
372 if (allocate_rirb(card) == FALSE)
373 {
374 D(bug("[HDAudio] Allocating RIRB failed!\n"));
375 return -1;
376 }
377
378 if (allocate_pos_buffer(card) == FALSE)
379 {
380 D(bug("[HDAudio] Allocating position buffer failed!\n"));
381 return -1;
382 }
383
384 // enable interrupts
385 pci_outl(HD_INTCTL_CIE | HD_INTCTL_GLOBAL, HD_INTCTL, card);
386 udelay(200);
387
388 /* Find the first codec with an audio function group */
389 for (i = 0; i < 16; i++)
390 {
391 if (card->codecbits & (1 << i))
392 {
393 card->codecnr = i;
394 if (power_up_all_nodes(card))
395 break;
396 }
397 }
398
399 if (perform_codec_specific_settings(card) == FALSE)
400 {
401 return -1;
402 }
403
404 if (dumpAll)
405 {
406 codec_discovery(card);
407 }
408
409 D(bug("[HDAudio] card_init() was a success!\n"));
410
411 return 0;
412 }
413
414
415 void card_cleanup(struct HDAudioChip *card)
416 {
417 }
418
419
420 static BOOL reset_chip(struct HDAudioChip *card)
421 {
422 int counter = 0;
423 UBYTE ubval = 0;
424 UBYTE tcsel;
425
426 /*
427 Intel® HIgh Definition Audio Traffic Class Assignment (TCSEL), bits 0:2 -> 000 = TC0
428 This register assigned the value to be placed in the TC field. CORB and RIRB data will always be
429 assigned TC0.
430 */
431 #define TCSEL_PCIREG 0x44
432 tcsel = inb_config(TCSEL_PCIREG, card->pci_dev);
433 tcsel &= ~0x07;
434 outb_config(TCSEL_PCIREG, tcsel, card->pci_dev);
435
436 pci_outb(0, HD_CORBCTL, card);
437 pci_outb(0, HD_RIRBCTL, card);
438
439 // Clear STATESTS just to be sure. After reset, this register holds the ID's of the connected codecs
440 pci_outb(0xFF, HD_STATESTS, card);
441
442 // Transition to reset state
443 outl_clearbits(1, HD_GCTL, card);
444
445 // Wait for bit 0 to read 0
446 for (counter = 0; counter < 1000; counter++)
447 {
448 ubval = pci_inb(HD_GCTL, card);
449
450 if ((ubval & 0x1) == 0)
451 {
452 break;
453 }
454
455 udelay(100);
456 }
457
458 if (counter == 1000)
459 {
460 D(bug("[HDAudio] Couldn't reset chip!\n"));
461 return FALSE;
462 }
463
464 udelay(100);
465 // 4.2.2. Take controller out of reset
466 outl_setbits(1, HD_GCTL, card);
467
468
469 // Wait for bit 0 to read 1
470 for (counter = 0; counter < 1000; counter++)
471 {
472 ubval = pci_inb(HD_GCTL, card);
473
474 if ((ubval & 0x1) == 1)
475 {
476 D(bug("[HDAudio] Codec came out of reset!\n"));
477 break;
478 }
479
480 udelay(100);
481 }
482
483 if (counter == 1000)
484 {
485 D(bug("[HDAudio] Couldn't reset chip!\n"));
486 return FALSE;
487 }
488
489 // The software must wait 250 microseconds after reading CRST as 1, but it's suggested to wait longer
490 udelay(1000);
491
492 // do not accept unsolicited events for now (jack sense etc.)
493 //outl_setbits((1 << 8), HD_GCTL, card); // accept unsolicited events
494
495 return TRUE;
496 }
497
498
499 static void codec_discovery(struct HDAudioChip *card)
500 {
501 UWORD i, j;
502
503 ULONG subnode_count_response = get_parameter(card->function_group,
504 VERB_GET_PARMS_NODE_COUNT, card);
505 UBYTE subnode_count = subnode_count_response & 0xFF;
506 UBYTE sub_starting_node = (subnode_count_response >> 16) & 0xFF;
507 ULONG connections = 0, config_default;
508
509 bug("[HDAudio] Subnode count = %d, sub_starting_node = %x\n",
510 subnode_count, sub_starting_node);
511
512 //bug("[HDAudio] Audio supported = %lx\n",
513 // get_parameter(card->function_group, 0xA, card));
514 //bug("[HDAudio] Sup streams = %lx\n",
515 // get_parameter(card->function_group, 0xB, card));
516
517 for (i = 0; i < subnode_count; i++) // widgets
518 {
519 const ULONG NID = i + sub_starting_node;
520 ULONG widget_caps;
521
522 widget_caps =
523 get_parameter(NID, VERB_GET_PARMS_AUDIO_WIDGET_CAPS, card);
524
525 bug("[HDAudio] Subnode %x has caps %lx\n", NID, widget_caps);
526 bug("[HDAudio] %xh: Supported PCM size/rate = %lx\n", NID,
527 get_parameter(NID, VERB_GET_PARMS_SUPPORTED_PCM_SIZE_RATE, card));
528
529 if (AUDIO_WIDGET_CAPS(widget_caps) == 0x4) // pin complex
530 {
531 bug("[HDAudio] PIN: caps = %lx\n",
532 get_parameter(NID, VERB_GET_PARMS_PIN_CAPS, card));
533 bug("[HDAudio] PIN: Connected = %s\n",
534 is_jack_connected(card, NID) ? "TRUE" : "FALSE");
535
536 config_default = send_command_12(card->codecnr, NID,
537 VERB_GET_CONFIG_DEFAULT, 0, card);
538 bug("[HDAudio] PIN: Configuration Default = %08lx\n",
539 config_default);
540 }
541
542 bug("[HDAudio] %xh: Input Amp caps = %lx\n", NID,
543 get_parameter(NID, 0xD, card));
544 bug("[HDAudio] %xh: Output Amp caps = %lx\n", NID,
545 get_parameter(NID, 0x12, card));
546
547 connections = get_parameter(NID, 0xE, card);
548 bug("[HDAudio] %xh: Conn list len = %lx\n", NID, connections);
549 if (connections > 0) // print connections
550 {
551 ULONG entry = 0;
552
553 bug("[HDAudio] %xh: Incoming connection list: ", NID);
554 for (entry = 0; entry < connections; entry+=4)
555 {
556 ULONG connectedTo = send_command_12(card->codecnr, NID,
557 VERB_GET_CONNECTION_LIST_ENTRY, entry, card);
558
559 bug("%lx, ", connectedTo);
560 }
561 bug("\n");
562 }
563
564 bug("[HDAudio] %xh: Supported power state = %lx\n", NID,
565 get_parameter(NID, 0xF, card));
566
567 ULONG n;
568 n = send_command_12(card->codecnr, NID,
569 VERB_GET_CONNECTION_SELECT, 0, card);
570 bug("[HDAudio] %xh: Connection selection = %lx\n", NID, n);
571
572 bug("[HDAudio] %xh: Input Amp gain =", NID);
573 for (j = 0; j < connections; j++)
574 {
575 if (j != 0) bug(",");
576 n = send_command_4(card->codecnr, NID, 0xB, j, card);
577 bug(" %ld", n & 0x7f);
578 if (n & 0x80) bug(" (muted)");
579 }
580 bug("\n");
581
582 n = send_command_4(card->codecnr, NID, 0xB, 0x8000, card);
583 bug("[HDAudio] %xh: Output Amp gain = %ld%s\n", NID, n & 0x7f,
584 n & 0x80 ? " (muted)" : "");
585
586 n = send_command_4(card->codecnr, NID, 0xA, 0, card);
587 bug("[HDAudio] %xh: Format = %lx\n", NID, n);
588 n = send_command_12(card->codecnr, NID, 0xF05, 0, card);
589 bug("[HDAudio] %xh: Power state = %lx\n", NID, n);
590 n = send_command_12(card->codecnr, NID, 0xF06, 0, card);
591 bug("[HDAudio] %xh: Stream = %lx\n", NID, n);
592 n = send_command_12(card->codecnr, NID, 0xF07, 0, card);
593 bug("[HDAudio] %xh: Pin widget control = %lx\n", NID, n);
594 bug("[HDAudio] --------------------------------\n\n");
595 }
596 }
597
598
599 static BOOL power_up_all_nodes(struct HDAudioChip *card)
600 {
601 int i;
602 ULONG node_count_response = get_parameter(0, VERB_GET_PARMS_NODE_COUNT, card);
603 UBYTE node_count = node_count_response & 0xFF;
604 UBYTE starting_node = (node_count_response >> 16) & 0xFF;
605 BOOL audio_found = FALSE;
606
607 D(bug("[HDAudio] power up\n"));
608 send_command_12(card->codecnr, 1, VERB_SET_POWER_STATE , 0, card); // send function reset to audio node, this should power up all nodes
609 udelay(20000);
610
611 for (i = 0; i < node_count && !audio_found; i++)
612 {
613 ULONG function_group_response = get_parameter(starting_node + i, VERB_GET_PARMS_FUNCTION_GROUP_TYPE, card);
614 UBYTE function_group = function_group_response & 0xFF;
615
616 if (function_group == AUDIO_FUNCTION)
617 {
618 int j;
619
620 ULONG subnode_count_response = get_parameter(starting_node + i, VERB_GET_PARMS_NODE_COUNT, card);
621 UBYTE subnode_count = subnode_count_response & 0xFF;
622 UBYTE sub_starting_node = (subnode_count_response >> 16) & 0xFF;
623
624 audio_found = TRUE;
625 card->function_group = starting_node + i;
626
627 for (j = 0; j < subnode_count; j++) // widgets
628 {
629 const ULONG NID = j + sub_starting_node;
630 ULONG widget_caps;
631
632 widget_caps = get_parameter(NID, VERB_GET_PARMS_AUDIO_WIDGET_CAPS, card);
633
634 {
635 if (AUDIO_WIDGET_POWER_CONTROL(widget_caps) == 1) // power control
636 {
637 ULONG power_state = 0;
638
639 power_state = send_command_12(card->codecnr, NID, VERB_GET_POWER_STATE, 0, card);
640 D(bug("[HDAudio] %xh: power state = %xh\n", NID, power_state));
641
642 if (power_state != 0)
643 {
644 D(bug("[HDAudio] Setting power state to 0\n"));
645 send_command_12(card->codecnr, NID, VERB_SET_POWER_STATE, 0, card);
646 }
647 }
648 }
649 }
650 }
651 }
652
653 return audio_found;
654 }
655
656
657 // allocates memory on the given boundary. Returns the aligned memory address and the non-aligned memory address
658 // in NonAlignedAddress, if not NULL.
659 void *pci_alloc_consistent(size_t size, APTR *NonAlignedAddress, unsigned int boundary)
660 {
661 void* address;
662 unsigned long a;
663
664 address = (void *) AllocVec(size + boundary, MEMF_PUBLIC | MEMF_CLEAR);
665
666 if (address != NULL)
667 {
668 a = (unsigned long) address;
669 a = (a + boundary - 1) & ~(boundary - 1);
670 address = (void *) a;
671 }
672
673 if (NonAlignedAddress)
674 {
675 *NonAlignedAddress = address;
676 }
677
678 return address;
679 }
680
681
682 void pci_free_consistent(void* addr)
683 {
684 FreeVec(addr);
685 }
686
687
688 ULONG get_parameter(UBYTE node, UBYTE parameter, struct HDAudioChip *card)
689 {
690 return send_command_12(card->codecnr, node, VERB_GET_PARMS, parameter, card);
691 }
692
693
694 ULONG send_command_4(UBYTE codec, UBYTE node, UBYTE verb, UWORD payload, struct HDAudioChip *card)
695 {
696 UWORD wp = pci_inw(HD_CORBWP, card) & 0xFF;
697 ULONG data = (codec << 28) | (node << 20) | (verb << 16) | payload;
698
699 if (wp == card->corb_entries - 1)
700 {
701 wp = 0;
702 }
703 else
704 {
705 wp++;
706 }
707
708 //bug("Sending command %lx\n", data);
709
710 card->corb[wp] = data;
711 pci_outw(wp, HD_CORBWP, card);
712
713 return get_response(card);
714 }
715
716
717 ULONG send_command_12(UBYTE codec, UBYTE node, UWORD verb, UBYTE payload, struct HDAudioChip *card)
718 {
719 UWORD wp = pci_inw(HD_CORBWP, card) & 0xFF;
720 ULONG data = (codec << 28) | (node << 20) | (verb << 8) | payload;
721
722 if (wp == card->corb_entries - 1)
723 {
724 wp = 0;
725 }
726 else
727 {
728 wp++;
729 }
730
731 //bug("Sending command %lx\n", data);
732
733 card->corb[wp] = data;
734 pci_outw(wp, HD_CORBWP, card);
735
736 return get_response(card);
737 }
738
739
740 ULONG get_response(struct HDAudioChip *card)
741 {
742 int timeout = 10000;
743 int i;
744 UBYTE rirb_wp;
745
746 udelay(20); //
747
748 // wait for interrupt
749 for (i = 0; i < timeout; i++)
750 {
751 if (card->rirb_irq > 0)
752 {
753 card->rirb_irq--;
754 break;
755 }
756 udelay(10);
757 }
758
759 if (i == timeout)
760 {
761 D(bug("[HDAudio] No IRQ!\n"));
762 }
763
764 for (i = 0; i < timeout; i++)
765 {
766 rirb_wp = pci_inb(HD_RIRBWP, card);
767
768 if (rirb_wp == card->rirb_rp) // strange, we expect the wp to have increased
769 {
770 D(bug("[HDAudio] WP has not increased! rirb_wp = %u, rirb_rp = %lu\n", rirb_wp, card->rirb_rp));
771 udelay(5000);
772 }
773 else
774 {
775 if ( ((rirb_wp > card->rirb_rp) &&
776 ((rirb_wp - card->rirb_rp) >= 2)) ||
777
778 ((rirb_wp < card->rirb_rp) &&
779 ( ((int) rirb_wp) + card->rirb_entries) - card->rirb_rp >= 2))
780 {
781 D(bug("[HDAudio] Write pointer is more than 1 step ahead!\n"));
782 }
783
784 ULONG addr;
785 ULONG response, response_ex; // 3.6.5 Response Input Ring Buffer
786
787 card->rirb_rp = rirb_wp;
788 addr = card->rirb_rp;
789 addr *= 2; // 64-bit entries
790
791 response = card->rirb[addr];
792 response_ex = card->rirb[addr + 1];
793 if (response_ex & 0x10) // unsolicited
794 {
795 D(bug("[HDAudio] Unsolicited response! Skipping!\n"));
796 }
797 else
798 {
799 //bug("Response is %lx\n", response);
800 return response;
801 }
802 }
803 }
804
805 D(bug("[HDAudio] ERROR in get_response() card->rirb_rp = %u!rirb_wp = %u\n", card->rirb_rp, rirb_wp));
806 return 0;
807 }
808
809
810 static BOOL allocate_corb(struct HDAudioChip *card)
811 {
812 UBYTE corbsize_reg;
813
814 // 4.4.1.3 Initialize the CORB
815
816 // stop the DMA
817 outb_clearbits(HD_CORBRUN, HD_CORBCTL, card);
818
819 // set CORB size
820 corbsize_reg = pci_inb(HD_CORBSIZE, card);
821 if (corbsize_reg & (1 << 6))
822 {
823 pci_outb(0x2, HD_CORBSIZE, card);
824 card->corb_entries = 256;
825 }
826 else if (corbsize_reg & (1 << 5))
827 {
828 pci_outb(0x1, HD_CORBSIZE, card);
829 card->corb_entries = 16;
830 }
831 else if (corbsize_reg & (1 << 4))
832 {
833 pci_outb(0x0, HD_CORBSIZE, card);
834 card->corb_entries = 2;
835 }
836
837 // Allocate CORB memory
838 card->corb = pci_alloc_consistent(4 * card->corb_entries, NULL, 128); // todo: virtual
839
840 // Set CORB base
841 #if defined(__AROS__) && (__WORDSIZE==64)
842 pci_outl((ULONG)((IPTR)card->corb & 0xFFFFFFFF), HD_CORB_LOW, card);
843 pci_outl((ULONG)(((IPTR)card->corb >> 32) & 0xFFFFFFFF), HD_CORB_HIGH, card);
844 #else
845 pci_outl((ULONG) card->corb, HD_CORB_LOW, card);
846 pci_outl(0, HD_CORB_HIGH, card);
847 #endif
848
849 //bug("Before reset rp: corbrp = %x\n", pci_inw(0x4A, card));
850
851 // Reset read pointer: if we set this, the CORB will not work??
852 //outw_setbits(HD_CORBRPRST, HD_CORBRP, card);
853
854 //bug("After reset rp: corbrp = %x\n", pci_inw(0x4A, card));
855
856 // Write a 0 to the write pointer to clear
857 pci_outw(0, HD_CORBWP, card);
858
859 // run it
860 outb_setbits(HD_CORBRUN, HD_CORBCTL, card);
861
862 if (card->corb)
863 {
864 return TRUE;
865 }
866 else
867 {
868 return FALSE;
869 }
870 }
871
872
873 static BOOL allocate_rirb(struct HDAudioChip *card)
874 {
875 UBYTE rirbsize_reg;
876
877 // 4.4.2.2 Initialize the RIRB
878
879 // stop the DMA
880 outb_clearbits(HD_RIRBRUN, HD_RIRBCTL, card);
881
882 // set rirb size
883 rirbsize_reg = pci_inb(HD_RIRBSIZE, card);
884 if (rirbsize_reg & (1 << 6))
885 {
886 pci_outb(0x2, HD_RIRBSIZE, card);
887 card->rirb_entries = 256;
888 }
889 else if (rirbsize_reg & (1 << 5))
890 {
891 pci_outb(0x1, HD_RIRBSIZE, card);
892 card->rirb_entries = 16;
893 }
894 else if (rirbsize_reg & (1 << 4))
895 {
896 pci_outb(0x0, HD_RIRBSIZE, card);
897 card->rirb_entries = 2;
898 }
899
900 card->rirb_irq = 0;
901
902 // Allocate rirb memory
903 card->rirb = pci_alloc_consistent(4 * 2 * card->rirb_entries, NULL, 128); // todo: virtual
904 card->rirb_rp = 0;
905
906 // Set rirb base
907 #if defined(__AROS__) && (__WORDSIZE==64)
908 pci_outl((ULONG)((IPTR)card->rirb & 0xFFFFFFFF), HD_RIRB_LOW, card);
909 pci_outl((ULONG)(((IPTR)card->rirb >> 32) & 0xFFFFFFFF), HD_RIRB_HIGH, card);
910 #else
911 pci_outl((ULONG) card->rirb, HD_RIRB_LOW, card);
912 pci_outl(0, HD_RIRB_HIGH, card);
913 #endif
914
915 // Reset read pointer: if we set this, it will not come out of reset??
916 //outw_setbits(HD_RIRBWPRST, HD_RIRBWP, card);
917
918 // Set N=1, which generates an interrupt for every response
919 pci_outw(1, HD_RINTCNT, card);
920
921 pci_outb(0x5, HD_RIRBSTS, card);
922
923 // run it and enable IRQ
924 outb_setbits(HD_RIRBRUN | HD_RINTCTL | 0x4, HD_RIRBCTL, card);
925
926 if (card->rirb)
927 {
928 return TRUE;
929 }
930 else
931 {
932 return FALSE;
933 }
934 }
935
936
937
938 static BOOL allocate_pos_buffer(struct HDAudioChip *card)
939 {
940 card->dma_position_buffer = pci_alloc_consistent(sizeof(APTR) * 36, NULL, 128);
941
942 //warning: DMA poition buffer is unused?
943 #if defined(__AROS__) && (__WORDSIZE==64)
944 pci_outl(0, HD_DPLBASE, card);
945 pci_outl(0, HD_DPUBASE, card);
946 #else
947 //pci_outl((ULONG) card->dma_position_buffer | HD_DPLBASE_ENABLE, HD_DPLBASE, card);
948 pci_outl(0, HD_DPLBASE, card);
949 pci_outl(0, HD_DPUBASE, card);
950 #endif
951
952 if (card->dma_position_buffer)
953 {
954 return TRUE;
955 }
956 else
957 {
958 return FALSE;
959 }
960 }
961
962
963 static BOOL alloc_streams(struct HDAudioChip *card)
964 {
965 int i;
966 card->nr_of_input_streams = (pci_inw(HD_GCAP, card) & HD_GCAP_ISS_MASK) >> 8;
967 card->nr_of_output_streams = (pci_inw(HD_GCAP, card) & HD_GCAP_OSS_MASK) >> 12;
968 card->nr_of_streams = card->nr_of_input_streams + card->nr_of_output_streams;
969 //bug("Streams in = %d, out = %d\n", card->nr_of_input_streams, card->nr_of_output_streams);
970
971 card->streams = (struct Stream *) AllocVec(sizeof(struct Stream) * card->nr_of_streams, MEMF_PUBLIC | MEMF_CLEAR);
972
973 for (i = 0; i < card->nr_of_streams; i++)
974 {
975 card->streams[i].bdl = NULL;
976 card->streams[i].bdl_nonaligned_addresses = NULL;
977 card->streams[i].sd_reg_offset = HD_SD_BASE_OFFSET + HD_SD_DESCRIPTOR_SIZE * i;
978 card->streams[i].index = i;
979 card->streams[i].tag = i + 1;
980 card->streams[i].fifo_size = pci_inw(card->streams[i].sd_reg_offset + HD_SD_OFFSET_FIFO_SIZE, card);
981
982 // clear the descriptor error, fifo error and buffer completion interrupt status flags
983 pci_outb(HD_SD_STATUS_MASK, card->streams[i].sd_reg_offset + HD_SD_OFFSET_STATUS, card);
984 }
985
986 if (card->streams)
987 {
988 return TRUE;
989 }
990 else
991 {
992 return FALSE;
993 }
994 }
995
996
997 /*static ULONG ResetHandler(struct ExceptionContext *ctx, struct ExecBase *pExecBase, struct HDAudioChip *card)
998 {
999 struct PCIDevice *dev = card->pci_dev;
1000
1001 return 0UL;
1002 }
1003
1004
1005 void AddResetHandler(struct HDAudioChip *card)
1006 {
1007 static struct Interrupt interrupt;
1008
1009 interrupt.is_Code = (void (*)())ResetHandler;
1010 interrupt.is_Data = (APTR) card;
1011 interrupt.is_Node.ln_Pri = 0;
1012 interrupt.is_Node.ln_Type = NT_EXTINTERRUPT;
1013 interrupt.is_Node.ln_Name = "reset handler";
1014
1015 AddResetCallback(&interrupt);
1016 }*/
1017
1018
1019 static BOOL perform_codec_specific_settings(struct HDAudioChip *card)
1020 {
1021 BOOL configured = FALSE;
1022 ULONG vendor_device_id = get_parameter(0x0, VERB_GET_PARMS_VENDOR_DEVICE, card); // get vendor and device ID from root node
1023 UWORD vendor = (vendor_device_id >> 16);
1024 UWORD device = (vendor_device_id & 0xFFFF);
1025
1026 card->dac_min_gain = -64.0;
1027 card->dac_max_gain = 0;
1028 card->dac_step_gain = 1.0;
1029
1030 D(bug("[HDAudio] vendor = %x, device = %x\n", vendor, device));
1031
1032 if (vendor == 0x10EC && forceQuery == FALSE) // Realtek
1033 {
1034 configured = perform_realtek_specific_settings(card, device);
1035 }
1036 else if (vendor == 0x1106 && forceQuery == FALSE) // VIA
1037 {
1038 configured = perform_via_specific_settings(card, device);
1039 }
1040 else if (vendor == 0x111d || (vendor == 0x8384 && forceQuery == FALSE)) // IDT
1041 {
1042 configured = perform_idt_specific_settings(card, device);
1043 }
1044 else if (vendor == 0x11d4 && forceQuery == FALSE) // Analog Devices
1045 {
1046 configured = perform_ad_specific_settings(card, device);
1047 }
1048
1049 // call query-based configuration if the vendor-specific configuration
1050 // functions haven't configured the codec or have only partially
1051 // configured it by overriding some values
1052 if (!configured)
1053 {
1054 if (!interrogate_unknown_chip(card))
1055 {
1056 return FALSE;
1057 }
1058 }
1059
1060 determine_frequencies(card);
1061 return TRUE;
1062 }
1063
1064
1065 static BOOL perform_realtek_specific_settings(struct HDAudioChip *card, UWORD device)
1066 {
1067 D(bug("[HDAudio] Found Realtek codec\n"));
1068
1069 if (!(device == 0x662
1070 || device == 0x663
1071 || device == 0x268
1072 || device == 0x269
1073 || device == 0x888))
1074 {
1075 D(bug("[HDAudio] Unknown Realtek codec.\n"));
1076 return FALSE;
1077 }
1078
1079 card->dac_nid = 0x2;
1080 card->dac_volume_nids[0] = 0x2;
1081 card->dac_volume_count = 1;
1082 card->adc_nid = 0x8;
1083
1084 card->adc_mixer_nid = 0x23;
1085 card->line_in_nid = 0x1A;
1086 card->mic1_nid = 0x18;
1087 card->mic2_nid = 0x19;
1088 card->cd_nid = 0x1C;
1089
1090 card->adc_mixer_is_mux = FALSE;
1091
1092 // FRONT pin (0x14)
1093 send_command_4(card->codecnr, 0x14, VERB_SET_AMP_GAIN, OUTPUT_AMP_GAIN | AMP_GAIN_LR, card); // set amplifier gain: unmute output of FRONT (Port-D)
1094
1095 send_command_12(card->codecnr, 0x14, VERB_SET_PIN_WIDGET_CONTROL, 0x40, card); // output enabled
1096 card->speaker_active = TRUE;
1097
1098 // MIC1 pin (0x18) as input
1099 send_command_12(card->codecnr, card->mic1_nid, VERB_SET_PIN_WIDGET_CONTROL, 0x20, card); // input enabled
1100
1101 send_command_4(card->codecnr, card->mic1_nid, VERB_SET_AMP_GAIN, INPUT_AMP_GAIN | AMP_GAIN_LR | 0, card); // set amplifier gain: unmute input and set boost to +10dB
1102
1103
1104 // device specific support
1105 if (device == 0x662 || device == 0x663) // Realtek ALC662/663
1106 {
1107 D(bug("[HDAudio] Adding ALC662/663 specific support\n"));
1108
1109 card->adc_mixer_indices[0] = 2; // line in
1110 card->adc_mixer_indices[1] = 0; // mic1
1111 card->adc_mixer_indices[2] = 1; // mic2
1112 card->adc_mixer_indices[3] = 4; // cd
1113 card->adc_mixer_indices[4] = 8; // mon mixer
1114
1115 card->adc_min_gain = -13.5;
1116 card->adc_max_gain = 33.0;
1117 card->adc_step_gain = 1.5;
1118
1119 // LINE2 pin (0x1B) as second front output (duplicates sound of 0xC (front DAC))
1120 send_command_4(card->codecnr, 0x1B, VERB_SET_AMP_GAIN, OUTPUT_AMP_GAIN | AMP_GAIN_LR, card); // set amplifier gain: unmute output of LINE2 (Port-E)
1121
1122 send_command_12(card->codecnr, 0x1B, VERB_SET_PIN_WIDGET_CONTROL, 0x40, card); // output enabled
1123
1124 // Monitor mixer (0xB): set the first 3 inputs to 0dB and unmute them
1125 send_command_4(card->codecnr, 0xB, VERB_SET_AMP_GAIN, INPUT_AMP_GAIN | AMP_GAIN_LR | 23 | (0 << 8), card); // set input amplifier gain and unmute (index 0 is MIC1), 23 is 0dB
1126
1127 send_command_4(card->codecnr, 0xB, VERB_SET_AMP_GAIN, INPUT_AMP_GAIN | AMP_GAIN_LR | 23 | (1 << 8), card); // set input amplifier gain and unmute (index 2 is MIC2), 23 is 0dB
1128
1129 send_command_4(card->codecnr, 0xB, VERB_SET_AMP_GAIN, INPUT_AMP_GAIN | AMP_GAIN_LR | 23 | (2 << 8), card); // set input amplifier gain and unmute (index 2 is LINE1), 23 is 0dB
1130
1131 // Front DAC (0xC)
1132 send_command_4(card->codecnr, 0xC, VERB_SET_AMP_GAIN, INPUT_AMP_GAIN | AMP_GAIN_LR, card); // unmute PCM at index 0
1133
1134 send_command_4(card->codecnr, 0xC, VERB_SET_AMP_GAIN, INPUT_AMP_GAIN | AMP_GAIN_LR | (1 << 8), card); // unmute monitor mixer at index 1
1135
1136 // LINE1 pin (0x1A) as input
1137 send_command_12(card->codecnr, card->line_in_nid, VERB_SET_PIN_WIDGET_CONTROL, 0x20, card); // input enabled
1138
1139 // MIC2 pin (0x19) as input
1140 send_command_12(card->codecnr, card->mic2_nid, VERB_SET_PIN_WIDGET_CONTROL, 0x20, card); // input enabled
1141
1142 send_command_4(card->codecnr, card->adc_mixer_nid, VERB_SET_AMP_GAIN, OUTPUT_AMP_GAIN | AMP_GAIN_LR | 11, card); // set amplifier gain: unmute and set to 0dB
1143 }
1144 else if (device == 0x268)
1145 {
1146 D(bug("[HDAudio] Adding ALC268 specific support\n"));
1147
1148 card->speaker_nid = 0x14;
1149 card->headphone_nid = 0x15;
1150
1151 card->adc_mixer_indices[0] = 2; // line in
1152 card->adc_mixer_indices[1] = 0; // mic1
1153 card->adc_mixer_indices[2] = 5; // mic2
1154 card->adc_mixer_indices[3] = 3; // cd
1155 card->adc_mixer_indices[4] = 255; // no mon mixer
1156
1157 card->adc_min_gain = -16.5;
1158 card->adc_max_gain = 30.0;
1159 card->adc_step_gain = 1.5;
1160
1161 card->adc_mixer_is_mux = TRUE;
1162
1163 // sum widget before output (0xF)
1164 send_command_4(card->codecnr, 0xF, VERB_SET_AMP_GAIN, INPUT_AMP_GAIN | AMP_GAIN_LR, card); // unmute
1165
1166 // sum widget before headphone output (0x10)
1167 send_command_4(card->codecnr, 0x10, VERB_SET_AMP_GAIN, INPUT_AMP_GAIN | AMP_GAIN_LR | (2 << 8), card); // unmute
1168
1169 // HP-OUT pin (0x15)
1170 send_command_4(card->codecnr, 0x15, VERB_SET_AMP_GAIN, OUTPUT_AMP_GAIN | AMP_GAIN_LR, card); // set amplifier gain: unmute output of HP-OUT (Port-A)
1171
1172 send_command_12(card->codecnr, 0x15, VERB_SET_PIN_WIDGET_CONTROL, 0x40, card); // output enabled
1173
1174 send_command_12(card->codecnr, 0x14, VERB_SET_EAPD, 0x2, card); // enable EAPD (external power amp)
1175
1176 send_command_12(card->codecnr, 0x15, VERB_SET_EAPD, 0x2, card); // enable EAPD (external power amp)
1177 }
1178 else if (device == 0x269) // Dell mini etc.
1179 {
1180 D(bug("[HDAudio] Adding ALC269 specific support\n"));
1181
1182 card->speaker_nid = 0x14;
1183 card->headphone_nid = 0x15;
1184
1185 card->adc_mixer_indices[0] = 2; // line in
1186 card->adc_mixer_indices[1] = 0; // mic1
1187 card->adc_mixer_indices[2] = 1; // mic2
1188 card->adc_mixer_indices[3] = 4; // cd
1189 card->adc_mixer_indices[4] = 6; // mon mixer
1190
1191 card->adc_min_gain = -17;
1192 card->adc_max_gain = 29.0;
1193 card->adc_step_gain = 1.0;
1194
1195 card->adc_mixer_is_mux = TRUE;
1196
1197 // Front DAC (0xC)
1198 send_command_4(card->codecnr, 0xC, VERB_SET_AMP_GAIN, INPUT_AMP_GAIN | AMP_GAIN_LR, card); // unmute PCM at index 0
1199
1200 send_command_4(card->codecnr, 0xC, VERB_SET_AMP_GAIN, INPUT_AMP_GAIN | AMP_GAIN_LR | (1 << 8), card); // unmute monitor mixer at index 1
1201
1202 // sum widget before output (0xF)
1203 send_command_4(card->codecnr, 0xF, VERB_SET_AMP_GAIN, INPUT_AMP_GAIN | AMP_GAIN_LR, card); // unmute
1204
1205 // sum widget before headphone output (0x10)
1206 send_command_4(card->codecnr, 0x10, VERB_SET_AMP_GAIN, INPUT_AMP_GAIN | AMP_GAIN_LR | (2 << 8), card); // unmute
1207
1208 // HP-OUT pin (0x15)
1209 send_command_4(card->codecnr, 0x15, VERB_SET_AMP_GAIN, OUTPUT_AMP_GAIN | AMP_GAIN_LR, card); // set amplifier gain: unmute output of HP-OUT (Port-A)
1210
1211 send_command_12(card->codecnr, 0x15, VERB_SET_PIN_WIDGET_CONTROL, 0x40, card); // output enabled
1212
1213 send_command_12(card->codecnr, 0x14, VERB_SET_EAPD, 0x2, card); // enable EAPD (external power amp)
1214
1215 send_command_12(card->codecnr, 0x15, VERB_SET_EAPD, 0x2, card); // enable EAPD (external power amp)
1216 }
1217 else if (device == 0x888) // ALC888
1218 {
1219 D(bug("[HDAudio] Adding ALC888 specific support\n"));
1220
1221 card->adc_mixer_indices[0] = 2; // line in
1222 card->adc_mixer_indices[1] = 0; // mic1
1223 card->adc_mixer_indices[2] = 1; // mic2
1224 card->adc_mixer_indices[3] = 4; // cd
1225 card->adc_mixer_indices[4] = 10; // mon mixer
1226
1227 card->adc_min_gain = -16.5;
1228 card->adc_max_gain = 30.0;
1229 card->adc_step_gain = 1.5;
1230
1231 card->dac_min_gain = -46.5;
1232 card->dac_max_gain = 0;
1233 card->dac_step_gain = 1.5;
1234
1235 card->dac_volume_nids[0] = 0xC;
1236 card->dac_volume_count = 1;
1237
1238 send_command_4(card->codecnr, 0xC, VERB_SET_AMP_GAIN, INPUT_AMP_GAIN | AMP_GAIN_LR, card); // unmute PCM at index 0
1239 send_command_4(card->codecnr, 0xC, VERB_SET_AMP_GAIN, INPUT_AMP_GAIN | AMP_GAIN_LR | (1 << 8), card); // unmute monitor mixer at index 1
1240 }
1241
1242 return TRUE;
1243 }
1244
1245
1246 static BOOL perform_via_specific_settings(struct HDAudioChip *card, UWORD device)
1247 {
1248 D(bug("[HDAudio] Found VIA codec\n"));
1249
1250 if (!(device == 0xE721 || device == 0x0397))
1251 {
1252 D(bug("[HDAudio] Unknown VIA codec.\n"));
1253 return FALSE;
1254 }
1255
1256 card->dac_nid = 0x10;
1257 card->adc_nid = 0x13;
1258
1259 card->adc_mixer_nid = 0x17;
1260 card->line_in_nid = 0x1B;
1261 card->mic1_nid = 0x1A;
1262 card->mic2_nid = 0x1E;
1263 card->cd_nid = 0x1F;
1264
1265 card->adc_mixer_is_mux = TRUE;
1266
1267 // FRONT pin (0x1C)
1268 send_command_4(card->codecnr, 0x1C, VERB_SET_AMP_GAIN, OUTPUT_AMP_GAIN | AMP_GAIN_LR | 0x1B, card); // set amplifier gain: unmute output and set to 0dB of FRONT (Port-D)
1269 send_command_12(card->codecnr, 0x1C, VERB_SET_PIN_WIDGET_CONTROL, 0x40, card); // output enabled
1270
1271 // MIC1 pin as input
1272 send_command_12(card->codecnr, card->mic1_nid, VERB_SET_PIN_WIDGET_CONTROL, 0x20, card); // input enabled
1273 send_command_4(card->codecnr, card->mic1_nid, VERB_SET_AMP_GAIN, INPUT_AMP_GAIN | AMP_GAIN_LR, card); // set amplifier gain: unmute input
1274
1275
1276 // device specific support
1277 if (device == 0xE721) // VIA VT1708B
1278 {
1279 D(bug("[HDAudio] Adding VIA VT1708B specific support\n"));
1280
1281 card->adc_mixer_indices[0] = 3; // line in
1282 card->adc_mixer_indices[1] = 2; // mic1
1283 card->adc_mixer_indices[2] = 4; // mic2
1284 card->adc_mixer_indices[3] = 1; // cd
1285 card->adc_mixer_indices[4] = 255; // mon mixer
1286
1287 card->adc_min_gain = -13.5;
1288 card->adc_max_gain = 33.0;
1289 card->adc_step_gain = 1.5;
1290 }
1291
1292 return TRUE;
1293 }
1294
1295 /*
1296 IDT specific settings
1297
1298 information: http://www.idt.com/document/92hd75b-datasheet-92hd75-being-discontinued-see-pdn-notice
1299
1300 TODO: input
1301
1302 */
1303 static BOOL perform_idt_specific_settings(struct HDAudioChip *card, UWORD device)
1304 {
1305 D(bug("[HDAudio] Found IDT codec\n"));
1306
1307 if (device == 0x76a0)
1308 {
1309 D(bug("[HDAudio] STAC9205 detected.\n"));
1310
1311 card->eapd_gpio_mask = 0x1;
1312 set_gpio(card->eapd_gpio_mask, card);
1313
1314 return FALSE;
1315 }
1316
1317 if (!(device == 0x7608))
1318 {
1319 D(bug("[HDAudio] Unknown IDT codec.\n"));
1320 return FALSE;
1321 }
1322
1323 card->dac_nid = 0x10;
1324 card->adc_nid = 0x12;
1325 card->adc_mixer_nid = 0x1C;
1326 card->dac_volume_nids[0] = 0x10;
1327 card->dac_volume_count = 1;
1328
1329 card->speaker_nid = 0x0D;
1330 card->headphone_nid = 0x0A;
1331
1332 card->line_in_nid = 0x0B;
1333 card->mic1_nid = 0x0B;
1334 card->mic2_nid = 0x0C;
1335 card->cd_nid = 0x0E; /* no cd but ...*/
1336
1337 card->adc_mixer_is_mux = TRUE;
1338
1339 /* to not to enable headphone and the speaker at the same time */
1340 card->speaker_active = TRUE;
1341
1342 /* enable eapd. Specs says this is spdif out, but this is required */
1343 send_command_12(card->codecnr, 0x1f, VERB_SET_EAPD, 0x2, card);
1344
1345 /* set connections */
1346 send_command_12 (card->codecnr, 0x0f, VERB_SET_CONNECTION_SELECT, 0, card); /* 48QFN specific */
1347 send_command_12 (card->codecnr, 0x0a, VERB_SET_CONNECTION_SELECT, 0, card); /* headset */
1348 send_command_12 (card->codecnr, 0x0d, VERB_SET_CONNECTION_SELECT, 0, card); /* speaker */
1349
1350 /* set output gains */
1351 send_command_4 (card->codecnr, 0x0f, VERB_SET_AMP_GAIN, OUTPUT_AMP_GAIN | AMP_GAIN_LR, card);
1352 send_command_4 (card->codecnr, 0x0a, VERB_SET_AMP_GAIN, OUTPUT_AMP_GAIN | AMP_GAIN_LR, card);
1353 send_command_4 (card->codecnr, 0x0d, VERB_SET_AMP_GAIN, OUTPUT_AMP_GAIN | AMP_GAIN_LR, card);
1354
1355 /* enable outputs */
1356 send_command_12(card->codecnr, 0x0f, VERB_SET_PIN_WIDGET_CONTROL, 0x40, card);
1357 send_command_12(card->codecnr, 0x0a, VERB_SET_PIN_WIDGET_CONTROL, 0x40, card);
1358 send_command_12(card->codecnr, 0x0d, VERB_SET_PIN_WIDGET_CONTROL, 0x40, card);
1359
1360 if (device == 0x7608)
1361 {
1362 /* move 0x7608 specific stuff here */
1363
1364 /* Not sure about indices */
1365 card->adc_mixer_indices[0] = 3; // line in
1366 card->adc_mixer_indices[1] = 2; // mic1
1367 card->adc_mixer_indices[2] = 4; // mic2
1368 card->adc_mixer_indices[3] = 1; // cd
1369 card->adc_mixer_indices[4] = 255; // no mon mixer
1370
1371 card->adc_min_gain = 0.0;
1372 card->adc_max_gain = 22.5;
1373 card->adc_step_gain = 1.5;
1374
1375 card->dac_min_gain = -95.25;
1376 card->dac_max_gain = 0.0;
1377 card->dac_step_gain = 0.75;
1378 }
1379
1380 return TRUE;
1381 }
1382
1383
1384 static BOOL perform_ad_specific_settings(struct HDAudioChip *card,
1385 UWORD device)
1386 {
1387 D(bug("[HDAudio] Found Analog Devices codec\n"));
1388
1389 // device specific support
1390 if (device == 0x1981) // AD1981HD
1391 {
1392 D(bug("[HDAudio] Adding AD1981HD specific support\n"));
1393 if (force_speaker_nid == 0)
1394 {
1395 force_speaker_nid = 0x7;
1396 }
1397 }
1398 else if (device == 0x1884) // AD1884
1399 {
1400 // Use the second DAC for all outputs, since the line-out port can't
1401 // use the first DAC!
1402 card->dac_nid = 0x4;
1403 send_command_12(card->codecnr, 0xe,
1404 VERB_SET_CONNECTION_SELECT, 1, card); // Mono
1405 send_command_12(card->codecnr, 0xf,
1406 VERB_SET_CONNECTION_SELECT, 1, card); // Port F
1407 send_command_12(card->codecnr, 0x22,
1408 VERB_SET_CONNECTION_SELECT, 1, card); // Port A
1409 send_command_12(card->codecnr, 0x23,
1410 VERB_SET_CONNECTION_SELECT, 1, card); // Port E
1411 }
1412
1413 return FALSE;
1414 }
1415
1416
1417 static void update_gpio(UBYTE mask, BOOL on, struct HDAudioChip *card)
1418 {
1419 ULONG gpio_data, gpio_enable, gpio_dir;
1420
1421 gpio_enable = send_command_12(card->codecnr, card->function_group,
1422 VERB_GET_GPIO_ENABLE, 0, card);
1423 gpio_enable |= mask;
1424 send_command_12(card->codecnr, card->function_group, VERB_SET_GPIO_ENABLE,
1425 gpio_enable, card);
1426
1427 gpio_dir = send_command_12(card->codecnr, card->function_group,
1428 VERB_GET_GPIO_DIR, 0, card);
1429 gpio_dir |= mask;
1430 send_command_12(card->codecnr, card->function_group, VERB_SET_GPIO_DIR,
1431 gpio_dir, card);
1432
1433 gpio_data = send_command_12(card->codecnr, card->function_group,
1434 VERB_GET_GPIO_DATA, 0, card);
1435 if (on)
1436 gpio_data |= mask;
1437 else
1438 gpio_data &= ~mask;
1439 send_command_12(card->codecnr, card->function_group, VERB_SET_GPIO_DATA,
1440 gpio_data, card);
1441 }
1442
1443
1444 static void set_gpio(UBYTE mask, struct HDAudioChip *card)
1445 {
1446 update_gpio(mask, TRUE, card);
1447 }
1448
1449
1450 static UBYTE get_connected_widget(UBYTE nid, UBYTE index,
1451 struct HDAudioChip *card)
1452 {
1453 UBYTE input_nid = 0;
1454 ULONG connections, entry;
1455
1456 connections = get_parameter(nid, 0xE, card);
1457 if (index < connections)
1458 {
1459 entry = send_command_12(card->codecnr, nid,
1460 VERB_GET_CONNECTION_LIST_ENTRY, index, card);
1461 input_nid = entry >> ((index % 4) * 8);
1462 }
1463
1464 return input_nid;
1465 }
1466
1467
1468 static UBYTE get_selected_widget(UBYTE nid, struct HDAudioChip *card)
1469 {
1470 UBYTE input_nid = 0;
1471 ULONG connections;
1472 ULONG index;
1473
1474 connections = get_parameter(nid, 0xE, card);
1475 if (connections > 0)
1476 {
1477 if (connections == 1)
1478 index = 0;
1479 else
1480 {
1481 index = send_command_12(card->codecnr, nid,
1482 VERB_GET_CONNECTION_SELECT, 0, card);
1483 }
1484
1485 input_nid = get_connected_widget(nid, index, card);
1486 }
1487
1488 return input_nid;
1489 }
1490
1491
1492 /* Adds a widget to the array of volume controlling widgets if it has volume
1493 * control */
1494 static void check_widget_volume(UBYTE nid, struct HDAudioChip *card)
1495 {
1496 ULONG parm;
1497
1498 parm = get_parameter(nid, VERB_GET_PARMS_AUDIO_WIDGET_CAPS, card);
1499 D(bug("[HDAudio] NID %xh: Audio widget caps = %lx\n", nid, parm));
1500 if (parm & 0x4) // OutAmpPre
1501 {
1502 D(bug("[HDAudio] NID %xh has volume control\n", nid));
1503 card->dac_volume_nids[card->dac_volume_count++] = nid;
1504 }
1505 else
1506 {
1507 D(bug("[HDAudio] NID %xh does not have volume control\n", nid));
1508 }
1509 }
1510
1511
1512 /* Unmute all of a widget's inputs and outputs */
1513 static void unmute_widget(UBYTE nid, struct HDAudioChip *card)
1514 {
1515 UWORD connections, i;
1516 ULONG gain;
1517
1518 D(bug("[HDAudio] Unmuting NID %xh\n", nid));
1519
1520 // Get number of inputs
1521 connections = get_parameter(nid, 0xE, card);
1522
1523 // Unmute inputs while retaining their gain levels
1524 for (i = 0; i < connections; i++)
1525 {
1526 gain = send_command_4(card->codecnr, nid, 0xB, i, card);
1527 send_command_4(card->codecnr, nid, VERB_SET_AMP_GAIN,
1528 INPUT_AMP_GAIN | AMP_GAIN_LR | i << 8 | gain & 0x7f, card);
1529 }
1530
1531 // Unmute output while retaining its gain level
1532 gain = send_command_4(card->codecnr, nid, 0xB, OUTPUT_AMP_GAIN, card);
1533 send_command_4(card->codecnr, nid, VERB_SET_AMP_GAIN,
1534 OUTPUT_AMP_GAIN | AMP_GAIN_LR | gain & 0x7f, card);
1535 }
1536
1537
1538 static BOOL interrogate_unknown_chip(struct HDAudioChip *card)
1539 {
1540 int dac, adc, front, steps = 0, offset0dB = 0;
1541 double step_size = 0.25;
1542 ULONG parm, widget_caps, nid;
1543 UWORD connections, i;
1544 UBYTE before_front = 0, first_subnode, subnode_limit;
1545
1546 D(bug("[HDAudio] Unknown codec, interrogating chip...\n"));
1547
1548 // Umute all widgets
1549 parm = get_parameter(card->function_group, VERB_GET_PARMS_NODE_COUNT, card);
1550 first_subnode = parm >> 16 & 0xFF;
1551 subnode_limit = first_subnode + (parm & 0xFF);
1552 for (i = first_subnode; i < subnode_limit; i++)
1553 {
1554 unmute_widget(i, card);
1555 }
1556
1557 if (card->dac_nid == 0)
1558 {
1559 // find out the first PCM DAC
1560 dac = find_widget(card, 0, 0);
1561
1562 if (dac == 0)
1563 {
1564 bug("Didn't find DAC!\n");
1565 return FALSE;
1566 }
1567
1568 card->dac_nid = dac;
1569 }
1570 D(bug("[HDAudio] DAC NID = %xh\n", card->dac_nid));
1571
1572 check_widget_volume(dac, card);
1573
1574 // find FRONT pin
1575 front = find_widget(card, 4, 0);
1576 D(bug("[HDAudio] Front PIN = %xh\n", front));
1577
1578 if (front == 0)
1579 {
1580 D(bug("[HDAudio] Didn't find jack/pin for line output!\n"));
1581 }
1582 else
1583 {
1584 send_command_12(card->codecnr, front, VERB_SET_PIN_WIDGET_CONTROL, 0x40, card); // output enabled
1585 send_command_12(card->codecnr, front, VERB_SET_CONNECTION_SELECT, 0, card); // use first input
1586 check_widget_volume(front, card);
1587 }
1588
1589 // find SPEAKER
1590 if (force_speaker_nid > 0)
1591 {
1592 D(bug("[HDAudio] Using speaker nid from config file\n"));
1593 card->speaker_nid = force_speaker_nid;
1594 }
1595 else
1596 {
1597 card->speaker_nid = find_widget(card, 4, 1);
1598 }
1599 D(bug("[HDAudio] Speaker NID = %xh\n", card->speaker_nid));
1600
1601 if (card->speaker_nid != 0)
1602 {
1603 // check if there is a power amp and if so, enable it
1604 if (get_parameter(card->speaker_nid, VERB_GET_PARMS_PIN_CAPS, card) & PIN_CAPS_EAPD_CAPABLE)
1605 {
1606 D(bug("[HDAudio] Enabling power amp of speaker\n"));
1607 send_command_12(card->codecnr, card->speaker_nid, VERB_SET_EAPD, 0x2, card); // enable EAPD (external power amp)
1608 }
1609
1610 D(bug("[HDAudio] Enabling speaker output\n"));
1611 send_command_12(card->codecnr, card->speaker_nid, VERB_SET_PIN_WIDGET_CONTROL, 0x40, card); // output enabled
1612 card->speaker_active = TRUE;
1613 send_command_12(card->codecnr, card->speaker_nid, VERB_SET_CONNECTION_SELECT, 0, card); // use first input
1614
1615 check_widget_volume(card->speaker_nid, card);
1616 }
1617 else
1618 {
1619 D(bug("[HDAudio] No speaker pin found, continuing anyway!\n"));
1620 }
1621
1622 // Find headphones socket
1623 card->headphone_nid = find_widget(card, 4, 2);
1624
1625 D(bug("[HDAudio] Headphone NID = %xh\n", card->headphone_nid));
1626
1627 if (card->headphone_nid != 0)
1628 {
1629 send_command_12(card->codecnr, card->headphone_nid, VERB_SET_PIN_WIDGET_CONTROL, 0xC0, card); // output enabled and headphone enabled
1630 send_command_12(card->codecnr, card->headphone_nid, VERB_SET_CONNECTION_SELECT, 0, card); // use first input
1631
1632 // check if there is a power amp and if so, enable it
1633 if (get_parameter(card->headphone_nid, VERB_GET_PARMS_PIN_CAPS, card) & PIN_CAPS_EAPD_CAPABLE)
1634 {
1635 D(bug("[HDAudio] Enabling power amp of headphone port\n"));
1636 send_command_12(card->codecnr, card->headphone_nid, VERB_SET_EAPD, 0x2, card); // enable EAPD (external power amp)
1637 }
1638
1639 check_widget_volume(card->headphone_nid, card);
1640 }
1641
1642 // find the node before the front, speaker or HP node
1643 if (front != 0)
1644 nid = front;
1645 else if (card->speaker_nid != 0)
1646 nid = card->speaker_nid;
1647 else if (card->headphone_nid != 0)
1648 nid = card->headphone_nid;
1649 else nid = 0;
1650
1651 if (nid != 0)
1652 before_front = (UBYTE)send_command_12(card->codecnr, nid,
1653 VERB_GET_CONNECTION_LIST_ENTRY, 0, card);
1654
1655 if (before_front != dac)
1656 {
1657 D(bug("[HDAudio] The widget before front/speaker/HP (%xh) is not equal to DAC!\n", before_front));
1658
1659 check_widget_volume(before_front, card);
1660 }
1661 else
1662 {
1663 D(bug("[HDAudio] The widget before front/speaker/HP is equal to DAC.\n"));
1664 }
1665
1666 for (i = 0; card->dac_volume_nids[i] != 0; i++)
1667 {
1668 parm = get_parameter(card->dac_volume_nids[i],
1669 VERB_GET_PARMS_AUDIO_WIDGET_CAPS, card);
1670 if ((parm & 0x8) != 0)
1671 parm = get_parameter(card->dac_volume_nids[i],
1672 VERB_GET_PARMS_OUTPUT_AMP_CAPS , card);
1673 else
1674 parm = get_parameter(card->function_group,
1675 VERB_GET_PARMS_OUTPUT_AMP_CAPS, card);
1676 D(bug("[HDAudio] NID %xh: Output amp caps = %lx\n", card->dac_volume_nids[i], parm));
1677
1678 step_size = (((parm >> 16) & 0x7F) + 1) * 0.25;
1679 steps = ((parm >> 8) & 0x7F);
1680 offset0dB = (parm & 0x7F);
1681
1682 if (steps != 0)
1683 {
1684 card->dac_min_gain = -(offset0dB * step_size);
1685 card->dac_max_gain = card->dac_min_gain + step_size * steps;
1686 card->dac_step_gain = step_size;
1687 D(bug("[HDAudio] Gain step size = %lu * 0.25 dB,"
1688 " min gain = %d, max gain = %d\n",
1689 (((parm >> 16) & 0x7F) + 1), (int) (card->dac_min_gain),
1690 (int) (card->dac_max_gain)));
1691 }
1692 }
1693
1694 // find out the first PCM ADC
1695 adc = find_widget(card, 1, 0);
1696 D(bug("[HDAudio] ADC NID = %xh\n", adc));
1697
1698 if (adc != 0)
1699 {
1700 card->adc_nid = adc;
1701
1702 card->line_in_nid = find_widget(card, 4, 8);
1703 D(bug("[HDAudio] Line-in NID = %xh\n", card->line_in_nid));
1704 card->mic1_nid = find_widget(card, 4, 0xA);
1705 D(bug("[HDAudio] Mic1 NID = %xh\n", card->mic1_nid));
1706
1707 // find ADC mixer by tracing a path from the ADC towards the ports
1708 nid = adc;
1709 while (nid != 0)
1710 {
1711 widget_caps = get_parameter(nid,
1712 VERB_GET_PARMS_AUDIO_WIDGET_CAPS, card);
1713 D(bug("[HDAudio] audio widget caps = %lx\n", widget_caps));
1714
1715 if (((widget_caps >> 20) & 0xF) == 0x3)
1716 {
1717 card->adc_mixer_nid = nid;
1718 D(bug("[HDAudio] ADC mixer NID = %xh\n", card->adc_mixer_nid));
1719 card->adc_mixer_is_mux = TRUE;
1720 }
1721
1722 nid = get_selected_widget(nid, card);
1723 }
1724
1725 if (card->line_in_nid != 0)
1726 {
1727 send_command_12(card->codecnr, card->line_in_nid,
1728 VERB_SET_PIN_WIDGET_CONTROL, 0x20, card); // input enabled
1729 }
1730 if (card->mic1_nid != 0)
1731 {
1732 send_command_12(card->codecnr, card->mic1_nid,
1733 VERB_SET_PIN_WIDGET_CONTROL, 0x20, card); // input enabled
1734 }
1735 }
1736 else
1737 bug("[HDAudio] Didn't find ADC!\n");
1738
1739 return TRUE;
1740 }
1741
1742
1743 static UBYTE find_widget(struct HDAudioChip *card, UBYTE type, UBYTE pin_type)
1744 {
1745 ULONG node_count_response = get_parameter(card->function_group,
1746 VERB_GET_PARMS_NODE_COUNT, card);
1747 UBYTE node_count = node_count_response & 0xFF;
1748 UBYTE starting_node = (node_count_response >> 16) & 0xFF;
1749 UBYTE i;
1750 ULONG config_default;
1751
1752 for (i = 0; i < node_count; i++) // widgets
1753 {
1754 UBYTE nid = i + starting_node;
1755 ULONG widget_caps, pin_caps, connections;
1756
1757 widget_caps = get_parameter(nid, VERB_GET_PARMS_AUDIO_WIDGET_CAPS,
1758 card);
1759
1760 if (((widget_caps >> 20) & 0xF) == type)
1761 {
1762 BOOL ok;
1763
1764 if (type == 4) // node is a pin widget
1765 {
1766 config_default = send_command_12(card->codecnr, nid,
1767 VERB_GET_CONFIG_DEFAULT, 0, card);
1768
1769 if (((config_default >> 20) & 0xF) == pin_type)
1770 {
1771 D(bug("[HDAudio] Config default for NID %x = %x\n", nid,
1772 config_default));
1773 if ((widget_caps & 1 << 8) != 0)
1774 connections = get_parameter(nid, 0xE, card) & 0x7f;
1775 else
1776 connections = 0;
1777 pin_caps =
1778 get_parameter(nid, VERB_GET_PARMS_PIN_CAPS, card);
1779 switch (pin_type)
1780 {
1781 case 0x0:
1782 case 0x1:
1783 case 0x2:
1784 case 0x4:
1785 case 0x5:
1786 ok = (pin_caps & PIN_CAPS_OUTPUT_CAPABLE) != 0
1787 && connections != 0;
1788 break;
1789 default:
1790 ok = (pin_caps & PIN_CAPS_INPUT_CAPABLE) != 0;
1791 }
1792
1793 // check speaker connection type is internal
1794 if (pin_type == 1 && (config_default >> 16 & 0xB) != 3)
1795 ok = FALSE;
1796
1797 // check headphone connection type is mini-jack
1798 if (pin_type == 2 && (config_default >> 16 & 0xF) != 1)
1799 ok = FALSE;
1800
1801 // check microphone connection type is mini-jack
1802 if (pin_type == 0xA && (config_default >> 16 & 0xF) != 1)
1803 ok = FALSE;
1804 }
1805 }
1806 else
1807 ok = (widget_caps & 0x1) == 1 && // stereo
1808 ((widget_caps >> 9) & 0x1) == 0; // analogue
1809
1810 if (ok)
1811 return nid;
1812 }
1813 }
1814
1815 return 0;
1816 }
1817
1818
1819 static void determine_frequencies(struct HDAudioChip *card)
1820 {
1821 ULONG verb = get_parameter(card->dac_nid, 0xA, card);
1822 UWORD samplerate_flags = verb & 0x0FFF;
1823 int i;
1824 ULONG freqs = 0;
1825 BOOL default_freq_found = FALSE;
1826
1827 if (samplerate_flags == 0)
1828 {
1829 verb = get_parameter(0x1, 0xA, card);
1830 samplerate_flags = verb & 0x0FFF;
1831 D(bug("[HDAudio] dac_nid didn't have a list of sample rates, trying AFG node\n"));
1832 }
1833
1834 // count number of frequencies
1835 for (i = 0; i < 12; i++)
1836 {
1837 if (samplerate_flags & (1 << i))
1838 {
1839 freqs++;
1840 }
1841 }
1842
1843 D(bug("[HDAudio] Frequencies found = %lu\n", freqs));
1844 card->frequencies = (struct Freq *) AllocVec(sizeof(struct Freq) * freqs, MEMF_PUBLIC | MEMF_CLEAR);
1845 card->nr_of_frequencies = freqs;
1846
1847 freqs = 0;
1848 for (i = 0; i < 12; i++)
1849 {
1850 if (samplerate_flags & (1 << i))
1851 {
1852 set_frequency_info(&(card->frequencies[freqs]), i);
1853
1854 if (card->frequencies[freqs].frequency == 44100 && !default_freq_found)
1855 {
1856 card->selected_freq_index = freqs; // set default freq index to 44100 Hz
1857 default_freq_found = TRUE;
1858 }
1859
1860 freqs++;
1861 }
1862 }
1863
1864 if (default_freq_found == FALSE)
1865 {
1866 D(bug("[HDAudio] 44100 Hz is not supported!\n"));
1867 if (freqs > 0)
1868 {
1869 D(bug("[HDAudio] Setting default frequency to %lu\n", card->frequencies[0].frequency));
1870 card->selected_freq_index = 0;
1871 }
1872 }
1873 }
1874
1875
1876
1877 static void set_frequency_info(struct Freq *freq, UWORD bitnr)
1878 {
1879 switch (bitnr)
1880 {
1881 case 0: freq->frequency = 8000;
1882 freq->base44100 = 0;
1883 freq->mult = 0;
1884 freq->div = 5;
1885 break;
1886
1887 case 1: freq->frequency = 11025;
1888 freq->base44100 = 1;
1889 freq->mult = 0;
1890 freq->div = 3;
1891 break;
1892
1893 case 2: freq->frequency = 16000;
1894 freq->base44100 = 0;
1895 freq->mult = 0;
1896 freq->div = 2;
1897 break;
1898
1899 case 3: freq->frequency = 22050;
1900 freq->base44100 = 1;
1901 freq->mult = 0;
1902 freq->div = 1;
1903 break;
1904
1905 case 4: freq->frequency = 32000;
1906 freq->base44100 = 0;
1907 freq->mult = 0;
1908 freq->div = 2;
1909 break;
1910
1911 case 5: freq->frequency = 44100;
1912 freq->base44100 = 1;
1913 freq->mult = 0;
1914 freq->div = 0;
1915 break;
1916
1917 case 6: freq->frequency = 48000;
1918 freq->base44100 = 0;
1919 freq->mult = 0;
1920 freq->div = 0;
1921 break;
1922
1923 case 7: freq->frequency = 88200;
1924 freq->base44100 = 1;
1925 freq->mult = 1;
1926 freq->div = 0;
1927 break;
1928
1929 case 8: freq->frequency = 96000;
1930 freq->base44100 = 0;
1931 freq->mult = 1;
1932 freq->div = 0;
1933 break;
1934
1935 case 9: freq->frequency = 176400;
1936 freq->base44100 = 1;
1937 freq->mult = 3;
1938 freq->div = 0;
1939 break;
1940
1941 case 10: freq->frequency = 192000;
1942 freq->base44100 = 0;
1943 freq->mult = 3;
1944 freq->div = 0;
1945 break;
1946
1947 default:
1948 D(bug("[HDAudio] Unsupported frequency!\n"));
1949 break;
1950 }
1951 }
1952
1953
1954 void set_monitor_volumes(struct HDAudioChip *card, double dB)
1955 {
1956 #if 0
1957 int i;
1958 #endif
1959 int dB_steps = (int) ((dB + 34.5) / 1.5);
1960
1961 if (dB_steps < 0)
1962 {
1963 dB_steps = 0;
1964 }
1965 else if (dB_steps > 31)
1966 {
1967 dB_steps = 31;
1968 }
1969
1970 #if 0
1971 for (i = 0; i < 9; i++)
1972 {
1973 if (i == 0 || i == 1 || i == 2 || i == 4)
1974 {
1975 send_command_4(card->codecnr, 0xB, VERB_SET_AMP_GAIN, INPUT_AMP_GAIN | AMP_GAIN_LR | (i << 8) | dB_steps, card);
1976 }
1977 else // mute
1978 {
1979 send_command_4(card->codecnr, 0xB, VERB_SET_AMP_GAIN, INPUT_AMP_GAIN | AMP_GAIN_LR | (i << 8) | (1 << 7), card);
1980 }
1981 }
1982 #endif
1983 }
1984
1985
1986 void set_adc_input(struct HDAudioChip *card)
1987 {
1988 int i;
1989
1990 if (card->input >= INPUTS)
1991 {
1992 card->input = 0;
1993 }
1994
1995 if (card->adc_mixer_is_mux == TRUE)
1996 {
1997 D(bug("[HDAudio] Selecting ADC input %d\n", card->adc_mixer_indices[card->input]));
1998 send_command_12(card->codecnr, card->adc_mixer_nid, VERB_SET_CONNECTION_SELECT,
1999 card->adc_mixer_indices[card->input], card);
2000 return;
2001 }
2002 else
2003 {
2004 for (i = 0; i < INPUTS; i++)
2005 {
2006 if (card->adc_mixer_indices[i] != 255) // input is present
2007 {
2008 if (i == card->input) // unmute or select
2009 {
2010 D(bug("[HDAudio] Unmuting ADC input %d\n", card->adc_mixer_indices[i]));
2011 send_command_4(card->codecnr, card->adc_mixer_nid, VERB_SET_AMP_GAIN,
2012 INPUT_AMP_GAIN | AMP_GAIN_LR | (card->adc_mixer_indices[i] << 8), card);
2013 }
2014 else // mute
2015 {
2016 D(bug("[HDAudio] Muting ADC input %d\n", card->adc_mixer_indices[i]));
2017 send_command_4(card->codecnr, card->adc_mixer_nid, VERB_SET_AMP_GAIN,
2018 INPUT_AMP_GAIN | AMP_GAIN_LR | (card->adc_mixer_indices[i] << 8) | (1 << 7), card);
2019
2020 }
2021 }
2022 }
2023 }
2024 }
2025
2026
2027 void set_adc_gain(struct HDAudioChip *card, double dB)
2028 {
2029 int dB_steps = (int) ( (dB - card->adc_min_gain) / card->adc_step_gain);
2030
2031 if (dB_steps < 0)
2032 {
2033 dB_steps = 0;
2034 }
2035
2036 if (card->adc_mixer_is_mux == TRUE)
2037 {
2038 send_command_4(card->codecnr, card->adc_mixer_nid, VERB_SET_AMP_GAIN, OUTPUT_AMP_GAIN | AMP_GAIN_LR | dB_steps, card);
2039 }
2040 else
2041 {
2042 send_command_4(card->codecnr, card->adc_nid, VERB_SET_AMP_GAIN, INPUT_AMP_GAIN | AMP_GAIN_LR | dB_steps, card);
2043 }
2044 }
2045
2046
2047 void set_dac_gain(struct HDAudioChip *card, double dB)
2048 {
2049 int i;
2050 int dB_steps = (int) ( (dB - card->dac_min_gain) / card->dac_step_gain);
2051
2052 if (dB_steps < 0)
2053 {
2054 dB_steps = 0;
2055 }
2056
2057 for (i = 0; i < card->dac_volume_count; i++)
2058 send_command_4(card->codecnr, card->dac_volume_nids[i],
2059 VERB_SET_AMP_GAIN, OUTPUT_AMP_GAIN | AMP_GAIN_LR | dB_steps, card);
2060 }
2061
2062
2063 void setForceQuery(void)
2064 {
2065 forceQuery = TRUE;
2066 }
2067
2068
2069 void setDumpAll(void)
2070 {
2071 dumpAll = TRUE;
2072 }
2073
2074
2075 void setForceSpeaker(int speaker_nid)
2076 {
2077 force_speaker_nid = speaker_nid;
2078 }
2079
2080
2081
2082 BOOL is_jack_connected(struct HDAudioChip *card, UBYTE NID)
2083 {
2084 ULONG result;
2085
2086 send_command_12(card->codecnr, NID, VERB_EXECUTE_PIN_SENSE, 0, card);
2087 udelay(2000);
2088 result = send_command_12(card->codecnr, NID, VERB_GET_PIN_SENSE, 0, card);
2089
2090 if (result & 0x80000000)
2091 {
2092 D(bug("[HDAudio] jack connected\n"));
2093 return TRUE;
2094 }
2095 else
2096 {
2097 D(bug("[HDAudio] jack disconnected\n"));
2098 return FALSE;
2099 }
2100 }
2101
2102
2103
2104 void detect_headphone_change(struct HDAudioChip *card)
2105 {
2106 if (card->speaker_nid != 0 &&
2107 card->headphone_nid != 0)
2108 {
2109 if (card->speaker_active &&
2110 is_jack_connected(card, card->headphone_nid)) // disable speaker
2111 {
2112 D(bug("[HDAudio] disabling speaker\n"));
2113 send_command_12(card->codecnr, card->speaker_nid, VERB_SET_PIN_WIDGET_CONTROL, 0x0, card); // output disabled
2114 card->speaker_active = FALSE;
2115 }
2116 else if (card->speaker_active == FALSE &&
2117 is_jack_connected(card, card->headphone_nid) == FALSE) // enable speaker
2118 {
2119 D(bug("[HDAudio] enabling speaker\n"));
2120 send_command_12(card->codecnr, card->speaker_nid, VERB_SET_PIN_WIDGET_CONTROL, 0x40, card); // output enabled
2121 card->speaker_active = TRUE;
2122 }
2123 }
2124 }
2125
Mirror of AROS' svn.