March 2021 - Alsa-devel - mailman.alsa-project.org

[PATCH 1/2] ASoC: tlv320aic32x4: Increase maximum register in regmap
by Annaliese McDermond 29 Mar '21

29 Mar '21

AIC32X4_REFPOWERUP was added as a register, but the maximum register value in the regmap and regmap range was not correspondingly increased. This caused an error when this register was attempted to be written. Fixes: ec96690 ("ASoC: tlv320aic32x4: Enable fast charge") Cc: stable(a)vger.kernel.org Signed-off-by: Annaliese McDermond <nh6z(a)nh6z.net> --- sound/soc/codecs/tlv320aic32x4.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/sound/soc/codecs/tlv320aic32x4.c b/sound/soc/codecs/tlv320aic32x4.c index f04f88c8d425..1ac3b3b12dc6 100644 --- a/sound/soc/codecs/tlv320aic32x4.c +++ b/sound/soc/codecs/tlv320aic32x4.c @@ -577,12 +577,12 @@ static const struct regmap_range_cfg aic32x4_regmap_pages[] = { .window_start = 0, .window_len = 128, .range_min = 0, - .range_max = AIC32X4_RMICPGAVOL, + .range_max = AIC32X4_REFPOWERUP, }, }; const struct regmap_config aic32x4_regmap_config = { - .max_register = AIC32X4_RMICPGAVOL, + .max_register = AIC32X4_REFPOWERUP, .ranges = aic32x4_regmap_pages, .num_ranges = ARRAY_SIZE(aic32x4_regmap_pages), }; -- 2.27.0

1 0

[PATCH 2/2] ASoC: tlv320aic32x4: Register clocks before registering component
by Annaliese McDermond 29 Mar '21

29 Mar '21

Clock registration must be performed before the component is registered. aic32x4_component_probe attempts to get all the clocks right off the bat. If the component is registered before the clocks there is a race condition where the clocks may not be registered by the time aic32x4_componet_probe actually runs. Fixes: d1c859d ("ASoC: codec: tlv3204: Increased maximum supported channels") Cc: stable(a)vger.kernel.org Signed-off-by: Annaliese McDermond <nh6z(a)nh6z.net> --- sound/soc/codecs/tlv320aic32x4.c | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/sound/soc/codecs/tlv320aic32x4.c b/sound/soc/codecs/tlv320aic32x4.c index 1ac3b3b12dc6..b689f26fc4be 100644 --- a/sound/soc/codecs/tlv320aic32x4.c +++ b/sound/soc/codecs/tlv320aic32x4.c @@ -1243,6 +1243,10 @@ int aic32x4_probe(struct device *dev, struct regmap *regmap) if (ret) goto err_disable_regulators; + ret = aic32x4_register_clocks(dev, aic32x4->mclk_name); + if (ret) + goto err_disable_regulators; + ret = devm_snd_soc_register_component(dev, &soc_component_dev_aic32x4, &aic32x4_dai, 1); if (ret) { @@ -1250,10 +1254,6 @@ int aic32x4_probe(struct device *dev, struct regmap *regmap) goto err_disable_regulators; } - ret = aic32x4_register_clocks(dev, aic32x4->mclk_name); - if (ret) - goto err_disable_regulators; - return 0; err_disable_regulators: -- 2.27.0

1 0

[PATCH 0/2] ASoC: tlv320aic32x4: Bugfixes for tlv320aic32x4 driver
by Annaliese McDermond 29 Mar '21

29 Mar '21

These are a couple of bugfixes for the tlv320aic32x4 driver that we discovered after the Raspberry Pi Foundation's move to the 5.10 kernel. The first increases the maximum value in the regmap configuration so that the powerup command actually works. The second changes the ordering of the clock registration in the module probe function so that the clocks are properly registered before the component probe function runs. Annaliese McDermond (2): ASoC: tlv320aic32x4: Increase maximum register in regmap ASoC: tlv320aic32x4: Register clocks before registering component sound/soc/codecs/tlv320aic32x4.c | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) -- 2.27.0

1 0

[PATCH 1/2] ALSA: hda: Re-add dropped snd_poewr_change_state() calls
by Takashi Iwai 29 Mar '21

29 Mar '21

The card power state change via snd_power_change_state() at the system suspend/resume seems dropped mistakenly during the PM code rewrite. The card power state doesn't play much role nowadays but it's still referred in a few places such as the HDMI codec driver. This patch restores them, but in a more appropriate place now in the prepare and complete callbacks. Fixes: f5dac54d9d93 ("ALSA: hda: Separate runtime and system suspend") Cc: <stable(a)vger.kernel.org> Signed-off-by: Takashi Iwai <tiwai(a)suse.de> --- sound/pci/hda/hda_intel.c | 2 ++ 1 file changed, 2 insertions(+) diff --git a/sound/pci/hda/hda_intel.c b/sound/pci/hda/hda_intel.c index 5b492c3f816c..12e51ac973c4 100644 --- a/sound/pci/hda/hda_intel.c +++ b/sound/pci/hda/hda_intel.c @@ -1025,6 +1025,7 @@ static int azx_prepare(struct device *dev) chip = card->private_data; chip->pm_prepared = 1; + snd_power_change_state(card, SNDRV_CTL_POWER_D3hot); /* HDA controller always requires different WAKEEN for runtime suspend * and system suspend, so don't use direct-complete here. @@ -1038,6 +1039,7 @@ static void azx_complete(struct device *dev) struct azx *chip; chip = card->private_data; + snd_power_change_state(card, SNDRV_CTL_POWER_D0); chip->pm_prepared = 0; } -- 2.26.2

1 1

[PATCH] ALSA: usb-audio: Apply sample rate quirk to Logitech Connect
by Ikjoon Jang 29 Mar '21

29 Mar '21

Logitech ConferenceCam Connect is a compound USB device with UVC and UAC. Not 100% reproducible but sometimes it keeps responding STALL to every control transfer once it receives get_freq request. This patch adds 046d:0x084c to a snd_usb_get_sample_rate_quirk list. Bugzilla: https://bugzilla.kernel.org/show_bug.cgi?id=203419 Signed-off-by: Ikjoon Jang <ikjn(a)chromium.org> --- sound/usb/quirks.c | 1 + 1 file changed, 1 insertion(+) diff --git a/sound/usb/quirks.c b/sound/usb/quirks.c index d3001fb18141..176437a441e6 100644 --- a/sound/usb/quirks.c +++ b/sound/usb/quirks.c @@ -1521,6 +1521,7 @@ bool snd_usb_get_sample_rate_quirk(struct snd_usb_audio *chip) case USB_ID(0x21b4, 0x0081): /* AudioQuest DragonFly */ case USB_ID(0x2912, 0x30c8): /* Audioengine D1 */ case USB_ID(0x413c, 0xa506): /* Dell AE515 sound bar */ + case USB_ID(0x046d, 0x084c): /* Logitech ConferenceCam Connect */ return true; } -- 2.31.0.291.g576ba9dcdaf-goog

4 7

[PATCH] ASoC: audio-graph-card: Add audio mixer for Motorola mdm6600
by Pavel Machek 29 Mar '21

29 Mar '21

