| // SPDX-License-Identifier: GPL-2.0-only |
| /* |
| * Apple Onboard Audio driver -- layout/machine id fabric |
| * |
| * Copyright 2006-2008 Johannes Berg <johannes@sipsolutions.net> |
| * |
| * This fabric module looks for sound codecs based on the |
| * layout-id or device-id property in the device tree. |
| */ |
| #include <asm/prom.h> |
| #include <linux/list.h> |
| #include <linux/module.h> |
| #include <linux/slab.h> |
| #include "../aoa.h" |
| #include "../soundbus/soundbus.h" |
| |
| MODULE_AUTHOR("Johannes Berg <johannes@sipsolutions.net>"); |
| MODULE_LICENSE("GPL"); |
| MODULE_DESCRIPTION("Layout-ID fabric for snd-aoa"); |
| |
| #define MAX_CODECS_PER_BUS 2 |
| |
| /* These are the connections the layout fabric |
| * knows about. It doesn't really care about the |
| * input ones, but I thought I'd separate them |
| * to give them proper names. The thing is that |
| * Apple usually will distinguish the active output |
| * by GPIOs, while the active input is set directly |
| * on the codec. Hence we here tell the codec what |
| * we think is connected. This information is hard- |
| * coded below ... */ |
| #define CC_SPEAKERS (1<<0) |
| #define CC_HEADPHONE (1<<1) |
| #define CC_LINEOUT (1<<2) |
| #define CC_DIGITALOUT (1<<3) |
| #define CC_LINEIN (1<<4) |
| #define CC_MICROPHONE (1<<5) |
| #define CC_DIGITALIN (1<<6) |
| /* pretty bogus but users complain... |
| * This is a flag saying that the LINEOUT |
| * should be renamed to HEADPHONE. |
| * be careful with input detection! */ |
| #define CC_LINEOUT_LABELLED_HEADPHONE (1<<7) |
| |
| struct codec_connection { |
| /* CC_ flags from above */ |
| int connected; |
| /* codec dependent bit to be set in the aoa_codec.connected field. |
| * This intentionally doesn't have any generic flags because the |
| * fabric has to know the codec anyway and all codecs might have |
| * different connectors */ |
| int codec_bit; |
| }; |
| |
| struct codec_connect_info { |
| char *name; |
| struct codec_connection *connections; |
| }; |
| |
| #define LAYOUT_FLAG_COMBO_LINEOUT_SPDIF (1<<0) |
| |
| struct layout { |
| unsigned int layout_id, device_id; |
| struct codec_connect_info codecs[MAX_CODECS_PER_BUS]; |
| int flags; |
| |
| /* if busname is not assigned, we use 'Master' below, |
| * so that our layout table doesn't need to be filled |
| * too much. |
| * We only assign these two if we expect to find more |
| * than one soundbus, i.e. on those machines with |
| * multiple layout-ids */ |
| char *busname; |
| int pcmid; |
| }; |
| |
| MODULE_ALIAS("sound-layout-36"); |
| MODULE_ALIAS("sound-layout-41"); |
| MODULE_ALIAS("sound-layout-45"); |
| MODULE_ALIAS("sound-layout-47"); |
| MODULE_ALIAS("sound-layout-48"); |
| MODULE_ALIAS("sound-layout-49"); |
| MODULE_ALIAS("sound-layout-50"); |
| MODULE_ALIAS("sound-layout-51"); |
| MODULE_ALIAS("sound-layout-56"); |
| MODULE_ALIAS("sound-layout-57"); |
| MODULE_ALIAS("sound-layout-58"); |
| MODULE_ALIAS("sound-layout-60"); |
| MODULE_ALIAS("sound-layout-61"); |
| MODULE_ALIAS("sound-layout-62"); |
| MODULE_ALIAS("sound-layout-64"); |
| MODULE_ALIAS("sound-layout-65"); |
| MODULE_ALIAS("sound-layout-66"); |
| MODULE_ALIAS("sound-layout-67"); |
| MODULE_ALIAS("sound-layout-68"); |
| MODULE_ALIAS("sound-layout-69"); |
| MODULE_ALIAS("sound-layout-70"); |
| MODULE_ALIAS("sound-layout-72"); |
| MODULE_ALIAS("sound-layout-76"); |
| MODULE_ALIAS("sound-layout-80"); |
| MODULE_ALIAS("sound-layout-82"); |
| MODULE_ALIAS("sound-layout-84"); |
| MODULE_ALIAS("sound-layout-86"); |
| MODULE_ALIAS("sound-layout-90"); |
| MODULE_ALIAS("sound-layout-92"); |
| MODULE_ALIAS("sound-layout-94"); |
| MODULE_ALIAS("sound-layout-96"); |
| MODULE_ALIAS("sound-layout-98"); |
| MODULE_ALIAS("sound-layout-100"); |
| |
| MODULE_ALIAS("aoa-device-id-14"); |
| MODULE_ALIAS("aoa-device-id-22"); |
| MODULE_ALIAS("aoa-device-id-31"); |
| MODULE_ALIAS("aoa-device-id-35"); |
| MODULE_ALIAS("aoa-device-id-44"); |
| |
| /* onyx with all but microphone connected */ |
| static struct codec_connection onyx_connections_nomic[] = { |
| { |
| .connected = CC_SPEAKERS | CC_HEADPHONE | CC_LINEOUT, |
| .codec_bit = 0, |
| }, |
| { |
| .connected = CC_DIGITALOUT, |
| .codec_bit = 1, |
| }, |
| { |
| .connected = CC_LINEIN, |
| .codec_bit = 2, |
| }, |
| {} /* terminate array by .connected == 0 */ |
| }; |
| |
| /* onyx on machines without headphone */ |
| static struct codec_connection onyx_connections_noheadphones[] = { |
| { |
| .connected = CC_SPEAKERS | CC_LINEOUT | |
| CC_LINEOUT_LABELLED_HEADPHONE, |
| .codec_bit = 0, |
| }, |
| { |
| .connected = CC_DIGITALOUT, |
| .codec_bit = 1, |
| }, |
| /* FIXME: are these correct? probably not for all the machines |
| * below ... If not this will need separating. */ |
| { |
| .connected = CC_LINEIN, |
| .codec_bit = 2, |
| }, |
| { |
| .connected = CC_MICROPHONE, |
| .codec_bit = 3, |
| }, |
| {} /* terminate array by .connected == 0 */ |
| }; |
| |
| /* onyx on machines with real line-out */ |
| static struct codec_connection onyx_connections_reallineout[] = { |
| { |
| .connected = CC_SPEAKERS | CC_LINEOUT | CC_HEADPHONE, |
| .codec_bit = 0, |
| }, |
| { |
| .connected = CC_DIGITALOUT, |
| .codec_bit = 1, |
| }, |
| { |
| .connected = CC_LINEIN, |
| .codec_bit = 2, |
| }, |
| {} /* terminate array by .connected == 0 */ |
| }; |
| |
| /* tas on machines without line out */ |
| static struct codec_connection tas_connections_nolineout[] = { |
| { |
| .connected = CC_SPEAKERS | CC_HEADPHONE, |
| .codec_bit = 0, |
| }, |
| { |
| .connected = CC_LINEIN, |
| .codec_bit = 2, |
| }, |
| { |
| .connected = CC_MICROPHONE, |
| .codec_bit = 3, |
| }, |
| {} /* terminate array by .connected == 0 */ |
| }; |
| |
| /* tas on machines with neither line out nor line in */ |
| static struct codec_connection tas_connections_noline[] = { |
| { |
| .connected = CC_SPEAKERS | CC_HEADPHONE, |
| .codec_bit = 0, |
| }, |
| { |
| .connected = CC_MICROPHONE, |
| .codec_bit = 3, |
| }, |
| {} /* terminate array by .connected == 0 */ |
| }; |
| |
| /* tas on machines without microphone */ |
| static struct codec_connection tas_connections_nomic[] = { |
| { |
| .connected = CC_SPEAKERS | CC_HEADPHONE | CC_LINEOUT, |
| .codec_bit = 0, |
| }, |
| { |
| .connected = CC_LINEIN, |
| .codec_bit = 2, |
| }, |
| {} /* terminate array by .connected == 0 */ |
| }; |
| |
| /* tas on machines with everything connected */ |
| static struct codec_connection tas_connections_all[] = { |
| { |
| .connected = CC_SPEAKERS | CC_HEADPHONE | CC_LINEOUT, |
| .codec_bit = 0, |
| }, |
| { |
| .connected = CC_LINEIN, |
| .codec_bit = 2, |
| }, |
| { |
| .connected = CC_MICROPHONE, |
| .codec_bit = 3, |
| }, |
| {} /* terminate array by .connected == 0 */ |
| }; |
| |
| static struct codec_connection toonie_connections[] = { |
| { |
| .connected = CC_SPEAKERS | CC_HEADPHONE, |
| .codec_bit = 0, |
| }, |
| {} /* terminate array by .connected == 0 */ |
| }; |
| |
| static struct codec_connection topaz_input[] = { |
| { |
| .connected = CC_DIGITALIN, |
| .codec_bit = 0, |
| }, |
| {} /* terminate array by .connected == 0 */ |
| }; |
| |
| static struct codec_connection topaz_output[] = { |
| { |
| .connected = CC_DIGITALOUT, |
| .codec_bit = 1, |
| }, |
| {} /* terminate array by .connected == 0 */ |
| }; |
| |
| static struct codec_connection topaz_inout[] = { |
| { |
| .connected = CC_DIGITALIN, |
| .codec_bit = 0, |
| }, |
| { |
| .connected = CC_DIGITALOUT, |
| .codec_bit = 1, |
| }, |
| {} /* terminate array by .connected == 0 */ |
| }; |
| |
| static struct layout layouts[] = { |
| /* last PowerBooks (15" Oct 2005) */ |
| { .layout_id = 82, |
| .flags = LAYOUT_FLAG_COMBO_LINEOUT_SPDIF, |
| .codecs[0] = { |
| .name = "onyx", |
| .connections = onyx_connections_noheadphones, |
| }, |
| .codecs[1] = { |
| .name = "topaz", |
| .connections = topaz_input, |
| }, |
| }, |
| /* PowerMac9,1 */ |
| { .layout_id = 60, |
| .codecs[0] = { |
| .name = "onyx", |
| .connections = onyx_connections_reallineout, |
| }, |
| }, |
| /* PowerMac9,1 */ |
| { .layout_id = 61, |
| .codecs[0] = { |
| .name = "topaz", |
| .connections = topaz_input, |
| }, |
| }, |
| /* PowerBook5,7 */ |
| { .layout_id = 64, |
| .flags = LAYOUT_FLAG_COMBO_LINEOUT_SPDIF, |
| .codecs[0] = { |
| .name = "onyx", |
| .connections = onyx_connections_noheadphones, |
| }, |
| }, |
| /* PowerBook5,7 */ |
| { .layout_id = 65, |
| .codecs[0] = { |
| .name = "topaz", |
| .connections = topaz_input, |
| }, |
| }, |
| /* PowerBook5,9 [17" Oct 2005] */ |
| { .layout_id = 84, |
| .flags = LAYOUT_FLAG_COMBO_LINEOUT_SPDIF, |
| .codecs[0] = { |
| .name = "onyx", |
| .connections = onyx_connections_noheadphones, |
| }, |
| .codecs[1] = { |
| .name = "topaz", |
| .connections = topaz_input, |
| }, |
| }, |
| /* PowerMac8,1 */ |
| { .layout_id = 45, |
| .codecs[0] = { |
| .name = "onyx", |
| .connections = onyx_connections_noheadphones, |
| }, |
| .codecs[1] = { |
| .name = "topaz", |
| .connections = topaz_input, |
| }, |
| }, |
| /* Quad PowerMac (analog in, analog/digital out) */ |
| { .layout_id = 68, |
| .codecs[0] = { |
| .name = "onyx", |
| .connections = onyx_connections_nomic, |
| }, |
| }, |
| /* Quad PowerMac (digital in) */ |
| { .layout_id = 69, |
| .codecs[0] = { |
| .name = "topaz", |
| .connections = topaz_input, |
| }, |
| .busname = "digital in", .pcmid = 1 }, |
| /* Early 2005 PowerBook (PowerBook 5,6) */ |
| { .layout_id = 70, |
| .codecs[0] = { |
| .name = "tas", |
| .connections = tas_connections_nolineout, |
| }, |
| }, |
| /* PowerBook 5,4 */ |
| { .layout_id = 51, |
| .codecs[0] = { |
| .name = "tas", |
| .connections = tas_connections_nolineout, |
| }, |
| }, |
| /* PowerBook6,1 */ |
| { .device_id = 31, |
| .codecs[0] = { |
| .name = "tas", |
| .connections = tas_connections_nolineout, |
| }, |
| }, |
| /* PowerBook6,5 */ |
| { .device_id = 44, |
| .codecs[0] = { |
| .name = "tas", |
| .connections = tas_connections_all, |
| }, |
| }, |
| /* PowerBook6,7 */ |
| { .layout_id = 80, |
| .codecs[0] = { |
| .name = "tas", |
| .connections = tas_connections_noline, |
| }, |
| }, |
| /* PowerBook6,8 */ |
| { .layout_id = 72, |
| .codecs[0] = { |
| .name = "tas", |
| .connections = tas_connections_nolineout, |
| }, |
| }, |
| /* PowerMac8,2 */ |
| { .layout_id = 86, |
| .codecs[0] = { |
| .name = "onyx", |
| .connections = onyx_connections_nomic, |
| }, |
| .codecs[1] = { |
| .name = "topaz", |
| .connections = topaz_input, |
| }, |
| }, |
| /* PowerBook6,7 */ |
| { .layout_id = 92, |
| .codecs[0] = { |
| .name = "tas", |
| .connections = tas_connections_nolineout, |
| }, |
| }, |
| /* PowerMac10,1 (Mac Mini) */ |
| { .layout_id = 58, |
| .codecs[0] = { |
| .name = "toonie", |
| .connections = toonie_connections, |
| }, |
| }, |
| { |
| .layout_id = 96, |
| .codecs[0] = { |
| .name = "onyx", |
| .connections = onyx_connections_noheadphones, |
| }, |
| }, |
| /* unknown, untested, but this comes from Apple */ |
| { .layout_id = 41, |
| .codecs[0] = { |
| .name = "tas", |
| .connections = tas_connections_all, |
| }, |
| }, |
| { .layout_id = 36, |
| .codecs[0] = { |
| .name = "tas", |
| .connections = tas_connections_nomic, |
| }, |
| .codecs[1] = { |
| .name = "topaz", |
| .connections = topaz_inout, |
| }, |
| }, |
| { .layout_id = 47, |
| .codecs[0] = { |
| .name = "onyx", |
| .connections = onyx_connections_noheadphones, |
| }, |
| }, |
| { .layout_id = 48, |
| .codecs[0] = { |
| .name = "topaz", |
| .connections = topaz_input, |
| }, |
| }, |
| { .layout_id = 49, |
| .codecs[0] = { |
| .name = "onyx", |
| .connections = onyx_connections_nomic, |
| }, |
| }, |
| { .layout_id = 50, |
| .codecs[0] = { |
| .name = "topaz", |
| .connections = topaz_input, |
| }, |
| }, |
| { .layout_id = 56, |
| .codecs[0] = { |
| .name = "onyx", |
| .connections = onyx_connections_noheadphones, |
| }, |
| }, |
| { .layout_id = 57, |
| .codecs[0] = { |
| .name = "topaz", |
| .connections = topaz_input, |
| }, |
| }, |
| { .layout_id = 62, |
| .codecs[0] = { |
| .name = "onyx", |
| .connections = onyx_connections_noheadphones, |
| }, |
| .codecs[1] = { |
| .name = "topaz", |
| .connections = topaz_output, |
| }, |
| }, |
| { .layout_id = 66, |
| .codecs[0] = { |
| .name = "onyx", |
| .connections = onyx_connections_noheadphones, |
| }, |
| }, |
| { .layout_id = 67, |
| .codecs[0] = { |
| .name = "topaz", |
| .connections = topaz_input, |
| }, |
| }, |
| { .layout_id = 76, |
| .codecs[0] = { |
| .name = "tas", |
| .connections = tas_connections_nomic, |
| }, |
| .codecs[1] = { |
| .name = "topaz", |
| .connections = topaz_inout, |
| }, |
| }, |
| { .layout_id = 90, |
| .codecs[0] = { |
| .name = "tas", |
| .connections = tas_connections_noline, |
| }, |
| }, |
| { .layout_id = 94, |
| .codecs[0] = { |
| .name = "onyx", |
| /* but it has an external mic?? how to select? */ |
| .connections = onyx_connections_noheadphones, |
| }, |
| }, |
| { .layout_id = 98, |
| .codecs[0] = { |
| .name = "toonie", |
| .connections = toonie_connections, |
| }, |
| }, |
| { .layout_id = 100, |
| .codecs[0] = { |
| .name = "topaz", |
| .connections = topaz_input, |
| }, |
| .codecs[1] = { |
| .name = "onyx", |
| .connections = onyx_connections_noheadphones, |
| }, |
| }, |
| /* PowerMac3,4 */ |
| { .device_id = 14, |
| .codecs[0] = { |
| .name = "tas", |
| .connections = tas_connections_noline, |
| }, |
| }, |
| /* PowerMac3,6 */ |
| { .device_id = 22, |
| .codecs[0] = { |
| .name = "tas", |
| .connections = tas_connections_all, |
| }, |
| }, |
| /* PowerBook5,2 */ |
| { .device_id = 35, |
| .codecs[0] = { |
| .name = "tas", |
| .connections = tas_connections_all, |
| }, |
| }, |
| {} |
| }; |
| |
| static struct layout *find_layout_by_id(unsigned int id) |
| { |
| struct layout *l; |
| |
| l = layouts; |
| while (l->codecs[0].name) { |
| if (l->layout_id == id) |
| return l; |
| l++; |
| } |
| return NULL; |
| } |
| |
| static struct layout *find_layout_by_device(unsigned int id) |
| { |
| struct layout *l; |
| |
| l = layouts; |
| while (l->codecs[0].name) { |
| if (l->device_id == id) |
| return l; |
| l++; |
| } |
| return NULL; |
| } |
| |
| static void use_layout(struct layout *l) |
| { |
| int i; |
| |
| for (i=0; i<MAX_CODECS_PER_BUS; i++) { |
| if (l->codecs[i].name) { |
| request_module("snd-aoa-codec-%s", l->codecs[i].name); |
| } |
| } |
| /* now we wait for the codecs to call us back */ |
| } |
| |
| struct layout_dev; |
| |
| struct layout_dev_ptr { |
| struct layout_dev *ptr; |
| }; |
| |
| struct layout_dev { |
| struct list_head list; |
| struct soundbus_dev *sdev; |
| struct device_node *sound; |
| struct aoa_codec *codecs[MAX_CODECS_PER_BUS]; |
| struct layout *layout; |
| struct gpio_runtime gpio; |
| |
| /* we need these for headphone/lineout detection */ |
| struct snd_kcontrol *headphone_ctrl; |
| struct snd_kcontrol *lineout_ctrl; |
| struct snd_kcontrol *speaker_ctrl; |
| struct snd_kcontrol *master_ctrl; |
| struct snd_kcontrol *headphone_detected_ctrl; |
| struct snd_kcontrol *lineout_detected_ctrl; |
| |
| struct layout_dev_ptr selfptr_headphone; |
| struct layout_dev_ptr selfptr_lineout; |
| |
| u32 have_lineout_detect:1, |
| have_headphone_detect:1, |
| switch_on_headphone:1, |
| switch_on_lineout:1; |
| }; |
| |
| static LIST_HEAD(layouts_list); |
| static int layouts_list_items; |
| /* this can go away but only if we allow multiple cards, |
| * make the fabric handle all the card stuff, etc... */ |
| static struct layout_dev *layout_device; |
| |
| #define control_info snd_ctl_boolean_mono_info |
| |
| #define AMP_CONTROL(n, description) \ |
| static int n##_control_get(struct snd_kcontrol *kcontrol, \ |
| struct snd_ctl_elem_value *ucontrol) \ |
| { \ |
| struct gpio_runtime *gpio = snd_kcontrol_chip(kcontrol); \ |
| if (gpio->methods && gpio->methods->get_##n) \ |
| ucontrol->value.integer.value[0] = \ |
| gpio->methods->get_##n(gpio); \ |
| return 0; \ |
| } \ |
| static int n##_control_put(struct snd_kcontrol *kcontrol, \ |
| struct snd_ctl_elem_value *ucontrol) \ |
| { \ |
| struct gpio_runtime *gpio = snd_kcontrol_chip(kcontrol); \ |
| if (gpio->methods && gpio->methods->set_##n) \ |
| gpio->methods->set_##n(gpio, \ |
| !!ucontrol->value.integer.value[0]); \ |
| return 1; \ |
| } \ |
| static struct snd_kcontrol_new n##_ctl = { \ |
| .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \ |
| .name = description, \ |
| .access = SNDRV_CTL_ELEM_ACCESS_READWRITE, \ |
| .info = control_info, \ |
| .get = n##_control_get, \ |
| .put = n##_control_put, \ |
| } |
| |
| AMP_CONTROL(headphone, "Headphone Switch"); |
| AMP_CONTROL(speakers, "Speakers Switch"); |
| AMP_CONTROL(lineout, "Line-Out Switch"); |
| AMP_CONTROL(master, "Master Switch"); |
| |
| static int detect_choice_get(struct snd_kcontrol *kcontrol, |
| struct snd_ctl_elem_value *ucontrol) |
| { |
| struct layout_dev *ldev = snd_kcontrol_chip(kcontrol); |
| |
| switch (kcontrol->private_value) { |
| case 0: |
| ucontrol->value.integer.value[0] = ldev->switch_on_headphone; |
| break; |
| case 1: |
| ucontrol->value.integer.value[0] = ldev->switch_on_lineout; |
| break; |
| default: |
| return -ENODEV; |
| } |
| return 0; |
| } |
| |
| static int detect_choice_put(struct snd_kcontrol *kcontrol, |
| struct snd_ctl_elem_value *ucontrol) |
| { |
| struct layout_dev *ldev = snd_kcontrol_chip(kcontrol); |
| |
| switch (kcontrol->private_value) { |
| case 0: |
| ldev->switch_on_headphone = !!ucontrol->value.integer.value[0]; |
| break; |
| case 1: |
| ldev->switch_on_lineout = !!ucontrol->value.integer.value[0]; |
| break; |
| default: |
| return -ENODEV; |
| } |
| return 1; |
| } |
| |
| static const struct snd_kcontrol_new headphone_detect_choice = { |
| .iface = SNDRV_CTL_ELEM_IFACE_MIXER, |
| .name = "Headphone Detect Autoswitch", |
| .info = control_info, |
| .access = SNDRV_CTL_ELEM_ACCESS_READWRITE, |
| .get = detect_choice_get, |
| .put = detect_choice_put, |
| .private_value = 0, |
| }; |
| |
| static const struct snd_kcontrol_new lineout_detect_choice = { |
| .iface = SNDRV_CTL_ELEM_IFACE_MIXER, |
| .name = "Line-Out Detect Autoswitch", |
| .info = control_info, |
| .access = SNDRV_CTL_ELEM_ACCESS_READWRITE, |
| .get = detect_choice_get, |
| .put = detect_choice_put, |
| .private_value = 1, |
| }; |
| |
| static int detected_get(struct snd_kcontrol *kcontrol, |
| struct snd_ctl_elem_value *ucontrol) |
| { |
| struct layout_dev *ldev = snd_kcontrol_chip(kcontrol); |
| int v; |
| |
| switch (kcontrol->private_value) { |
| case 0: |
| v = ldev->gpio.methods->get_detect(&ldev->gpio, |
| AOA_NOTIFY_HEADPHONE); |
| break; |
| case 1: |
| v = ldev->gpio.methods->get_detect(&ldev->gpio, |
| AOA_NOTIFY_LINE_OUT); |
| break; |
| default: |
| return -ENODEV; |
| } |
| ucontrol->value.integer.value[0] = v; |
| return 0; |
| } |
| |
| static const struct snd_kcontrol_new headphone_detected = { |
| .iface = SNDRV_CTL_ELEM_IFACE_MIXER, |
| .name = "Headphone Detected", |
| .info = control_info, |
| .access = SNDRV_CTL_ELEM_ACCESS_READ, |
| .get = detected_get, |
| .private_value = 0, |
| }; |
| |
| static const struct snd_kcontrol_new lineout_detected = { |
| .iface = SNDRV_CTL_ELEM_IFACE_MIXER, |
| .name = "Line-Out Detected", |
| .info = control_info, |
| .access = SNDRV_CTL_ELEM_ACCESS_READ, |
| .get = detected_get, |
| .private_value = 1, |
| }; |
| |
| static int check_codec(struct aoa_codec *codec, |
| struct layout_dev *ldev, |
| struct codec_connect_info *cci) |
| { |
| const u32 *ref; |
| char propname[32]; |
| struct codec_connection *cc; |
| |
| /* if the codec has a 'codec' node, we require a reference */ |
| if (of_node_name_eq(codec->node, "codec")) { |
| snprintf(propname, sizeof(propname), |
| "platform-%s-codec-ref", codec->name); |
| ref = of_get_property(ldev->sound, propname, NULL); |
| if (!ref) { |
| printk(KERN_INFO "snd-aoa-fabric-layout: " |
| "required property %s not present\n", propname); |
| return -ENODEV; |
| } |
| if (*ref != codec->node->phandle) { |
| printk(KERN_INFO "snd-aoa-fabric-layout: " |
| "%s doesn't match!\n", propname); |
| return -ENODEV; |
| } |
| } else { |
| if (layouts_list_items != 1) { |
| printk(KERN_INFO "snd-aoa-fabric-layout: " |
| "more than one soundbus, but no references.\n"); |
| return -ENODEV; |
| } |
| } |
| codec->soundbus_dev = ldev->sdev; |
| codec->gpio = &ldev->gpio; |
| |
| cc = cci->connections; |
| if (!cc) |
| return -EINVAL; |
| |
| printk(KERN_INFO "snd-aoa-fabric-layout: can use this codec\n"); |
| |
| codec->connected = 0; |
| codec->fabric_data = cc; |
| |
| while (cc->connected) { |
| codec->connected |= 1<<cc->codec_bit; |
| cc++; |
| } |
| |
| return 0; |
| } |
| |
| static int layout_found_codec(struct aoa_codec *codec) |
| { |
| struct layout_dev *ldev; |
| int i; |
| |
| list_for_each_entry(ldev, &layouts_list, list) { |
| for (i=0; i<MAX_CODECS_PER_BUS; i++) { |
| if (!ldev->layout->codecs[i].name) |
| continue; |
| if (strcmp(ldev->layout->codecs[i].name, codec->name) == 0) { |
| if (check_codec(codec, |
| ldev, |
| &ldev->layout->codecs[i]) == 0) |
| return 0; |
| } |
| } |
| } |
| return -ENODEV; |
| } |
| |
| static void layout_remove_codec(struct aoa_codec *codec) |
| { |
| int i; |
| /* here remove the codec from the layout dev's |
| * codec reference */ |
| |
| codec->soundbus_dev = NULL; |
| codec->gpio = NULL; |
| for (i=0; i<MAX_CODECS_PER_BUS; i++) { |
| } |
| } |
| |
| static void layout_notify(void *data) |
| { |
| struct layout_dev_ptr *dptr = data; |
| struct layout_dev *ldev; |
| int v, update; |
| struct snd_kcontrol *detected, *c; |
| struct snd_card *card = aoa_get_card(); |
| |
| ldev = dptr->ptr; |
| if (data == &ldev->selfptr_headphone) { |
| v = ldev->gpio.methods->get_detect(&ldev->gpio, AOA_NOTIFY_HEADPHONE); |
| detected = ldev->headphone_detected_ctrl; |
| update = ldev->switch_on_headphone; |
| if (update) { |
| ldev->gpio.methods->set_speakers(&ldev->gpio, !v); |
| ldev->gpio.methods->set_headphone(&ldev->gpio, v); |
| ldev->gpio.methods->set_lineout(&ldev->gpio, 0); |
| } |
| } else if (data == &ldev->selfptr_lineout) { |
| v = ldev->gpio.methods->get_detect(&ldev->gpio, AOA_NOTIFY_LINE_OUT); |
| detected = ldev->lineout_detected_ctrl; |
| update = ldev->switch_on_lineout; |
| if (update) { |
| ldev->gpio.methods->set_speakers(&ldev->gpio, !v); |
| ldev->gpio.methods->set_headphone(&ldev->gpio, 0); |
| ldev->gpio.methods->set_lineout(&ldev->gpio, v); |
| } |
| } else |
| return; |
| |
| if (detected) |
| snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE, &detected->id); |
| if (update) { |
| c = ldev->headphone_ctrl; |
| if (c) |
| snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE, &c->id); |
| c = ldev->speaker_ctrl; |
| if (c) |
| snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE, &c->id); |
| c = ldev->lineout_ctrl; |
| if (c) |
| snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE, &c->id); |
| } |
| } |
| |
| static void layout_attached_codec(struct aoa_codec *codec) |
| { |
| struct codec_connection *cc; |
| struct snd_kcontrol *ctl; |
| int headphones, lineout; |
| struct layout_dev *ldev = layout_device; |
| |
| /* need to add this codec to our codec array! */ |
| |
| cc = codec->fabric_data; |
| |
| headphones = codec->gpio->methods->get_detect(codec->gpio, |
| AOA_NOTIFY_HEADPHONE); |
| lineout = codec->gpio->methods->get_detect(codec->gpio, |
| AOA_NOTIFY_LINE_OUT); |
| |
| if (codec->gpio->methods->set_master) { |
| ctl = snd_ctl_new1(&master_ctl, codec->gpio); |
| ldev->master_ctrl = ctl; |
| aoa_snd_ctl_add(ctl); |
| } |
| while (cc->connected) { |
| if (cc->connected & CC_SPEAKERS) { |
| if (headphones <= 0 && lineout <= 0) |
| ldev->gpio.methods->set_speakers(codec->gpio, 1); |
| ctl = snd_ctl_new1(&speakers_ctl, codec->gpio); |
| ldev->speaker_ctrl = ctl; |
| aoa_snd_ctl_add(ctl); |
| } |
| if (cc->connected & CC_HEADPHONE) { |
| if (headphones == 1) |
| ldev->gpio.methods->set_headphone(codec->gpio, 1); |
| ctl = snd_ctl_new1(&headphone_ctl, codec->gpio); |
| ldev->headphone_ctrl = ctl; |
| aoa_snd_ctl_add(ctl); |
| ldev->have_headphone_detect = |
| !ldev->gpio.methods |
| ->set_notify(&ldev->gpio, |
| AOA_NOTIFY_HEADPHONE, |
| layout_notify, |
| &ldev->selfptr_headphone); |
| if (ldev->have_headphone_detect) { |
| ctl = snd_ctl_new1(&headphone_detect_choice, |
| ldev); |
| aoa_snd_ctl_add(ctl); |
| ctl = snd_ctl_new1(&headphone_detected, |
| ldev); |
| ldev->headphone_detected_ctrl = ctl; |
| aoa_snd_ctl_add(ctl); |
| } |
| } |
| if (cc->connected & CC_LINEOUT) { |
| if (lineout == 1) |
| ldev->gpio.methods->set_lineout(codec->gpio, 1); |
| ctl = snd_ctl_new1(&lineout_ctl, codec->gpio); |
| if (cc->connected & CC_LINEOUT_LABELLED_HEADPHONE) |
| strlcpy(ctl->id.name, |
| "Headphone Switch", sizeof(ctl->id.name)); |
| ldev->lineout_ctrl = ctl; |
| aoa_snd_ctl_add(ctl); |
| ldev->have_lineout_detect = |
| !ldev->gpio.methods |
| ->set_notify(&ldev->gpio, |
| AOA_NOTIFY_LINE_OUT, |
| layout_notify, |
| &ldev->selfptr_lineout); |
| if (ldev->have_lineout_detect) { |
| ctl = snd_ctl_new1(&lineout_detect_choice, |
| ldev); |
| if (cc->connected & CC_LINEOUT_LABELLED_HEADPHONE) |
| strlcpy(ctl->id.name, |
| "Headphone Detect Autoswitch", |
| sizeof(ctl->id.name)); |
| aoa_snd_ctl_add(ctl); |
| ctl = snd_ctl_new1(&lineout_detected, |
| ldev); |
| if (cc->connected & CC_LINEOUT_LABELLED_HEADPHONE) |
| strlcpy(ctl->id.name, |
| "Headphone Detected", |
| sizeof(ctl->id.name)); |
| ldev->lineout_detected_ctrl = ctl; |
| aoa_snd_ctl_add(ctl); |
| } |
| } |
| cc++; |
| } |
| /* now update initial state */ |
| if (ldev->have_headphone_detect) |
| layout_notify(&ldev->selfptr_headphone); |
| if (ldev->have_lineout_detect) |
| layout_notify(&ldev->selfptr_lineout); |
| } |
| |
| static struct aoa_fabric layout_fabric = { |
| .name = "SoundByLayout", |
| .owner = THIS_MODULE, |
| .found_codec = layout_found_codec, |
| .remove_codec = layout_remove_codec, |
| .attached_codec = layout_attached_codec, |
| }; |
| |
| static int aoa_fabric_layout_probe(struct soundbus_dev *sdev) |
| { |
| struct device_node *sound = NULL; |
| const unsigned int *id; |
| struct layout *layout = NULL; |
| struct layout_dev *ldev = NULL; |
| int err; |
| |
| /* hm, currently we can only have one ... */ |
| if (layout_device) |
| return -ENODEV; |
| |
| /* by breaking out we keep a reference */ |
| for_each_child_of_node(sdev->ofdev.dev.of_node, sound) { |
| if (of_node_is_type(sound, "soundchip")) |
| break; |
| } |
| if (!sound) |
| return -ENODEV; |
| |
| id = of_get_property(sound, "layout-id", NULL); |
| if (id) { |
| layout = find_layout_by_id(*id); |
| } else { |
| id = of_get_property(sound, "device-id", NULL); |
| if (id) |
| layout = find_layout_by_device(*id); |
| } |
| |
| if (!layout) { |
| printk(KERN_ERR "snd-aoa-fabric-layout: unknown layout\n"); |
| goto outnodev; |
| } |
| |
| ldev = kzalloc(sizeof(struct layout_dev), GFP_KERNEL); |
| if (!ldev) |
| goto outnodev; |
| |
| layout_device = ldev; |
| ldev->sdev = sdev; |
| ldev->sound = sound; |
| ldev->layout = layout; |
| ldev->gpio.node = sound->parent; |
| switch (layout->layout_id) { |
| case 0: /* anything with device_id, not layout_id */ |
| case 41: /* that unknown machine no one seems to have */ |
| case 51: /* PowerBook5,4 */ |
| case 58: /* Mac Mini */ |
| ldev->gpio.methods = ftr_gpio_methods; |
| printk(KERN_DEBUG |
| "snd-aoa-fabric-layout: Using direct GPIOs\n"); |
| break; |
| default: |
| ldev->gpio.methods = pmf_gpio_methods; |
| printk(KERN_DEBUG |
| "snd-aoa-fabric-layout: Using PMF GPIOs\n"); |
| } |
| ldev->selfptr_headphone.ptr = ldev; |
| ldev->selfptr_lineout.ptr = ldev; |
| dev_set_drvdata(&sdev->ofdev.dev, ldev); |
| list_add(&ldev->list, &layouts_list); |
| layouts_list_items++; |
| |
| /* assign these before registering ourselves, so |
| * callbacks that are done during registration |
| * already have the values */ |
| sdev->pcmid = ldev->layout->pcmid; |
| if (ldev->layout->busname) { |
| sdev->pcmname = ldev->layout->busname; |
| } else { |
| sdev->pcmname = "Master"; |
| } |
| |
| ldev->gpio.methods->init(&ldev->gpio); |
| |
| err = aoa_fabric_register(&layout_fabric, &sdev->ofdev.dev); |
| if (err && err != -EALREADY) { |
| printk(KERN_INFO "snd-aoa-fabric-layout: can't use," |
| " another fabric is active!\n"); |
| goto outlistdel; |
| } |
| |
| use_layout(layout); |
| ldev->switch_on_headphone = 1; |
| ldev->switch_on_lineout = 1; |
| return 0; |
| outlistdel: |
| /* we won't be using these then... */ |
| ldev->gpio.methods->exit(&ldev->gpio); |
| /* reset if we didn't use it */ |
| sdev->pcmname = NULL; |
| sdev->pcmid = -1; |
| list_del(&ldev->list); |
| layouts_list_items--; |
| kfree(ldev); |
| outnodev: |
| of_node_put(sound); |
| layout_device = NULL; |
| return -ENODEV; |
| } |
| |
| static int aoa_fabric_layout_remove(struct soundbus_dev *sdev) |
| { |
| struct layout_dev *ldev = dev_get_drvdata(&sdev->ofdev.dev); |
| int i; |
| |
| for (i=0; i<MAX_CODECS_PER_BUS; i++) { |
| if (ldev->codecs[i]) { |
| aoa_fabric_unlink_codec(ldev->codecs[i]); |
| } |
| ldev->codecs[i] = NULL; |
| } |
| list_del(&ldev->list); |
| layouts_list_items--; |
| of_node_put(ldev->sound); |
| |
| ldev->gpio.methods->set_notify(&ldev->gpio, |
| AOA_NOTIFY_HEADPHONE, |
| NULL, |
| NULL); |
| ldev->gpio.methods->set_notify(&ldev->gpio, |
| AOA_NOTIFY_LINE_OUT, |
| NULL, |
| NULL); |
| |
| ldev->gpio.methods->exit(&ldev->gpio); |
| layout_device = NULL; |
| kfree(ldev); |
| sdev->pcmid = -1; |
| sdev->pcmname = NULL; |
| return 0; |
| } |
| |
| #ifdef CONFIG_PM_SLEEP |
| static int aoa_fabric_layout_suspend(struct device *dev) |
| { |
| struct layout_dev *ldev = dev_get_drvdata(dev); |
| |
| if (ldev->gpio.methods && ldev->gpio.methods->all_amps_off) |
| ldev->gpio.methods->all_amps_off(&ldev->gpio); |
| |
| return 0; |
| } |
| |
| static int aoa_fabric_layout_resume(struct device *dev) |
| { |
| struct layout_dev *ldev = dev_get_drvdata(dev); |
| |
| if (ldev->gpio.methods && ldev->gpio.methods->all_amps_restore) |
| ldev->gpio.methods->all_amps_restore(&ldev->gpio); |
| |
| return 0; |
| } |
| |
| static SIMPLE_DEV_PM_OPS(aoa_fabric_layout_pm_ops, |
| aoa_fabric_layout_suspend, aoa_fabric_layout_resume); |
| |
| #endif |
| |
| static struct soundbus_driver aoa_soundbus_driver = { |
| .name = "snd_aoa_soundbus_drv", |
| .owner = THIS_MODULE, |
| .probe = aoa_fabric_layout_probe, |
| .remove = aoa_fabric_layout_remove, |
| .driver = { |
| .owner = THIS_MODULE, |
| #ifdef CONFIG_PM_SLEEP |
| .pm = &aoa_fabric_layout_pm_ops, |
| #endif |
| } |
| }; |
| |
| static int __init aoa_fabric_layout_init(void) |
| { |
| return soundbus_register_driver(&aoa_soundbus_driver); |
| } |
| |
| static void __exit aoa_fabric_layout_exit(void) |
| { |
| soundbus_unregister_driver(&aoa_soundbus_driver); |
| aoa_fabric_unregister(&layout_fabric); |
| } |
| |
| module_init(aoa_fabric_layout_init); |
| module_exit(aoa_fabric_layout_exit); |