xref: /openbmc/linux/sound/aoa/fabrics/layout.c (revision b6dcefde)
1 /*
2  * Apple Onboard Audio driver -- layout/machine id fabric
3  *
4  * Copyright 2006-2008 Johannes Berg <johannes@sipsolutions.net>
5  *
6  * GPL v2, can be found in COPYING.
7  *
8  *
9  * This fabric module looks for sound codecs based on the
10  * layout-id or device-id property in the device tree.
11  */
12 #include <asm/prom.h>
13 #include <linux/list.h>
14 #include <linux/module.h>
15 #include "../aoa.h"
16 #include "../soundbus/soundbus.h"
17 
18 MODULE_AUTHOR("Johannes Berg <johannes@sipsolutions.net>");
19 MODULE_LICENSE("GPL");
20 MODULE_DESCRIPTION("Layout-ID fabric for snd-aoa");
21 
22 #define MAX_CODECS_PER_BUS	2
23 
24 /* These are the connections the layout fabric
25  * knows about. It doesn't really care about the
26  * input ones, but I thought I'd separate them
27  * to give them proper names. The thing is that
28  * Apple usually will distinguish the active output
29  * by GPIOs, while the active input is set directly
30  * on the codec. Hence we here tell the codec what
31  * we think is connected. This information is hard-
32  * coded below ... */
33 #define CC_SPEAKERS	(1<<0)
34 #define CC_HEADPHONE	(1<<1)
35 #define CC_LINEOUT	(1<<2)
36 #define CC_DIGITALOUT	(1<<3)
37 #define CC_LINEIN	(1<<4)
38 #define CC_MICROPHONE	(1<<5)
39 #define CC_DIGITALIN	(1<<6)
40 /* pretty bogus but users complain...
41  * This is a flag saying that the LINEOUT
42  * should be renamed to HEADPHONE.
43  * be careful with input detection! */
44 #define CC_LINEOUT_LABELLED_HEADPHONE	(1<<7)
45 
46 struct codec_connection {
47 	/* CC_ flags from above */
48 	int connected;
49 	/* codec dependent bit to be set in the aoa_codec.connected field.
50 	 * This intentionally doesn't have any generic flags because the
51 	 * fabric has to know the codec anyway and all codecs might have
52 	 * different connectors */
53 	int codec_bit;
54 };
55 
56 struct codec_connect_info {
57 	char *name;
58 	struct codec_connection *connections;
59 };
60 
61 #define LAYOUT_FLAG_COMBO_LINEOUT_SPDIF	(1<<0)
62 
63 struct layout {
64 	unsigned int layout_id, device_id;
65 	struct codec_connect_info codecs[MAX_CODECS_PER_BUS];
66 	int flags;
67 
68 	/* if busname is not assigned, we use 'Master' below,
69 	 * so that our layout table doesn't need to be filled
70 	 * too much.
71 	 * We only assign these two if we expect to find more
72 	 * than one soundbus, i.e. on those machines with
73 	 * multiple layout-ids */
74 	char *busname;
75 	int pcmid;
76 };
77 
78 MODULE_ALIAS("sound-layout-36");
79 MODULE_ALIAS("sound-layout-41");
80 MODULE_ALIAS("sound-layout-45");
81 MODULE_ALIAS("sound-layout-47");
82 MODULE_ALIAS("sound-layout-48");
83 MODULE_ALIAS("sound-layout-49");
84 MODULE_ALIAS("sound-layout-50");
85 MODULE_ALIAS("sound-layout-51");
86 MODULE_ALIAS("sound-layout-56");
87 MODULE_ALIAS("sound-layout-57");
88 MODULE_ALIAS("sound-layout-58");
89 MODULE_ALIAS("sound-layout-60");
90 MODULE_ALIAS("sound-layout-61");
91 MODULE_ALIAS("sound-layout-62");
92 MODULE_ALIAS("sound-layout-64");
93 MODULE_ALIAS("sound-layout-65");
94 MODULE_ALIAS("sound-layout-66");
95 MODULE_ALIAS("sound-layout-67");
96 MODULE_ALIAS("sound-layout-68");
97 MODULE_ALIAS("sound-layout-69");
98 MODULE_ALIAS("sound-layout-70");
99 MODULE_ALIAS("sound-layout-72");
100 MODULE_ALIAS("sound-layout-76");
101 MODULE_ALIAS("sound-layout-80");
102 MODULE_ALIAS("sound-layout-82");
103 MODULE_ALIAS("sound-layout-84");
104 MODULE_ALIAS("sound-layout-86");
105 MODULE_ALIAS("sound-layout-90");
106 MODULE_ALIAS("sound-layout-92");
107 MODULE_ALIAS("sound-layout-94");
108 MODULE_ALIAS("sound-layout-96");
109 MODULE_ALIAS("sound-layout-98");
110 MODULE_ALIAS("sound-layout-100");
111 
112 MODULE_ALIAS("aoa-device-id-14");
113 MODULE_ALIAS("aoa-device-id-22");
114 MODULE_ALIAS("aoa-device-id-35");
115 
116 /* onyx with all but microphone connected */
117 static struct codec_connection onyx_connections_nomic[] = {
118 	{
119 		.connected = CC_SPEAKERS | CC_HEADPHONE | CC_LINEOUT,
120 		.codec_bit = 0,
121 	},
122 	{
123 		.connected = CC_DIGITALOUT,
124 		.codec_bit = 1,
125 	},
126 	{
127 		.connected = CC_LINEIN,
128 		.codec_bit = 2,
129 	},
130 	{} /* terminate array by .connected == 0 */
131 };
132 
133 /* onyx on machines without headphone */
134 static struct codec_connection onyx_connections_noheadphones[] = {
135 	{
136 		.connected = CC_SPEAKERS | CC_LINEOUT |
137 			     CC_LINEOUT_LABELLED_HEADPHONE,
138 		.codec_bit = 0,
139 	},
140 	{
141 		.connected = CC_DIGITALOUT,
142 		.codec_bit = 1,
143 	},
144 	/* FIXME: are these correct? probably not for all the machines
145 	 * below ... If not this will need separating. */
146 	{
147 		.connected = CC_LINEIN,
148 		.codec_bit = 2,
149 	},
150 	{
151 		.connected = CC_MICROPHONE,
152 		.codec_bit = 3,
153 	},
154 	{} /* terminate array by .connected == 0 */
155 };
156 
157 /* onyx on machines with real line-out */
158 static struct codec_connection onyx_connections_reallineout[] = {
159 	{
160 		.connected = CC_SPEAKERS | CC_LINEOUT | CC_HEADPHONE,
161 		.codec_bit = 0,
162 	},
163 	{
164 		.connected = CC_DIGITALOUT,
165 		.codec_bit = 1,
166 	},
167 	{
168 		.connected = CC_LINEIN,
169 		.codec_bit = 2,
170 	},
171 	{} /* terminate array by .connected == 0 */
172 };
173 
174 /* tas on machines without line out */
175 static struct codec_connection tas_connections_nolineout[] = {
176 	{
177 		.connected = CC_SPEAKERS | CC_HEADPHONE,
178 		.codec_bit = 0,
179 	},
180 	{
181 		.connected = CC_LINEIN,
182 		.codec_bit = 2,
183 	},
184 	{
185 		.connected = CC_MICROPHONE,
186 		.codec_bit = 3,
187 	},
188 	{} /* terminate array by .connected == 0 */
189 };
190 
191 /* tas on machines with neither line out nor line in */
192 static struct codec_connection tas_connections_noline[] = {
193 	{
194 		.connected = CC_SPEAKERS | CC_HEADPHONE,
195 		.codec_bit = 0,
196 	},
197 	{
198 		.connected = CC_MICROPHONE,
199 		.codec_bit = 3,
200 	},
201 	{} /* terminate array by .connected == 0 */
202 };
203 
204 /* tas on machines without microphone */
205 static struct codec_connection tas_connections_nomic[] = {
206 	{
207 		.connected = CC_SPEAKERS | CC_HEADPHONE | CC_LINEOUT,
208 		.codec_bit = 0,
209 	},
210 	{
211 		.connected = CC_LINEIN,
212 		.codec_bit = 2,
213 	},
214 	{} /* terminate array by .connected == 0 */
215 };
216 
217 /* tas on machines with everything connected */
218 static struct codec_connection tas_connections_all[] = {
219 	{
220 		.connected = CC_SPEAKERS | CC_HEADPHONE | CC_LINEOUT,
221 		.codec_bit = 0,
222 	},
223 	{
224 		.connected = CC_LINEIN,
225 		.codec_bit = 2,
226 	},
227 	{
228 		.connected = CC_MICROPHONE,
229 		.codec_bit = 3,
230 	},
231 	{} /* terminate array by .connected == 0 */
232 };
233 
234 static struct codec_connection toonie_connections[] = {
235 	{
236 		.connected = CC_SPEAKERS | CC_HEADPHONE,
237 		.codec_bit = 0,
238 	},
239 	{} /* terminate array by .connected == 0 */
240 };
241 
242 static struct codec_connection topaz_input[] = {
243 	{
244 		.connected = CC_DIGITALIN,
245 		.codec_bit = 0,
246 	},
247 	{} /* terminate array by .connected == 0 */
248 };
249 
250 static struct codec_connection topaz_output[] = {
251 	{
252 		.connected = CC_DIGITALOUT,
253 		.codec_bit = 1,
254 	},
255 	{} /* terminate array by .connected == 0 */
256 };
257 
258 static struct codec_connection topaz_inout[] = {
259 	{
260 		.connected = CC_DIGITALIN,
261 		.codec_bit = 0,
262 	},
263 	{
264 		.connected = CC_DIGITALOUT,
265 		.codec_bit = 1,
266 	},
267 	{} /* terminate array by .connected == 0 */
268 };
269 
270 static struct layout layouts[] = {
271 	/* last PowerBooks (15" Oct 2005) */
272 	{ .layout_id = 82,
273 	  .flags = LAYOUT_FLAG_COMBO_LINEOUT_SPDIF,
274 	  .codecs[0] = {
275 		.name = "onyx",
276 		.connections = onyx_connections_noheadphones,
277 	  },
278 	  .codecs[1] = {
279 		.name = "topaz",
280 		.connections = topaz_input,
281 	  },
282 	},
283 	/* PowerMac9,1 */
284 	{ .layout_id = 60,
285 	  .codecs[0] = {
286 		.name = "onyx",
287 		.connections = onyx_connections_reallineout,
288 	  },
289 	},
290 	/* PowerMac9,1 */
291 	{ .layout_id = 61,
292 	  .codecs[0] = {
293 		.name = "topaz",
294 		.connections = topaz_input,
295 	  },
296 	},
297 	/* PowerBook5,7 */
298 	{ .layout_id = 64,
299 	  .flags = LAYOUT_FLAG_COMBO_LINEOUT_SPDIF,
300 	  .codecs[0] = {
301 		.name = "onyx",
302 		.connections = onyx_connections_noheadphones,
303 	  },
304 	},
305 	/* PowerBook5,7 */
306 	{ .layout_id = 65,
307 	  .codecs[0] = {
308 		.name = "topaz",
309 		.connections = topaz_input,
310 	  },
311 	},
312 	/* PowerBook5,9 [17" Oct 2005] */
313 	{ .layout_id = 84,
314 	  .flags = LAYOUT_FLAG_COMBO_LINEOUT_SPDIF,
315 	  .codecs[0] = {
316 		.name = "onyx",
317 		.connections = onyx_connections_noheadphones,
318 	  },
319 	  .codecs[1] = {
320 		.name = "topaz",
321 		.connections = topaz_input,
322 	  },
323 	},
324 	/* PowerMac8,1 */
325 	{ .layout_id = 45,
326 	  .codecs[0] = {
327 		.name = "onyx",
328 		.connections = onyx_connections_noheadphones,
329 	  },
330 	  .codecs[1] = {
331 		.name = "topaz",
332 		.connections = topaz_input,
333 	  },
334 	},
335 	/* Quad PowerMac (analog in, analog/digital out) */
336 	{ .layout_id = 68,
337 	  .codecs[0] = {
338 		.name = "onyx",
339 		.connections = onyx_connections_nomic,
340 	  },
341 	},
342 	/* Quad PowerMac (digital in) */
343 	{ .layout_id = 69,
344 	  .codecs[0] = {
345 		.name = "topaz",
346 		.connections = topaz_input,
347 	  },
348 	  .busname = "digital in", .pcmid = 1 },
349 	/* Early 2005 PowerBook (PowerBook 5,6) */
350 	{ .layout_id = 70,
351 	  .codecs[0] = {
352 		.name = "tas",
353 		.connections = tas_connections_nolineout,
354 	  },
355 	},
356 	/* PowerBook 5,4 */
357 	{ .layout_id = 51,
358 	  .codecs[0] = {
359 		.name = "tas",
360 		.connections = tas_connections_nolineout,
361 	  },
362 	},
363 	/* PowerBook6,7 */
364 	{ .layout_id = 80,
365 	  .codecs[0] = {
366 		.name = "tas",
367 		.connections = tas_connections_noline,
368 	  },
369 	},
370 	/* PowerBook6,8 */
371 	{ .layout_id = 72,
372 	  .codecs[0] = {
373 		.name = "tas",
374 		.connections = tas_connections_nolineout,
375 	  },
376 	},
377 	/* PowerMac8,2 */
378 	{ .layout_id = 86,
379 	  .codecs[0] = {
380 		.name = "onyx",
381 		.connections = onyx_connections_nomic,
382 	  },
383 	  .codecs[1] = {
384 		.name = "topaz",
385 		.connections = topaz_input,
386 	  },
387 	},
388 	/* PowerBook6,7 */
389 	{ .layout_id = 92,
390 	  .codecs[0] = {
391 		.name = "tas",
392 		.connections = tas_connections_nolineout,
393 	  },
394 	},
395 	/* PowerMac10,1 (Mac Mini) */
396 	{ .layout_id = 58,
397 	  .codecs[0] = {
398 		.name = "toonie",
399 		.connections = toonie_connections,
400 	  },
401 	},
402 	{
403 	  .layout_id = 96,
404 	  .codecs[0] = {
405 	  	.name = "onyx",
406 	  	.connections = onyx_connections_noheadphones,
407 	  },
408 	},
409 	/* unknown, untested, but this comes from Apple */
410 	{ .layout_id = 41,
411 	  .codecs[0] = {
412 		.name = "tas",
413 		.connections = tas_connections_all,
414 	  },
415 	},
416 	{ .layout_id = 36,
417 	  .codecs[0] = {
418 		.name = "tas",
419 		.connections = tas_connections_nomic,
420 	  },
421 	  .codecs[1] = {
422 		.name = "topaz",
423 		.connections = topaz_inout,
424 	  },
425 	},
426 	{ .layout_id = 47,
427 	  .codecs[0] = {
428 		.name = "onyx",
429 		.connections = onyx_connections_noheadphones,
430 	  },
431 	},
432 	{ .layout_id = 48,
433 	  .codecs[0] = {
434 		.name = "topaz",
435 		.connections = topaz_input,
436 	  },
437 	},
438 	{ .layout_id = 49,
439 	  .codecs[0] = {
440 		.name = "onyx",
441 		.connections = onyx_connections_nomic,
442 	  },
443 	},
444 	{ .layout_id = 50,
445 	  .codecs[0] = {
446 		.name = "topaz",
447 		.connections = topaz_input,
448 	  },
449 	},
450 	{ .layout_id = 56,
451 	  .codecs[0] = {
452 		.name = "onyx",
453 		.connections = onyx_connections_noheadphones,
454 	  },
455 	},
456 	{ .layout_id = 57,
457 	  .codecs[0] = {
458 		.name = "topaz",
459 		.connections = topaz_input,
460 	  },
461 	},
462 	{ .layout_id = 62,
463 	  .codecs[0] = {
464 		.name = "onyx",
465 		.connections = onyx_connections_noheadphones,
466 	  },
467 	  .codecs[1] = {
468 		.name = "topaz",
469 		.connections = topaz_output,
470 	  },
471 	},
472 	{ .layout_id = 66,
473 	  .codecs[0] = {
474 		.name = "onyx",
475 		.connections = onyx_connections_noheadphones,
476 	  },
477 	},
478 	{ .layout_id = 67,
479 	  .codecs[0] = {
480 		.name = "topaz",
481 		.connections = topaz_input,
482 	  },
483 	},
484 	{ .layout_id = 76,
485 	  .codecs[0] = {
486 		.name = "tas",
487 		.connections = tas_connections_nomic,
488 	  },
489 	  .codecs[1] = {
490 		.name = "topaz",
491 		.connections = topaz_inout,
492 	  },
493 	},
494 	{ .layout_id = 90,
495 	  .codecs[0] = {
496 		.name = "tas",
497 		.connections = tas_connections_noline,
498 	  },
499 	},
500 	{ .layout_id = 94,
501 	  .codecs[0] = {
502 		.name = "onyx",
503 		/* but it has an external mic?? how to select? */
504 		.connections = onyx_connections_noheadphones,
505 	  },
506 	},
507 	{ .layout_id = 98,
508 	  .codecs[0] = {
509 		.name = "toonie",
510 		.connections = toonie_connections,
511 	  },
512 	},
513 	{ .layout_id = 100,
514 	  .codecs[0] = {
515 		.name = "topaz",
516 		.connections = topaz_input,
517 	  },
518 	  .codecs[1] = {
519 		.name = "onyx",
520 		.connections = onyx_connections_noheadphones,
521 	  },
522 	},
523 	/* PowerMac3,4 */
524 	{ .device_id = 14,
525 	  .codecs[0] = {
526 		.name = "tas",
527 		.connections = tas_connections_noline,
528 	  },
529 	},
530 	/* PowerMac3,6 */
531 	{ .device_id = 22,
532 	  .codecs[0] = {
533 		.name = "tas",
534 		.connections = tas_connections_all,
535 	  },
536 	},
537 	/* PowerBook5,2 */
538 	{ .device_id = 35,
539 	  .codecs[0] = {
540 		.name = "tas",
541 		.connections = tas_connections_all,
542 	  },
543 	},
544 	{}
545 };
546 
547 static struct layout *find_layout_by_id(unsigned int id)
548 {
549 	struct layout *l;
550 
551 	l = layouts;
552 	while (l->codecs[0].name) {
553 		if (l->layout_id == id)
554 			return l;
555 		l++;
556 	}
557 	return NULL;
558 }
559 
560 static struct layout *find_layout_by_device(unsigned int id)
561 {
562 	struct layout *l;
563 
564 	l = layouts;
565 	while (l->codecs[0].name) {
566 		if (l->device_id == id)
567 			return l;
568 		l++;
569 	}
570 	return NULL;
571 }
572 
573 static void use_layout(struct layout *l)
574 {
575 	int i;
576 
577 	for (i=0; i<MAX_CODECS_PER_BUS; i++) {
578 		if (l->codecs[i].name) {
579 			request_module("snd-aoa-codec-%s", l->codecs[i].name);
580 		}
581 	}
582 	/* now we wait for the codecs to call us back */
583 }
584 
585 struct layout_dev;
586 
587 struct layout_dev_ptr {
588 	struct layout_dev *ptr;
589 };
590 
591 struct layout_dev {
592 	struct list_head list;
593 	struct soundbus_dev *sdev;
594 	struct device_node *sound;
595 	struct aoa_codec *codecs[MAX_CODECS_PER_BUS];
596 	struct layout *layout;
597 	struct gpio_runtime gpio;
598 
599 	/* we need these for headphone/lineout detection */
600 	struct snd_kcontrol *headphone_ctrl;
601 	struct snd_kcontrol *lineout_ctrl;
602 	struct snd_kcontrol *speaker_ctrl;
603 	struct snd_kcontrol *master_ctrl;
604 	struct snd_kcontrol *headphone_detected_ctrl;
605 	struct snd_kcontrol *lineout_detected_ctrl;
606 
607 	struct layout_dev_ptr selfptr_headphone;
608 	struct layout_dev_ptr selfptr_lineout;
609 
610 	u32 have_lineout_detect:1,
611 	    have_headphone_detect:1,
612 	    switch_on_headphone:1,
613 	    switch_on_lineout:1;
614 };
615 
616 static LIST_HEAD(layouts_list);
617 static int layouts_list_items;
618 /* this can go away but only if we allow multiple cards,
619  * make the fabric handle all the card stuff, etc... */
620 static struct layout_dev *layout_device;
621 
622 #define control_info	snd_ctl_boolean_mono_info
623 
624 #define AMP_CONTROL(n, description)					\
625 static int n##_control_get(struct snd_kcontrol *kcontrol,		\
626 			   struct snd_ctl_elem_value *ucontrol)		\
627 {									\
628 	struct gpio_runtime *gpio = snd_kcontrol_chip(kcontrol);	\
629 	if (gpio->methods && gpio->methods->get_##n)			\
630 		ucontrol->value.integer.value[0] =			\
631 			gpio->methods->get_##n(gpio);			\
632 	return 0;							\
633 }									\
634 static int n##_control_put(struct snd_kcontrol *kcontrol,		\
635 			   struct snd_ctl_elem_value *ucontrol)		\
636 {									\
637 	struct gpio_runtime *gpio = snd_kcontrol_chip(kcontrol);	\
638 	if (gpio->methods && gpio->methods->get_##n)			\
639 		gpio->methods->set_##n(gpio,				\
640 			!!ucontrol->value.integer.value[0]);		\
641 	return 1;							\
642 }									\
643 static struct snd_kcontrol_new n##_ctl = {				\
644 	.iface = SNDRV_CTL_ELEM_IFACE_MIXER,				\
645 	.name = description,						\
646 	.access = SNDRV_CTL_ELEM_ACCESS_READWRITE,                      \
647 	.info = control_info,						\
648 	.get = n##_control_get,						\
649 	.put = n##_control_put,						\
650 }
651 
652 AMP_CONTROL(headphone, "Headphone Switch");
653 AMP_CONTROL(speakers, "Speakers Switch");
654 AMP_CONTROL(lineout, "Line-Out Switch");
655 AMP_CONTROL(master, "Master Switch");
656 
657 static int detect_choice_get(struct snd_kcontrol *kcontrol,
658 			     struct snd_ctl_elem_value *ucontrol)
659 {
660 	struct layout_dev *ldev = snd_kcontrol_chip(kcontrol);
661 
662 	switch (kcontrol->private_value) {
663 	case 0:
664 		ucontrol->value.integer.value[0] = ldev->switch_on_headphone;
665 		break;
666 	case 1:
667 		ucontrol->value.integer.value[0] = ldev->switch_on_lineout;
668 		break;
669 	default:
670 		return -ENODEV;
671 	}
672 	return 0;
673 }
674 
675 static int detect_choice_put(struct snd_kcontrol *kcontrol,
676 			     struct snd_ctl_elem_value *ucontrol)
677 {
678 	struct layout_dev *ldev = snd_kcontrol_chip(kcontrol);
679 
680 	switch (kcontrol->private_value) {
681 	case 0:
682 		ldev->switch_on_headphone = !!ucontrol->value.integer.value[0];
683 		break;
684 	case 1:
685 		ldev->switch_on_lineout = !!ucontrol->value.integer.value[0];
686 		break;
687 	default:
688 		return -ENODEV;
689 	}
690 	return 1;
691 }
692 
693 static struct snd_kcontrol_new headphone_detect_choice = {
694 	.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
695 	.name = "Headphone Detect Autoswitch",
696 	.info = control_info,
697 	.access = SNDRV_CTL_ELEM_ACCESS_READWRITE,
698 	.get = detect_choice_get,
699 	.put = detect_choice_put,
700 	.private_value = 0,
701 };
702 
703 static struct snd_kcontrol_new lineout_detect_choice = {
704 	.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
705 	.name = "Line-Out Detect Autoswitch",
706 	.info = control_info,
707 	.access = SNDRV_CTL_ELEM_ACCESS_READWRITE,
708 	.get = detect_choice_get,
709 	.put = detect_choice_put,
710 	.private_value = 1,
711 };
712 
713 static int detected_get(struct snd_kcontrol *kcontrol,
714 			struct snd_ctl_elem_value *ucontrol)
715 {
716 	struct layout_dev *ldev = snd_kcontrol_chip(kcontrol);
717 	int v;
718 
719 	switch (kcontrol->private_value) {
720 	case 0:
721 		v = ldev->gpio.methods->get_detect(&ldev->gpio,
722 						   AOA_NOTIFY_HEADPHONE);
723 		break;
724 	case 1:
725 		v = ldev->gpio.methods->get_detect(&ldev->gpio,
726 						   AOA_NOTIFY_LINE_OUT);
727 		break;
728 	default:
729 		return -ENODEV;
730 	}
731 	ucontrol->value.integer.value[0] = v;
732 	return 0;
733 }
734 
735 static struct snd_kcontrol_new headphone_detected = {
736 	.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
737 	.name = "Headphone Detected",
738 	.info = control_info,
739 	.access = SNDRV_CTL_ELEM_ACCESS_READ,
740 	.get = detected_get,
741 	.private_value = 0,
742 };
743 
744 static struct snd_kcontrol_new lineout_detected = {
745 	.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
746 	.name = "Line-Out Detected",
747 	.info = control_info,
748 	.access = SNDRV_CTL_ELEM_ACCESS_READ,
749 	.get = detected_get,
750 	.private_value = 1,
751 };
752 
753 static int check_codec(struct aoa_codec *codec,
754 		       struct layout_dev *ldev,
755 		       struct codec_connect_info *cci)
756 {
757 	const u32 *ref;
758 	char propname[32];
759 	struct codec_connection *cc;
760 
761 	/* if the codec has a 'codec' node, we require a reference */
762 	if (codec->node && (strcmp(codec->node->name, "codec") == 0)) {
763 		snprintf(propname, sizeof(propname),
764 			 "platform-%s-codec-ref", codec->name);
765 		ref = of_get_property(ldev->sound, propname, NULL);
766 		if (!ref) {
767 			printk(KERN_INFO "snd-aoa-fabric-layout: "
768 				"required property %s not present\n", propname);
769 			return -ENODEV;
770 		}
771 		if (*ref != codec->node->linux_phandle) {
772 			printk(KERN_INFO "snd-aoa-fabric-layout: "
773 				"%s doesn't match!\n", propname);
774 			return -ENODEV;
775 		}
776 	} else {
777 		if (layouts_list_items != 1) {
778 			printk(KERN_INFO "snd-aoa-fabric-layout: "
779 				"more than one soundbus, but no references.\n");
780 			return -ENODEV;
781 		}
782 	}
783 	codec->soundbus_dev = ldev->sdev;
784 	codec->gpio = &ldev->gpio;
785 
786 	cc = cci->connections;
787 	if (!cc)
788 		return -EINVAL;
789 
790 	printk(KERN_INFO "snd-aoa-fabric-layout: can use this codec\n");
791 
792 	codec->connected = 0;
793 	codec->fabric_data = cc;
794 
795 	while (cc->connected) {
796 		codec->connected |= 1<<cc->codec_bit;
797 		cc++;
798 	}
799 
800 	return 0;
801 }
802 
803 static int layout_found_codec(struct aoa_codec *codec)
804 {
805 	struct layout_dev *ldev;
806 	int i;
807 
808 	list_for_each_entry(ldev, &layouts_list, list) {
809 		for (i=0; i<MAX_CODECS_PER_BUS; i++) {
810 			if (!ldev->layout->codecs[i].name)
811 				continue;
812 			if (strcmp(ldev->layout->codecs[i].name, codec->name) == 0) {
813 				if (check_codec(codec,
814 						ldev,
815 						&ldev->layout->codecs[i]) == 0)
816 					return 0;
817 			}
818 		}
819 	}
820 	return -ENODEV;
821 }
822 
823 static void layout_remove_codec(struct aoa_codec *codec)
824 {
825 	int i;
826 	/* here remove the codec from the layout dev's
827 	 * codec reference */
828 
829 	codec->soundbus_dev = NULL;
830 	codec->gpio = NULL;
831 	for (i=0; i<MAX_CODECS_PER_BUS; i++) {
832 	}
833 }
834 
835 static void layout_notify(void *data)
836 {
837 	struct layout_dev_ptr *dptr = data;
838 	struct layout_dev *ldev;
839 	int v, update;
840 	struct snd_kcontrol *detected, *c;
841 	struct snd_card *card = aoa_get_card();
842 
843 	ldev = dptr->ptr;
844 	if (data == &ldev->selfptr_headphone) {
845 		v = ldev->gpio.methods->get_detect(&ldev->gpio, AOA_NOTIFY_HEADPHONE);
846 		detected = ldev->headphone_detected_ctrl;
847 		update = ldev->switch_on_headphone;
848 		if (update) {
849 			ldev->gpio.methods->set_speakers(&ldev->gpio, !v);
850 			ldev->gpio.methods->set_headphone(&ldev->gpio, v);
851 			ldev->gpio.methods->set_lineout(&ldev->gpio, 0);
852 		}
853 	} else if (data == &ldev->selfptr_lineout) {
854 		v = ldev->gpio.methods->get_detect(&ldev->gpio, AOA_NOTIFY_LINE_OUT);
855 		detected = ldev->lineout_detected_ctrl;
856 		update = ldev->switch_on_lineout;
857 		if (update) {
858 			ldev->gpio.methods->set_speakers(&ldev->gpio, !v);
859 			ldev->gpio.methods->set_headphone(&ldev->gpio, 0);
860 			ldev->gpio.methods->set_lineout(&ldev->gpio, v);
861 		}
862 	} else
863 		return;
864 
865 	if (detected)
866 		snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE, &detected->id);
867 	if (update) {
868 		c = ldev->headphone_ctrl;
869 		if (c)
870 			snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE, &c->id);
871 		c = ldev->speaker_ctrl;
872 		if (c)
873 			snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE, &c->id);
874 		c = ldev->lineout_ctrl;
875 		if (c)
876 			snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE, &c->id);
877 	}
878 }
879 
880 static void layout_attached_codec(struct aoa_codec *codec)
881 {
882 	struct codec_connection *cc;
883 	struct snd_kcontrol *ctl;
884 	int headphones, lineout;
885 	struct layout_dev *ldev = layout_device;
886 
887 	/* need to add this codec to our codec array! */
888 
889 	cc = codec->fabric_data;
890 
891 	headphones = codec->gpio->methods->get_detect(codec->gpio,
892 						      AOA_NOTIFY_HEADPHONE);
893  	lineout = codec->gpio->methods->get_detect(codec->gpio,
894 						   AOA_NOTIFY_LINE_OUT);
895 
896 	if (codec->gpio->methods->set_master) {
897 		ctl = snd_ctl_new1(&master_ctl, codec->gpio);
898 		ldev->master_ctrl = ctl;
899 		aoa_snd_ctl_add(ctl);
900 	}
901 	while (cc->connected) {
902 		if (cc->connected & CC_SPEAKERS) {
903 			if (headphones <= 0 && lineout <= 0)
904 				ldev->gpio.methods->set_speakers(codec->gpio, 1);
905 			ctl = snd_ctl_new1(&speakers_ctl, codec->gpio);
906 			ldev->speaker_ctrl = ctl;
907 			aoa_snd_ctl_add(ctl);
908 		}
909 		if (cc->connected & CC_HEADPHONE) {
910 			if (headphones == 1)
911 				ldev->gpio.methods->set_headphone(codec->gpio, 1);
912 			ctl = snd_ctl_new1(&headphone_ctl, codec->gpio);
913 			ldev->headphone_ctrl = ctl;
914 			aoa_snd_ctl_add(ctl);
915 			ldev->have_headphone_detect =
916 				!ldev->gpio.methods
917 					->set_notify(&ldev->gpio,
918 						     AOA_NOTIFY_HEADPHONE,
919 						     layout_notify,
920 						     &ldev->selfptr_headphone);
921 			if (ldev->have_headphone_detect) {
922 				ctl = snd_ctl_new1(&headphone_detect_choice,
923 						   ldev);
924 				aoa_snd_ctl_add(ctl);
925 				ctl = snd_ctl_new1(&headphone_detected,
926 						   ldev);
927 				ldev->headphone_detected_ctrl = ctl;
928 				aoa_snd_ctl_add(ctl);
929 			}
930 		}
931 		if (cc->connected & CC_LINEOUT) {
932 			if (lineout == 1)
933 				ldev->gpio.methods->set_lineout(codec->gpio, 1);
934 			ctl = snd_ctl_new1(&lineout_ctl, codec->gpio);
935 			if (cc->connected & CC_LINEOUT_LABELLED_HEADPHONE)
936 				strlcpy(ctl->id.name,
937 					"Headphone Switch", sizeof(ctl->id.name));
938 			ldev->lineout_ctrl = ctl;
939 			aoa_snd_ctl_add(ctl);
940 			ldev->have_lineout_detect =
941 				!ldev->gpio.methods
942 					->set_notify(&ldev->gpio,
943 						     AOA_NOTIFY_LINE_OUT,
944 						     layout_notify,
945 						     &ldev->selfptr_lineout);
946 			if (ldev->have_lineout_detect) {
947 				ctl = snd_ctl_new1(&lineout_detect_choice,
948 						   ldev);
949 				if (cc->connected & CC_LINEOUT_LABELLED_HEADPHONE)
950 					strlcpy(ctl->id.name,
951 						"Headphone Detect Autoswitch",
952 						sizeof(ctl->id.name));
953 				aoa_snd_ctl_add(ctl);
954 				ctl = snd_ctl_new1(&lineout_detected,
955 						   ldev);
956 				if (cc->connected & CC_LINEOUT_LABELLED_HEADPHONE)
957 					strlcpy(ctl->id.name,
958 						"Headphone Detected",
959 						sizeof(ctl->id.name));
960 				ldev->lineout_detected_ctrl = ctl;
961 				aoa_snd_ctl_add(ctl);
962 			}
963 		}
964 		cc++;
965 	}
966 	/* now update initial state */
967 	if (ldev->have_headphone_detect)
968 		layout_notify(&ldev->selfptr_headphone);
969 	if (ldev->have_lineout_detect)
970 		layout_notify(&ldev->selfptr_lineout);
971 }
972 
973 static struct aoa_fabric layout_fabric = {
974 	.name = "SoundByLayout",
975 	.owner = THIS_MODULE,
976 	.found_codec = layout_found_codec,
977 	.remove_codec = layout_remove_codec,
978 	.attached_codec = layout_attached_codec,
979 };
980 
981 static int aoa_fabric_layout_probe(struct soundbus_dev *sdev)
982 {
983 	struct device_node *sound = NULL;
984 	const unsigned int *id;
985 	struct layout *layout = NULL;
986 	struct layout_dev *ldev = NULL;
987 	int err;
988 
989 	/* hm, currently we can only have one ... */
990 	if (layout_device)
991 		return -ENODEV;
992 
993 	/* by breaking out we keep a reference */
994 	while ((sound = of_get_next_child(sdev->ofdev.node, sound))) {
995 		if (sound->type && strcasecmp(sound->type, "soundchip") == 0)
996 			break;
997 	}
998 	if (!sound)
999 		return -ENODEV;
1000 
1001 	id = of_get_property(sound, "layout-id", NULL);
1002 	if (id) {
1003 		layout = find_layout_by_id(*id);
1004 	} else {
1005 		id = of_get_property(sound, "device-id", NULL);
1006 		if (id)
1007 			layout = find_layout_by_device(*id);
1008 	}
1009 
1010 	if (!layout) {
1011 		printk(KERN_ERR "snd-aoa-fabric-layout: unknown layout\n");
1012 		goto outnodev;
1013 	}
1014 
1015 	ldev = kzalloc(sizeof(struct layout_dev), GFP_KERNEL);
1016 	if (!ldev)
1017 		goto outnodev;
1018 
1019 	layout_device = ldev;
1020 	ldev->sdev = sdev;
1021 	ldev->sound = sound;
1022 	ldev->layout = layout;
1023 	ldev->gpio.node = sound->parent;
1024 	switch (layout->layout_id) {
1025 	case 0:  /* anything with device_id, not layout_id */
1026 	case 41: /* that unknown machine no one seems to have */
1027 	case 51: /* PowerBook5,4 */
1028 	case 58: /* Mac Mini */
1029 		ldev->gpio.methods = ftr_gpio_methods;
1030 		printk(KERN_DEBUG
1031 		       "snd-aoa-fabric-layout: Using direct GPIOs\n");
1032 		break;
1033 	default:
1034 		ldev->gpio.methods = pmf_gpio_methods;
1035 		printk(KERN_DEBUG
1036 		       "snd-aoa-fabric-layout: Using PMF GPIOs\n");
1037 	}
1038 	ldev->selfptr_headphone.ptr = ldev;
1039 	ldev->selfptr_lineout.ptr = ldev;
1040 	dev_set_drvdata(&sdev->ofdev.dev, ldev);
1041 	list_add(&ldev->list, &layouts_list);
1042 	layouts_list_items++;
1043 
1044 	/* assign these before registering ourselves, so
1045 	 * callbacks that are done during registration
1046 	 * already have the values */
1047 	sdev->pcmid = ldev->layout->pcmid;
1048 	if (ldev->layout->busname) {
1049 		sdev->pcmname = ldev->layout->busname;
1050 	} else {
1051 		sdev->pcmname = "Master";
1052 	}
1053 
1054 	ldev->gpio.methods->init(&ldev->gpio);
1055 
1056 	err = aoa_fabric_register(&layout_fabric, &sdev->ofdev.dev);
1057 	if (err && err != -EALREADY) {
1058 		printk(KERN_INFO "snd-aoa-fabric-layout: can't use,"
1059 				 " another fabric is active!\n");
1060 		goto outlistdel;
1061 	}
1062 
1063 	use_layout(layout);
1064 	ldev->switch_on_headphone = 1;
1065 	ldev->switch_on_lineout = 1;
1066 	return 0;
1067  outlistdel:
1068 	/* we won't be using these then... */
1069 	ldev->gpio.methods->exit(&ldev->gpio);
1070 	/* reset if we didn't use it */
1071 	sdev->pcmname = NULL;
1072 	sdev->pcmid = -1;
1073 	list_del(&ldev->list);
1074 	layouts_list_items--;
1075  outnodev:
1076  	of_node_put(sound);
1077  	layout_device = NULL;
1078  	kfree(ldev);
1079 	return -ENODEV;
1080 }
1081 
1082 static int aoa_fabric_layout_remove(struct soundbus_dev *sdev)
1083 {
1084 	struct layout_dev *ldev = dev_get_drvdata(&sdev->ofdev.dev);
1085 	int i;
1086 
1087 	for (i=0; i<MAX_CODECS_PER_BUS; i++) {
1088 		if (ldev->codecs[i]) {
1089 			aoa_fabric_unlink_codec(ldev->codecs[i]);
1090 		}
1091 		ldev->codecs[i] = NULL;
1092 	}
1093 	list_del(&ldev->list);
1094 	layouts_list_items--;
1095 	of_node_put(ldev->sound);
1096 
1097 	ldev->gpio.methods->set_notify(&ldev->gpio,
1098 				       AOA_NOTIFY_HEADPHONE,
1099 				       NULL,
1100 				       NULL);
1101 	ldev->gpio.methods->set_notify(&ldev->gpio,
1102 				       AOA_NOTIFY_LINE_OUT,
1103 				       NULL,
1104 				       NULL);
1105 
1106 	ldev->gpio.methods->exit(&ldev->gpio);
1107 	layout_device = NULL;
1108 	kfree(ldev);
1109 	sdev->pcmid = -1;
1110 	sdev->pcmname = NULL;
1111 	return 0;
1112 }
1113 
1114 #ifdef CONFIG_PM
1115 static int aoa_fabric_layout_suspend(struct soundbus_dev *sdev, pm_message_t state)
1116 {
1117 	struct layout_dev *ldev = dev_get_drvdata(&sdev->ofdev.dev);
1118 
1119 	if (ldev->gpio.methods && ldev->gpio.methods->all_amps_off)
1120 		ldev->gpio.methods->all_amps_off(&ldev->gpio);
1121 
1122 	return 0;
1123 }
1124 
1125 static int aoa_fabric_layout_resume(struct soundbus_dev *sdev)
1126 {
1127 	struct layout_dev *ldev = dev_get_drvdata(&sdev->ofdev.dev);
1128 
1129 	if (ldev->gpio.methods && ldev->gpio.methods->all_amps_off)
1130 		ldev->gpio.methods->all_amps_restore(&ldev->gpio);
1131 
1132 	return 0;
1133 }
1134 #endif
1135 
1136 static struct soundbus_driver aoa_soundbus_driver = {
1137 	.name = "snd_aoa_soundbus_drv",
1138 	.owner = THIS_MODULE,
1139 	.probe = aoa_fabric_layout_probe,
1140 	.remove = aoa_fabric_layout_remove,
1141 #ifdef CONFIG_PM
1142 	.suspend = aoa_fabric_layout_suspend,
1143 	.resume = aoa_fabric_layout_resume,
1144 #endif
1145 	.driver = {
1146 		.owner = THIS_MODULE,
1147 	}
1148 };
1149 
1150 static int __init aoa_fabric_layout_init(void)
1151 {
1152 	int err;
1153 
1154 	err = soundbus_register_driver(&aoa_soundbus_driver);
1155 	if (err)
1156 		return err;
1157 	return 0;
1158 }
1159 
1160 static void __exit aoa_fabric_layout_exit(void)
1161 {
1162 	soundbus_unregister_driver(&aoa_soundbus_driver);
1163 	aoa_fabric_unregister(&layout_fabric);
1164 }
1165 
1166 module_init(aoa_fabric_layout_init);
1167 module_exit(aoa_fabric_layout_exit);
1168