motmdm.c handles audio configuration on "gsmtty2"; it needs to know whether we are in call or not; that part is in motmdm-state.c and listens on "gsmtty1". To configure Alsamixer for voice calls do for example: Speaker Right -> Voice Call Noise Cancellation -> Unmute Call Output -> Speakerphone Call -> 100 Mic2 -> 40 Left -> Mic 2 Voice -> 55 Mic2 -> 40 Left -> Mic 2 Tony wrote original version using custom interface to n_gsm, Pavel switched it to plain serdev and split it to two drivers to be easier to debug and understand. Credit is Tony's, bugs are probably Pavel's. Signed-off-by: Pavel Machek <pavel(a)ucw.cz> Co-authored-by: Tony Lindgren <tony(a)atomide.com> --- v2: Fix compile error. --- sound/soc/codecs/Kconfig | 8 + sound/soc/codecs/Makefile | 4 + sound/soc/codecs/motmdm-state.c | 177 ++++++++ sound/soc/codecs/motmdm.c | 688 ++++++++++++++++++++++++++++++++ 4 files changed, 877 insertions(+) create mode 100644 sound/soc/codecs/motmdm-state.c create mode 100644 sound/soc/codecs/motmdm.c diff --git a/sound/soc/codecs/Kconfig b/sound/soc/codecs/Kconfig index ba4eb54aafcb..94000ab3cf3e 100644 --- a/sound/soc/codecs/Kconfig +++ b/sound/soc/codecs/Kconfig @@ -932,6 +932,14 @@ config SND_SOC_MAX9860 depends on I2C select REGMAP_I2C +config SND_SOC_MOTMDM + tristate "Motorola Modem TS 27.010 Voice Call Codec" + depends on SERIAL_DEV_BUS + help + Enable support for Motorola TS 27.010 serdev voice + call codec driver for Motorola Mapphone series of + devices such as Droid 4. + config SND_SOC_MSM8916_WCD_ANALOG tristate "Qualcomm MSM8916 WCD Analog Codec" depends on SPMI || COMPILE_TEST diff --git a/sound/soc/codecs/Makefile b/sound/soc/codecs/Makefile index d277f0366e09..f63022e0a292 100644 --- a/sound/soc/codecs/Makefile +++ b/sound/soc/codecs/Makefile @@ -128,6 +128,8 @@ snd-soc-max9850-objs := max9850.o snd-soc-max9860-objs := max9860.o snd-soc-mc13783-objs := mc13783.o snd-soc-ml26124-objs := ml26124.o +snd-soc-motmdm-objs := motmdm.o +snd-soc-motmdm-state-objs := motmdm-state.o snd-soc-msm8916-analog-objs := msm8916-wcd-analog.o snd-soc-msm8916-digital-objs := msm8916-wcd-digital.o snd-soc-mt6351-objs := mt6351.o @@ -443,6 +445,8 @@ obj-$(CONFIG_SND_SOC_MAX9850) += snd-soc-max9850.o obj-$(CONFIG_SND_SOC_MAX9860) += snd-soc-max9860.o obj-$(CONFIG_SND_SOC_MC13783) += snd-soc-mc13783.o obj-$(CONFIG_SND_SOC_ML26124) += snd-soc-ml26124.o +obj-$(CONFIG_SND_SOC_MOTMDM) += snd-soc-motmdm.o +obj-$(CONFIG_SND_SOC_MOTMDM) += snd-soc-motmdm-state.o obj-$(CONFIG_SND_SOC_MSM8916_WCD_ANALOG) +=snd-soc-msm8916-analog.o obj-$(CONFIG_SND_SOC_MSM8916_WCD_DIGITAL) +=snd-soc-msm8916-digital.o obj-$(CONFIG_SND_SOC_MT6351) += snd-soc-mt6351.o diff --git a/sound/soc/codecs/motmdm-state.c b/sound/soc/codecs/motmdm-state.c new file mode 100644 index 000000000000..a3b2870c5167 --- /dev/null +++ b/sound/soc/codecs/motmdm-state.c @@ -0,0 +1,177 @@ +// SPDX-License-Identifier: GPL-2.0 +/* + * Motorola Mapphone MDM6600 voice call audio support + * Copyright 2018 - 2020 Tony Lindgren <tony(a)atomide.com> + * Copyright 2020 - 2021 Pavel Machek <pavel(a)ucw.cz> + * + * Designed to provide notifications about voice call state to the + * motmdm.c driver. This one listens on "gsmtty1". + */ + +#include <linux/init.h> +#include <linux/kfifo.h> +#include <linux/module.h> +#include <linux/of_graph.h> +#include <linux/platform_device.h> +#include <linux/regmap.h> +#include <linux/serdev.h> + +#include <sound/soc.h> +#include <sound/tlv.h> + +#define MOTMDM_HEADER_LEN 5 /* U1234 */ +#define MOTMDM_AUDIO_MAX_LEN 128 +#define MOTMDM_VOICE_RESP_LEN 7 /* U1234~+CIEV= */ + +struct motmdm_driver_data { + struct serdev_device *serdev; + unsigned char *buf; + size_t len; + spinlock_t lock; /* enable/disabled lock */ +}; + +static BLOCKING_NOTIFIER_HEAD(modem_state_chain_head); + +int register_modem_state_notifier(struct notifier_block *nb) +{ + return blocking_notifier_chain_register(&modem_state_chain_head, nb); +} +EXPORT_SYMBOL_GPL(register_modem_state_notifier); + +int unregister_modem_state_notifier(struct notifier_block *nb) +{ + return blocking_notifier_chain_unregister(&modem_state_chain_head, nb); +} +EXPORT_SYMBOL_GPL(unregister_modem_state_notifier); + +static int modem_state_notifier_call_chain(unsigned long val) +{ + int ret; + ret = __blocking_notifier_call_chain(&modem_state_chain_head, val, NULL, + -1, NULL); + return notifier_to_errno(ret); +} + +/* Parses the voice call state from unsolicited notifications on dlci1 */ +static int motmdm_voice_get_state(struct motmdm_driver_data *ddata, + const unsigned char *buf, + size_t len) +{ + struct device *dev = &ddata->serdev->dev; + bool enable; + const unsigned char *state; + + if (len < MOTMDM_HEADER_LEN + MOTMDM_VOICE_RESP_LEN + 5) + return 0; + + /* We only care about the unsolicted messages */ + if (buf[MOTMDM_HEADER_LEN] != '~') + return 0; + + if (strncmp(buf + MOTMDM_HEADER_LEN + 1, "+CIEV=", 6)) + return len; + + state = buf + MOTMDM_HEADER_LEN + MOTMDM_VOICE_RESP_LEN; + dev_info(dev, "%s: ciev=%5s\n", __func__, state); + + if (!strncmp(state, "1,1,0", 5) || /* connecting */ + !strncmp(state, "1,4,0", 5) || /* incoming call */ + !strncmp(state, "1,2,0", 5)) /* connected */ + enable = true; + else if (!strncmp(state, "1,0,0", 5) || /* disconnected */ + !strncmp(state, "1,0,2", 5)) /* call failed */ + enable = false; + else + return len; + + modem_state_notifier_call_chain(enable); + return len; +} + +static int voice_receive_data(struct serdev_device *serdev, + const unsigned char *buf, + size_t len) +{ + struct motmdm_driver_data *ddata = serdev_device_get_drvdata(serdev); + + if (len > MOTMDM_AUDIO_MAX_LEN) + len = MOTMDM_AUDIO_MAX_LEN; + + if (len <= MOTMDM_HEADER_LEN) + return 0; + + if (buf[MOTMDM_HEADER_LEN] == '~') + motmdm_voice_get_state(ddata, buf, len); + + return len; +} + +static const struct serdev_device_ops voice_serdev_ops = { + .receive_buf = voice_receive_data, + .write_wakeup = serdev_device_write_wakeup, +}; + +static void motmdm_free_voice_serdev(struct motmdm_driver_data *ddata) +{ + serdev_device_close(ddata->serdev); +} + +static int motmdm_soc_probe(struct serdev_device *serdev) +{ + struct device *dev = &serdev->dev; + struct motmdm_driver_data *ddata; + int error; + + ddata = devm_kzalloc(dev, sizeof(*ddata), GFP_KERNEL); + if (!ddata) + return -ENOMEM; + + ddata->serdev = serdev; + spin_lock_init(&ddata->lock); + ddata->len = MOTMDM_AUDIO_MAX_LEN; + + ddata->buf = devm_kzalloc(dev, ddata->len, GFP_KERNEL); + if (!ddata->buf) + return -ENOMEM; + + serdev_device_set_drvdata(ddata->serdev, ddata); + serdev_device_set_client_ops(ddata->serdev, &voice_serdev_ops); + + error = serdev_device_open(ddata->serdev); + return error; +} + +static void motmdm_state_remove(struct serdev_device *serdev) +{ + struct motmdm_driver_data *ddata = serdev_device_get_drvdata(serdev); + + motmdm_free_voice_serdev(ddata); +} + +static int motmdm_state_probe(struct serdev_device *serdev) +{ + return motmdm_soc_probe(serdev); +} + +#ifdef CONFIG_OF +static const struct of_device_id motmdm_of_match[] = { + { .compatible = "motorola,mapphone-mdm6600-modem" }, + {}, +}; +MODULE_DEVICE_TABLE(of, motmdm_of_match); +#endif + +static struct serdev_device_driver motmdm_state_driver = { + .driver = { + .name = "mot-mdm6600-modem", + .of_match_table = of_match_ptr(motmdm_of_match), + }, + .probe = motmdm_state_probe, + .remove = motmdm_state_remove, +}; +module_serdev_device_driver(motmdm_state_driver); + +MODULE_ALIAS("platform:motmdm-state"); +MODULE_DESCRIPTION("Motorola Mapphone MDM6600 modem state driver"); +MODULE_AUTHOR("Pavel Machek <pavel(a)ucw.cz>"); +MODULE_LICENSE("GPL v2"); diff --git a/sound/soc/codecs/motmdm.c b/sound/soc/codecs/motmdm.c new file mode 100644 index 000000000000..93615a01ff1b --- /dev/null +++ b/sound/soc/codecs/motmdm.c @@ -0,0 +1,688 @@ +// SPDX-License-Identifier: GPL-2.0 +/* + * Motorola Mapphone MDM6600 voice call audio support + * Copyright 2018 - 2020 Tony Lindgren <tony(a)atomide.com> + * Copyright 2020 - 2021 Pavel Machek <pavel(a)ucw.cz> + * + * This one handles audio configuration on "gsmtty2"; it needs to know + * whether we are in call or not, and that part is in motmdm-state.c + * and listens on "gsmtty1". + */ + +#include <linux/init.h> +#include <linux/kfifo.h> +#include <linux/module.h> +#include <linux/of_graph.h> +#include <linux/platform_device.h> +#include <linux/regmap.h> +#include <linux/serdev.h> + +#include <sound/soc.h> +#include <sound/tlv.h> + +#include "motmdm-state.h" + +#define MOTMDM_HEADER_LEN 5 /* U1234 */ + +#define MOTMDM_AUDIO_RESP_LEN 6 /* U1234+XXXX= */ +#define MOTMDM_AUDIO_MAX_LEN 128 + +#define MOTMDM_VOICE_RESP_LEN 7 /* U1234~+CIEV= */ + +struct motmdm_driver_data { + struct notifier_block notifier; + struct snd_soc_component *component; + struct snd_soc_dai *master_dai; + struct device *modem; + struct serdev_device *serdev; + struct regmap *regmap; + unsigned char *buf; + size_t len; + unsigned int parsed:1; + unsigned int enabled:1; + spinlock_t lock; /* enable/disabled lock */ + struct mutex mutex; /* for sending commands */ + wait_queue_head_t read_queue; + + unsigned int dtmf_val; + unsigned int dtmf_en; +}; + +enum motmdm_cmd { + CMD_AT_EACC, + CMD_AT_CLVL, + CMD_AT_NREC, +}; + +const char * const motmd_read_fmt[] = { + [CMD_AT_EACC] = "AT+EACC?", + [CMD_AT_CLVL] = "AT+CLVL?", + [CMD_AT_NREC] = "AT+NREC?", +}; + +const char * const motmd_write_fmt[] = { + [CMD_AT_EACC] = "AT+EACC=%u,0", + [CMD_AT_CLVL] = "AT+CLVL=%u", + [CMD_AT_NREC] = "AT+NREC=%u", +}; + +/* + * Currently unconfigured additional inactive (error producing) options + * seem to be: + * "TTY Headset", "HCQ Headset", "VCQ Headset", "No-Mic Headset", + * "Handset Fluence Med", "Handset Fluence Low", "Car Dock", "Lapdock" + */ +static const char * const motmdm_out_mux_texts[] = { + "Handset", "Headset", "Speakerphone", "Bluetooth", +}; + +static SOC_ENUM_SINGLE_EXT_DECL(motmdm_out_enum, motmdm_out_mux_texts); + +static const DECLARE_TLV_DB_SCALE(motmdm_gain_tlv, 0, 100, 0); + +int motmdm_send_command(struct motmdm_driver_data *ddata, + const u8 *buf, int len) +{ + struct device *dev = ddata->component->dev; + const int timeout_ms = 1000; + unsigned char cmd[MOTMDM_AUDIO_MAX_LEN]; + int ret, cmdlen; + + cmdlen = len + 5 + 1; + if (cmdlen > MOTMDM_AUDIO_MAX_LEN) + return -EINVAL; + + mutex_lock(&ddata->mutex); + memset(ddata->buf, 0, ddata->len); + ddata->parsed = false; + snprintf(cmd, cmdlen, "U%04li%s", jiffies % 10000, buf); + + ret = serdev_device_write(ddata->serdev, cmd, cmdlen, MAX_SCHEDULE_TIMEOUT); + if (ret < 0) + goto out_unlock; + + serdev_device_wait_until_sent(ddata->serdev, 0); + + ret = wait_event_timeout(ddata->read_queue, ddata->parsed, + msecs_to_jiffies(timeout_ms)); + if (ret == 0) { + ret = -ETIMEDOUT; + goto out_unlock; + } else if (ret < 0) { + goto out_unlock; + } + + if (strstr(ddata->buf, "ERROR")) { + dev_err(dev, "command %s error %s\n", cmd, ddata->buf); + ret = -EPIPE; + } + + ret = len; + +out_unlock: + mutex_unlock(&ddata->mutex); + printk("send_command -- ret %d\n", ret); + + return ret; +} + +static int motmdm_read_reg(void *context, unsigned int reg, + unsigned int *value) +{ + struct snd_soc_component *component = context; + struct motmdm_driver_data *ddata = snd_soc_component_get_drvdata(component); + const unsigned char *cmd; + unsigned int val; + int error; + + cmd = motmd_read_fmt[reg]; + error = motmdm_send_command(ddata, cmd, strlen(cmd)); + if (error < 0) { + dev_err(component->dev, "%s: %s failed with %i\n", + __func__, cmd, error); + + return error; + } + + error = kstrtouint(ddata->buf + MOTMDM_AUDIO_RESP_LEN, 0, &val); + if (error) + return -ENODEV; + + *value = val; + + return error; +} + +static int motmdm_write_reg(void *context, unsigned int reg, + unsigned int value) +{ + struct snd_soc_component *component = context; + struct motmdm_driver_data *ddata = snd_soc_component_get_drvdata(component); + const unsigned char *fmt, *cmd; + int error; + + fmt = motmd_write_fmt[reg]; + cmd = kasprintf(GFP_KERNEL, fmt, value); + if (!cmd) { + error = -ENOMEM; + goto free; + } + + error = motmdm_send_command(ddata, cmd, strlen(cmd)); + if (error < 0) + dev_err(component->dev, "%s: %s failed with %i\n", + __func__, cmd, error); + +free: + kfree(cmd); + + return error; +} + +static const struct reg_default motmdm_reg_defaults[] = { + { CMD_AT_EACC, 0x0 }, + { CMD_AT_CLVL, 0x0 }, +}; + +static const struct regmap_config motmdm_regmap = { + .reg_bits = 32, + .reg_stride = 1, + .val_bits = 32, + .max_register = CMD_AT_NREC, + .reg_defaults = motmdm_reg_defaults, + .num_reg_defaults = ARRAY_SIZE(motmdm_reg_defaults), + .cache_type = REGCACHE_RBTREE, + .reg_read = motmdm_read_reg, + .reg_write = motmdm_write_reg, +}; + +static int motmdm_value_get(struct snd_kcontrol *kcontrol, + struct snd_ctl_elem_value *ucontrol, + enum motmdm_cmd reg, + int cmd_base) +{ + struct snd_soc_component *component = snd_soc_kcontrol_component(kcontrol); + struct motmdm_driver_data *ddata = snd_soc_component_get_drvdata(component); + unsigned int val; + int error; + + error = regmap_read(ddata->regmap, reg, &val); + if (error) + return error; + + if (val >= cmd_base) + val -= cmd_base; + + ucontrol->value.enumerated.item[0] = val; + + return 0; +} + +static int motmdm_value_put(struct snd_kcontrol *kcontrol, + struct snd_ctl_elem_value *ucontrol, + enum motmdm_cmd reg, + int cmd_base) +{ + struct snd_soc_component *component = snd_soc_kcontrol_component(kcontrol); + struct motmdm_driver_data *ddata = snd_soc_component_get_drvdata(component); + int error; + + error = regmap_write(ddata->regmap, reg, + ucontrol->value.enumerated.item[0] + cmd_base); + if (error) + return error; + + regcache_mark_dirty(ddata->regmap); + + return error; +} + +static int motmdm_audio_out_get(struct snd_kcontrol *kcontrol, + struct snd_ctl_elem_value *ucontrol) +{ + return motmdm_value_get(kcontrol, ucontrol, CMD_AT_EACC, 1); +} + +static int motmdm_audio_out_put(struct snd_kcontrol *kcontrol, + struct snd_ctl_elem_value *ucontrol) +{ + return motmdm_value_put(kcontrol, ucontrol, CMD_AT_EACC, 1); +} + +static int motmdm_gain_get(struct snd_kcontrol *kcontrol, + struct snd_ctl_elem_value *ucontrol) +{ + return motmdm_value_get(kcontrol, ucontrol, CMD_AT_CLVL, 0); +} + +static int motmdm_gain_put(struct snd_kcontrol *kcontrol, + struct snd_ctl_elem_value *ucontrol) +{ + return motmdm_value_put(kcontrol, ucontrol, CMD_AT_CLVL, 0); +} + +static int motmdm_noise_get(struct snd_kcontrol *kcontrol, + struct snd_ctl_elem_value *ucontrol) +{ + return motmdm_value_get(kcontrol, ucontrol, CMD_AT_NREC, 0); +} + +static int motmdm_noise_put(struct snd_kcontrol *kcontrol, + struct snd_ctl_elem_value *ucontrol) +{ + return motmdm_value_put(kcontrol, ucontrol, CMD_AT_NREC, 0); +} + +static const char * const motmdm_tonegen_dtmf_key_txt[] = { + "0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "A", "B", "C", "D", + "*", "#" +}; + +static SOC_ENUM_SINGLE_EXT_DECL(motmd_tonegen_dtmf_enum, + motmdm_tonegen_dtmf_key_txt); + +static int motmdm_dtmf_get(struct snd_kcontrol *kcontrol, + struct snd_ctl_elem_value *ucontrol) +{ + struct snd_soc_component *component = + snd_soc_kcontrol_component(kcontrol); + struct motmdm_driver_data *ddata = + snd_soc_component_get_drvdata(component); + + ucontrol->value.enumerated.item[0] = ddata->dtmf_val; + + return 0; +} + +static int motmdm_dtmf_put(struct snd_kcontrol *kcontrol, + struct snd_ctl_elem_value *ucontrol) +{ + struct snd_soc_component *component = + snd_soc_kcontrol_component(kcontrol); + struct motmdm_driver_data *ddata = + snd_soc_component_get_drvdata(component); + + ddata->dtmf_val = ucontrol->value.enumerated.item[0]; + + return 0; +} + +static int motmdm_tonegen_dtmf_send_get(struct snd_kcontrol *kcontrol, + struct snd_ctl_elem_value *ucontrol) +{ + struct snd_soc_component *component = + snd_soc_kcontrol_component(kcontrol); + struct motmdm_driver_data *ddata = + snd_soc_component_get_drvdata(component); + + ucontrol->value.enumerated.item[0] = ddata->dtmf_en; + + return 0; +} + +static int motmdm_tonegen_dtmf_send_put(struct snd_kcontrol *kcontrol, + struct snd_ctl_elem_value *ucontrol) +{ + struct snd_soc_component *component = + snd_soc_kcontrol_component(kcontrol); + struct motmdm_driver_data *ddata = + snd_soc_component_get_drvdata(component); + const unsigned char *cmd, *fmt = "AT+DTSE=%s,%i"; + const char *tone = ""; + int error; + + if (!ddata->enabled) + return 0; + + ddata->dtmf_en = ucontrol->value.enumerated.item[0]; + if (ddata->dtmf_en) + tone = motmdm_tonegen_dtmf_key_txt[ddata->dtmf_val]; + + /* Value 0 enables tone generator, 1 disables it */ + cmd = kasprintf(GFP_KERNEL, fmt, tone, !ddata->dtmf_en); + + error = motmdm_send_command(ddata, cmd, strlen(cmd)); + if (error < 0) { + dev_err(component->dev, "%s: %s failed with %i\n", + __func__, cmd, error); + goto free; + } + +free: + kfree(cmd); + + return error; +} + +static int +motmdm_enable_primary_dai(struct snd_soc_component *component) +{ + struct motmdm_driver_data *ddata = + snd_soc_component_get_drvdata(component); + int error; + + if (!ddata->master_dai) + return -ENODEV; + + error = snd_soc_dai_set_sysclk(ddata->master_dai, 1, 19200000, + SND_SOC_CLOCK_OUT); + if (error) + return error; + + error = snd_soc_dai_set_fmt(ddata->master_dai, + SND_SOC_DAIFMT_I2S | + SND_SOC_DAIFMT_NB_NF | + SND_SOC_DAIFMT_CBM_CFM); + if (error) + return error; + + error = snd_soc_dai_set_tdm_slot(ddata->master_dai, 0, 1, 1, 8); + if (error) + return error; + + return error; +} + +static int +motmdm_disable_primary_dai(struct snd_soc_component *component) +{ + struct motmdm_driver_data *ddata = + snd_soc_component_get_drvdata(component); + int error; + + if (!ddata->master_dai) { + return -ENODEV; + } + + error = snd_soc_dai_set_sysclk(ddata->master_dai, 0, 26000000, + SND_SOC_CLOCK_OUT); + if (error) { + return error; + } + + error = snd_soc_dai_set_fmt(ddata->master_dai, + SND_SOC_DAIFMT_CBM_CFM); + if (error) { + return error; + } + + error = snd_soc_dai_set_tdm_slot(ddata->master_dai, 0, 0, 0, 48); + if (error) { + return error; + } + + return error; +} + +static int motmdm_find_primary_dai(struct snd_soc_component *component, + const char *name) +{ + struct motmdm_driver_data *ddata = + snd_soc_component_get_drvdata(component); + struct device_node *bitclkmaster = NULL, *framemaster = NULL; + struct device_node *ep, *master_ep, *master = NULL; + struct snd_soc_dai_link_component dlc = { 0 }; + unsigned int daifmt; + + ep = of_graph_get_next_endpoint(component->dev->of_node, NULL); + if (!ep) + return -ENODEV; + + master_ep = of_graph_get_remote_endpoint(ep); + of_node_put(ep); + if (!master_ep) + return -ENODEV; + + daifmt = snd_soc_of_parse_daifmt(master_ep, NULL, + &bitclkmaster, &framemaster); + of_node_put(master_ep); + if (bitclkmaster && framemaster) + master = of_graph_get_port_parent(bitclkmaster); + of_node_put(bitclkmaster); + of_node_put(framemaster); + if (!master) + return -ENODEV; + + dlc.of_node = master; + dlc.dai_name = name; + ddata->master_dai = snd_soc_find_dai(&dlc); + of_node_put(master); + if (!ddata->master_dai) + return -EPROBE_DEFER; + + dev_info(component->dev, "Master DAI is %s\n", + dev_name(ddata->master_dai->dev)); + + return 0; +} + +static int motmdm_parse_tdm(struct snd_soc_component *component) +{ + return motmdm_find_primary_dai(component, "cpcap-voice"); +} + +static const struct snd_kcontrol_new motmdm_snd_controls[] = { + SOC_ENUM_EXT("Call Output", motmdm_out_enum, + motmdm_audio_out_get, + motmdm_audio_out_put), + SOC_SINGLE_EXT_TLV("Call Volume", + 0, 0, 7, 0, + motmdm_gain_get, + motmdm_gain_put, + motmdm_gain_tlv), + SOC_SINGLE_BOOL_EXT("Call Noise Cancellation", 0, + motmdm_noise_get, + motmdm_noise_put), + SOC_ENUM_EXT("Call DTMF", motmd_tonegen_dtmf_enum, + motmdm_dtmf_get, + motmdm_dtmf_put), + SOC_SINGLE_BOOL_EXT("Call DTMF Send", 0, + motmdm_tonegen_dtmf_send_get, + motmdm_tonegen_dtmf_send_put), +}; + +static struct snd_soc_dai_driver motmdm_dai[] = { + { + .name = "mdm-call", + .playback = { + .stream_name = "Voice Call Playback", + .channels_min = 1, + .channels_max = 2, + .rates = SNDRV_PCM_RATE_8000 | SNDRV_PCM_RATE_16000, + .formats = SNDRV_PCM_FMTBIT_S16_LE, + }, + .capture = { + .stream_name = "Voice Call Capture", + .channels_min = 1, + .channels_max = 2, + .rates = SNDRV_PCM_RATE_8000 | SNDRV_PCM_RATE_16000, + .formats = SNDRV_PCM_FMTBIT_S16_LE, + }, + }, +}; + +static int +motmdm_notifier_call(struct notifier_block *bl, unsigned long state, + void *unused) +{ + struct motmdm_driver_data *ddata = + container_of(bl, struct motmdm_driver_data, notifier); + bool enable, notify = false; + unsigned long flags; + + enable = !!state; + + spin_lock_irqsave(&ddata->lock, flags); + if (ddata->enabled != enable) { + ddata->enabled = enable; + notify = true; + } + spin_unlock_irqrestore(&ddata->lock, flags); + + if (!notify) + return NOTIFY_DONE; + + if (enable) + motmdm_enable_primary_dai(ddata->component); + else + motmdm_disable_primary_dai(ddata->component); + + return NOTIFY_DONE; +} + +static int voice_receive_data(struct serdev_device *serdev, + const unsigned char *buf, + size_t len) +{ + struct motmdm_driver_data *ddata = serdev_device_get_drvdata(serdev); + struct device *dev = ddata->component->dev; + + printk("voice_receive_data: have %s %d\n", buf, len); + + if (len > MOTMDM_AUDIO_MAX_LEN) + len = MOTMDM_AUDIO_MAX_LEN; + + if (len <= MOTMDM_HEADER_LEN) + return 0; + + printk("voice_receive_data: command reply? -- %s %d\n", buf, len); + + snprintf(ddata->buf, len - MOTMDM_HEADER_LEN, buf + MOTMDM_HEADER_LEN); + dev_info(dev, "%s: received: %s\n", __func__, ddata->buf); + ddata->parsed = true; + wake_up(&ddata->read_queue); + + return len; +} + +static const struct serdev_device_ops voice_serdev_ops = { + .receive_buf = voice_receive_data, + .write_wakeup = serdev_device_write_wakeup, +}; + +static void motmdm_free_voice_serdev(struct motmdm_driver_data *ddata) +{ + serdev_device_close(ddata->serdev); +} + +static int motmdm_soc_probe(struct snd_soc_component *component) +{ + struct motmdm_driver_data *ddata; + const unsigned char *cmd = "AT+CMUT=0"; + int error; + u32 line; + + ddata = devm_kzalloc(component->dev, sizeof(*ddata), GFP_KERNEL); + if (!ddata) + return -ENOMEM; + + error = of_property_read_u32(component->dev->of_node, "reg", &line); + if (error) + return error; + + ddata->serdev = (struct serdev_device *) component->dev; + ddata->component = component; + ddata->modem = component->dev->parent; + mutex_init(&ddata->mutex); + init_waitqueue_head(&ddata->read_queue); + ddata->len = PAGE_SIZE; + spin_lock_init(&ddata->lock); + snd_soc_component_set_drvdata(component, ddata); + ddata->len = MOTMDM_AUDIO_MAX_LEN; + + ddata->buf = devm_kzalloc(component->dev, ddata->len, GFP_KERNEL); + if (!ddata->buf) + return -ENOMEM; + + ddata->regmap = devm_regmap_init(component->dev, NULL, component, + &motmdm_regmap); + if (IS_ERR(ddata->regmap)) { + error = PTR_ERR(ddata->regmap); + dev_err(component->dev, "%s: Failed to allocate regmap: %d\n", + __func__, error); + + return error; + } + + serdev_device_set_drvdata(ddata->serdev, ddata); + serdev_device_set_client_ops(ddata->serdev, &voice_serdev_ops); + + error = serdev_device_open(ddata->serdev); + if (error) + return error; + + error = motmdm_parse_tdm(component); + if (error) + goto unregister_serdev; + + regcache_sync(ddata->regmap); + + error = motmdm_send_command(ddata, cmd, strlen(cmd)); + if (error < 0) + goto unregister_serdev; + + error = motmdm_disable_primary_dai(ddata->component); + if (error) + goto unregister_serdev; + + ddata->notifier.notifier_call = motmdm_notifier_call; + register_modem_state_notifier(&ddata->notifier); + + return 0; + +unregister_serdev: + motmdm_free_voice_serdev(ddata); + serdev_device_close(ddata->serdev); + + return error; +} + +static void motmdm_soc_remove(struct snd_soc_component *component) +{ + struct motmdm_driver_data *ddata = snd_soc_component_get_drvdata(component); + + unregister_modem_state_notifier(&ddata->notifier); + + motmdm_free_voice_serdev(ddata); +} + +static struct snd_soc_component_driver soc_codec_dev_motmdm = { + .probe = motmdm_soc_probe, + .remove = motmdm_soc_remove, + .controls = motmdm_snd_controls, + .num_controls = ARRAY_SIZE(motmdm_snd_controls), + .idle_bias_on = 1, + .use_pmdown_time = 1, + .endianness = 1, + .non_legacy_dai_naming = 1, +}; + +static int motmdm_codec_probe(struct serdev_device *serdev) +{ + return devm_snd_soc_register_component(&serdev->dev, + &soc_codec_dev_motmdm, + motmdm_dai, + ARRAY_SIZE(motmdm_dai)); +} + +#ifdef CONFIG_OF +static const struct of_device_id motmdm_of_match[] = { + { .compatible = "motorola,mapphone-mdm6600-codec" }, + {}, +}; +MODULE_DEVICE_TABLE(of, motmdm_of_match); +#endif + +static struct serdev_device_driver motmdm_driver = { + .probe = motmdm_codec_probe, + .driver = { + .name = "mot-mdm6600-codec", + .of_match_table = of_match_ptr(motmdm_of_match), + }, +}; +module_serdev_device_driver(motmdm_driver); + +MODULE_ALIAS("platform:motmdm-codec"); +MODULE_DESCRIPTION("ASoC Motorola Mapphone MDM6600 codec driver"); +MODULE_AUTHOR("Tony Lindgren <tony(a)atomide.com>"); +MODULE_LICENSE("GPL v2"); -- 2.20.1 -- http://www.livejournal.com/~pavelmachek

3 2

[PATCH v5 1/2] platform/x86: dell-privacy: Add support for Dell hardware privacy
by Perry Yuan 28 Mar '21

28 Mar '21

From: Perry Yuan <perry_yuan(a)dell.com> add support for Dell privacy driver for the Dell units equipped hardware privacy design, which protect users privacy of audio and camera from hardware level. Once the audio or camera privacy mode activated, any applications will not get any audio or video stream when user pressed ctrl+F4 hotkey, audio privacy mode will be enabled, micmute led will be also changed accordingly The micmute led is fully controlled by hardware & EC(embedded controller) and camera mute hotkey is Ctrl+F9. Currently design only emmits SW_CAMERA_LENS_COVER event while the camera lens shutter will be changed by EC & hw(hadware) control *The flow is like this: 1) User presses key. HW does stuff with this key (timeout timer is started) 2) WMI event is emitted from BIOS to kernel 3) WMI event is received by dell-privacy 4) KEY_MICMUTE emitted from dell-privacy 5) Userland picks up key and modifies kcontrol for SW mute 6) Codec kernel driver catches and calls ledtrig_audio_set, like this: ledtrig_audio_set(LED_AUDIO_MICMUTE, rt715->micmute_led ? LED_ON :LED_OFF); 7) If "LED" is set to on dell-privacy notifies EC, and timeout is cancelled, HW mic mute activated. Signed-off-by: Perry Yuan <perry_yuan(a)dell.com> --- v4 -> v5: * addressed feedback from Randy Dunlap * addressed feedback from Pierre-Louis Bossart * rebase to latest 5.12 rc4 upstream kernel * fix some space alignment problem v3 -> v4: * fix format for Kconfig * add sysfs document * add flow comments to the privacy wmi/acpi driver * addressed feedback from Barnabás Pőcze[Thanks very much] * export privacy_valid to make the global state simpler to query * fix one issue which will block the dell-laptop driver to load when privacy driver invalid * addressed feedback from Pierre-Louis Bossart,remove the EC ID match v2 -> v3: * add sysfs attributes doc v1 -> v2: * query EC handle from EC driver directly. * fix some code style. * add KEY_END to keymap array. * clean platform device when cleanup called * use hexadecimal format for log print in dev_dbg * remove __set_bit for the report keys from probe. * fix keymap leak * add err_free_keymap in dell_privacy_wmi_probe * wmi driver will be unregistered if privacy_acpi_init() fails * add sysfs attribute files for user space query. * add leds micmute driver to privacy acpi * add more design info the commit info --- --- .../testing/sysfs-platform-dell-privacy-wmi | 32 ++ drivers/platform/x86/dell/Kconfig | 16 + drivers/platform/x86/dell/Makefile | 3 + drivers/platform/x86/dell/dell-laptop.c | 23 +- drivers/platform/x86/dell/dell-privacy-acpi.c | 164 +++++++++ drivers/platform/x86/dell/dell-privacy-wmi.c | 340 ++++++++++++++++++ drivers/platform/x86/dell/dell-privacy-wmi.h | 35 ++ drivers/platform/x86/dell/dell-wmi.c | 27 +- 8 files changed, 627 insertions(+), 13 deletions(-) create mode 100644 Documentation/ABI/testing/sysfs-platform-dell-privacy-wmi create mode 100644 drivers/platform/x86/dell/dell-privacy-acpi.c create mode 100644 drivers/platform/x86/dell/dell-privacy-wmi.c create mode 100644 drivers/platform/x86/dell/dell-privacy-wmi.h diff --git a/Documentation/ABI/testing/sysfs-platform-dell-privacy-wmi b/Documentation/ABI/testing/sysfs-platform-dell-privacy-wmi new file mode 100644 index 000000000000..20c15a51ec38 --- /dev/null +++ b/Documentation/ABI/testing/sysfs-platform-dell-privacy-wmi @@ -0,0 +1,32 @@ +What: /sys/bus/wmi/devices/6932965F-1671-4CEB-B988-D3AB0A901919/devices_supported +Date: Feb 2021 +KernelVersion: 5.12 +Contact: "perry.yuan(a)dell.com>" +Description: + Display which dell hardware level privacy devices are supported + “Dell Privacy” is a set of HW, FW, and SW features to enhance + Dell’s commitment to platform privacy for MIC, Camera, and + ePrivacy screens. + The supported hardware privacy devices are: + - 0 = Not Supported + - 1 = Supported + - Bit0 -> Microphone + - Bit1 -> Camera + - Bit2 -> ePrivacy Screen + +What: /sys/bus/wmi/devices/6932965F-1671-4CEB-B988-D3AB0A901919/current_state +Date: Feb 2021 +KernelVersion: 5.12 +Contact: "perry.yuan(a)dell.com>" +Description: + Allow user space to check current dell privacy device state. + Describes the Device State class exposed by BIOS which can be + consumed by various applications interested in knowing the Privacy + feature capabilities + There are three Bits for available states: + - 0 = Enabled + - 1 = Disabled + - Bit0 -> Microphone + - Bit1 -> Camera + - Bit2 -> ePrivacyScreen + diff --git a/drivers/platform/x86/dell/Kconfig b/drivers/platform/x86/dell/Kconfig index e0a55337f51a..0e0f1eb35bd6 100644 --- a/drivers/platform/x86/dell/Kconfig +++ b/drivers/platform/x86/dell/Kconfig @@ -204,4 +204,20 @@ config DELL_WMI_SYSMAN To compile this driver as a module, choose M here: the module will be called dell-wmi-sysman. +config DELL_PRIVACY + tristate "Dell Hardware Privacy Support" + depends on ACPI + depends on ACPI_WMI + depends on INPUT + depends on DELL_LAPTOP + depends on LEDS_TRIGGER_AUDIO + select DELL_WMI + help + This driver provides support for the "Dell Hardware Privacy" feature + of Dell laptops. + Support for a micmute and camera mute privacy will be provided as + hardware button Ctrl+F4 and Ctrl+F9 hotkey. + + To compile this driver as a module, choose M here: the module will + be called dell_privacy. endif # X86_PLATFORM_DRIVERS_DELL diff --git a/drivers/platform/x86/dell/Makefile b/drivers/platform/x86/dell/Makefile index d720a3e42ae3..8b0883ee9412 100644 --- a/drivers/platform/x86/dell/Makefile +++ b/drivers/platform/x86/dell/Makefile @@ -19,3 +19,6 @@ obj-$(CONFIG_DELL_WMI_AIO) += dell-wmi-aio.o obj-$(CONFIG_DELL_WMI_DESCRIPTOR) += dell-wmi-descriptor.o obj-$(CONFIG_DELL_WMI_LED) += dell-wmi-led.o obj-$(CONFIG_DELL_WMI_SYSMAN) += dell-wmi-sysman/ +obj-$(CONFIG_DELL_PRIVACY) += dell-privacy.o +dell-privacy-objs := dell-privacy-wmi.o \ + dell-privacy-acpi.o diff --git a/drivers/platform/x86/dell/dell-laptop.c b/drivers/platform/x86/dell/dell-laptop.c index 70edc5bb3a14..4c840ab6cb59 100644 --- a/drivers/platform/x86/dell/dell-laptop.c +++ b/drivers/platform/x86/dell/dell-laptop.c @@ -31,6 +31,8 @@ #include "dell-rbtn.h" #include "dell-smbios.h" +#include "dell-privacy-wmi.h" + struct quirk_entry { bool touchpad_led; bool kbd_led_not_present; @@ -90,6 +92,7 @@ static struct rfkill *wifi_rfkill; static struct rfkill *bluetooth_rfkill; static struct rfkill *wwan_rfkill; static bool force_rfkill; +static bool has_privacy; module_param(force_rfkill, bool, 0444); MODULE_PARM_DESC(force_rfkill, "enable rfkill on non whitelisted models"); @@ -2206,10 +2209,16 @@ static int __init dell_init(void) if (dell_smbios_find_token(GLOBAL_MIC_MUTE_DISABLE) && dell_smbios_find_token(GLOBAL_MIC_MUTE_ENABLE)) { - micmute_led_cdev.brightness = ledtrig_audio_get(LED_AUDIO_MICMUTE); - ret = led_classdev_register(&platform_device->dev, &micmute_led_cdev); - if (ret < 0) - goto fail_led; + if (!privacy_valid) + has_privacy = true; + else + has_privacy = false; + if (!has_privacy) { + micmute_led_cdev.brightness = ledtrig_audio_get(LED_AUDIO_MICMUTE); + ret = led_classdev_register(&platform_device->dev, &micmute_led_cdev); + if (ret < 0) + goto fail_led; + } } if (acpi_video_get_backlight_type() != acpi_backlight_vendor) @@ -2257,7 +2266,8 @@ static int __init dell_init(void) fail_get_brightness: backlight_device_unregister(dell_backlight_device); fail_backlight: - led_classdev_unregister(&micmute_led_cdev); + if (!has_privacy) + led_classdev_unregister(&micmute_led_cdev); fail_led: dell_cleanup_rfkill(); fail_rfkill: @@ -2278,7 +2288,8 @@ static void __exit dell_exit(void) touchpad_led_exit(); kbd_led_exit(); backlight_device_unregister(dell_backlight_device); - led_classdev_unregister(&micmute_led_cdev); + if (!has_privacy) + led_classdev_unregister(&micmute_led_cdev); dell_cleanup_rfkill(); if (platform_device) { platform_device_unregister(platform_device); diff --git a/drivers/platform/x86/dell/dell-privacy-acpi.c b/drivers/platform/x86/dell/dell-privacy-acpi.c new file mode 100644 index 000000000000..4c785b62c7c4 --- /dev/null +++ b/drivers/platform/x86/dell/dell-privacy-acpi.c @@ -0,0 +1,164 @@ +// SPDX-License-Identifier: GPL-2.0-only +/* + * Dell privacy notification driver + * + * Copyright (C) 2021 Dell Inc. All Rights Reserved. + */ + +#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt + +#include <linux/acpi.h> +#include <linux/bits.h> +#include <linux/device.h> +#include <linux/fs.h> +#include <linux/kernel.h> +#include <linux/leds.h> +#include <linux/module.h> +#include <linux/mutex.h> +#include <linux/platform_device.h> +#include <linux/string.h> +#include <linux/sysfs.h> +#include <linux/slab.h> +#include <linux/types.h> +#include <linux/wmi.h> + +#include "dell-privacy-wmi.h" + +#define PRIVACY_PLATFORM_NAME "dell-privacy-acpi" +#define DELL_PRIVACY_GUID "6932965F-1671-4CEB-B988-D3AB0A901919" + +struct privacy_acpi_priv { + struct device *dev; + struct platform_device *platform_device; + struct led_classdev cdev; +}; +static struct privacy_acpi_priv *privacy_acpi; + +static int dell_privacy_micmute_led_set(struct led_classdev *led_cdev, + enum led_brightness brightness) +{ + struct privacy_acpi_priv *priv = privacy_acpi; + acpi_status status; + acpi_handle handle; + static char *acpi_method = (char *)"ECAK"; + + handle = ec_get_handle(); + if (!handle) + return -EIO; + if (!acpi_has_method(handle, acpi_method)) + return -EIO; + status = acpi_evaluate_object(handle, acpi_method, NULL, NULL); + if (ACPI_FAILURE(status)) { + dev_err(priv->dev, "Error setting privacy EC ack value: %s\n", + acpi_format_exception(status)); + return -EIO; + } + pr_debug("set dell privacy micmute ec ack event done\n"); + return 0; +} + +static int dell_privacy_acpi_remove(struct platform_device *pdev) +{ + struct privacy_acpi_priv *priv = dev_get_drvdata(privacy_acpi->dev); + + led_classdev_unregister(&priv->cdev); + + return 0; +} +/* + * Pressing the mute key activates a time delayed circuit to physically cut + * off the mute. The LED is in the same circuit, so it reflects the true + * state of the HW mute. The reason for the EC "ack" is so that software + * can first invoke a SW mute before the HW circuit is cut off. Without SW + * cutting this off first does not affect the time delayed muting or status + * of the LED but there is a possibility of a "popping" noise. + * + * If the EC receives the SW ack, the circuit will be activated before the + * delay completed. + * + * Exposing as an LED device allows the codec drivers notification path to + * EC ACK to work + */ +static int dell_privacy_leds_setup(struct device *dev) +{ + struct privacy_acpi_priv *priv = dev_get_drvdata(dev); + int ret = 0; + + priv->cdev.name = "dell-privacy::micmute"; + priv->cdev.max_brightness = 1; + priv->cdev.brightness_set_blocking = dell_privacy_micmute_led_set; + priv->cdev.default_trigger = "audio-micmute"; + priv->cdev.brightness = ledtrig_audio_get(LED_AUDIO_MICMUTE); + ret = devm_led_classdev_register(dev, &priv->cdev); + if (ret) + return ret; + return 0; +} + +static int dell_privacy_acpi_probe(struct platform_device *pdev) +{ + int ret; + + platform_set_drvdata(pdev, privacy_acpi); + privacy_acpi->dev = &pdev->dev; + privacy_acpi->platform_device = pdev; + + ret = dell_privacy_leds_setup(&pdev->dev); + if (ret) + return -EIO; + + return 0; +} + +static struct platform_driver dell_privacy_platform_drv = { + .driver = { + .name = PRIVACY_PLATFORM_NAME, + }, + .probe = dell_privacy_acpi_probe, + .remove = dell_privacy_acpi_remove, +}; + +int __init dell_privacy_acpi_init(void) +{ + int err; + struct platform_device *pdev; + + if (!wmi_has_guid(DELL_PRIVACY_GUID)) + return -ENODEV; + + privacy_acpi = kzalloc(sizeof(*privacy_acpi), GFP_KERNEL); + if (!privacy_acpi) + return -ENOMEM; + + err = platform_driver_register(&dell_privacy_platform_drv); + if (err) + goto pdrv_err; + + pdev = platform_device_register_simple( + PRIVACY_PLATFORM_NAME, PLATFORM_DEVID_NONE, NULL, 0); + if (IS_ERR(pdev)) { + err = PTR_ERR(pdev); + goto pdev_err; + } + + return 0; + +pdev_err: + platform_device_unregister(pdev); +pdrv_err: + kfree(privacy_acpi); + return err; +} + +void __exit dell_privacy_acpi_exit(void) +{ + struct platform_device *pdev = to_platform_device(privacy_acpi->dev); + + platform_device_unregister(pdev); + platform_driver_unregister(&dell_privacy_platform_drv); + kfree(privacy_acpi); +} + +MODULE_AUTHOR("Perry Yuan <perry_yuan(a)dell.com>"); +MODULE_DESCRIPTION("DELL Privacy ACPI Driver"); +MODULE_LICENSE("GPL"); diff --git a/drivers/platform/x86/dell/dell-privacy-wmi.c b/drivers/platform/x86/dell/dell-privacy-wmi.c new file mode 100644 index 000000000000..8bde97613477 --- /dev/null +++ b/drivers/platform/x86/dell/dell-privacy-wmi.c @@ -0,0 +1,340 @@ +// SPDX-License-Identifier: GPL-2.0-only +/* + * Dell privacy notification driver + * + * Copyright (C) 2021 Dell Inc. All Rights Reserved. + */ + +#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt + +#include <linux/acpi.h> +#include <linux/input.h> +#include <linux/input/sparse-keymap.h> +#include <linux/list.h> +#include <linux/module.h> +#include <linux/wmi.h> + +#include "dell-privacy-wmi.h" + +#define DELL_PRIVACY_GUID "6932965F-1671-4CEB-B988-D3AB0A901919" +#define MICROPHONE_STATUS BIT(0) +#define CAMERA_STATUS BIT(1) +#define PRIVACY_SCREEN_STATUS BIT(2) + +/* + * The wmi_list is used to store the privacy_priv struct with mutex protecting + */ +static LIST_HEAD(wmi_list); +static DEFINE_MUTEX(list_mutex); +/* + * global privacy state for other modules to query if the privacy driver loaded successfully + * or no privacy WMI device was detected at initial probe phase + */ +int privacy_valid = -EPROBE_DEFER; +EXPORT_SYMBOL_GPL(privacy_valid); + +struct privacy_wmi_data { + struct input_dev *input_dev; + struct wmi_device *wdev; + struct list_head list; + u32 features_present; + u32 last_status; +}; + +/* + * Keymap for WMI privacy events of type 0x0012 + */ +static const struct key_entry dell_wmi_keymap_type_0012[] = { + /* privacy mic mute */ + { KE_KEY, 0x0001, { KEY_MICMUTE } }, + /* privacy camera mute */ + { KE_SW, 0x0002, { SW_CAMERA_LENS_COVER } }, + { KE_END, 0}, +}; + +int dell_privacy_state(void) +{ + return privacy_valid; +} +EXPORT_SYMBOL_GPL(dell_privacy_state); +/* + * The flow of privacy event: + * 1) User presses key. HW does stuff with this key (timeout is started) + * 2) WMI event is emitted from BIOS + * 3) WMI event is received by dell-privacy + * 4) KEY_MICMUTE emitted from dell-privacy + * 5) Userland picks up key and modifies kcontrol for SW mute + * 6) Codec kernel driver catches and calls ledtrig_audio_set defined by + * dell-privacy-acpi driver. + * codec driver will call like this to switch micmute led state. + * ledtrig_audio_set(LED_AUDIO_MICMUTE, micmute_led ? LED_ON :LED_OFF); + * 7) If "LED" is set to on dell-privacy notifies EC,and timeout is cancelled, + * HW mic mute activated. + */ +void dell_privacy_process_event(int type, int code, int status) +{ + struct privacy_wmi_data *priv; + const struct key_entry *key; + + mutex_lock(&list_mutex); + priv = list_first_entry_or_null(&wmi_list, + struct privacy_wmi_data, + list); + if (!priv) { + pr_err("dell privacy priv is NULL\n"); + goto error; + } + key = sparse_keymap_entry_from_scancode(priv->input_dev, (type << 16) | code); + if (!key) { + dev_dbg(&priv->wdev->dev, "Unknown key with type 0x%04x and code 0x%04x pressed\n", + type, code); + goto error; + } + switch (code) { + case DELL_PRIVACY_TYPE_AUDIO: /* Mic mute */ + priv->last_status = status; + sparse_keymap_report_entry(priv->input_dev, key, 1, true); + break; + case DELL_PRIVACY_TYPE_CAMERA: /* Camera mute */ + priv->last_status = status; + sparse_keymap_report_entry(priv->input_dev, key, 1, true); + break; + default: + dev_dbg(&priv->wdev->dev, "unknown event type 0x%04x 0x%04x", + type, code); + } + +error: + mutex_unlock(&list_mutex); +} +EXPORT_SYMBOL_GPL(dell_privacy_process_event); + +static ssize_t devices_supported_show(struct device *dev, + struct device_attribute *attr, + char *buf) +{ + struct privacy_wmi_data *priv = dev_get_drvdata(dev); + + return sysfs_emit(buf, "%x\n", priv->features_present); +} + +static ssize_t current_state_show(struct device *dev, + struct device_attribute *attr, + char *buf) +{ + struct privacy_wmi_data *priv = dev_get_drvdata(dev); + + return sysfs_emit(buf, "%x\n", priv->last_status); +} + +static DEVICE_ATTR_RO(devices_supported); +static DEVICE_ATTR_RO(current_state); + +static struct attribute *privacy_attributes[] = { + &dev_attr_devices_supported.attr, + &dev_attr_current_state.attr, + NULL, +}; + +static const struct attribute_group privacy_attribute_group = { + .attrs = privacy_attributes +}; + +/* + * Describes the Device State class exposed by BIOS which can be consumed by + * various applications interested in knowing the Privacy feature capabilities. + * class DeviceState + * { + * [key, read] string InstanceName; + * [read] boolean ReadOnly; + * [WmiDataId(1), read] uint32 DevicesSupported; + * 0 – None, 0x1 – Microphone, 0x2 – Camera, 0x4 -ePrivacy Screen + * [WmiDataId(2), read] uint32 CurrentState; + * 0:Off; 1:On. Bit0 – Microphone, Bit1 – Camera, Bit2 - ePrivacyScreen + * }; + */ + +static int get_current_status(struct wmi_device *wdev) +{ + struct privacy_wmi_data *priv = dev_get_drvdata(&wdev->dev); + union acpi_object *obj_present; + u32 *buffer; + int ret = 0; + + if (!priv) { + pr_err("dell privacy priv is NULL\n"); + return -EINVAL; + } + /* check privacy support features and device states */ + obj_present = wmidev_block_query(wdev, 0); + if (!obj_present) { + dev_err(&wdev->dev, "failed to read Binary MOF\n"); + ret = -EIO; + privacy_valid = ret; + return ret; + } + + if (obj_present->type != ACPI_TYPE_BUFFER) { + dev_err(&wdev->dev, "Binary MOF is not a buffer!\n"); + ret = -EIO; + privacy_valid = ret; + goto obj_free; + } + /* Although it's not technically a failure, this would lead to + * unexpected behavior + */ + if (obj_present->buffer.length != 8) { + dev_err(&wdev->dev, "Dell privacy buffer has unexpected length (%d)!\n", + obj_present->buffer.length); + ret = -EINVAL; + privacy_valid = ret; + goto obj_free; + } + buffer = (u32 *)obj_present->buffer.pointer; + priv->features_present = buffer[0]; + priv->last_status = buffer[1]; + privacy_valid = 0; + +obj_free: + kfree(obj_present); + return ret; +} + +static int dell_privacy_wmi_probe(struct wmi_device *wdev, const void *context) +{ + struct privacy_wmi_data *priv; + struct key_entry *keymap; + int ret, i; + + priv = devm_kzalloc(&wdev->dev, sizeof(*priv), GFP_KERNEL); + if (!priv) + return -ENOMEM; + + dev_set_drvdata(&wdev->dev, priv); + priv->wdev = wdev; + /* create evdev passing interface */ + priv->input_dev = devm_input_allocate_device(&wdev->dev); + if (!priv->input_dev) + return -ENOMEM; + /* remap the wmi keymap event to new keymap */ + keymap = kcalloc(ARRAY_SIZE(dell_wmi_keymap_type_0012), + sizeof(struct key_entry), GFP_KERNEL); + if (!keymap) { + ret = -ENOMEM; + goto err_free_dev; + } + /* remap the keymap code with Dell privacy key type 0x12 as prefix + * KEY_MICMUTE scancode will be reported as 0x120001 + */ + for (i = 0; i < ARRAY_SIZE(dell_wmi_keymap_type_0012); i++) { + keymap[i] = dell_wmi_keymap_type_0012[i]; + keymap[i].code |= (0x0012 << 16); + } + ret = sparse_keymap_setup(priv->input_dev, keymap, NULL); + if (ret) + return ret; + priv->input_dev->dev.parent = &wdev->dev; + priv->input_dev->name = "Dell Privacy Driver"; + priv->input_dev->id.bustype = BUS_HOST; + if (input_register_device(priv->input_dev)) { + pr_debug("input_register_device failed to register!\n"); + goto err_free_keymap; + } + mutex_lock(&list_mutex); + list_add_tail(&priv->list, &wmi_list); + mutex_unlock(&list_mutex); + + if (get_current_status(priv->wdev)) + goto err_free_input; + + ret = devm_device_add_group(&wdev->dev, &privacy_attribute_group); + if (ret) + goto err_free_input; + + kfree(keymap); + return 0; + +err_free_input: + input_unregister_device(priv->input_dev); +err_free_keymap: + privacy_valid = -ENODEV; + kfree(keymap); +err_free_dev: + return ret; +} + +static int dell_privacy_wmi_remove(struct wmi_device *wdev) +{ + struct privacy_wmi_data *priv = dev_get_drvdata(&wdev->dev); + + mutex_lock(&list_mutex); + list_del(&priv->list); + mutex_unlock(&list_mutex); + privacy_valid = -ENODEV; + input_unregister_device(priv->input_dev); + + return 0; +} + +static const struct wmi_device_id dell_wmi_privacy_wmi_id_table[] = { + { .guid_string = DELL_PRIVACY_GUID }, + { }, +}; + +static struct wmi_driver dell_privacy_wmi_driver = { + .driver = { + .name = "dell-privacy", + }, + .probe = dell_privacy_wmi_probe, + .remove = dell_privacy_wmi_remove, + .id_table = dell_wmi_privacy_wmi_id_table, +}; + +static int __init init_dell_privacy(void) +{ + int ret; + + ret = wmi_has_guid(DELL_PRIVACY_GUID); + if (!ret) { + privacy_valid = -ENODEV; + pr_debug("Unable to detect available Dell privacy devices: %d\n", ret); + return privacy_valid; + } + + ret = wmi_driver_register(&dell_privacy_wmi_driver); + if (ret) { + pr_err("failed to initialize privacy wmi driver: %d\n", ret); + return ret; + } + + ret = dell_privacy_acpi_init(); + if (ret) { + pr_err("failed to initialize privacy acpi driver: %d\n", ret); + goto err_init; + } + + return 0; + +err_init: + wmi_driver_unregister(&dell_privacy_wmi_driver); + return ret; +} + +static void dell_privacy_wmi_exit(void) +{ + wmi_driver_unregister(&dell_privacy_wmi_driver); +} + +static void __exit exit_dell_privacy(void) +{ + dell_privacy_wmi_exit(); + dell_privacy_acpi_exit(); +} + +module_init(init_dell_privacy); +module_exit(exit_dell_privacy); + +MODULE_DEVICE_TABLE(wmi, dell_wmi_privacy_wmi_id_table); +MODULE_AUTHOR("Perry Yuan <perry_yuan(a)dell.com>"); +MODULE_DESCRIPTION("Dell Privacy WMI Driver"); +MODULE_LICENSE("GPL"); diff --git a/drivers/platform/x86/dell/dell-privacy-wmi.h b/drivers/platform/x86/dell/dell-privacy-wmi.h new file mode 100644 index 000000000000..6dda2990df5d --- /dev/null +++ b/drivers/platform/x86/dell/dell-privacy-wmi.h @@ -0,0 +1,35 @@ +/* SPDX-License-Identifier: GPL-2.0-only */ +/* + * Dell privacy notification driver + * + * Copyright (C) 2021 Dell Inc. All Rights Reserved. + */ + +#ifndef _DELL_PRIVACY_WMI_H_ +#define _DELL_PRIVACY_WMI_H_ + +#if IS_ENABLED(CONFIG_DELL_PRIVACY) +extern int privacy_valid; +int dell_privacy_state(void); +void dell_privacy_process_event(int type, int code, int status); +#else /* CONFIG_DELL_PRIVACY */ +int privacy_valid = -ENODEV; +static inline int dell_privacy_state(void) +{ + return privacy_valid; +} + +static inline void dell_privacy_process_event(int type, int code, int status) +{} +#endif /* CONFIG_DELL_PRIVACY */ + +int dell_privacy_acpi_init(void); +void dell_privacy_acpi_exit(void); + +/* DELL Privacy Type */ +enum { + DELL_PRIVACY_TYPE_UNKNOWN = 0x0, + DELL_PRIVACY_TYPE_AUDIO, + DELL_PRIVACY_TYPE_CAMERA, +}; +#endif diff --git a/drivers/platform/x86/dell/dell-wmi.c b/drivers/platform/x86/dell/dell-wmi.c index bbdb3e860892..389e86de24b0 100644 --- a/drivers/platform/x86/dell/dell-wmi.c +++ b/drivers/platform/x86/dell/dell-wmi.c @@ -13,20 +13,22 @@ #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt -#include <linux/kernel.h> -#include <linux/module.h> +#include <linux/acpi.h> +#include <linux/dmi.h> #include <linux/init.h> -#include <linux/slab.h> -#include <linux/types.h> #include <linux/input.h> #include <linux/input/sparse-keymap.h> -#include <linux/acpi.h> +#include <linux/kernel.h> +#include <linux/module.h> +#include <linux/slab.h> #include <linux/string.h> -#include <linux/dmi.h> +#include <linux/types.h> #include <linux/wmi.h> #include <acpi/video.h> + #include "dell-smbios.h" #include "dell-wmi-descriptor.h" +#include "dell-privacy-wmi.h" MODULE_AUTHOR("Matthew Garrett <mjg(a)redhat.com>"); MODULE_AUTHOR("Pali Rohár <pali(a)kernel.org>"); @@ -381,6 +383,7 @@ static void dell_wmi_notify(struct wmi_device *wdev, u16 *buffer_entry, *buffer_end; acpi_size buffer_size; int len, i; + int err; if (obj->type != ACPI_TYPE_BUFFER) { pr_warn("bad response type %x\n", obj->type); @@ -427,7 +430,6 @@ static void dell_wmi_notify(struct wmi_device *wdev, switch (buffer_entry[1]) { case 0x0000: /* One key pressed or event occurred */ - case 0x0012: /* Event with extended data occurred */ if (len > 2) dell_wmi_process_key(wdev, buffer_entry[1], buffer_entry[2]); @@ -439,6 +441,17 @@ static void dell_wmi_notify(struct wmi_device *wdev, dell_wmi_process_key(wdev, buffer_entry[1], buffer_entry[i]); break; + case 0x0012: + err = dell_privacy_state(); + if (err == 0) { + dell_privacy_process_event(buffer_entry[1], + buffer_entry[3], buffer_entry[4]); + } else { + if (len > 2) + dell_wmi_process_key(wdev, buffer_entry[1], + buffer_entry[2]); + } + break; default: /* Unknown event */ pr_info("Unknown WMI event type 0x%x\n", (int)buffer_entry[1]); -- 2.25.1

6 11

[PATCH 1/1] Adding some Roland devices' USB digital audio
by Lucas 28 Mar '21

28 Mar '21

A few days ago, I found this excellent informational post, and that Mike Oliphant's patch is in mainline now: http://blog.nostatic.org/2020/01/getting-boss-gt-1-effects-processor-to.html Since I was fairly certain it applies to the Roland devices I own, I added my USB IDs. Wonderfully, now USB audio capture seems to be working perfectly from the three devices I can test: the INTEGRA-7, Boutique D-05, & VG-99! I've also tested all three for playback capability, since that's implied when a device is using implicit feedback, which I hadn't realized the first time around. Anyway, they all seem to be working as expected for playback too. There are two caveats for playback, though: 1. The INTEGRA-7 won't output playback in any mode other than its "96[kHz]" setting, though capture works with all of its Sample Rate choices. 2. The D-05's analog outputs aren't as clean as the other two devices, with little quiet occasional clicks sounding something like dust on an LP record's play. Possibly that can be chalked up to it having only 1/8" minijack connections, but I suspect something more driver-related as I've not noticed it during use as a synthesizer. Its firmware version is "1.02(1033)," so not up-to-date which may mean it's just the hardware itself, but I've decided not to risk any changes with it yet. If I knew I could revert it, that would be another story. Also USB captures from it, play perfectly cleanly on my usual sound device, the Edirol UA-4FX. You probably already know this, as someone coded them, but here are the commands I've had to use for format compatibility with these devices: D-05: arecord -D hw:Boutique -f S32_LE -c 2 -r 96000 ./file.wav aplay -D hw:Boutique -f S32_LE -c 2 -r 96000 ./file.wav INTEGRA-7: arecord -D hw:INTEGRA7 -f S32_LE -c 2 -r 96000 ./file.wav (then change MENU->SYSTEM->SOUND->Sampling Rate to 44.1 [kHz] (otherwise its 96[kHz]) and change MENU->SYSTEM->SOUND->Ext Part Source Select to USB AUDIO) arecord -D hw:INTEGRA7 -f S32_LE -c 2 -r 44100 ./file-44100.wav aplay -D hw:INTEGRA7 -f S32_LE -c 2 -r 44100 ./file-44100.wav VG-99: arecord -D hw:VG99 -f S24_3LE -c 2 -r 44100 ./file.wav aplay -D hw:VG99 -f S24_3LE -c 2 -r 44100 ./file.wav I searched a bit for other Roland devices people have had USB digital audio issues with over the years, and took the liberty of adding them to the patch too. Likely there are still many more, especially in the Boutique line, but I couldn't find their USB IDs. I have another of the devices I added, with the patch, arriving soon (the R-26) so I'll have to get back to you with how that works too. I hope this can be added to the mainline kernel too, as this support should help many that have struggled. I, certainly, have been hoping somebody would figure this out for quite a while, and even bought a USB through/monitoring device to try to develop it myself (sadly, the software supporting that has its own bugs, so I probably should've just used wireshark). Suffice it to say, I'm quite happy to have this figured out, and to not have to delve into stuff I know nothing about! :) Thanks to anyone looking into adding this, Lucas The patch follows: diff -Nurp linux-5.11.9.orig/sound/usb/implicit.c linux-5.11.9.roland/sound/usb/implicit.c --- linux-5.11.9.orig/sound/usb/implicit.c 2021-03-24 05:54:19.000000000 -0500 +++ linux-5.11.9.roland/sound/usb/implicit.c 2021-03-26 21:43:10.177824402 -0500 @@ -71,27 +71,55 @@ static const struct snd_usb_implicit_fb_ .ep_num = 0x84, .iface = 0 }, /* MOTU MicroBook II */ /* No quirk for playback but with capture quirk (see below) */ + IMPLICIT_FB_SKIP_DEV(0x0582, 0x00a6), /* Roland JUNO-G */ + IMPLICIT_FB_SKIP_DEV(0x0582, 0x00ad), /* Roland SH-201 */ + IMPLICIT_FB_SKIP_DEV(0x0582, 0x00b2), /* Roland VG-99 */ + IMPLICIT_FB_SKIP_DEV(0x0582, 0x00c7), /* Roland V-Synth GT */ + IMPLICIT_FB_SKIP_DEV(0x0582, 0x0111), /* Roland GAIA SH-01 */ + IMPLICIT_FB_SKIP_DEV(0x0582, 0x0120), /* Roland OCTA-CAPTURE */ + IMPLICIT_FB_SKIP_DEV(0x0582, 0x012b), /* Roland DUO-CAPTURE */ + IMPLICIT_FB_SKIP_DEV(0x0582, 0x012f), /* Roland QUAD-CAPTURE */ IMPLICIT_FB_SKIP_DEV(0x0582, 0x0130), /* BOSS BR-80 */ - IMPLICIT_FB_SKIP_DEV(0x0582, 0x0171), /* BOSS RC-505 */ + IMPLICIT_FB_SKIP_DEV(0x0582, 0x0138), /* BOSS RC-300 */ + IMPLICIT_FB_SKIP_DEV(0x0582, 0x013e), /* Roland R-26 */ + IMPLICIT_FB_SKIP_DEV(0x0582, 0x015b), /* Roland INTEGRA-7 */ + IMPLICIT_FB_SKIP_DEV(0x0582, 0x0171), /* BOSS RC-505 */ + IMPLICIT_FB_SKIP_DEV(0x0582, 0x017c), /* Roland TR-8 */ IMPLICIT_FB_SKIP_DEV(0x0582, 0x0185), /* BOSS GP-10 */ IMPLICIT_FB_SKIP_DEV(0x0582, 0x0189), /* BOSS GT-100v2 */ + IMPLICIT_FB_SKIP_DEV(0x0582, 0x01b5), /* Roland JP-08 */ IMPLICIT_FB_SKIP_DEV(0x0582, 0x01d6), /* BOSS GT-1 */ IMPLICIT_FB_SKIP_DEV(0x0582, 0x01d8), /* BOSS Katana */ IMPLICIT_FB_SKIP_DEV(0x0582, 0x01e5), /* BOSS GT-001 */ - IMPLICIT_FB_SKIP_DEV(0x0582, 0x0203), /* BOSS AD-10 */ + IMPLICIT_FB_SKIP_DEV(0x0582, 0x01ff), /* Roland D-05 */ + IMPLICIT_FB_SKIP_DEV(0x0582, 0x0203), /* BOSS AD-10 */ {} /* terminator */ }; /* Implicit feedback quirk table for capture: only FIXED type */ static const struct snd_usb_implicit_fb_match capture_implicit_fb_quirks[] = { + IMPLICIT_FB_FIXED_DEV(0x0582, 0x00a6, 0x0d, 0x01), /* Roland JUNO-G */ + IMPLICIT_FB_FIXED_DEV(0x0582, 0x00ad, 0x0d, 0x01), /* Roland SH-201 */ + IMPLICIT_FB_FIXED_DEV(0x0582, 0x00b2, 0x0d, 0x01), /* Roland VG-99 */ + IMPLICIT_FB_FIXED_DEV(0x0582, 0x00c7, 0x0d, 0x01), /* Roland V-Synth GT */ + IMPLICIT_FB_FIXED_DEV(0x0582, 0x0111, 0x0d, 0x01), /* Roland GAIA SH-01 */ + IMPLICIT_FB_FIXED_DEV(0x0582, 0x0120, 0x0d, 0x01), /* Roland OCTA-CAPTURE */ + IMPLICIT_FB_FIXED_DEV(0x0582, 0x012b, 0x0d, 0x01), /* Roland DUO-CAPTURE */ + IMPLICIT_FB_FIXED_DEV(0x0582, 0x012f, 0x0d, 0x01), /* Roland QUAD-CAPTURE */ IMPLICIT_FB_FIXED_DEV(0x0582, 0x0130, 0x0d, 0x01), /* BOSS BR-80 */ + IMPLICIT_FB_FIXED_DEV(0x0582, 0x0138, 0x0d, 0x01), /* BOSS RC-300 */ + IMPLICIT_FB_FIXED_DEV(0x0582, 0x013e, 0x0d, 0x01), /* Roland R-26 */ + IMPLICIT_FB_FIXED_DEV(0x0582, 0x015b, 0x0d, 0x01), /* Roland INTEGRA-7 */ IMPLICIT_FB_FIXED_DEV(0x0582, 0x0171, 0x0d, 0x01), /* BOSS RC-505 */ + IMPLICIT_FB_FIXED_DEV(0x0582, 0x017c, 0x0d, 0x01), /* Roland TR-8 */ IMPLICIT_FB_FIXED_DEV(0x0582, 0x0185, 0x0d, 0x01), /* BOSS GP-10 */ IMPLICIT_FB_FIXED_DEV(0x0582, 0x0189, 0x0d, 0x01), /* BOSS GT-100v2 */ + IMPLICIT_FB_FIXED_DEV(0x0582, 0x01b5, 0x0d, 0x01), /* Roland JP-08 */ IMPLICIT_FB_FIXED_DEV(0x0582, 0x01d6, 0x0d, 0x01), /* BOSS GT-1 */ IMPLICIT_FB_FIXED_DEV(0x0582, 0x01d8, 0x0d, 0x01), /* BOSS Katana */ IMPLICIT_FB_FIXED_DEV(0x0582, 0x01e5, 0x0d, 0x01), /* BOSS GT-001 */ + IMPLICIT_FB_FIXED_DEV(0x0582, 0x01ff, 0x0d, 0x01), /* Roland D-05 */ IMPLICIT_FB_FIXED_DEV(0x0582, 0x0203, 0x0d, 0x01), /* BOSS AD-10 */ {} /* terminator */

1 3

Re: 003 Firewire Isoch Rate Matching
by Takashi Sakamoto 27 Mar '21

27 Mar '21

Hi, (C.C. to alsa-devel, for someone interested in the topic) On Mon, Mar 22, 2021 at 03:10:57AM -0400, paul(a)neyrinck.com wrote: > Hi Takashi. It is nice to hear back from you. > > > The specific point of payload in isochronous packet from the model is that > > audio data frame is encoded by specific way. We call it as > > 'double-oh-three' algorithm and your can see its detail in Robin Gareus's > > documentation[4], who worked for reverse-engineering. You can see current > > implementation in 'sound/firewire/digi00x/amdtp-dot.c'. > > Yes, I see the middle byte encryption. But I am ignoring it for now while > I try to trying to get streaming to operate. I assume that I should be > able to first implement audio streaming and then implement the encryption > later. > > > Another point is that the sequence of number of data blocks per packet does > > not follow to IEC 61883-1/6. In this point, it's a mutation. > > Can you point me to the code that manages this? This is not something I > understand yet and I think I need more information. > > > The way to start/keep/stop a pair of isochronous communication is not so > > complicated and you can see it in `sound/firewire/digi00x/digi00x-stream.c`. > > I have the "start/keep" part working. My code streams talker packets of 19 > channels (1 MIDI + 18 24-bit audio). The 003 1394 LED changes from > flashing to constantly ON, but the audio output of the 003 is very > bad...just audio glitches. I looked at the FireWire analyzer image on > Robin Gareus' web page. But it shows a small sample. > > Are there any FireWire analyzer data files available to look at to help > me understand the protocols? On Mon, Mar 22, 2021 at 20:07:50PM -0400, paul(a)neyrinck.com wrote: > I have a question about something I do not understand. Does the 003 > require configuration of PCR (Plug Control Registers)? I am ignoring > this (because I don't understand it yet). At first, I describe the way to management a pair of isochronous packet streaming for the target device. Any registers of PCR is not used by 002/003. Instead, quadlet write operation to registers of target device is used for the equivalent operations: * 0x'ffff'e000'0110: sampling transfer frequency * 0x'ffff'e000'0100: registration for a pair of isochronous channels * 0x'ffff'e000'0004: start/stop packet streaming (The LED turns on/off). * 0x'ffff'e000'0000: current status of packet streaming Then the target device starts to transfer isochronous packet to IEEE 1394 bus, and listen to isochronous packet from IEEE 1394 bus, according to registered isochronous channels. You can see current implementation in begin_session() helper function in 'sound/firewire/digi00x/digi00x-stream.c'[1]. Of course, you need to keep isochronous bandwidth and channels in advance of packet streaming. Lock operations are used according to specification of IEEE 1394. You need to communicate to 'isochronous resource manager' node at current bus generation (it can differ each generation): * 0x'ffff'f000'0220: bandwidth * 0x'ffff'f000'0224: channel 31-18 * 0x'ffff'f000'0228: channel 17-0 I guess firewire stack on OS X has API for the above operations. The target device has service for applications to get current sampling rate from external inputs; e.g. S/PDIF: * 0x'ffff'e000'0114: rate of external clock source * 0x'ffff'e000'012c: detection of external clock input The target device can also switch source of sampling clock: * 0x'ffff'e000'0118: source of sampling clock The target device can switch mode of optical interface between ADAT and S/PDIF: * 0x'ffff'e000'011c: optical interface mode Next, I describe the way to process audio data frame in the isochronous packet. One isochronous packet consists of Common Isochronous Packet (CIP) header and payload. For example: CIP | quadlet ------- | ---------- header | 0x00130032 | 0x90020000 payload | ... | ... For the fields in CIP header, please refer to IEC 61883-1/6 which came from specification in vendor association (1394TA). Fortunately, the updated version of ancestor specification is freely available, 'Audio and Music Data Transmission Protocol 2.3' (1394 Trade Association, April 24, 2012, Document 2009013)[2]. The remarkable point of 002/003 case is that SYT field is not used, thus media clock recovery is done just by the number of data blocks in sequence of packet for base cycle time (not cleared yet). CIP payload consists of several number of 'data blocks' according to current sampling transfer frequency (STF). The first quadlet of each data block is for MIDI conformant data channel, which has sequence multiplexing. Some multi bit linear audio data channels follows. In detail, please refer to the above specification. The point is that one data block has one audio data frame. In the case of 002/003, the size of data block is: STF | data channel count -------- | ------------------ 44.1 kHz | 1 + 8 + 8 + 2 (MIDI/Analog/ADAT/SPDIF) 48.0 kHz | 1 + 8 + 8 + 2 (MIDI/Analog/ADAT/SPDIF) 88.2 kHz | 1 + 8 + 2 (MIDI/Analog/SPDIF) 96.0 kHz | 1 + 8 + 2 (MIDI/Analog/SPDIF) Well, we need to adjust the number of data blocks in sequence of packet to keep effective sampling rate (='media clock' in IEEE 1722). For this purpose, IEC 61883-1/6 defines two ways; blocking and non-blocking. In blocking way, an packet has fixed number of data blocks or empty packet. An example at 44.1 STF: isoc | the number of data cycle | blocks per packet ----- | ------------------- 0 | 8 1 | 8 2 | 0 3 | 8 4 | 8 5 | 8 6 | 0 ... | ... In non-blocking way, the number data blocks per packet is variable according to sampling timing each isochronous cycle. An example at 44.1 STF: isoc | the number of data cycle | blocks per packet ----- | ------------------- 0 | 6 1 | 6 2 | 5 3 | 6 4 | 5 5 | 6 6 | 5 ... | ... The above is basics of adjustment for media clock. You can see current implementation of ALSA firewire stack in 'calculate_data_blocks()' helper function in 'sound/firewire/amdtp-stream.c'[3]. In the implementation, the sequence of packet to the target device is adjusted independent of the sequence of packet from the target device. As you issued, the lack of adjustment is the cause of pop-noise in generated sound. We need the way to recover media clock in the sequence of packet from the target device. But as long as I know, the way is different between device types and models. For example, the sequence of packet from Windows driver to 002 is different from the one to 003 in the point. It's the reason that the issue is long standing. Additionally, Digi 002 and 003 uses protocol mutated from the above mechanism in the point of media clock. For example, we can see the actual sequence of packet to the target device at 48.0 kHz STF in Robin Gareus' post[5]. By calculating the number of data blocks according to data block counter field in CIP header: number of | data data blocks | block | counter ----------- | ------- - | 0x32 7 | 0x39 7 | 0x40 5 | 0x45 5 | 0x4a 5 | 0x4f 5 | 0x54 5 | 0x59 5 | 0x5e 5 | 0x63 5 | 0x68 7 | 0x6f 7 | 0x76 7 | 0x7d 7 | 0x84 7 | 0x8b 7 | 0x92 7 | 0x99 7 | 0xa0 5 | 0xa5 5 | 0xaa 5 | 0xaf 5 | 0xb4 5 | 0xb9 5 | 0xbe 5 | 0xc3 5 | 0xc8 7 | 0xcf 7 | 0xd6 7 | 0xdd It's neither blocking nor non-blocking. The sequence is relevant to both of packet buffering and audio data frame buffering, thus the above sequence the size of buffering is not something I know. I use DAP Technology FireSpy 810[5] for packet analyzing (fortunately I found it at bargain price in used market). The libhinoko[6] can make your Linux box as packet analyzer and might be useful. Enough later, I'll send you log of packet sequence for long duration (1 min or so) for 003 console and rack. > I have a Pro Tools license on Mac and PC. I think I have an Mbox 2 Pro > available to me. Please let me know how I can help you solve Mbox 2. Ok, thanks. I'll post some questions about control application for M-Box 2 Pro enough later. [1] https://git.kernel.org/pub/scm/linux/kernel/git/tiwai/sound.git/tree/sound/… [2] http://1394ta.org/developers/publicspecs/2009013.pdf [3] https://git.kernel.org/pub/scm/linux/kernel/git/tiwai/sound.git/tree/sound/… [4] https://github.com/takaswie/snd-firewire-improve/issues/26#issuecomment-803… [5] https://gareus.org/wiki/digi003 [6] https://www.daptechnology.com/products/bus-analyzer/single-bus/single-bus-g… [7] https://mailman.alsa-project.org/pipermail/alsa-devel/2019-April/147862.html Regards Takashi Sakamoto

1 1

[PATCH] Behringer UFX1604: get rid of pops and clicks while on 96000hz
by Geraldo 27 Mar '21

27 Mar '21

Hello everyone! This one has been bugging me for quite a while. I went deep hard in the guts of ALSA to try to solve it, and it turned out to be a minor thing apparently. The problem is old, and every UFX1604 Linux user can attest that it's impossible to use 96000hz in DUPLEX mode without annoying pops and clicks on the capture stream. The fix is simple: after we alter the CLOCK_SOURCE to match our sample rate, let's tell the CLOCK_SELECTOR we want CLOCK_SOURCE 212 (synced to USB SOF) on pin 1. Solves the problem for me, no more pops and clicks while on 96000hz. If you own an UFX1604 please give this patch a good testing. Let me know if it solves the pops and clicks on the input stream for you while on DUPLEX 96000hz. --- clock.c.git 2021-03-22 04:19:55.543485748 -0300 +++ clock.c 2021-03-25 19:23:38.597197159 -0300 @@ -610,6 +610,13 @@ int snd_usb_set_sample_rate_v2v3(struct if (err < 0) return err; + if (chip->usb_id == USB_ID(0x1397, 0x0001)) { /* Behringer UFX1604 */ + printk(KERN_WARNING "Setting clock selector for UFX1604"); + err = uac_clock_selector_set_val(chip, 211, 1); + if (err < 0) + return err; + } + return get_sample_rate_v2v3(chip, fmt->iface, fmt->altsetting, clock); }

1 2